@lexical/mdast 0.0.0-bootstrap.0 → 0.47.0

package/dist/LexicalMdast.dev.js

@@ -0,0 +1,2620 @@
+/**
+ * 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.
+ *
+ */
+
+'use strict';
+
+var extension = require('@lexical/extension');
+var lexical = require('lexical');
+var selection = require('@lexical/selection');
+var mdastUtilToMarkdown = require('mdast-util-to-markdown');
+var mdastUtilToString = require('mdast-util-to-string');
+var codeCore = require('@lexical/code-core');
+var link = require('@lexical/link');
+var list = require('@lexical/list');
+var richText = require('@lexical/rich-text');
+var mdastUtilGfmAutolinkLiteral = require('mdast-util-gfm-autolink-literal');
+var mdastUtilGfmStrikethrough = require('mdast-util-gfm-strikethrough');
+var mdastUtilGfmTaskListItem = require('mdast-util-gfm-task-list-item');
+var micromarkExtensionGfmAutolinkLiteral = require('micromark-extension-gfm-autolink-literal');
+var micromarkExtensionGfmStrikethrough = require('micromark-extension-gfm-strikethrough');
+var micromarkExtensionGfmTaskListItem = require('micromark-extension-gfm-task-list-item');
+var mdastUtilFromMarkdown = require('mdast-util-from-markdown');
+var table = require('@lexical/table');
+var mdastUtilGfmTable = require('mdast-util-gfm-table');
+var micromarkExtensionGfmTable = require('micromark-extension-gfm-table');
+
+/**
+ * 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. */
+const listMarkerState = /* @__PURE__ */lexical.createState('mdastListMarker', {
+  parse: v => v === '-' || v === '*' || v === '+' ? v : '',
+  resetOnCopyNode: true
+});
+
+/** The delimiter (`.` or `)`) an ordered `ListNode` used. */
+const orderedMarkerState = /* @__PURE__ */lexical.createState('mdastOrderedMarker', {
+  parse: v => v === '.' || v === ')' ? v : '',
+  resetOnCopyNode: true
+});
+
+/** The marker (`_`) an italic run used when it was not the default `*`. */
+const emphasisMarkerState = /* @__PURE__ */lexical.createState('mdastEmphasisMarker', {
+  parse: v => v === '_' ? '_' : '',
+  resetOnCopyNode: true
+});
+
+/** The marker (`_`) a bold run used when it was not the default `*`. */
+const strongMarkerState = /* @__PURE__ */lexical.createState('mdastStrongMarker', {
+  parse: v => v === '_' ? '_' : '',
+  resetOnCopyNode: true
+});
+
+/** Whether a (level 1/2) `HeadingNode` was written in setext style. */
+const setextState = /* @__PURE__ */lexical.createState('mdastSetext', {
+  parse: v => v === true,
+  resetOnCopyNode: true
+});
+
+/** The fence a `CodeNode` used (e.g. ```` ``` ````, ````` ```` `````, `~~~`). */
+const codeFenceState = /* @__PURE__ */lexical.createState('mdastCodeFence', {
+  parse: v => typeof v === 'string' && /^(`{3,}|~{3,})$/.test(v) ? v : '',
+  resetOnCopyNode: true
+});
+
+/**
+ * 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.
+ */
+const codeMetaState = /* @__PURE__ */lexical.createState('mdastCodeMeta', {
+  parse: v => typeof v === 'string' ? v : '',
+  resetOnCopyNode: true
+});
+
+/**
+ * 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.
+ */
+const hardLineBreakState = /* @__PURE__ */lexical.createState('mdastHardLineBreak', {
+  parse: v => typeof v === 'string' && /^(\\| {2,})$/.test(v) ? v : '',
+  resetOnCopyNode: true
+});
+
+/**
+ * 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.
+ */
+const paragraphBreakState = /* @__PURE__ */lexical.createState('mdastParagraphBreak', {
+  parse: v => v === true,
+  resetOnCopyNode: true
+});
+
+/** The marker (`-`, `*`, `_`) a thematic break / `HorizontalRuleNode` used. */
+const hrMarkerState = /* @__PURE__ */lexical.createState('mdastHrMarker', {
+  parse: v => v === '-' || v === '*' || v === '_' ? v : '',
+  resetOnCopyNode: true
+});
+
+/**
+ * The syntax a `LinkNode` was written in: `'inline'` (`[text](url)`),
+ * `'autolink'` (`<url>`), or `'literal'` (a bare GFM autolink literal,
+ * `https://…` in prose).
+ */
+const linkStyleState = /* @__PURE__ */lexical.createState('mdastLinkStyle', {
+  parse: v => v === 'inline' || v === 'autolink' || v === 'literal' ? v : '',
+  resetOnCopyNode: true
+});
+
+/**
+ * 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.
+ *
+ */
+
+
+/**
+ * Appends `nodes` to `element` via {@link ElementNode.splice} (the primitive
+ * `append` delegates to, taking an array directly), returning the element.
+ */
+function $append(element, nodes) {
+  return element.splice(element.getChildrenSize(), 0, nodes);
+}
+
+/**
+ * Prepends `nodes` to `element` via {@link ElementNode.splice} (the primitive
+ * `append` delegates to, taking an array directly), returning the element.
+ */
+function $prepend(element, nodes) {
+  return element.splice(0, 0, nodes);
+}
+
+/**
+ * Whether `node` is a block-level node: a non-inline element *or* a non-inline
+ * decorator (e.g. a horizontal rule).
+ */
+function $isBlockLevelNode(node) {
+  return (lexical.$isElementNode(node) || lexical.$isDecoratorNode(node)) && !node.isInline();
+}
+
+/** A `LineBreakNode` marking a paragraph boundary inside a container. */
+function $createParagraphBreakNode() {
+  return lexical.$setState(lexical.$createLineBreakNode(), paragraphBreakState, true);
+}
+
+/** Reads the first source character of `node` (an inline delimiter, if any). */
+function inlineMarker(ctx, node) {
+  if (!ctx.source || !node.position || node.position.start.offset == null) {
+    return undefined;
+  }
+  return ctx.source[node.position.start.offset];
+}
+const FORMAT_BOLD = lexical.TEXT_TYPE_TO_FORMAT.bold;
+const FORMAT_ITALIC = lexical.TEXT_TYPE_TO_FORMAT.italic;
+const FORMAT_STRIKETHROUGH = lexical.TEXT_TYPE_TO_FORMAT.strikethrough;
+const FORMAT_CODE = lexical.TEXT_TYPE_TO_FORMAT.code;
+const TEXT_FORMAT_MASK = FORMAT_BOLD | FORMAT_ITALIC | FORMAT_STRIKETHROUGH | FORMAT_CODE;
+
+/* -------------------------------------------------------------------------- *
+ * Import handlers: mdast node -> Lexical node(s)                              *
+ * -------------------------------------------------------------------------- */
+
+const $importParagraph = (node, ctx) => $append(lexical.$createParagraphNode(), ctx.importChildren(node));
+const $importHeading = (node, ctx) => {
+  const heading = richText.$createHeadingNode(`h${node.depth}`);
+  // A level 1/2 heading that does not start with a valid ATX marker (`#`..
+  // `######` followed by whitespace or end of line) was written in setext
+  // style. Checking for the trailing boundary matters: `#foo\n===` is a
+  // setext heading whose *content* begins with `#`.
+  if (ctx.source && node.position && (node.depth === 1 || node.depth === 2)) {
+    const offset = node.position.start.offset;
+    if (offset != null && !/^ {0,3}#{1,6}([ \t\r\n]|$)/.test(ctx.source.slice(offset, offset + 10))) {
+      lexical.$setState(heading, setextState, true);
+    }
+  }
+  return $append(heading, ctx.importChildren(node));
+};
+const $importBlockquote = (node, ctx) => {
+  const quote = richText.$createQuoteNode();
+  const children = [];
+  for (const child of node.children) {
+    if (child.type === 'paragraph') {
+      if (children.length > 0) {
+        children.push($createParagraphBreakNode());
+      }
+      children.push(...ctx.importChildren(child));
+    } else {
+      // Nested blocks (lists, code, nested quotes) are imported as-is so they
+      // are not silently flattened to text.
+      children.push(...ctx.importNode(child));
+    }
+  }
+  return $append(quote, children);
+};
+
+/**
+ * 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.
+ */
+function $importBlockChildren(parent, ctx) {
+  const blocks = [];
+  let pendingParagraph = null;
+  const flushPending = () => {
+    if (pendingParagraph) {
+      blocks.push(pendingParagraph);
+      pendingParagraph = null;
+    }
+  };
+  for (const child of parent.children) {
+    for (const node of ctx.importNode(child)) {
+      if ($isBlockLevelNode(node)) {
+        flushPending();
+        blocks.push(node);
+      } else {
+        if (!pendingParagraph) {
+          pendingParagraph = lexical.$createParagraphNode();
+        }
+        $append(pendingParagraph, [node]);
+      }
+    }
+  }
+  flushPending();
+  return blocks;
+}
+
+/**
+ * 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`.
+ */
+const $importShadowRootBlockquote = (node, ctx) => $append(richText.$createQuoteNode({
+  shadowRoot: true
+}), $importBlockChildren(node, ctx));
+
+/** Maps an mdast `list` node to the Lexical {@link ListType} it represents. */
+function $listTypeFromMdast(node) {
+  if (node.ordered) {
+    return 'number';
+  }
+  for (const child of node.children) {
+    if (child.type === 'listItem' && child.checked != null) {
+      return 'check';
+    }
+  }
+  return 'bullet';
+}
+const $importList = (node, ctx) => {
+  const listType = $listTypeFromMdast(node);
+  const start = node.ordered && node.start != null ? node.start : 1;
+  const list$1 = list.$createListNode(listType, start);
+  // Preserve the literal marker the list used so export can reproduce it.
+  // A bounded window is enough: an ordered marker is at most 9 digits plus
+  // the delimiter (CommonMark), a bullet is a single character.
+  const firstItem = node.children[0];
+  const itemOffset = ctx.source && firstItem && firstItem.position ? firstItem.position.start.offset : undefined;
+  if (itemOffset != null) {
+    const markerWindow = ctx.source.slice(itemOffset, itemOffset + 16);
+    if (listType === 'number') {
+      const match = markerWindow.match(/^\s*\d+([.)])/);
+      const delimiter = match && match[1];
+      if (delimiter === '.' || delimiter === ')') {
+        lexical.$setState(list$1, orderedMarkerState, delimiter);
+      }
+    } else {
+      const match = markerWindow.match(/^\s*([-*+])/);
+      const bullet = match && match[1];
+      if (bullet === '-' || bullet === '*' || bullet === '+') {
+        lexical.$setState(list$1, listMarkerState, bullet);
+      }
+    }
+  }
+  return $append(list$1, node.children.flatMap(child => ctx.importNode(child)));
+};
+const $importListItem = (node, ctx) => {
+  const item = list.$createListItemNode(typeof node.checked === 'boolean' ? node.checked : undefined);
+  const extraItems = [];
+  for (const child of node.children) {
+    if (child.type === 'list') {
+      // A nested list is represented in Lexical as a ListItemNode whose only
+      // child is the nested ListNode, appended as a sibling of this item.
+      extraItems.push($append(list.$createListItemNode(), ctx.importNode(child)));
+    } else if (child.type === 'paragraph') {
+      if (item.getChildrenSize() > 0) {
+        $append(item, [$createParagraphBreakNode()]);
+      }
+      $append(item, ctx.importChildren(child));
+    } else {
+      $append(item, ctx.importNode(child));
+    }
+  }
+  return [item, ...extraItems];
+};
+const $importCode = (node, ctx) => {
+  const code = codeCore.$createCodeNode(node.lang || undefined);
+  // Preserve the literal fence (e.g. ``` vs ~~~ vs ````) for round-tripping.
+  // The fence is on the construct's first line; bound the scan to it.
+  if (ctx.source && node.position && node.position.start.offset != null) {
+    const offset = node.position.start.offset;
+    const lineEnd = ctx.source.indexOf('\n', offset);
+    const line = ctx.source.slice(offset, lineEnd === -1 ? undefined : lineEnd);
+    const match = line.match(/^[ \t]*(`{3,}|~{3,})/);
+    if (match) {
+      lexical.$setState(code, codeFenceState, match[1]);
+    }
+  }
+  // CodeNode only models the language; keep the rest of the info string
+  // (` ```js title=x `) as node state so it survives the round-trip.
+  if (node.meta) {
+    lexical.$setState(code, codeMetaState, node.meta);
+  }
+  if (node.value) {
+    $append(code, [lexical.$createTextNode(node.value)]);
+  }
+  return code;
+};
+const importText = (node, ctx) => ctx.createText(node.value);
+const importHtml = (node, ctx) => ctx.createText(node.value);
+const importInlineCode = (node, ctx) => ctx.createText(node.value, ctx.format | FORMAT_CODE);
+
+/**
+ * Builds the emphasis/strong import handler: applies the format bit and
+ * records an underscore delimiter (`_em_` / `__b__`) on the resulting text
+ * nodes; `*` is the default and isn't stored.
+ */
+function makeEmphasisImporter(format, markerState) {
+  return (node, ctx) => {
+    const children = ctx.importChildren(node, format);
+    if (inlineMarker(ctx, node) === '_') {
+      for (const child of children) {
+        if (lexical.$isTextNode(child)) {
+          lexical.$setState(child, markerState, '_');
+        }
+      }
+    }
+    return children;
+  };
+}
+const $importEmphasis = /* @__PURE__ */makeEmphasisImporter(FORMAT_ITALIC, emphasisMarkerState);
+const $importStrong = /* @__PURE__ */makeEmphasisImporter(FORMAT_BOLD, strongMarkerState);
+const importDelete = (node, ctx) => ctx.importChildren(node, FORMAT_STRIKETHROUGH);
+const $importBreak = (node, ctx) => {
+  // An mdast `break` is always a HARD break; preserve whether it was written
+  // as `\` or as trailing spaces, defaulting to `\` when the literal cannot
+  // be recovered. (Soft breaks are newlines inside text values and stay
+  // unmarked, serializing back to a plain newline.)
+  let marker = '\\';
+  if (ctx.source && node.position) {
+    const {
+      start,
+      end
+    } = node.position;
+    if (start.offset != null && end.offset != null) {
+      const raw = ctx.source.slice(start.offset, end.offset).replace(/\n$/, '');
+      if (/^ {2,}$/.test(raw)) {
+        marker = raw;
+      }
+    }
+  }
+  return [lexical.$setState(lexical.$createLineBreakNode(), hardLineBreakState, marker)];
+};
+const $importLink = (node, ctx) => {
+  const link$1 = $append(link.$createLinkNode(node.url, {
+    title: node.title == null ? undefined : node.title
+  }), ctx.importChildren(node));
+  // Preserve the syntax the link was written in (`[text](url)` vs `<url>`
+  // vs a bare GFM autolink literal) so it round-trips unchanged.
+  if (ctx.source && node.position && node.position.start.offset != null) {
+    const first = ctx.source[node.position.start.offset];
+    lexical.$setState(link$1, linkStyleState, first === '[' ? 'inline' : first === '<' ? 'autolink' : 'literal');
+  }
+  return link$1;
+};
+
+/**
+ * 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.
+ */
+const $importLinkReference = (node, ctx) => {
+  const definition = ctx.getDefinition(node.identifier);
+  if (definition) {
+    return $append(link.$createLinkNode(definition.url, {
+      title: definition.title == null ? undefined : definition.title
+    }), ctx.importChildren(node));
+  }
+  const {
+    position
+  } = node;
+  if (ctx.source && position && position.start.offset != null) {
+    return ctx.createText(ctx.source.slice(position.start.offset, position.end.offset));
+  }
+  // Approximate the literal when the source is unavailable.
+  return [...ctx.createText('['), ...ctx.importChildren(node), ...ctx.createText(']')];
+};
+
+/**
+ * Definitions (`[id]: url "title"`) are consumed by {@link collectDefinitions}
+ * before the walk; the node itself produces no content.
+ */
+const importDefinition = () => [];
+
+/* -------------------------------------------------------------------------- *
+ * Export handlers: Lexical node -> mdast node(s)                             *
+ * -------------------------------------------------------------------------- */
+
+const exportParagraph = (node, ctx) => {
+  if (!lexical.$isParagraphNode(node)) {
+    return null;
+  }
+  return {
+    children: ctx.exportInline(node),
+    type: 'paragraph'
+  };
+};
+const HEADING_DEPTHS = {
+  h1: 1,
+  h2: 2,
+  h3: 3,
+  h4: 4,
+  h5: 5,
+  h6: 6
+};
+const $exportHeading = (node, ctx) => {
+  if (!richText.$isHeadingNode(node)) {
+    return null;
+  }
+  const heading = {
+    children: ctx.exportInline(node),
+    depth: HEADING_DEPTHS[node.getTag()],
+    type: 'heading'
+  };
+  // Only pin the style when it is known; nodes created in the editor defer
+  // to the document-level serialization options.
+  if (lexical.$getState(node, setextState)) {
+    heading.data = {
+      mdastSetext: true
+    };
+  }
+  return heading;
+};
+const exportQuote = (node, ctx) => {
+  if (!richText.$isQuoteNode(node)) {
+    return null;
+  }
+  // A shadow root quote holds block-level children that dispatch directly;
+  // a legacy quote holds inline content that must be reassembled into
+  // paragraphs. Branching per node lets both forms coexist in one document.
+  // Children of a shadow root quote dispatch through the registry, which
+  // erases types; block-level output is the dispatch contract here.
+  return {
+    children: node.isShadowRoot() ? ctx.exportChildren(node) : ctx.exportBlocks(node),
+    type: 'blockquote'
+  };
+};
+const $exportCode = node => {
+  if (!codeCore.$isCodeNode(node)) {
+    return null;
+  }
+  const code = {
+    lang: node.getLanguage() || null,
+    type: 'code',
+    value: node.getTextContent()
+  };
+  // The info-string tail is a first-class mdast field; to-markdown emits it
+  // after the language (and forces fenced style).
+  const meta = lexical.$getState(node, codeMetaState);
+  if (meta) {
+    code.meta = meta;
+  }
+  // `data.mdastFence` is read back by the exporter's to-markdown wrapper.
+  // Only pin the fence when known; editor-created code blocks defer to the
+  // document-level serialization options.
+  const fence = lexical.$getState(node, codeFenceState);
+  if (fence) {
+    code.data = {
+      mdastFence: fence
+    };
+  }
+  return code;
+};
+const $exportLink = (node, ctx) => {
+  if (!link.$isLinkNode(node) || link.$isAutoLinkNode(node)) {
+    return null;
+  }
+  const link$1 = {
+    children: ctx.exportInline(node),
+    title: node.getTitle() ?? null,
+    type: 'link',
+    url: node.getURL()
+  };
+  // Only pinned when known — editor-created links defer to the default
+  // serialization (autolink form when the text is the URL).
+  const style = lexical.$getState(node, linkStyleState);
+  if (style) {
+    link$1.data = {
+      mdastLinkStyle: style
+    };
+  }
+  return link$1;
+};
+function $exportListNode(node, ctx) {
+  const listType = node.getListType();
+  const list$1 = {
+    children: [],
+    ordered: listType === 'number',
+    spread: false,
+    start: listType === 'number' ? node.getStart() : undefined,
+    type: 'list'
+  };
+  // Preserve the marker the list used; read back by the exporter's
+  // to-markdown wrapper. Only pinned when known — editor-created lists defer
+  // to the document-level serialization options.
+  if (listType === 'number') {
+    const marker = lexical.$getState(node, orderedMarkerState);
+    if (marker) {
+      list$1.data = {
+        mdastBulletOrdered: marker
+      };
+    }
+  } else {
+    const marker = lexical.$getState(node, listMarkerState);
+    if (marker) {
+      list$1.data = {
+        mdastBullet: marker
+      };
+    }
+  }
+  let previousItem = null;
+  for (const child of node.getChildren()) {
+    // Structural iteration bypasses the walk's selection filter, so items a
+    // selection export does not reach are skipped here.
+    if (!list.$isListItemNode(child) || !ctx.isIncluded(child)) {
+      continue;
+    }
+    const firstChild = child.getFirstChild();
+    // A list item whose sole child is a nested list represents nesting: attach
+    // the nested list to the previous item's children.
+    if (child.getChildrenSize() === 1 && list.$isListNode(firstChild)) {
+      const nested = $exportListNode(firstChild, ctx);
+      if (previousItem) {
+        previousItem.children.push(nested);
+      } else {
+        list$1.children.push({
+          children: [nested],
+          spread: false,
+          type: 'listItem'
+        });
+      }
+      continue;
+    }
+    const item = {
+      checked: listType === 'check' ? child.getChecked() ?? false : null,
+      children: ctx.exportBlocks(child),
+      spread: false,
+      type: 'listItem'
+    };
+    list$1.children.push(item);
+    previousItem = item;
+  }
+  return list$1;
+}
+const $exportList = (node, ctx) => {
+  if (!list.$isListNode(node)) {
+    return null;
+  }
+  return $exportListNode(node, ctx);
+};
+
+/**
+ * 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.
+ */
+function phrasingFromFormattedText(value, format) {
+  let content = format & FORMAT_CODE ? {
+    type: 'inlineCode',
+    value
+  } : {
+    type: 'text',
+    value
+  };
+  if (format & FORMAT_ITALIC) {
+    content = {
+      children: [content],
+      type: 'emphasis'
+    };
+  }
+  if (format & FORMAT_BOLD) {
+    content = {
+      children: [content],
+      type: 'strong'
+    };
+  }
+  if (format & FORMAT_STRIKETHROUGH) {
+    content = {
+      children: [content],
+      type: 'delete'
+    };
+  }
+  return content;
+}
+const exportText = node => {
+  if (!lexical.$isTextNode(node)) {
+    return null;
+  }
+  return phrasingFromFormattedText(node.getTextContent(), node.getFormat() & TEXT_FORMAT_MASK);
+};
+const $exportLineBreak = node => lexical.$isLineBreakNode(node) ? {
+  data: {
+    mdastBreak: lexical.$getState(node, hardLineBreakState)
+  },
+  type: 'break'
+} : null;
+const exportTab = node => lexical.$isTabNode(node) ? {
+  type: 'text',
+  value: '\t'
+} : null;
+
+/**
+ * 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.
+ *
+ */
+
+
+/**
+ * Runs `fn` with `state.options` temporarily overridden, restoring the
+ * previous values afterwards so a per-node override never leaks into the rest
+ * of the serialization.
+ */
+function withOptions(state, overrides, fn) {
+  const {
+    options
+  } = state;
+  const saved = {};
+  for (const key of Object.keys(overrides)) {
+    saved[key] = options[key];
+    options[key] = overrides[key];
+  }
+  try {
+    return fn();
+  } finally {
+    for (const key of Object.keys(saved)) {
+      options[key] = saved[key];
+    }
+  }
+}
+
+/**
+ * A to-markdown extension whose handlers reproduce the literal Markdown syntax
+ * captured on import (and stored on the Lexical nodes), by temporarily
+ * steering the default handlers with per-node options. Delegating to the
+ * defaults keeps all the indentation / nesting / disambiguation behavior
+ * intact while still honoring each node's original marker/fence. Nodes without
+ * captured syntax fall straight through to the defaults, so document-level
+ * options (and contributed `toMarkdownExtensions`) still apply to them.
+ */
+const SYNTAX_TO_MARKDOWN = {
+  handlers: {
+    break(node, parent, state, info) {
+      // Delegate first: the default handler substitutes a space when a real
+      // EOL is unsafe in the current construct (headings, table cells). Only
+      // when it chose the hard-break form does the preserved marker apply:
+      // trailing-space markers are reproduced, and the empty marker means the
+      // break is SOFT (a source newline or editor line break) and serializes
+      // as a plain newline rather than being upgraded to a hard break.
+      const result = mdastUtilToMarkdown.defaultHandlers.break(node, parent, state, info);
+      if (result !== '\\\n') {
+        return result;
+      }
+      const marker = node.data && node.data.mdastBreak;
+      if (!marker) {
+        return '\n';
+      }
+      return /^ {2,}$/.test(marker) ? `${marker}\n` : result;
+    },
+    code(node, parent, state, info) {
+      const fence = node.data && node.data.mdastFence;
+      if (!fence) {
+        return mdastUtilToMarkdown.defaultHandlers.code(node, parent, state, info);
+      }
+      return withOptions(state, {
+        fence: fence[0] === '~' ? '~' : '`',
+        fences: true
+      }, () => mdastUtilToMarkdown.defaultHandlers.code(node, parent, state, info));
+    },
+    heading(node, parent, state, info) {
+      // `data.mdastSetext` is only present (true) for imported setext
+      // headings; everything else defers to the document-level option.
+      if (!(node.data && node.data.mdastSetext === true)) {
+        return mdastUtilToMarkdown.defaultHandlers.heading(node, parent, state, info);
+      }
+      return withOptions(state, {
+        setext: true
+      }, () => mdastUtilToMarkdown.defaultHandlers.heading(node, parent, state, info));
+    },
+    link(node, parent, state, info) {
+      // `data.mdastLinkStyle` preserves the syntax the link was written in.
+      // A title can't be expressed in autolink/literal form, so links with a
+      // title always fall through to the default (resource form).
+      const style = node.data && node.data.mdastLinkStyle;
+      if (style === 'literal' && node.title == null) {
+        // A bare GFM autolink literal: emit the visible text as-is. The
+        // gfm-autolink-literal to-markdown extension keeps surrounding
+        // escaping consistent so it re-parses as the same literal.
+        return mdastUtilToString.toString(node);
+      }
+      if (style === 'inline') {
+        // Force `[text](url)` even when the text equals the URL (the
+        // default handler would normalize that to an autolink).
+        return withOptions(state, {
+          resourceLink: true
+        }, () => mdastUtilToMarkdown.defaultHandlers.link(node, parent, state, info));
+      }
+      return mdastUtilToMarkdown.defaultHandlers.link(node, parent, state, info);
+    },
+    list(node, parent, state, info) {
+      if (node.ordered) {
+        const ordered = node.data && node.data.mdastBulletOrdered;
+        if (ordered == null) {
+          return mdastUtilToMarkdown.defaultHandlers.list(node, parent, state, info);
+        }
+        return withOptions(state, {
+          bulletOrdered: ordered
+        }, () => mdastUtilToMarkdown.defaultHandlers.list(node, parent, state, info));
+      }
+      const bullet = node.data && node.data.mdastBullet;
+      if (bullet == null) {
+        return mdastUtilToMarkdown.defaultHandlers.list(node, parent, state, info);
+      }
+      return withOptions(state, {
+        bullet,
+        bulletOther: bullet === '-' ? '*' : '-'
+      }, () => mdastUtilToMarkdown.defaultHandlers.list(node, parent, state, info));
+    },
+    thematicBreak(node, parent, state) {
+      const marker = node.data && node.data.mdastRule;
+      if (marker !== '-' && marker !== '*' && marker !== '_') {
+        return mdastUtilToMarkdown.defaultHandlers.thematicBreak(node, parent, state);
+      }
+      return withOptions(state, {
+        rule: marker
+      }, () => mdastUtilToMarkdown.defaultHandlers.thematicBreak(node, parent, state));
+    }
+  }
+};
+
+/**
+ * Accumulates adjacent plain text nodes that share a format so they serialize
+ * to a single delimiter pair (e.g. `**ab**` rather than `**a****b**`). Shared
+ * by the inline and block export walks.
+ */
+class TextRunAccumulator {
+  format = -1;
+  value = '';
+
+  /**
+   * Returns `true` when `child` was absorbed. A format change flushes the
+   * previous run into `out` first. The caller decides *which* text nodes
+   * are eligible (plain text with no export rule of its own); this only
+   * guards the node kind.
+   */
+  push(child, out) {
+    if (!lexical.$isTextNode(child)) {
+      return false;
+    }
+    const format = child.getFormat() & TEXT_FORMAT_MASK;
+    if (format === this.format) {
+      this.value += child.getTextContent();
+    } else {
+      this.flushInto(out);
+      this.format = format;
+      this.value = child.getTextContent();
+    }
+    return true;
+  }
+  flushInto(out) {
+    if (this.format >= 0) {
+      out.push(phrasingFromFormattedText(this.value, this.format));
+    }
+    this.format = -1;
+    this.value = '';
+  }
+}
+function createNodeExporter(compiled, selection$1 = null) {
+  const {
+    exportHandlers
+  } = compiled;
+  // Incremented whenever a selected leaf contributes output. Parents compare
+  // it before/after recursing to keep an element that is not itself selected
+  // but hosts selected content (the markdown analogue of extractWithChild).
+  let selectionHits = 0;
+
+  /**
+   * Whether the run accumulator may absorb `child`: a text node whose only
+   * export behavior would be the core text fallback. A node whose type has
+   * its own registered rule (or the core `'text'` rule, which the
+   * accumulator supersedes to merge adjacent runs) must not be swallowed —
+   * this keeps replaced/custom text nodes dispatching to their handlers.
+   */
+  function mayAccumulate(child) {
+    const handler = exportHandlers.get(child.getType());
+    return handler === undefined || handler === exportText;
+  }
+
+  /**
+   * Selection filter for one child. With no selection every child passes
+   * through unchanged. Leaves (text, line break, decorator) pass only when
+   * selected, a partially selected text node as a detached clone sliced to
+   * the selected range; `null` means skip. Elements always pass — they are
+   * judged after recursion by {@link $dispatchElement}.
+   */
+  function $filterChild(child) {
+    if (selection$1 === null || lexical.$isElementNode(child)) {
+      return child;
+    }
+    if (!child.isSelected(selection$1)) {
+      return null;
+    }
+    selectionHits++;
+    return lexical.$isTextNode(child) ? selection.$sliceSelectedTextNodeContent(selection$1, child, 'clone') : child;
+  }
+
+  /**
+   * Whether `node` or any descendant is selected. See
+   * {@link MdastExportContext.isIncluded}.
+   */
+  function $isIncluded(node) {
+    if (selection$1 === null || node.isSelected(selection$1)) {
+      return true;
+    }
+    if (lexical.$isElementNode(node)) {
+      for (const child of node.getChildren()) {
+        if ($isIncluded(child)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Dispatches an element child, appending its output to `out` unless a
+   * selection is active and neither the element nor any descendant is
+   * selected.
+   */
+  function $dispatchElement(child, out) {
+    const selfSelected = selection$1 !== null && child.isSelected(selection$1);
+    if (selfSelected) {
+      selectionHits++;
+    }
+    const before = selectionHits;
+    const result = $dispatch(child);
+    if (selection$1 === null || selfSelected || selectionHits > before) {
+      out.push(...result);
+    }
+  }
+  const context = {
+    exportBlocks: node => $exportBlocks(node),
+    exportChildren: node => {
+      const out = [];
+      for (const child of node.getChildren()) {
+        const target = $filterChild(child);
+        if (target === null) {
+          continue;
+        }
+        if (lexical.$isElementNode(target)) {
+          $dispatchElement(target, out);
+        } else {
+          out.push(...$dispatch(target));
+        }
+      }
+      return out;
+    },
+    exportInline: node => $exportInline(node),
+    isIncluded: $isIncluded
+  };
+  function $dispatch(node) {
+    const handler = exportHandlers.get(node.getType());
+    if (handler) {
+      const result = handler(node, context);
+      if (result != null) {
+        return Array.isArray(result) ? result : [result];
+      }
+    }
+    // Fallbacks keep unknown nodes from disappearing entirely; text and line
+    // breaks reuse the core handlers so their behavior can't drift.
+    const asText = exportText(node);
+    if (asText !== null) {
+      return [asText];
+    }
+    const asBreak = $exportLineBreak(node);
+    if (asBreak !== null) {
+      return [asBreak];
+    }
+    if (lexical.$isElementNode(node)) {
+      return context.exportChildren(node);
+    }
+    const text = node.getTextContent();
+    return text ? [{
+      type: 'text',
+      value: text
+    }] : [];
+  }
+
+  /**
+   * Converts the inline children of `node` into phrasing content.
+   */
+  function $exportInline(node) {
+    const result = [];
+    const runs = new TextRunAccumulator();
+    for (const child of node.getChildren()) {
+      const target = $filterChild(child);
+      if (target === null) {
+        continue;
+      }
+      if (!(mayAccumulate(target) && runs.push(target, result))) {
+        runs.flushInto(result);
+        if (lexical.$isElementNode(target)) {
+          // The registry erases types; phrasing output is the dispatch
+          // contract for inline children.
+          $dispatchElement(target, result);
+        } else {
+          result.push(...$dispatch(target));
+        }
+      }
+    }
+    runs.flushInto(result);
+    return result;
+  }
+
+  /**
+   * Converts a container whose Lexical children are inline (block quote, list
+   * item) into mdast block content. A LineBreakNode marked as a paragraph
+   * boundary (set by the import handlers when joining sibling paragraphs)
+   * splits the content; any other LineBreakNode stays an inline `break`
+   * (hard or soft according to its marker). Nested block children pass
+   * through directly.
+   */
+  function $exportBlocks(node) {
+    const blocks = [];
+    let inline = [];
+    const runs = new TextRunAccumulator();
+    const flushParagraph = () => {
+      runs.flushInto(inline);
+      if (inline.length > 0) {
+        blocks.push({
+          children: inline,
+          type: 'paragraph'
+        });
+        inline = [];
+      }
+    };
+    for (const child of node.getChildren()) {
+      const target = $filterChild(child);
+      if (target === null) {
+        continue;
+      }
+      if (lexical.$isLineBreakNode(target)) {
+        const asBreak = $exportLineBreak(target);
+        if (lexical.$getState(target, paragraphBreakState) || asBreak === null) {
+          flushParagraph();
+        } else {
+          runs.flushInto(inline);
+          inline.push(asBreak);
+        }
+      } else if (mayAccumulate(target) && runs.push(target, inline)) {
+        continue;
+      } else if ($isBlockLevelNode(target)) {
+        flushParagraph();
+        if (lexical.$isElementNode(target)) {
+          // The registry erases types; block-level output is the dispatch
+          // contract for block children.
+          $dispatchElement(target, blocks);
+        } else {
+          blocks.push(...$dispatch(target));
+        }
+      } else if (lexical.$isElementNode(target)) {
+        runs.flushInto(inline);
+        $dispatchElement(target, inline);
+      } else {
+        runs.flushInto(inline);
+        inline.push(...$dispatch(target));
+      }
+    }
+    flushParagraph();
+    if (blocks.length === 0) {
+      blocks.push({
+        children: [],
+        type: 'paragraph'
+      });
+    }
+    return blocks;
+  }
+  return {
+    exportChildren: context.exportChildren
+  };
+}
+
+/**
+ * Picks the document-level emphasis and strong delimiters from the first
+ * italic / bold text node that recorded a known delimiter on import, scanning
+ * the tree rooted at `node`. Mixing delimiters within one document is not
+ * supported by to-markdown's escaping, so a single choice is made per
+ * document; nodes with no recorded delimiter (created in the editor) are
+ * skipped so they cannot mask the document's authored style.
+ */
+function $dominantInlineMarkers(node) {
+  let emphasis;
+  let strong;
+  const visit = element => {
+    for (const child of element.getChildren()) {
+      if (lexical.$isTextNode(child)) {
+        if (emphasis === undefined && child.hasFormat('italic')) {
+          const marker = lexical.$getState(child, emphasisMarkerState);
+          if (marker === '_') {
+            emphasis = '_';
+          }
+        }
+        if (strong === undefined && child.hasFormat('bold')) {
+          const marker = lexical.$getState(child, strongMarkerState);
+          if (marker === '_') {
+            strong = '_';
+          }
+        }
+      } else if (lexical.$isElementNode(child)) {
+        visit(child);
+      }
+      if (emphasis !== undefined && strong !== undefined) {
+        return;
+      }
+    }
+  };
+  visit(node);
+  return {
+    emphasis,
+    strong
+  };
+}
+
+/**
+ * Creates a reusable exporter that converts the Lexical tree rooted at the
+ * supplied element (or the editor root) — or just the selected content —
+ * into a Markdown string.
+ */
+function createMdastExport(compiled) {
+  // The unfiltered exporter has no per-call state and is shared by every
+  // whole-document export; selection exports build a fresh one per call.
+  const documentExporter = createNodeExporter(compiled);
+  const $toMdast = (root, exporter) => ({
+    // The registry erases types; root-level output is the dispatch contract
+    // for top-level children.
+    children: exporter.exportChildren(root),
+    type: 'root'
+  });
+  const $serialize = (tree, root) => {
+    // Emphasis/strong delimiters are document-level; the delimiter recorded on
+    // import wins, otherwise contributed toMarkdownExtensions (and the '-'
+    // bullet baseline) decide. Defaults ride as the FIRST extension so that
+    // contributed extensions can override them; SYNTAX_TO_MARKDOWN runs last
+    // so its handlers reproduce the per-node syntax captured on import.
+    const {
+      emphasis,
+      strong
+    } = $dominantInlineMarkers(root);
+    const defaults = {
+      bullet: '-'
+    };
+    if (emphasis) {
+      defaults.emphasis = emphasis;
+    }
+    if (strong) {
+      defaults.strong = strong;
+    }
+    const out = mdastUtilToMarkdown.toMarkdown(tree, {
+      extensions: [defaults, ...compiled.toMarkdownExtensions, SYNTAX_TO_MARKDOWN]
+    });
+    // toMarkdown always appends a trailing newline; drop it so callers get the
+    // same shape as `@lexical/markdown`'s `$convertToMarkdownString`.
+    return out.replace(/\n$/, '');
+  };
+  const $exportToMdast = node => $toMdast(node || lexical.$getRoot(), documentExporter);
+  const $exportToMarkdown = node => {
+    const root = node || lexical.$getRoot();
+    return $serialize($toMdast(root, documentExporter), root);
+  };
+  const $exportSelectionToMarkdown = (selection = lexical.$getSelection()) => {
+    if (selection === null || lexical.$isRangeSelection(selection) && selection.isCollapsed()) {
+      return '';
+    }
+    const root = lexical.$getRoot();
+    return $serialize($toMdast(root, createNodeExporter(compiled, selection)), root);
+  };
+  return {
+    $exportSelectionToMarkdown,
+    $exportToMarkdown,
+    $exportToMdast
+  };
+}
+
+/**
+ * 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.
+ *
+ */
+
+/**
+ * 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`.
+ */
+function compileMdast(config) {
+  const importHandlers = new Map();
+  const exportHandlers = new Map();
+  for (const rule of config.importRules) {
+    if (!importHandlers.has(rule.type)) {
+      importHandlers.set(rule.type, rule.$import);
+    }
+  }
+  for (const rule of config.exportRules) {
+    if (!exportHandlers.has(rule.type)) {
+      exportHandlers.set(rule.type, rule.$export);
+    }
+  }
+  return {
+    exportHandlers,
+    importHandlers,
+    inlineShortcutTriggers: new Set(config.inlineShortcutTriggers),
+    inlineShortcutTypes: new Set(config.inlineShortcutTypes),
+    mdastExtensions: [...config.mdastExtensions],
+    micromarkExtensions: [...config.micromarkExtensions],
+    toMarkdownExtensions: [...config.toMarkdownExtensions]
+  };
+}
+
+/**
+ * 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.
+ *
+ */
+
+
+/**
+ * Splits `value` into a run of `TextNode`s via {@link tokenizeRawText}:
+ * `\n` becomes a `LineBreakNode` and `\t` a `TabNode` (matching how typed
+ * content is represented in the editor), with `format` applied to each text
+ * segment. Empty segments are dropped so a leading/trailing/standalone
+ * separator yields only its node.
+ */
+function $createTextNodes(value, format) {
+  const out = [];
+  lexical.tokenizeRawText(value, {
+    linebreak: () => out.push(lexical.$createLineBreakNode()),
+    tab: () => out.push(lexical.$createTabNode()),
+    text: segment => {
+      const textNode = lexical.$createTextNode(segment);
+      if (format) {
+        textNode.setFormat(format);
+      }
+      out.push(textNode);
+    }
+  });
+  return out;
+}
+
+/** A resolved `[identifier]: url "title"` definition. */
+
+/**
+ * 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.
+ */
+function collectDefinitions(tree) {
+  const definitions = new Map();
+  const visit = node => {
+    if (node.type === 'definition') {
+      // CommonMark: the FIRST definition of an identifier wins.
+      if (!definitions.has(node.identifier)) {
+        definitions.set(node.identifier, {
+          title: node.title,
+          url: node.url
+        });
+      }
+    }
+    if ('children' in node) {
+      for (const child of node.children) {
+        visit(child);
+      }
+    }
+  };
+  visit(tree);
+  return definitions;
+}
+const NO_DEFINITIONS = new Map();
+
+/**
+ * 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.
+ */
+function createNodeImporter(compiled, source = '', definitions = NO_DEFINITIONS) {
+  const {
+    importHandlers
+  } = compiled;
+  // The context only depends on the accumulated format bitmask, which takes a
+  // handful of distinct values per document — cache instead of allocating one
+  // (plus three closures) per visited node.
+  const contextByFormat = new Map();
+  function getContext(format) {
+    let context = contextByFormat.get(format);
+    if (context === undefined) {
+      context = {
+        createText: (value, fmt) => $createTextNodes(value, fmt == null ? format : fmt),
+        format,
+        getDefinition: identifier => definitions.get(identifier),
+        importChildren: (parent, extra) => $importChildren(parent, format | (extra || 0)),
+        importNode: (node, extra) => $importNode(node, format | (extra || 0)),
+        source
+      };
+      contextByFormat.set(format, context);
+    }
+    return context;
+  }
+  function $importNode(node, format) {
+    const handler = importHandlers.get(node.type);
+    if (handler) {
+      const result = handler(node, getContext(format));
+      if (result == null) {
+        return [];
+      }
+      return Array.isArray(result) ? result : [result];
+    }
+    // Fallback: unwrap unknown containers, render unknown literals as text, and
+    // drop anything else so no content silently corrupts the tree.
+    if ('children' in node) {
+      return $importChildren(node, format);
+    }
+    if ('value' in node && typeof node.value === 'string') {
+      return $createTextNodes(node.value, format);
+    }
+    return [];
+  }
+  function $importChildren(parent, format) {
+    const out = [];
+    for (const child of parent.children) {
+      out.push(...$importNode(child, format));
+    }
+    return out;
+  }
+  return {
+    $importChildren,
+    $importNode
+  };
+}
+
+/**
+ * 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.
+ */
+function createMdastImport(compiled) {
+  const $generateNodes = (tree, source) => {
+    const {
+      $importNode
+    } = createNodeImporter(compiled, source, collectDefinitions(tree));
+
+    // Top-level mdast children should produce block-level Lexical nodes. Any
+    // stray inline content (e.g. from a fallback) is wrapped in a paragraph
+    // so the result only ever contains valid block children.
+    const blocks = [];
+    let pendingParagraph = null;
+    const flushPending = () => {
+      if (pendingParagraph) {
+        blocks.push(pendingParagraph);
+        pendingParagraph = null;
+      }
+    };
+    for (const child of tree.children) {
+      for (const lexicalNode of $importNode(child, 0)) {
+        if ($isBlockLevelNode(lexicalNode)) {
+          flushPending();
+          blocks.push(lexicalNode);
+        } else {
+          if (!pendingParagraph) {
+            pendingParagraph = lexical.$createParagraphNode();
+          }
+          $append(pendingParagraph, [lexicalNode]);
+        }
+      }
+    }
+    flushPending();
+    return blocks;
+  };
+  const $generateNodesFromMarkdown = markdown => $generateNodes(mdastUtilFromMarkdown.fromMarkdown(markdown, {
+    extensions: compiled.micromarkExtensions,
+    mdastExtensions: compiled.mdastExtensions
+  }), markdown);
+  const $generateNodesFromMdast = tree => $generateNodes(tree, '');
+  const $replaceWithBlocks = (blocks, node) => {
+    const root = node || lexical.$getRoot();
+    root.clear();
+    $prepend(root, blocks.length > 0 ? blocks : [lexical.$createParagraphNode()]);
+    if (lexical.$getSelection() !== null) {
+      root.selectStart();
+    }
+  };
+  return {
+    $generateNodesFromMarkdown,
+    $generateNodesFromMdast,
+    $importMarkdown: (markdown, node) => $replaceWithBlocks($generateNodesFromMarkdown(markdown), node),
+    $importMdast: (tree, node) => $replaceWithBlocks($generateNodesFromMdast(tree), node)
+  };
+}
+
+/**
+ * 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.
+ *
+ */
+
+/**
+ * Returns the offset of the first content character inside a block construct,
+ * i.e. the length of the leading block marker (`"## "`, `"- "`, `"> "`, ...).
+ * When the construct has no content yet (the user has only typed the marker)
+ * the whole `line` is the marker.
+ *
+ * The walk descends through *container* levels only (blockquote -> paragraph,
+ * list -> listItem -> paragraph) and stops at the first inline child of a
+ * paragraph or heading — descending further would treat inline delimiters
+ * (`**`, `[`, `` ` ``) as part of the block marker.
+ */
+function contentStartOffset(node, line) {
+  let current = node;
+  for (;;) {
+    if (current.type === 'heading' || current.type === 'paragraph') {
+      const first = current.children[0];
+      return first && first.position && first.position.start.offset != null ? first.position.start.offset : line.length;
+    }
+    if (!('children' in current) || current.children.length === 0) {
+      return line.length;
+    }
+    current = current.children[0];
+  }
+}
+
+/**
+ * `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`.
+ */
+class MarkdownStreamScanner {
+  compiled;
+  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.
+   */
+  supportsTaskListItems;
+  constructor(compiled) {
+    this.compiled = compiled;
+    this.importNode = createNodeImporter(compiled, '').$importNode;
+    const probe = this.parse('- [x] a').children[0];
+    this.supportsTaskListItems = probe != null && probe.type === 'list' && probe.children[0].checked === true;
+  }
+
+  /** Characters that can close an inline construct for this registry. */
+  get inlineTriggers() {
+    return this.compiled.inlineShortcutTriggers;
+  }
+  parse(value) {
+    return mdastUtilFromMarkdown.fromMarkdown(value, {
+      extensions: this.compiled.micromarkExtensions,
+      mdastExtensions: this.compiled.mdastExtensions
+    });
+  }
+
+  /**
+   * Materializes an mdast inline node into Lexical nodes using the same
+   * import handlers as the full-document importer.
+   */
+  importInline(node) {
+    return this.importNode(node, 0);
+  }
+
+  /**
+   * Recognizes a block-level construct at the start of `line`. Returns the
+   * matched construct together with the marker length, or `null`.
+   */
+  scanBlock(line) {
+    if (line.trim() === '') {
+      return null;
+    }
+    const first = this.parse(line).children[0];
+    // Only offer shortcuts for constructs the registry can actually import:
+    // in a granular setup (e.g. no blockquote extension) the syntax should
+    // stay literal rather than materialize an unregistered node.
+    if (!first || !this.compiled.importHandlers.has(first.type)) {
+      return null;
+    }
+    switch (first.type) {
+      case 'heading':
+        return {
+          kind: 'heading',
+          markerLength: contentStartOffset(first, line),
+          node: first
+        };
+      case 'blockquote':
+        return {
+          kind: 'blockquote',
+          markerLength: contentStartOffset(first, line),
+          node: first
+        };
+      case 'list':
+        return {
+          kind: 'list',
+          markerLength: contentStartOffset(first, line),
+          node: first
+        };
+      case 'code':
+        // A code construct recognized from a single line is just the opening
+        // fence (possibly with a language); the entire line is the marker.
+        return {
+          kind: 'code',
+          markerLength: line.length,
+          node: first
+        };
+      default:
+        return 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) {
+    if (value.length === 0) {
+      return null;
+    }
+    const tree = this.parse(value);
+    const lastBlock = tree.children[tree.children.length - 1];
+    if (!lastBlock || lastBlock.type !== 'paragraph') {
+      return null;
+    }
+    const last = lastBlock.children[lastBlock.children.length - 1];
+    if (!last || !last.position || last.position.end.offset !== value.length || !this.compiled.inlineShortcutTypes.has(last.type)) {
+      return null;
+    }
+    // Guard against firing mid-delimiter: while typing `**bold*` the parser
+    // briefly sees emphasis (`*bold*`) closing at the caret with a stray `*`
+    // in front. If the opening delimiter is immediately preceded by the same
+    // delimiter character, defer until the user finishes the longer run.
+    const start = last.position.start.offset ?? 0;
+    const openChar = value[start];
+    if (start > 0 && value[start - 1] === openChar && this.compiled.inlineShortcutTriggers.has(openChar)) {
+      return null;
+    }
+    return last;
+  }
+}
+
+/**
+ * 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.
+ *
+ */
+
+
+/**
+ * Block markers are at most a few characters (`'###### '`, `'   999. '`,
+ * `'- [x] '`); when the caret is past this column a space cannot complete a
+ * block marker, so the micromark scan is skipped entirely.
+ */
+const MAX_BLOCK_MARKER_LENGTH = 24;
+
+/** Removes the first `n` characters from the leading text nodes of `element`. */
+function $stripLeading(element, n) {
+  let remaining = n;
+  let child = element.getFirstChild();
+  while (remaining > 0 && child) {
+    if (!lexical.$isTextNode(child)) {
+      break;
+    }
+    const text = child.getTextContent();
+    if (text.length <= remaining) {
+      const next = child.getNextSibling();
+      remaining -= text.length;
+      child.remove();
+      child = next;
+    } else {
+      child.setTextContent(text.slice(remaining));
+      remaining = 0;
+    }
+  }
+}
+
+/**
+ * Replaces `paragraph` with the block construct described by `match`, keeping
+ * the content that followed the marker.
+ */
+function $applyBlock(paragraph, match) {
+  // Capture the fence before the marker is stripped from the paragraph.
+  const fence = match.kind === 'code' ? paragraph.getTextContent().match(/^[ \t]*(`{3,}|~{3,})/) : null;
+  $stripLeading(paragraph, match.markerLength);
+  const remaining = paragraph.getChildren();
+  if (match.kind === 'code') {
+    const code = codeCore.$createCodeNode(match.node.lang || undefined);
+    // Keep the typed fence and info-string tail so export reproduces them.
+    if (fence) {
+      lexical.$setState(code, codeFenceState, fence[1]);
+    }
+    if (match.node.meta) {
+      lexical.$setState(code, codeMetaState, match.node.meta);
+    }
+    $append(code, remaining);
+    paragraph.replace(code);
+    code.selectStart();
+    return true;
+  }
+  let target;
+  let selectInto;
+  if (match.kind === 'heading') {
+    const heading = $append(richText.$createHeadingNode(`h${match.node.depth}`), remaining);
+    target = heading;
+    selectInto = heading;
+  } else if (match.kind === 'blockquote') {
+    const quote = $append(richText.$createQuoteNode(), remaining);
+    target = quote;
+    selectInto = quote;
+  } else {
+    const listNode = match.node;
+    const listType = $listTypeFromMdast(listNode);
+    const start = listNode.ordered && listNode.start != null ? listNode.start : 1;
+    const list$1 = list.$createListNode(listType, start);
+    const firstItem = listNode.children[0];
+    const checked = firstItem && firstItem.type === 'listItem' && typeof firstItem.checked === 'boolean' ? firstItem.checked : undefined;
+    const item = $append(list.$createListItemNode(checked), remaining);
+    $append(list$1, [item]);
+    target = list$1;
+    selectInto = item;
+  }
+  paragraph.replace(target);
+  selectInto.selectStart();
+  return true;
+}
+
+/**
+ * Cheap check that `text` (up to the caret) could plausibly contain a closed
+ * inline construct ending in `closeChar`, before paying for a micromark parse.
+ * A closing `)` needs a `](` link infix; any other delimiter needs an earlier
+ * occurrence of itself to act as the opener.
+ */
+function mayCloseInlineConstruct(text, closeChar) {
+  return closeChar === ')' ? text.lastIndexOf('](') > 0 : text.lastIndexOf(closeChar, text.length - 2) !== -1;
+}
+
+/**
+ * Materializes the inline construct ending at `anchorOffset` inside
+ * `anchorNode`, replacing the raw markdown span with formatted Lexical nodes.
+ */
+function $applyInline(anchorNode, anchorOffset, scanner) {
+  const upTo = anchorNode.getTextContent().slice(0, anchorOffset);
+  const inlineNode = scanner.scanInline(upTo);
+  if (!inlineNode || !inlineNode.position) {
+    return false;
+  }
+  const start = inlineNode.position.start.offset ?? 0;
+  const end = anchorOffset;
+  let target;
+  if (start <= 0) {
+    [target] = anchorNode.splitText(end);
+  } else {
+    const parts = anchorNode.splitText(start, end);
+    target = parts.length === 3 ? parts[1] : parts[parts.length - 1];
+  }
+  const lexicalNodes = scanner.importInline(inlineNode);
+  if (lexicalNodes.length === 0) {
+    return false;
+  }
+  let prev = lexicalNodes[0];
+  target.replace(prev);
+  for (let i = 1; i < lexicalNodes.length; i++) {
+    prev.insertAfter(lexicalNodes[i]);
+    prev = lexicalNodes[i];
+  }
+  if (lexical.$isTextNode(prev)) {
+    const size = prev.getTextContentSize();
+    prev.select(size, size);
+  } else {
+    prev.selectNext(0, 0);
+  }
+  return true;
+}
+
+/**
+ * Matches a GFM task-list checkbox marker (`[ ] `, `[x] `) typed at line
+ * start. Exactly one character is required between the brackets, matching
+ * micromark's gfm-task-list-item grammar — `[]` is not a checkbox.
+ */
+const CHECKBOX_REGEX = /^\[([ xX])\]\s$/;
+
+/**
+ * Handles a checkbox marker typed at the start of a line. micromark only
+ * recognizes a task-list item once it already has a list-item prefix, so by
+ * the time the user types `[ ] ` the paragraph is usually already a bullet
+ * list item (from the earlier `- ` shortcut). This promotes that item — or a
+ * bare paragraph — to a Lexical check list.
+ */
+function $tryCheckbox(anchorNode, parent, anchorOffset) {
+  if (parent.getFirstChild() !== anchorNode) {
+    return false;
+  }
+  const prefix = parent.getTextContent().slice(0, anchorOffset);
+  const match = prefix.match(CHECKBOX_REGEX);
+  if (!match) {
+    return false;
+  }
+  const checked = match[1].toLowerCase() === 'x';
+  if (list.$isListItemNode(parent)) {
+    const list$1 = parent.getParent();
+    if (!list.$isListNode(list$1) || list$1.getListType() === 'number') {
+      return false;
+    }
+    $stripLeading(parent, match[0].length);
+    list$1.setListType('check');
+    parent.setChecked(checked);
+    return true;
+  }
+  if ($isShortcutParagraph(parent, anchorNode)) {
+    $stripLeading(parent, match[0].length);
+    const remaining = parent.getChildren();
+    const list$1 = list.$createListNode('check');
+    const item = $append(list.$createListItemNode(checked), remaining);
+    $append(list$1, [item]);
+    parent.replace(list$1);
+    item.selectStart();
+    return true;
+  }
+  return false;
+}
+function $isShortcutParagraph(node, anchorNode) {
+  return lexical.$isParagraphNode(node) && lexical.$isRootOrShadowRoot(node.getParent()) && node.getFirstChild() === anchorNode;
+}
+
+/**
+ * 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.
+ */
+function registerMarkdownShortcuts(editor, compiled) {
+  const scanner = new MarkdownStreamScanner(compiled);
+  const inlineTriggers = scanner.inlineTriggers;
+  // Composition end fires per IME commit (every CJK syllable, dead-key
+  // resolve, ...). Only enter the transformer pass when the just-committed
+  // character can plausibly close a trigger.
+  const compositionEndTriggers = new Set([' ', ...inlineTriggers]);
+  return lexical.mergeRegister(editor.registerUpdateListener(({
+    tags,
+    dirtyLeaves,
+    editorState,
+    prevEditorState
+  }) => {
+    // Ignore updates from collaboration and undo/redo (changes already
+    // calculated), and anything that dirtied no leaves (pure selection
+    // moves) before paying for any editor-state reads.
+    if (dirtyLeaves.size === 0 || tags.has(lexical.COLLABORATION_TAG) || tags.has(lexical.HISTORIC_TAG)) {
+      return;
+    }
+    // If the editor is still composing we must wait for the commit.
+    if (editor.isComposing()) {
+      return;
+    }
+    // A composition commit lands without moving the selection (and may
+    // commit several characters at once), so it bypasses the typed-one-
+    // character heuristics below.
+    const isCompositionEnd = tags.has(lexical.COMPOSITION_END_TAG);
+    const selection = editorState.read(lexical.$getSelection);
+    const prevSelection = prevEditorState.read(lexical.$getSelection);
+    if (!lexical.$isRangeSelection(selection) || !lexical.$isRangeSelection(prevSelection) || !selection.isCollapsed() || selection.is(prevSelection) && !isCompositionEnd) {
+      return;
+    }
+    const anchorKey = selection.anchor.key;
+    const anchorOffset = selection.anchor.offset;
+    const anchorNode = editorState._nodeMap.get(anchorKey);
+    if (!lexical.$isTextNode(anchorNode) || !dirtyLeaves.has(anchorKey)) {
+      return;
+    }
+    // Only react to a single typed character: the caret must have
+    // advanced exactly one position (or sit right after the first
+    // character of a fresh node). This keeps paste, drag-drop, and
+    // deletions — which can leave the caret after a delimiter — from
+    // firing destructive transforms.
+    if (!isCompositionEnd && anchorOffset !== 1 && !(prevSelection.anchor.key === anchorKey && anchorOffset === prevSelection.anchor.offset + 1)) {
+      return;
+    }
+    const textContent = editorState.read(() => anchorNode.getTextContent());
+    const typedChar = textContent[anchorOffset - 1];
+    if (isCompositionEnd && !compositionEndTriggers.has(typedChar)) {
+      return;
+    }
+    if (typedChar !== ' ' && !inlineTriggers.has(typedChar)) {
+      return;
+    }
+    // Cheap prefilter: an inline construct needs an opener earlier in the
+    // text; skip the micromark parse when there is none.
+    if (typedChar !== ' ' && !mayCloseInlineConstruct(textContent.slice(0, anchorOffset), typedChar)) {
+      return;
+    }
+    editor.update(() => {
+      const node = lexical.$getNodeByKey(anchorKey);
+      if (!lexical.$isTextNode(node) || node.hasFormat('code')) {
+        // Per CommonMark, code spans take precedence over any other
+        // inline construct; never transform inside one.
+        return;
+      }
+      const parent = node.getParent();
+      if (parent === null || codeCore.$isCodeNode(parent)) {
+        return;
+      }
+      let transformed = false;
+      if (typedChar === ' ') {
+        if (scanner.supportsTaskListItems && $tryCheckbox(node, parent, anchorOffset)) {
+          transformed = true;
+        } else if (anchorOffset <= MAX_BLOCK_MARKER_LENGTH && $isShortcutParagraph(parent, node)) {
+          // The marker must end exactly at the caret, so scanning the
+          // prefix is sufficient (and cheaper than the whole line).
+          const match = scanner.scanBlock(node.getTextContent().slice(0, anchorOffset));
+          if (match && match.kind !== 'code' && match.markerLength === anchorOffset) {
+            transformed = $applyBlock(parent, match);
+          }
+        }
+      } else {
+        transformed = $applyInline(node, anchorOffset, scanner);
+      }
+      if (transformed) {
+        lexical.$addUpdateTag(lexical.HISTORY_PUSH_TAG);
+      }
+    });
+  }), editor.registerCommand(lexical.KEY_ENTER_COMMAND, event => {
+    if (event !== null && event.shiftKey) {
+      return false;
+    }
+    const selection = lexical.$getSelection();
+    if (!lexical.$isRangeSelection(selection) || !selection.isCollapsed()) {
+      return false;
+    }
+    const anchorNode = selection.anchor.getNode();
+    if (!lexical.$isTextNode(anchorNode) || anchorNode.hasFormat('code')) {
+      return false;
+    }
+    const parent = anchorNode.getParent();
+    const anchorOffset = selection.anchor.offset;
+    if (parent === null || codeCore.$isCodeNode(parent) || !$isShortcutParagraph(parent, anchorNode) || anchorOffset !== anchorNode.getTextContentSize()) {
+      return false;
+    }
+    const match = scanner.scanBlock(parent.getTextContent());
+    // Only convert when the whole line is the marker (`## `, `- `,
+    // '```lang title=x'). A line with content after the marker was either
+    // already converted at the trailing space, or deliberately reverted
+    // with undo — Enter must not re-convert it.
+    if (match && match.markerLength === anchorOffset && $applyBlock(parent, match)) {
+      if (event !== null) {
+        event.preventDefault();
+      }
+      return true;
+    }
+    return false;
+  },
+  // The lowest priority that still pre-empts the default rich-text Enter
+  // handler: prepended to the editor-priority queue, so every listener at
+  // LOW and above (and none of the defaults) runs first.
+  lexical.COMMAND_PRIORITY_BEFORE_EDITOR));
+}
+
+/**
+ * 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.
+ *
+ */
+
+
+/**
+ * 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
+ */
+
+/**
+ * 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
+ */
+
+// The baseline rules that need no node packages: paragraphs and inline text
+// formatting (CommonMark handles these without any micromark extension).
+const CORE_IMPORT_RULES = [{
+  $import: $importParagraph,
+  type: 'paragraph'
+}, {
+  $import: importText,
+  type: 'text'
+}, {
+  $import: importHtml,
+  type: 'html'
+}, {
+  $import: importInlineCode,
+  type: 'inlineCode'
+}, {
+  $import: $importEmphasis,
+  type: 'emphasis'
+}, {
+  $import: $importStrong,
+  type: 'strong'
+}, {
+  $import: $importBreak,
+  type: 'break'
+}];
+const CORE_EXPORT_RULES = [{
+  $export: exportParagraph,
+  type: 'paragraph'
+}, {
+  $export: exportText,
+  type: 'text'
+}, {
+  $export: $exportLineBreak,
+  type: 'linebreak'
+}, {
+  $export: exportTab,
+  type: 'tab'
+}];
+
+/**
+ * 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
+ */
+const MdastImportExtension = /* @__PURE__ */lexical.defineExtension({
+  build(editor, config) {
+    const registry = compileMdast(config);
+    const {
+      $generateNodesFromMarkdown,
+      $generateNodesFromMdast: $generateNodesFromTree,
+      $importMarkdown,
+      $importMdast
+    } = createMdastImport(registry);
+    return {
+      $convertFromMarkdownString: $importMarkdown,
+      $convertFromMdast: $importMdast,
+      $generateNodesFromMarkdownString: $generateNodesFromMarkdown,
+      $generateNodesFromMdast: $generateNodesFromTree,
+      registry
+    };
+  },
+  config: /* @__PURE__ */lexical.safeCast({
+    exportRules: CORE_EXPORT_RULES,
+    importRules: CORE_IMPORT_RULES,
+    // Core CommonMark inline formatting; feature extensions contribute
+    // their own types/triggers (links add 'link'/')', strikethrough adds
+    // 'delete'/'~').
+    inlineShortcutTriggers: ['*', '_', '`'],
+    inlineShortcutTypes: ['emphasis', 'inlineCode', 'strong'],
+    mdastExtensions: [],
+    micromarkExtensions: [],
+    toMarkdownExtensions: []
+  }),
+  mergeConfig(config, partial) {
+    // Prepend contributed rules so extensions merged later (closer to the
+    // editor root) take priority, matching DOMImportExtension's convention.
+    // Every key is set explicitly so an explicitly-undefined key in `partial`
+    // (allowed by Partial<MdastConfig>) can never clobber the merged arrays.
+    function mergeArray(contributed, existing) {
+      return contributed ? [...contributed, ...existing] : existing;
+    }
+    return lexical.shallowMergeConfig(config, {
+      exportRules: mergeArray(partial.exportRules, config.exportRules),
+      importRules: mergeArray(partial.importRules, config.importRules),
+      inlineShortcutTriggers: mergeArray(partial.inlineShortcutTriggers, config.inlineShortcutTriggers),
+      inlineShortcutTypes: mergeArray(partial.inlineShortcutTypes, config.inlineShortcutTypes),
+      mdastExtensions: mergeArray(partial.mdastExtensions, config.mdastExtensions),
+      micromarkExtensions: mergeArray(partial.micromarkExtensions, config.micromarkExtensions),
+      toMarkdownExtensions: mergeArray(partial.toMarkdownExtensions, config.toMarkdownExtensions)
+    });
+  },
+  name: '@lexical/mdast/Import'
+});
+
+/**
+ * ATX (`# …`) and setext headings, shipping {@link HeadingNode}.
+ * @experimental
+ */
+const MdastHeadingExtension = /* @__PURE__ */lexical.defineExtension({
+  dependencies: [/* @__PURE__ */lexical.configExtension(MdastImportExtension, {
+    exportRules: [{
+      $export: $exportHeading,
+      type: 'heading'
+    }],
+    importRules: [{
+      $import: $importHeading,
+      type: 'heading'
+    }]
+  })],
+  name: '@lexical/mdast/Heading',
+  nodes: [richText.HeadingNode]
+});
+
+/**
+ * Block quotes (`> …`), shipping {@link QuoteNode}. For blockquotes that hold
+ * block-level children (nested lists, code, quotes) with full fidelity, add
+ * {@link MdastShadowRootQuoteExtension}.
+ * @experimental
+ */
+const MdastBlockquoteExtension = /* @__PURE__ */lexical.defineExtension({
+  dependencies: [/* @__PURE__ */lexical.configExtension(MdastImportExtension, {
+    exportRules: [{
+      $export: exportQuote,
+      type: 'quote'
+    }],
+    importRules: [{
+      $import: $importBlockquote,
+      type: 'blockquote'
+    }]
+  })],
+  name: '@lexical/mdast/Blockquote',
+  nodes: [richText.QuoteNode]
+});
+
+/**
+ * Convenience bundle of {@link MdastHeadingExtension} and
+ * {@link MdastBlockquoteExtension} — the constructs backed by
+ * `@lexical/rich-text` nodes.
+ * @experimental
+ */
+const MdastRichTextExtension = /* @__PURE__ */lexical.defineExtension({
+  dependencies: [MdastHeadingExtension, MdastBlockquoteExtension],
+  name: '@lexical/mdast/RichText'
+});
+
+/**
+ * Ordered and unordered lists, shipping {@link ListNode} and
+ * {@link ListItemNode}. For GFM task lists (`- [x] …`) add
+ * {@link MdastTaskListExtension}.
+ * @experimental
+ */
+const MdastListExtension = /* @__PURE__ */lexical.defineExtension({
+  dependencies: [/* @__PURE__ */lexical.configExtension(MdastImportExtension, {
+    exportRules: [{
+      $export: $exportList,
+      type: 'list'
+    }],
+    importRules: [{
+      $import: $importList,
+      type: 'list'
+    }, {
+      $import: $importListItem,
+      type: 'listItem'
+    }]
+  })],
+  name: '@lexical/mdast/List',
+  nodes: [list.ListNode, list.ListItemNode]
+});
+
+/**
+ * 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
+ */
+const MdastTaskListExtension = /* @__PURE__ */lexical.defineExtension({
+  dependencies: [MdastListExtension, /* @__PURE__ */lexical.configExtension(MdastImportExtension, {
+    mdastExtensions: [/* @__PURE__ */mdastUtilGfmTaskListItem.gfmTaskListItemFromMarkdown()],
+    micromarkExtensions: [/* @__PURE__ */micromarkExtensionGfmTaskListItem.gfmTaskListItem()],
+    toMarkdownExtensions: [/* @__PURE__ */mdastUtilGfmTaskListItem.gfmTaskListItemToMarkdown()]
+  })],
+  name: '@lexical/mdast/TaskList'
+});
+
+/**
+ * Fenced and indented code blocks, shipping {@link CodeNode}.
+ * @experimental
+ */
+const MdastCodeExtension = /* @__PURE__ */lexical.defineExtension({
+  dependencies: [/* @__PURE__ */lexical.configExtension(MdastImportExtension, {
+    exportRules: [{
+      $export: $exportCode,
+      type: 'code'
+    }],
+    importRules: [{
+      $import: $importCode,
+      type: 'code'
+    }]
+  })],
+  name: '@lexical/mdast/Code',
+  nodes: [codeCore.CodeNode]
+});
+
+/**
+ * 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
+ */
+const MdastLinkExtension = /* @__PURE__ */lexical.defineExtension({
+  dependencies: [/* @__PURE__ */lexical.configExtension(MdastImportExtension, {
+    exportRules: [{
+      $export: $exportLink,
+      type: 'link'
+    }],
+    importRules: [{
+      $import: $importLink,
+      type: 'link'
+    }, {
+      $import: $importLinkReference,
+      type: 'linkReference'
+    }, {
+      $import: importDefinition,
+      type: 'definition'
+    }],
+    inlineShortcutTriggers: [')'],
+    inlineShortcutTypes: ['link']
+  })],
+  name: '@lexical/mdast/Link',
+  nodes: [link.LinkNode]
+});
+
+/**
+ * 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
+ */
+const MdastAutolinkLiteralExtension = /* @__PURE__ */lexical.defineExtension({
+  dependencies: [MdastLinkExtension, /* @__PURE__ */lexical.configExtension(MdastImportExtension, {
+    mdastExtensions: [/* @__PURE__ */mdastUtilGfmAutolinkLiteral.gfmAutolinkLiteralFromMarkdown()],
+    micromarkExtensions: [/* @__PURE__ */micromarkExtensionGfmAutolinkLiteral.gfmAutolinkLiteral()],
+    toMarkdownExtensions: [/* @__PURE__ */mdastUtilGfmAutolinkLiteral.gfmAutolinkLiteralToMarkdown()]
+  })],
+  name: '@lexical/mdast/AutolinkLiteral'
+});
+
+/**
+ * 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
+ */
+const MdastShadowRootQuoteExtension = /* @__PURE__ */lexical.defineExtension({
+  dependencies: [MdastBlockquoteExtension,
+  // Declared after (and depending on) MdastBlockquoteExtension so this
+  // blockquote rule merges later and takes priority over the default.
+  /* @__PURE__ */
+  lexical.configExtension(MdastImportExtension, {
+    importRules: [{
+      $import: $importShadowRootBlockquote,
+      type: 'blockquote'
+    }]
+  })],
+  name: '@lexical/mdast/ShadowRootQuote'
+});
+const $importThematicBreak = (node, ctx) => {
+  const hr = extension.$createHorizontalRuleNode();
+  // Preserve the marker character (`---` vs `***` vs `___`).
+  if (ctx.source && node.position && node.position.start.offset != null) {
+    const marker = ctx.source.slice(node.position.start.offset, node.position.start.offset + 4).trimStart()[0];
+    if (marker === '-' || marker === '*' || marker === '_') {
+      lexical.$setState(hr, hrMarkerState, marker);
+    }
+  }
+  return hr;
+};
+const $exportThematicBreak = node => {
+  if (!extension.$isHorizontalRuleNode(node)) {
+    return null;
+  }
+  const rule = {
+    type: 'thematicBreak'
+  };
+  const marker = lexical.$getState(node, hrMarkerState);
+  if (marker) {
+    rule.data = {
+      mdastRule: marker
+    };
+  }
+  return rule;
+};
+
+/**
+ * Thematic breaks (`---`, `***`, `___`), mapped to
+ * {@link HorizontalRuleExtension}'s `HorizontalRuleNode`. The original marker
+ * character is preserved on round-trip.
+ * @experimental
+ */
+const MdastHorizontalRuleExtension = /* @__PURE__ */lexical.defineExtension({
+  dependencies: [extension.HorizontalRuleExtension, /* @__PURE__ */lexical.configExtension(MdastImportExtension, {
+    exportRules: [{
+      $export: $exportThematicBreak,
+      type: 'horizontalrule'
+    }],
+    importRules: [{
+      $import: $importThematicBreak,
+      type: 'thematicBreak'
+    }]
+  })],
+  name: '@lexical/mdast/HorizontalRule'
+});
+
+/**
+ * GFM `~~strikethrough~~`, mapped to the Lexical `strikethrough` text format.
+ * Needs no extra nodes (the core text handlers carry the format bit).
+ * @experimental
+ */
+const MdastStrikethroughExtension = /* @__PURE__ */lexical.defineExtension({
+  dependencies: [/* @__PURE__ */lexical.configExtension(MdastImportExtension, {
+    importRules: [{
+      $import: importDelete,
+      type: 'delete'
+    }],
+    inlineShortcutTriggers: ['~'],
+    inlineShortcutTypes: ['delete'],
+    mdastExtensions: [/* @__PURE__ */mdastUtilGfmStrikethrough.gfmStrikethroughFromMarkdown()],
+    micromarkExtensions: [/* @__PURE__ */micromarkExtensionGfmStrikethrough.gfmStrikethrough()],
+    toMarkdownExtensions: [/* @__PURE__ */mdastUtilGfmStrikethrough.gfmStrikethroughToMarkdown()]
+  })],
+  name: '@lexical/mdast/Strikethrough'
+});
+
+/**
+ * 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
+ */
+const MdastCommonMarkExtension = /* @__PURE__ */lexical.defineExtension({
+  dependencies: [MdastRichTextExtension, MdastListExtension, MdastCodeExtension, MdastLinkExtension, MdastHorizontalRuleExtension],
+  name: '@lexical/mdast/CommonMark'
+});
+/**
+ * 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
+ */
+const MdastShortcutsExtension = /* @__PURE__ */lexical.defineExtension({
+  build: (editor, config) => extension.namedSignals(config),
+  config: /* @__PURE__ */lexical.safeCast({
+    disabled: false
+  }),
+  dependencies: [MdastImportExtension],
+  name: '@lexical/mdast/Shortcuts',
+  register: (editor, config, state) => {
+    const {
+      disabled
+    } = state.getOutput();
+    return extension.effect(() => {
+      if (disabled.value) {
+        return undefined;
+      }
+      const {
+        registry
+      } = extension.getExtensionDependencyFromEditor(editor, MdastImportExtension).output;
+      return registerMarkdownShortcuts(editor, registry);
+    });
+  }
+});
+
+/**
+ * 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
+ */
+function $convertFromMarkdownString(markdown, node) {
+  extension.$getExtensionOutput(MdastImportExtension).$convertFromMarkdownString(markdown, node);
+}
+
+/**
+ * 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
+ */
+function $convertFromMdast(tree, node) {
+  extension.$getExtensionOutput(MdastImportExtension).$convertFromMdast(tree, node);
+}
+
+/**
+ * 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
+ */
+function $generateNodesFromMarkdownString(markdown) {
+  return extension.$getExtensionOutput(MdastImportExtension).$generateNodesFromMarkdownString(markdown);
+}
+
+/**
+ * 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
+ */
+function $generateNodesFromMdast(tree) {
+  return extension.$getExtensionOutput(MdastImportExtension).$generateNodesFromMdast(tree);
+}
+
+/**
+ * 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.
+ *
+ */
+
+
+/**
+ * The runtime API exposed by {@link MdastExportExtension}. Obtain it inside a
+ * read/update with `$getExtensionOutput(MdastExportExtension)`, or use the
+ * {@link $convertToMarkdownString} shorthand.
+ * @experimental
+ */
+
+/**
+ * Markdown serialization for `@lexical/mdast`. Import
+ * (`MdastImportExtension` and the feature extensions that contribute to it) and
+ * export are separate extensions so that editors which only *parse* Markdown
+ * — never serialize back — don't bundle `mdast-util-to-markdown`.
+ *
+ * The export rules themselves are contributed by the same feature extensions
+ * that contribute import rules; this extension compiles the shared registry
+ * into a serializer:
+ * ```ts
+ * dependencies: [MdastCommonMarkExtension, MdastExportExtension]
+ * ```
+ * @experimental
+ */
+const MdastExportExtension = /* @__PURE__ */lexical.defineExtension({
+  build(editor, config, state) {
+    const {
+      registry
+    } = state.getDependency(MdastImportExtension).output;
+    const {
+      $exportSelectionToMarkdown,
+      $exportToMdast,
+      $exportToMarkdown
+    } = createMdastExport(registry);
+    return {
+      $convertSelectionToMarkdownString: $exportSelectionToMarkdown,
+      $convertToMarkdownString: $exportToMarkdown,
+      $convertToMdast: $exportToMdast
+    };
+  },
+  dependencies: [MdastImportExtension],
+  name: '@lexical/mdast/Export'
+});
+
+/**
+ * Shorthand for
+ * `$getExtensionOutput(MdastExportExtension).$convertToMarkdownString`.
+ * Must be called inside an `editor.read()` or `editor.update()`. Throws if
+ * the editor was not built with {@link MdastExportExtension}.
+ * @experimental
+ */
+function $convertToMarkdownString(node) {
+  return extension.$getExtensionOutput(MdastExportExtension).$convertToMarkdownString(node);
+}
+
+/**
+ * Shorthand for `$getExtensionOutput(MdastExportExtension).$convertToMdast`.
+ * Must be called inside an `editor.read()` or `editor.update()`. Throws if
+ * the editor was not built with {@link MdastExportExtension}.
+ * @experimental
+ */
+function $convertToMdast(node) {
+  return extension.$getExtensionOutput(MdastExportExtension).$convertToMdast(node);
+}
+
+/**
+ * Shorthand for
+ * `$getExtensionOutput(MdastExportExtension).$convertSelectionToMarkdownString`.
+ * Serializes only the selected content (defaulting to the current selection)
+ * to a Markdown string; returns `''` for a null or collapsed selection.
+ * Must be called inside an `editor.read()` or `editor.update()`. Throws if
+ * the editor was not built with {@link MdastExportExtension}.
+ * @experimental
+ */
+function $convertSelectionToMarkdownString(selection) {
+  return extension.$getExtensionOutput(MdastExportExtension).$convertSelectionToMarkdownString(selection);
+}
+
+/**
+ * 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.
+ *
+ */
+
+
+/**
+ * Convenience bundle of {@link MdastImportExtension} and
+ * {@link MdastExportExtension}: Markdown parsing *and* serialization.
+ *
+ * Depend on this when you want both directions without thinking about it:
+ * ```ts
+ * dependencies: [MdastCommonMarkExtension, MdastExtension]
+ * ```
+ * Editors that never serialize back to Markdown can skip it (feature
+ * extensions already pull in {@link MdastImportExtension}) and avoid
+ * bundling the serializer (`mdast-util-to-markdown`).
+ * @experimental
+ */
+const MdastExtension = /* @__PURE__ */lexical.defineExtension({
+  dependencies: [MdastImportExtension, MdastExportExtension],
+  name: '@lexical/mdast/Mdast'
+});
+
+/**
+ * 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.
+ *
+ */
+
+
+/** The per-column alignment (`| :-: |`) a table's delimiter row declared. */
+const tableAlignState = /* @__PURE__ */lexical.createState('mdastTableAlign', {
+  parse: v => Array.isArray(v) ? v.map(a => a === 'center' || a === 'left' || a === 'right' ? a : null) : [],
+  resetOnCopyNode: true
+});
+const $importTable = (node, ctx) => {
+  const table$1 = table.$createTableNode();
+  if (node.align && node.align.some(a => a != null)) {
+    lexical.$setState(table$1, tableAlignState, node.align);
+  }
+  node.children.forEach((row, rowIndex) => {
+    const rowNode = table.$createTableRowNode();
+    for (const cell of row.children) {
+      const cellNode = table.$createTableCellNode(rowIndex === 0 ? table.TableCellHeaderStates.ROW : table.TableCellHeaderStates.NO_STATUS);
+      const paragraph = lexical.$createParagraphNode();
+      $append(paragraph, ctx.importChildren(cell));
+      $append(cellNode, [paragraph]);
+      $append(rowNode, [cellNode]);
+    }
+    $append(table$1, [rowNode]);
+  });
+  return table$1;
+};
+const $exportTable = (node, ctx) => {
+  if (!table.$isTableNode(node)) {
+    return null;
+  }
+  const rows = [];
+  for (const row of node.getChildren()) {
+    // Structural iteration bypasses the walk's selection filter, so rows a
+    // selection export does not reach are skipped here. Cells stay: dropping
+    // one would shift the remaining cells into other columns.
+    if (!table.$isTableRowNode(row) || !ctx.isIncluded(row)) {
+      continue;
+    }
+    const cells = [];
+    for (const cell of row.getChildren()) {
+      if (!table.$isTableCellNode(cell)) {
+        continue;
+      }
+      const children = [];
+      for (const child of cell.getChildren()) {
+        if (lexical.$isElementNode(child)) {
+          // GFM cells hold a single line of phrasing content; multiple block
+          // children (paragraphs from Enter inside the cell) are joined with
+          // hard breaks, which gfm-table serializes as spaces inside the cell.
+          if (children.length > 0) {
+            children.push({
+              type: 'break'
+            });
+          }
+          children.push(...ctx.exportInline(child));
+        }
+      }
+      cells.push({
+        children,
+        type: 'tableCell'
+      });
+    }
+    rows.push({
+      children: cells,
+      type: 'tableRow'
+    });
+  }
+  return {
+    align: lexical.$getState(node, tableAlignState),
+    children: rows,
+    type: 'table'
+  };
+};
+
+/**
+ * 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
+ */
+const MdastTableExtension = /* @__PURE__ */lexical.defineExtension({
+  dependencies: [/* @__PURE__ */extension.configExtension(MdastImportExtension, {
+    exportRules: [{
+      $export: $exportTable,
+      type: 'table'
+    }],
+    importRules: [{
+      $import: $importTable,
+      type: 'table'
+    }],
+    mdastExtensions: [/* @__PURE__ */mdastUtilGfmTable.gfmTableFromMarkdown()],
+    micromarkExtensions: [/* @__PURE__ */micromarkExtensionGfmTable.gfmTable()],
+    toMarkdownExtensions: [/* @__PURE__ */mdastUtilGfmTable.gfmTableToMarkdown()]
+  })],
+  name: '@lexical/mdast/Table',
+  nodes: [table.TableNode, table.TableRowNode, table.TableCellNode]
+});
+
+/**
+ * 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.
+ *
+ */
+
+
+/**
+ * Convenience bundle of every GFM extension — strikethrough, task lists,
+ * literal autolinks, and tables — mirroring the scope of
+ * `micromark-extension-gfm`. Combine with `MdastCommonMarkExtension` for
+ * GitHub-flavored Markdown:
+ * ```ts
+ * dependencies: [MdastCommonMarkExtension, MdastGfmExtension]
+ * ```
+ * Each member is also usable individually when you only want some of GFM
+ * (e.g. task lists without tables).
+ * @experimental
+ */
+const MdastGfmExtension = /* @__PURE__ */lexical.defineExtension({
+  dependencies: [MdastStrikethroughExtension, MdastTaskListExtension, MdastAutolinkLiteralExtension, MdastTableExtension],
+  name: '@lexical/mdast/Gfm'
+});
+
+exports.$convertFromMarkdownString = $convertFromMarkdownString;
+exports.$convertFromMdast = $convertFromMdast;
+exports.$convertSelectionToMarkdownString = $convertSelectionToMarkdownString;
+exports.$convertToMarkdownString = $convertToMarkdownString;
+exports.$convertToMdast = $convertToMdast;
+exports.$generateNodesFromMarkdownString = $generateNodesFromMarkdownString;
+exports.$generateNodesFromMdast = $generateNodesFromMdast;
+exports.MdastAutolinkLiteralExtension = MdastAutolinkLiteralExtension;
+exports.MdastBlockquoteExtension = MdastBlockquoteExtension;
+exports.MdastCodeExtension = MdastCodeExtension;
+exports.MdastCommonMarkExtension = MdastCommonMarkExtension;
+exports.MdastExportExtension = MdastExportExtension;
+exports.MdastExtension = MdastExtension;
+exports.MdastGfmExtension = MdastGfmExtension;
+exports.MdastHeadingExtension = MdastHeadingExtension;
+exports.MdastHorizontalRuleExtension = MdastHorizontalRuleExtension;
+exports.MdastImportExtension = MdastImportExtension;
+exports.MdastLinkExtension = MdastLinkExtension;
+exports.MdastListExtension = MdastListExtension;
+exports.MdastRichTextExtension = MdastRichTextExtension;
+exports.MdastShadowRootQuoteExtension = MdastShadowRootQuoteExtension;
+exports.MdastShortcutsExtension = MdastShortcutsExtension;
+exports.MdastStrikethroughExtension = MdastStrikethroughExtension;
+exports.MdastTableExtension = MdastTableExtension;
+exports.MdastTaskListExtension = MdastTaskListExtension;