@lexical/markdown 0.49.1-nightly.20260902.0 → 0.50.0

package/dist/LexicalMarkdown.dev.js

@@ -280,6 +280,112 @@ function getIndent(whitespaces) {
   }
   return indent;
 }
+
+/**
+ * The column the text after `whitespaces` starts at, expanding a tab to the
+ * next multiple of `LIST_INDENT_SIZE` the way CommonMark does.
+ */
+function getColumn(whitespaces) {
+  let column = 0;
+  for (const char of whitespaces) {
+    column += char === '\t' ? LIST_INDENT_SIZE - column % LIST_INDENT_SIZE : 1;
+  }
+  return column;
+}
+
+/**
+ * The content columns of the list levels the lines placed so far have left
+ * open, outermost first, or null outside a markdown import.
+ *
+ * A sublist is measured against the column where its parent item's content
+ * begins rather than against a fixed number of spaces: that is what lets
+ * `1. a` take a three-space sublist while `- a` takes a two-space one, and
+ * what keeps two items written at the same column siblings even when that
+ * column is deep enough to have opened a level.
+ *
+ * Only the line that opened a level knows the column it was written at, and
+ * nothing in the tree records it afterwards, so the columns are carried from
+ * line to line for the length of one import. A shortcut typed into an editor
+ * is a line on its own with no such run behind it and keeps reading its indent
+ * as a fixed `LIST_INDENT_SIZE` per level, which is the step `$listExport`
+ * writes and the one the toolbar and Tab indent by.
+ */
+let importListColumns = null;
+let importJoinsLooseLists = false;
+
+/**
+ * Run `fn` with the columns of a single markdown import tracked across the
+ * lines it places. Restores whatever was being tracked around it, so an import
+ * that runs inside another one does not disturb it.
+ *
+ * `joinLooseLists` reads a blank line between list lines as making the list
+ * loose rather than ending it. An import that preserves new lines keeps blank
+ * paragraphs as content, so there a blank line closes the list like any other
+ * block.
+ *
+ * @internal
+ */
+function withListIndentColumns(joinLooseLists, fn) {
+  const previousColumns = importListColumns;
+  const previousJoins = importJoinsLooseLists;
+  importListColumns = [];
+  importJoinsLooseLists = joinLooseLists;
+  try {
+    return fn();
+  } finally {
+    importListColumns = previousColumns;
+    importJoinsLooseLists = previousJoins;
+  }
+}
+
+/**
+ * The indent `whitespaces` names given the levels open above it: the innermost
+ * level whose content column it reaches, or 0 when it reaches none of them.
+ */
+function getColumnIndent(columns, whitespaces) {
+  const column = getColumn(whitespaces);
+  for (let i = columns.length - 1; i >= 0; i--) {
+    if (column >= columns[i]) {
+      return i + 1;
+    }
+  }
+  return 0;
+}
+
+/**
+ * The column this line opens its content at: where the matched marker ends,
+ * with tabs expanded, so `-\ta` opens at the tab stop and not two columns in.
+ * A check list item is marked by its bullet — the `[ ]` is content — so
+ * `- [ ] a` opens where `- a` does. Capped one `LIST_INDENT_SIZE` past the
+ * marker so that the indent `$listExport` writes always nests: a sublist of
+ * `100. ` is exported with four spaces, short of that marker's real content
+ * column.
+ */
+function getContentColumn(match, listType) {
+  let prefix = match[0];
+  if (listType === 'check') {
+    const bullet = prefix.slice(match[1].length).match(/^[-*+]\s/);
+    if (bullet) {
+      prefix = match[1] + bullet[0];
+    }
+  }
+  return Math.min(getColumn(prefix), getColumn(match[1]) + LIST_INDENT_SIZE);
+}
+
+/**
+ * Record the content column that this line leaves open for the lines below it,
+ * closing the levels it stepped back out of.
+ */
+function setOpenColumn(columns, indent, match, listType) {
+  // An indent read from `getIndent` rather than from the columns can name a
+  // level no line of this import opened, so any gap below it is filled with
+  // the fixed step that reading assumed.
+  for (let i = columns.length; i < indent; i++) {
+    columns[i] = (i + 1) * LIST_INDENT_SIZE;
+  }
+  columns.length = indent;
+  columns[indent] = getContentColumn(match, listType);
+}
 const listReplace = listType => {
   return (parentNode, children, match, isImport) => {
     if (richText.$isHeadingNode(parentNode) || !isImport && $isUnreplaceableBlock(parentNode)) {
@@ -287,13 +393,34 @@ const listReplace = listType => {
     }
     const previousNode = parentNode.getPreviousSibling();
     const nextNode = parentNode.getNextSibling();
-    const listItem = list.$createListItemNode(listType === 'check' ? match[3] === 'x' : undefined);
+    const listItem = list.$createListItemNode(
+    // CHECK_LIST_REGEX matches case-insensitively, so `[X]` is checked too.
+    listType === 'check' ? /^x$/i.test(match[3] || '') : undefined);
     const firstMatchChar = match[0].trim()[0];
     const listMarker = (listType === 'bullet' || listType === 'check') && firstMatchChar === listMarkerState.parse(firstMatchChar) ? firstMatchChar : undefined;
-    if (list.$isListNode(nextNode) && nextNode.getListType() === listType) {
-      if (listMarker) {
-        lexical.$setState(nextNode, listMarkerState, listMarker);
+    // A block of another kind closes every level above this line. Blank lines
+    // do not: they only make the list loose, and a blank line must not decide
+    // how the line after it is read, or the same sublist would be read one way
+    // written tightly and another written with a blank line before it. So the
+    // line is measured against, and placed into, the list it follows across
+    // any blank lines, and the levels close only when the nearest block that
+    // is not one is no longer the list itself. Outside such an import — a
+    // typed shortcut, or an import that keeps its blank lines as content — a
+    // blank line above the line is a block like any other.
+    const columns = importListColumns;
+    let precedingBlock = previousNode;
+    if (columns !== null) {
+      if (importJoinsLooseLists) {
+        while (precedingBlock !== null && isEmptyParagraph(precedingBlock)) {
+          precedingBlock = precedingBlock.getPreviousSibling();
+        }
       }
+      if (!list.$isListNode(precedingBlock)) {
+        columns.length = 0;
+      }
+    }
+    const indent = columns === null || columns.length === 0 ? getIndent(match[1]) : getColumnIndent(columns, match[1]);
+    if (list.$isListNode(nextNode) && nextNode.getListType() === listType) {
       const firstChild = nextNode.getFirstChild();
       if (firstChild !== null) {
         firstChild.insertBefore(listItem);
@@ -302,24 +429,24 @@ const listReplace = listType => {
         nextNode.append(listItem);
       }
       // The new list item lands at index 0, so the typed number becomes the
-      // list's starting value. #8677.
-      if (listType === 'number') {
+      // list's starting value. #8677. An indented item only passes through —
+      // `setIndent` below moves it into a sublist — so its number belongs to
+      // that sublist, not to the list it leaves.
+      if (listType === 'number' && indent === 0) {
         nextNode.setStart(Number(match[2]));
       }
       parentNode.remove();
-    } else if (list.$isListNode(previousNode) && previousNode.getListType() === listType) {
-      if (listMarker) {
-        lexical.$setState(previousNode, listMarkerState, listMarker);
-      }
-      // The new item is appended at the end and inherits the existing
-      // sequence, so the typed number is intentionally ignored here.
-      previousNode.append(listItem);
+    } else if (list.$isListNode(precedingBlock) && (precedingBlock.getListType() === listType || indent > 0)) {
+      // An item of the same type continues the list, and inherits the
+      // existing sequence — the typed number is intentionally ignored. An
+      // indented item of another type belongs inside it too: it is appended
+      // at the top level here, `setIndent` below moves it to its level, and a
+      // list of the right type is spliced in once the level it lands in is
+      // known.
+      precedingBlock.append(listItem);
       parentNode.remove();
     } else {
       const list$1 = list.$createListNode(listType, listType === 'number' ? Number(match[2]) : undefined);
-      if (listMarker) {
-        lexical.$setState(list$1, listMarkerState, listMarker);
-      }
       list$1.append(listItem);
       parentNode.replace(list$1);
     }
@@ -327,12 +454,58 @@ const listReplace = listType => {
     if (!isImport) {
       listItem.select(0, 0);
     }
-    const indent = getIndent(match[1]);
     if (indent) {
       listItem.setIndent(indent);
+      $retypeNestedList(listItem, listType, match);
+    }
+    // The marker belongs to the list the item actually ends up in, which is
+    // only known once it has been indented and retyped.
+    const listNode = listItem.getParent();
+    if (listMarker && list.$isListNode(listNode)) {
+      lexical.$setState(listNode, listMarkerState, listMarker);
+    }
+    if (columns !== null) {
+      setOpenColumn(columns, indent, match, listType);
     }
   };
 };
+
+/**
+ * `setIndent` nests an item by copying the list it is in, so an item whose
+ * type differs from the list above it lands in a nested list of the wrong
+ * type. Split it out into a list of its own type, in place, so that a sublist
+ * can change type the way CommonMark lets it — `1. a` may be followed by an
+ * indented `- b`, and that by an indented `- [ ] c`.
+ */
+function $retypeNestedList(listItem, listType, match) {
+  const nestedList = listItem.getParent();
+  if (!list.$isListNode(nestedList) || nestedList.getListType() === listType) {
+    return;
+  }
+  const wrapper = nestedList.getParent();
+  if (!list.$isListItemNode(wrapper)) {
+    return;
+  }
+  const retypedList = list.$createListNode(listType, listType === 'number' ? Number(match[2]) : undefined);
+  // `setIndent` either appends the item to the nested list or puts it in
+  // front of it, so the list of its own type belongs on whichever side of the
+  // one it was placed in it already sits on.
+  const isFirst = listItem.getPreviousSibling() === null;
+  // `append` moves the item without disturbing the selection, which
+  // `remove` would relocate to a sibling and leave there — the caret has to
+  // stay in the item the shortcut just created.
+  retypedList.append(listItem);
+  const retypedWrapper = list.$createListItemNode();
+  retypedWrapper.append(retypedList);
+  if (isFirst) {
+    wrapper.insertBefore(retypedWrapper);
+  } else {
+    wrapper.insertAfter(retypedWrapper);
+  }
+  if (nestedList.getChildrenSize() === 0) {
+    wrapper.remove();
+  }
+}
 const $listExport = (listNode, exportChildren, depth, selection) => {
   const output = [];
   const children = listNode.getChildren();
@@ -1702,15 +1875,22 @@ function $importMarkdownNodes(markdownString, container, transformers, shouldPre
   const textFormatTransformersIndex = createTextFormatTransformersIndex(byType.textFormat);
   const lines = markdownString.split('\n');
   const linesLength = lines.length;
-  for (let i = 0; i < linesLength; i++) {
-    const lineText = lines[i];
-    const [imported, shiftedIndex] = $importMultiline(lines, i, byType.multilineElement, container);
-    if (imported) {
-      i = shiftedIndex;
-      continue;
+
+  // A list line is measured against the column its parent item's content
+  // starts at, which only the line that opened that level knows. Blank lines
+  // between list lines make the list loose rather than ending it — except
+  // when they are being preserved, where they are content like any block.
+  withListIndentColumns(!shouldPreserveNewLines, () => {
+    for (let i = 0; i < linesLength; i++) {
+      const lineText = lines[i];
+      const [imported, shiftedIndex] = $importMultiline(lines, i, byType.multilineElement, container);
+      if (imported) {
+        i = shiftedIndex;
+        continue;
+      }
+      $importBlocks(lineText, container, byType.element, textFormatTransformersIndex, byType.textMatch, shouldPreserveNewLines);
     }
-    $importBlocks(lineText, container, byType.element, textFormatTransformersIndex, byType.textMatch, shouldPreserveNewLines);
-  }
+  });
   const children = container.getChildren();
   for (const child of children) {
     if (!shouldPreserveNewLines && isEmptyParagraph(child) && container.getChildrenSize() > 1) {
@@ -1854,26 +2034,36 @@ function $importBlocks(lineText, rootNode, elementTransformers, textFormatTransf
   }
 }
 
-// Look in node for '\t' and create a TabNode for each occurrence.
+// Look in node for '\t' and create a TabNode for each occurrence. The
+// replacement nodes are built directly rather than through
+// `splitText(...offsets)`: spreading one argument per tab boundary overflows
+// the call stack on a long run of tabs, and the text can hold arbitrarily
+// many.
 function $normalizeMarkdownTextNode(textNode) {
-  const tabOffsets = new Set();
+  // A TabNode is a TextNode whose content is a tab, so without this guard the
+  // rebuild below would destroy it and create an equivalent one in its place.
+  if (lexical.$isTabNode(textNode)) {
+    return;
+  }
   const text = textNode.getTextContent();
-  let index = text.indexOf('\t');
-
-  // Find all tab occurrences
-  while (index !== -1) {
-    tabOffsets.add(index);
-    tabOffsets.add(index + 1);
-    index = text.indexOf('\t', index + 1);
+  if (!text.includes('\t')) {
+    return;
   }
-
-  // Split node to isolate each tab then replace '\t' into TabNode
-  const splitNodes = textNode.splitText(...tabOffsets);
-  splitNodes.forEach(node => {
-    if (node.getTextContent() === '\t') {
-      node.replace(lexical.$createTabNode());
+  const format = textNode.getFormat();
+  const style = textNode.getStyle();
+  const nodes = [];
+  let start = 0;
+  for (let index = text.indexOf('\t'); index !== -1; index = text.indexOf('\t', index + 1)) {
+    if (index > start) {
+      nodes.push(lexical.$createTextNode(text.slice(start, index)).setFormat(format).setStyle(style));
     }
-  });
+    nodes.push(lexical.$createTabNode());
+    start = index + 1;
+  }
+  if (start < text.length) {
+    nodes.push(lexical.$createTextNode(text.slice(start)).setFormat(format).setStyle(style));
+  }
+  textNode.getParentOrThrow().splice(textNode.getIndexWithinParent(), 1, nodes);
 }
 function createTextFormatTransformersIndex(textTransformers) {
   const transformersByTag = {};

package/dist/LexicalMarkdown.dev.mjs

@@ -6,7 +6,7 @@
  *
  */
 
-import { $isParagraphNode, $isTextNode, $setState, $createTextNode, $getState, $findMatchingParent, $createLineBreakNode, createState, $isLineBreakNode, $getRoot, $isElementNode, $isDecoratorNode, $createParagraphNode, $createTabNode, mergeRegister, COLLABORATION_TAG, HISTORIC_TAG, COMPOSITION_END_TAG, $getSelection, $isRangeSelection, $addUpdateTag, HISTORY_PUSH_TAG, KEY_ENTER_COMMAND, COMMAND_PRIORITY_LOW, $isRootOrShadowRoot, $createRangeSelection, $setSelection, TEXT_TYPE_TO_FORMAT, ArtificialNode__DO_NOT_USE } from 'lexical';
+import { $isParagraphNode, $isTextNode, $setState, $createTextNode, $getState, $findMatchingParent, $createLineBreakNode, createState, $isLineBreakNode, $getRoot, $isElementNode, $isDecoratorNode, $isTabNode, $createTabNode, $createParagraphNode, mergeRegister, COLLABORATION_TAG, HISTORIC_TAG, COMPOSITION_END_TAG, $getSelection, $isRangeSelection, $addUpdateTag, HISTORY_PUSH_TAG, KEY_ENTER_COMMAND, COMMAND_PRIORITY_LOW, $isRootOrShadowRoot, $createRangeSelection, $setSelection, TEXT_TYPE_TO_FORMAT, ArtificialNode__DO_NOT_USE } from 'lexical';
 import { $sliceSelectedTextNodeContent } from '@lexical/selection';
 import { CodeNode, $createCodeNode, $isCodeNode } from '@lexical/code-core';
 import { LinkNode, $isLinkNode, $createLinkNode, $isAutoLinkNode } from '@lexical/link';
@@ -278,6 +278,112 @@ function getIndent(whitespaces) {
   }
   return indent;
 }
+
+/**
+ * The column the text after `whitespaces` starts at, expanding a tab to the
+ * next multiple of `LIST_INDENT_SIZE` the way CommonMark does.
+ */
+function getColumn(whitespaces) {
+  let column = 0;
+  for (const char of whitespaces) {
+    column += char === '\t' ? LIST_INDENT_SIZE - column % LIST_INDENT_SIZE : 1;
+  }
+  return column;
+}
+
+/**
+ * The content columns of the list levels the lines placed so far have left
+ * open, outermost first, or null outside a markdown import.
+ *
+ * A sublist is measured against the column where its parent item's content
+ * begins rather than against a fixed number of spaces: that is what lets
+ * `1. a` take a three-space sublist while `- a` takes a two-space one, and
+ * what keeps two items written at the same column siblings even when that
+ * column is deep enough to have opened a level.
+ *
+ * Only the line that opened a level knows the column it was written at, and
+ * nothing in the tree records it afterwards, so the columns are carried from
+ * line to line for the length of one import. A shortcut typed into an editor
+ * is a line on its own with no such run behind it and keeps reading its indent
+ * as a fixed `LIST_INDENT_SIZE` per level, which is the step `$listExport`
+ * writes and the one the toolbar and Tab indent by.
+ */
+let importListColumns = null;
+let importJoinsLooseLists = false;
+
+/**
+ * Run `fn` with the columns of a single markdown import tracked across the
+ * lines it places. Restores whatever was being tracked around it, so an import
+ * that runs inside another one does not disturb it.
+ *
+ * `joinLooseLists` reads a blank line between list lines as making the list
+ * loose rather than ending it. An import that preserves new lines keeps blank
+ * paragraphs as content, so there a blank line closes the list like any other
+ * block.
+ *
+ * @internal
+ */
+function withListIndentColumns(joinLooseLists, fn) {
+  const previousColumns = importListColumns;
+  const previousJoins = importJoinsLooseLists;
+  importListColumns = [];
+  importJoinsLooseLists = joinLooseLists;
+  try {
+    return fn();
+  } finally {
+    importListColumns = previousColumns;
+    importJoinsLooseLists = previousJoins;
+  }
+}
+
+/**
+ * The indent `whitespaces` names given the levels open above it: the innermost
+ * level whose content column it reaches, or 0 when it reaches none of them.
+ */
+function getColumnIndent(columns, whitespaces) {
+  const column = getColumn(whitespaces);
+  for (let i = columns.length - 1; i >= 0; i--) {
+    if (column >= columns[i]) {
+      return i + 1;
+    }
+  }
+  return 0;
+}
+
+/**
+ * The column this line opens its content at: where the matched marker ends,
+ * with tabs expanded, so `-\ta` opens at the tab stop and not two columns in.
+ * A check list item is marked by its bullet — the `[ ]` is content — so
+ * `- [ ] a` opens where `- a` does. Capped one `LIST_INDENT_SIZE` past the
+ * marker so that the indent `$listExport` writes always nests: a sublist of
+ * `100. ` is exported with four spaces, short of that marker's real content
+ * column.
+ */
+function getContentColumn(match, listType) {
+  let prefix = match[0];
+  if (listType === 'check') {
+    const bullet = prefix.slice(match[1].length).match(/^[-*+]\s/);
+    if (bullet) {
+      prefix = match[1] + bullet[0];
+    }
+  }
+  return Math.min(getColumn(prefix), getColumn(match[1]) + LIST_INDENT_SIZE);
+}
+
+/**
+ * Record the content column that this line leaves open for the lines below it,
+ * closing the levels it stepped back out of.
+ */
+function setOpenColumn(columns, indent, match, listType) {
+  // An indent read from `getIndent` rather than from the columns can name a
+  // level no line of this import opened, so any gap below it is filled with
+  // the fixed step that reading assumed.
+  for (let i = columns.length; i < indent; i++) {
+    columns[i] = (i + 1) * LIST_INDENT_SIZE;
+  }
+  columns.length = indent;
+  columns[indent] = getContentColumn(match, listType);
+}
 const listReplace = listType => {
   return (parentNode, children, match, isImport) => {
     if ($isHeadingNode(parentNode) || !isImport && $isUnreplaceableBlock(parentNode)) {
@@ -285,13 +391,34 @@ const listReplace = listType => {
     }
     const previousNode = parentNode.getPreviousSibling();
     const nextNode = parentNode.getNextSibling();
-    const listItem = $createListItemNode(listType === 'check' ? match[3] === 'x' : undefined);
+    const listItem = $createListItemNode(
+    // CHECK_LIST_REGEX matches case-insensitively, so `[X]` is checked too.
+    listType === 'check' ? /^x$/i.test(match[3] || '') : undefined);
     const firstMatchChar = match[0].trim()[0];
     const listMarker = (listType === 'bullet' || listType === 'check') && firstMatchChar === listMarkerState.parse(firstMatchChar) ? firstMatchChar : undefined;
-    if ($isListNode(nextNode) && nextNode.getListType() === listType) {
-      if (listMarker) {
-        $setState(nextNode, listMarkerState, listMarker);
+    // A block of another kind closes every level above this line. Blank lines
+    // do not: they only make the list loose, and a blank line must not decide
+    // how the line after it is read, or the same sublist would be read one way
+    // written tightly and another written with a blank line before it. So the
+    // line is measured against, and placed into, the list it follows across
+    // any blank lines, and the levels close only when the nearest block that
+    // is not one is no longer the list itself. Outside such an import — a
+    // typed shortcut, or an import that keeps its blank lines as content — a
+    // blank line above the line is a block like any other.
+    const columns = importListColumns;
+    let precedingBlock = previousNode;
+    if (columns !== null) {
+      if (importJoinsLooseLists) {
+        while (precedingBlock !== null && isEmptyParagraph(precedingBlock)) {
+          precedingBlock = precedingBlock.getPreviousSibling();
+        }
       }
+      if (!$isListNode(precedingBlock)) {
+        columns.length = 0;
+      }
+    }
+    const indent = columns === null || columns.length === 0 ? getIndent(match[1]) : getColumnIndent(columns, match[1]);
+    if ($isListNode(nextNode) && nextNode.getListType() === listType) {
       const firstChild = nextNode.getFirstChild();
       if (firstChild !== null) {
         firstChild.insertBefore(listItem);
@@ -300,24 +427,24 @@ const listReplace = listType => {
         nextNode.append(listItem);
       }
       // The new list item lands at index 0, so the typed number becomes the
-      // list's starting value. #8677.
-      if (listType === 'number') {
+      // list's starting value. #8677. An indented item only passes through —
+      // `setIndent` below moves it into a sublist — so its number belongs to
+      // that sublist, not to the list it leaves.
+      if (listType === 'number' && indent === 0) {
         nextNode.setStart(Number(match[2]));
       }
       parentNode.remove();
-    } else if ($isListNode(previousNode) && previousNode.getListType() === listType) {
-      if (listMarker) {
-        $setState(previousNode, listMarkerState, listMarker);
-      }
-      // The new item is appended at the end and inherits the existing
-      // sequence, so the typed number is intentionally ignored here.
-      previousNode.append(listItem);
+    } else if ($isListNode(precedingBlock) && (precedingBlock.getListType() === listType || indent > 0)) {
+      // An item of the same type continues the list, and inherits the
+      // existing sequence — the typed number is intentionally ignored. An
+      // indented item of another type belongs inside it too: it is appended
+      // at the top level here, `setIndent` below moves it to its level, and a
+      // list of the right type is spliced in once the level it lands in is
+      // known.
+      precedingBlock.append(listItem);
       parentNode.remove();
     } else {
       const list = $createListNode(listType, listType === 'number' ? Number(match[2]) : undefined);
-      if (listMarker) {
-        $setState(list, listMarkerState, listMarker);
-      }
       list.append(listItem);
       parentNode.replace(list);
     }
@@ -325,12 +452,58 @@ const listReplace = listType => {
     if (!isImport) {
       listItem.select(0, 0);
     }
-    const indent = getIndent(match[1]);
     if (indent) {
       listItem.setIndent(indent);
+      $retypeNestedList(listItem, listType, match);
+    }
+    // The marker belongs to the list the item actually ends up in, which is
+    // only known once it has been indented and retyped.
+    const listNode = listItem.getParent();
+    if (listMarker && $isListNode(listNode)) {
+      $setState(listNode, listMarkerState, listMarker);
+    }
+    if (columns !== null) {
+      setOpenColumn(columns, indent, match, listType);
     }
   };
 };
+
+/**
+ * `setIndent` nests an item by copying the list it is in, so an item whose
+ * type differs from the list above it lands in a nested list of the wrong
+ * type. Split it out into a list of its own type, in place, so that a sublist
+ * can change type the way CommonMark lets it — `1. a` may be followed by an
+ * indented `- b`, and that by an indented `- [ ] c`.
+ */
+function $retypeNestedList(listItem, listType, match) {
+  const nestedList = listItem.getParent();
+  if (!$isListNode(nestedList) || nestedList.getListType() === listType) {
+    return;
+  }
+  const wrapper = nestedList.getParent();
+  if (!$isListItemNode(wrapper)) {
+    return;
+  }
+  const retypedList = $createListNode(listType, listType === 'number' ? Number(match[2]) : undefined);
+  // `setIndent` either appends the item to the nested list or puts it in
+  // front of it, so the list of its own type belongs on whichever side of the
+  // one it was placed in it already sits on.
+  const isFirst = listItem.getPreviousSibling() === null;
+  // `append` moves the item without disturbing the selection, which
+  // `remove` would relocate to a sibling and leave there — the caret has to
+  // stay in the item the shortcut just created.
+  retypedList.append(listItem);
+  const retypedWrapper = $createListItemNode();
+  retypedWrapper.append(retypedList);
+  if (isFirst) {
+    wrapper.insertBefore(retypedWrapper);
+  } else {
+    wrapper.insertAfter(retypedWrapper);
+  }
+  if (nestedList.getChildrenSize() === 0) {
+    wrapper.remove();
+  }
+}
 const $listExport = (listNode, exportChildren, depth, selection) => {
   const output = [];
   const children = listNode.getChildren();
@@ -1700,15 +1873,22 @@ function $importMarkdownNodes(markdownString, container, transformers, shouldPre
   const textFormatTransformersIndex = createTextFormatTransformersIndex(byType.textFormat);
   const lines = markdownString.split('\n');
   const linesLength = lines.length;
-  for (let i = 0; i < linesLength; i++) {
-    const lineText = lines[i];
-    const [imported, shiftedIndex] = $importMultiline(lines, i, byType.multilineElement, container);
-    if (imported) {
-      i = shiftedIndex;
-      continue;
+
+  // A list line is measured against the column its parent item's content
+  // starts at, which only the line that opened that level knows. Blank lines
+  // between list lines make the list loose rather than ending it — except
+  // when they are being preserved, where they are content like any block.
+  withListIndentColumns(!shouldPreserveNewLines, () => {
+    for (let i = 0; i < linesLength; i++) {
+      const lineText = lines[i];
+      const [imported, shiftedIndex] = $importMultiline(lines, i, byType.multilineElement, container);
+      if (imported) {
+        i = shiftedIndex;
+        continue;
+      }
+      $importBlocks(lineText, container, byType.element, textFormatTransformersIndex, byType.textMatch, shouldPreserveNewLines);
     }
-    $importBlocks(lineText, container, byType.element, textFormatTransformersIndex, byType.textMatch, shouldPreserveNewLines);
-  }
+  });
   const children = container.getChildren();
   for (const child of children) {
     if (!shouldPreserveNewLines && isEmptyParagraph(child) && container.getChildrenSize() > 1) {
@@ -1852,26 +2032,36 @@ function $importBlocks(lineText, rootNode, elementTransformers, textFormatTransf
   }
 }
 
-// Look in node for '\t' and create a TabNode for each occurrence.
+// Look in node for '\t' and create a TabNode for each occurrence. The
+// replacement nodes are built directly rather than through
+// `splitText(...offsets)`: spreading one argument per tab boundary overflows
+// the call stack on a long run of tabs, and the text can hold arbitrarily
+// many.
 function $normalizeMarkdownTextNode(textNode) {
-  const tabOffsets = new Set();
+  // A TabNode is a TextNode whose content is a tab, so without this guard the
+  // rebuild below would destroy it and create an equivalent one in its place.
+  if ($isTabNode(textNode)) {
+    return;
+  }
   const text = textNode.getTextContent();
-  let index = text.indexOf('\t');
-
-  // Find all tab occurrences
-  while (index !== -1) {
-    tabOffsets.add(index);
-    tabOffsets.add(index + 1);
-    index = text.indexOf('\t', index + 1);
+  if (!text.includes('\t')) {
+    return;
   }
-
-  // Split node to isolate each tab then replace '\t' into TabNode
-  const splitNodes = textNode.splitText(...tabOffsets);
-  splitNodes.forEach(node => {
-    if (node.getTextContent() === '\t') {
-      node.replace($createTabNode());
+  const format = textNode.getFormat();
+  const style = textNode.getStyle();
+  const nodes = [];
+  let start = 0;
+  for (let index = text.indexOf('\t'); index !== -1; index = text.indexOf('\t', index + 1)) {
+    if (index > start) {
+      nodes.push($createTextNode(text.slice(start, index)).setFormat(format).setStyle(style));
     }
-  });
+    nodes.push($createTabNode());
+    start = index + 1;
+  }
+  if (start < text.length) {
+    nodes.push($createTextNode(text.slice(start)).setFormat(format).setStyle(style));
+  }
+  textNode.getParentOrThrow().splice(textNode.getIndexWithinParent(), 1, nodes);
 }
 function createTextFormatTransformersIndex(textTransformers) {
   const transformersByTag = {};