@lexical/code 0.3.6 → 0.3.9

package/LexicalCode.dev.js

@@ -20,6 +20,7 @@ require('prismjs/components/prism-rust');
 require('prismjs/components/prism-swift');
 var utils = require('@lexical/utils');
 var lexical = require('lexical');
+var code = require('@lexical/code');
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -28,1012 +29,1069 @@ var lexical = require('lexical');
  * LICENSE file in the root directory of this source tree.
  *
  */
-const DEFAULT_CODE_LANGUAGE = 'javascript';
 
-const mapToPrismLanguage = language => {
-  // eslint-disable-next-line no-prototype-builtins
-  return language != null && Prism.languages.hasOwnProperty(language) ? language : undefined;
-};
+function isSpaceOrTabChar(char) {
+  return char === ' ' || char === '\t';
+}
 
-const getDefaultCodeLanguage = () => DEFAULT_CODE_LANGUAGE;
-const getCodeLanguages = () => Object.keys(Prism.languages).filter( // Prism has several language helpers mixed into languages object
-// so filtering them out here to get langs list
-language => typeof Prism.languages[language] !== 'function').sort();
-class CodeHighlightNode extends lexical.TextNode {
-  constructor(text, highlightType, key) {
-    super(text, key);
-    this.__highlightType = highlightType;
-  }
+function findFirstNotSpaceOrTabCharAtText(text, isForward) {
+  const length = text.length;
+  let offset = -1;
 
-  static getType() {
-    return 'code-highlight';
-  }
+  if (isForward) {
+    for (let i = 0; i < length; i++) {
+      const char = text[i];
 
-  static clone(node) {
-    return new CodeHighlightNode(node.__text, node.__highlightType || undefined, node.__key);
-  }
+      if (!isSpaceOrTabChar(char)) {
+        offset = i;
+        break;
+      }
+    }
+  } else {
+    for (let i = length - 1; i > -1; i--) {
+      const char = text[i];
 
-  getHighlightType() {
-    const self = this.getLatest();
-    return self.__highlightType;
+      if (!isSpaceOrTabChar(char)) {
+        offset = i;
+        break;
+      }
+    }
   }
 
-  createDOM(config) {
-    const element = super.createDOM(config);
-    const className = getHighlightThemeClass(config.theme, this.__highlightType);
-    utils.addClassNamesToElement(element, className);
-    return element;
-  }
+  return offset;
+}
 
-  updateDOM(prevNode, dom, config) {
-    const update = super.updateDOM(prevNode, dom, config);
-    const prevClassName = getHighlightThemeClass(config.theme, prevNode.__highlightType);
-    const nextClassName = getHighlightThemeClass(config.theme, this.__highlightType);
+function getStartOfCodeInLine(anchor) {
+  let currentNode = null;
+  let currentNodeOffset = -1;
+  const previousSiblings = anchor.getPreviousSiblings();
+  previousSiblings.push(anchor);
 
-    if (prevClassName !== nextClassName) {
-      if (prevClassName) {
-        utils.removeClassNamesFromElement(dom, prevClassName);
-      }
+  while (previousSiblings.length > 0) {
+    const node = previousSiblings.pop();
 
-      if (nextClassName) {
-        utils.addClassNamesToElement(dom, nextClassName);
+    if (code.$isCodeHighlightNode(node)) {
+      const text = node.getTextContent();
+      const offset = findFirstNotSpaceOrTabCharAtText(text, true);
+
+      if (offset !== -1) {
+        currentNode = node;
+        currentNodeOffset = offset;
       }
     }
 
-    return update;
+    if (lexical.$isLineBreakNode(node)) {
+      break;
+    }
   }
 
-  static importJSON(serializedNode) {
-    const node = $createCodeHighlightNode(serializedNode.text, serializedNode.highlightType);
-    node.setFormat(serializedNode.format);
-    node.setDetail(serializedNode.detail);
-    node.setMode(serializedNode.mode);
-    node.setStyle(serializedNode.style);
-    return node;
-  }
+  if (currentNode === null) {
+    const nextSiblings = anchor.getNextSiblings();
 
-  exportJSON() {
-    return { ...super.exportJSON(),
-      highlightType: this.getHighlightType(),
-      type: 'code-highlight',
-      version: 1
-    };
-  } // Prevent formatting (bold, underline, etc)
+    while (nextSiblings.length > 0) {
+      const node = nextSiblings.shift();
 
+      if (code.$isCodeHighlightNode(node)) {
+        const text = node.getTextContent();
+        const offset = findFirstNotSpaceOrTabCharAtText(text, true);
 
-  setFormat(format) {
-    return this;
+        if (offset !== -1) {
+          currentNode = node;
+          currentNodeOffset = offset;
+          break;
+        }
+      }
+
+      if (lexical.$isLineBreakNode(node)) {
+        break;
+      }
+    }
   }
 
+  return {
+    node: currentNode,
+    offset: currentNodeOffset
+  };
 }
+function getEndOfCodeInLine(anchor) {
+  let currentNode = null;
+  let currentNodeOffset = -1;
+  const nextSiblings = anchor.getNextSiblings();
+  nextSiblings.unshift(anchor);
 
-function getHighlightThemeClass(theme, highlightType) {
-  return highlightType && theme && theme.codeHighlight && theme.codeHighlight[highlightType];
-}
+  while (nextSiblings.length > 0) {
+    const node = nextSiblings.shift();
 
-function $createCodeHighlightNode(text, highlightType) {
-  return new CodeHighlightNode(text, highlightType);
-}
-function $isCodeHighlightNode(node) {
-  return node instanceof CodeHighlightNode;
-}
-const LANGUAGE_DATA_ATTRIBUTE = 'data-highlight-language';
-class CodeNode extends lexical.ElementNode {
-  static getType() {
-    return 'code';
-  }
+    if (code.$isCodeHighlightNode(node)) {
+      const text = node.getTextContent();
+      const offset = findFirstNotSpaceOrTabCharAtText(text, false);
 
-  static clone(node) {
-    return new CodeNode(node.__language, node.__key);
+      if (offset !== -1) {
+        currentNode = node;
+        currentNodeOffset = offset + 1;
+      }
+    }
+
+    if (lexical.$isLineBreakNode(node)) {
+      break;
+    }
   }
 
-  constructor(language, key) {
-    super(key);
-    this.__language = mapToPrismLanguage(language);
-  } // View
+  if (currentNode === null) {
+    const previousSiblings = anchor.getPreviousSiblings();
+
+    while (previousSiblings.length > 0) {
+      const node = previousSiblings.pop();
 
+      if (code.$isCodeHighlightNode(node)) {
+        const text = node.getTextContent();
+        const offset = findFirstNotSpaceOrTabCharAtText(text, false);
 
-  createDOM(config) {
-    const element = document.createElement('code');
-    utils.addClassNamesToElement(element, config.theme.code);
-    element.setAttribute('spellcheck', 'false');
-    const language = this.getLanguage();
+        if (offset !== -1) {
+          currentNode = node;
+          currentNodeOffset = offset + 1;
+          break;
+        }
+      }
 
-    if (language) {
-      element.setAttribute(LANGUAGE_DATA_ATTRIBUTE, language);
+      if (lexical.$isLineBreakNode(node)) {
+        break;
+      }
     }
-
-    return element;
   }
 
-  updateDOM(prevNode, dom) {
-    const language = this.__language;
-    const prevLanguage = prevNode.__language;
+  return {
+    node: currentNode,
+    offset: currentNodeOffset
+  };
+}
 
-    if (language) {
-      if (language !== prevLanguage) {
-        dom.setAttribute(LANGUAGE_DATA_ATTRIBUTE, language);
-      }
-    } else if (prevLanguage) {
-      dom.removeAttribute(LANGUAGE_DATA_ATTRIBUTE);
-    }
+function textNodeTransform(node, editor) {
+  // Since CodeNode has flat children structure we only need to check
+  // if node's parent is a code node and run highlighting if so
+  const parentNode = node.getParent();
 
-    return false;
+  if (code.$isCodeNode(parentNode)) {
+    codeNodeTransform(parentNode, editor);
+  } else if (code.$isCodeHighlightNode(node)) {
+    // When code block converted into paragraph or other element
+    // code highlight nodes converted back to normal text
+    node.replace(lexical.$createTextNode(node.__text));
   }
+}
 
-  static importDOM() {
-    return {
-      code: node => ({
-        conversion: convertPreElement,
-        priority: 0
-      }),
-      div: node => ({
-        conversion: convertDivElement,
-        priority: 1
-      }),
-      pre: node => ({
-        conversion: convertPreElement,
-        priority: 0
-      }),
-      table: node => {
-        const table = node; // domNode is a <table> since we matched it by nodeName
+function updateCodeGutter(node, editor) {
+  const codeElement = editor.getElementByKey(node.getKey());
 
-        if (isGitHubCodeTable(table)) {
-          return {
-            conversion: convertTableElement,
-            priority: 4
-          };
-        }
+  if (codeElement === null) {
+    return;
+  }
 
-        return null;
-      },
-      td: node => {
-        // element is a <td> since we matched it by nodeName
-        const td = node;
-        const table = td.closest('table');
+  const children = node.getChildren();
+  const childrenLength = children.length; // @ts-ignore: internal field
 
-        if (isGitHubCodeCell(td)) {
-          return {
-            conversion: convertTableCellElement,
-            priority: 4
-          };
-        }
+  if (childrenLength === codeElement.__cachedChildrenLength) {
+    // Avoid updating the attribute if the children length hasn't changed.
+    return;
+  } // @ts-ignore:: internal field
 
-        if (table && isGitHubCodeTable(table)) {
-          // Return a no-op if it's a table cell in a code table, but not a code line.
-          // Otherwise it'll fall back to the T
-          return {
-            conversion: convertCodeNoop,
-            priority: 4
-          };
-        }
-
-        return null;
-      },
-      tr: node => {
-        // element is a <tr> since we matched it by nodeName
-        const tr = node;
-        const table = tr.closest('table');
 
-        if (table && isGitHubCodeTable(table)) {
-          return {
-            conversion: convertCodeNoop,
-            priority: 4
-          };
-        }
+  codeElement.__cachedChildrenLength = childrenLength;
+  let gutter = '1';
+  let count = 1;
 
-        return null;
-      }
-    };
+  for (let i = 0; i < childrenLength; i++) {
+    if (lexical.$isLineBreakNode(children[i])) {
+      gutter += '\n' + ++count;
+    }
   }
 
-  static importJSON(serializedNode) {
-    const node = $createCodeNode(serializedNode.language);
-    node.setFormat(serializedNode.format);
-    node.setIndent(serializedNode.indent);
-    node.setDirection(serializedNode.direction);
-    return node;
+  codeElement.setAttribute('data-gutter', gutter);
+} // Using `skipTransforms` to prevent extra transforms since reformatting the code
+// will not affect code block content itself.
+//
+// Using extra flag (`isHighlighting`) since both CodeNode and CodeHighlightNode
+// transforms might be called at the same time (e.g. new CodeHighlight node inserted) and
+// in both cases we'll rerun whole reformatting over CodeNode, which is redundant.
+// Especially when pasting code into CodeBlock.
+
+
+let isHighlighting = false;
+
+function codeNodeTransform(node, editor) {
+  if (isHighlighting) {
+    return;
   }
 
-  exportJSON() {
-    return { ...super.exportJSON(),
-      language: this.getLanguage(),
-      type: 'code',
-      version: 1
-    };
-  } // Mutation
+  isHighlighting = true; // When new code block inserted it might not have language selected
 
+  if (node.getLanguage() === undefined) {
+    node.setLanguage(code.DEFAULT_CODE_LANGUAGE);
+  } // Using nested update call to pass `skipTransforms` since we don't want
+  // each individual codehighlight node to be transformed again as it's already
+  // in its final state
 
-  insertNewAfter(selection) {
-    const children = this.getChildren();
-    const childrenLength = children.length;
 
-    if (childrenLength >= 2 && children[childrenLength - 1].getTextContent() === '\n' && children[childrenLength - 2].getTextContent() === '\n' && selection.isCollapsed() && selection.anchor.key === this.__key && selection.anchor.offset === childrenLength) {
-      children[childrenLength - 1].remove();
-      children[childrenLength - 2].remove();
-      const newElement = lexical.$createParagraphNode();
-      this.insertAfter(newElement);
-      return newElement;
-    } // If the selection is within the codeblock, find all leading tabs and
-    // spaces of the current line. Create a new line that has all those
-    // tabs and spaces, such that leading indentation is preserved.
+  editor.update(() => {
+    updateAndRetainSelection(node, () => {
+      const code$1 = node.getTextContent();
+      const tokens = Prism.tokenize(code$1, Prism.languages[node.getLanguage() || ''] || Prism.languages[code.DEFAULT_CODE_LANGUAGE]);
+      const highlightNodes = getHighlightNodes(tokens);
+      const diffRange = getDiffRange(node.getChildren(), highlightNodes);
+      const {
+        from,
+        to,
+        nodesForReplacement
+      } = diffRange;
 
+      if (from !== to || nodesForReplacement.length) {
+        node.splice(from, to - from, nodesForReplacement);
+        return true;
+      }
 
-    const anchor = selection.anchor.getNode();
-    const firstNode = getFirstCodeHighlightNodeOfLine(anchor);
+      return false;
+    });
+  }, {
+    onUpdate: () => {
+      isHighlighting = false;
+    },
+    skipTransforms: true
+  });
+}
 
-    if (firstNode != null) {
-      let leadingWhitespace = 0;
-      const firstNodeText = firstNode.getTextContent();
+function getHighlightNodes(tokens) {
+  const nodes = [];
+  tokens.forEach(token => {
+    if (typeof token === 'string') {
+      const partials = token.split('\n');
 
-      while (leadingWhitespace < firstNodeText.length && /[\t ]/.test(firstNodeText[leadingWhitespace])) {
-        leadingWhitespace += 1;
+      for (let i = 0; i < partials.length; i++) {
+        const text = partials[i];
+
+        if (text.length) {
+          nodes.push(code.$createCodeHighlightNode(text));
+        }
+
+        if (i < partials.length - 1) {
+          nodes.push(lexical.$createLineBreakNode());
+        }
       }
+    } else {
+      const {
+        content
+      } = token;
 
-      if (leadingWhitespace > 0) {
-        const whitespace = firstNodeText.substring(0, leadingWhitespace);
-        const indentedChild = $createCodeHighlightNode(whitespace);
-        anchor.insertAfter(indentedChild);
-        selection.insertNodes([lexical.$createLineBreakNode()]);
-        indentedChild.select();
-        return indentedChild;
+      if (typeof content === 'string') {
+        nodes.push(code.$createCodeHighlightNode(content, token.type));
+      } else if (Array.isArray(content) && content.length === 1 && typeof content[0] === 'string') {
+        nodes.push(code.$createCodeHighlightNode(content[0], token.type));
+      } else if (Array.isArray(content)) {
+        nodes.push(...getHighlightNodes(content));
       }
     }
+  });
+  return nodes;
+} // Wrapping update function into selection retainer, that tries to keep cursor at the same
+// position as before.
 
-    return null;
-  }
-
-  canInsertTab() {
-    const selection = lexical.$getSelection();
 
-    if (!lexical.$isRangeSelection(selection) || !selection.isCollapsed()) {
-      return false;
-    }
+function updateAndRetainSelection(node, updateFn) {
+  const selection = lexical.$getSelection();
 
-    return true;
+  if (!lexical.$isRangeSelection(selection) || !selection.anchor) {
+    return;
   }
 
-  canIndent() {
-    return false;
-  }
+  const anchor = selection.anchor;
+  const anchorOffset = anchor.offset;
+  const isNewLineAnchor = anchor.type === 'element' && lexical.$isLineBreakNode(node.getChildAtIndex(anchor.offset - 1));
+  let textOffset = 0; // Calculating previous text offset (all text node prior to anchor + anchor own text offset)
 
-  collapseAtStart() {
-    const paragraph = lexical.$createParagraphNode();
-    const children = this.getChildren();
-    children.forEach(child => paragraph.append(child));
-    this.replace(paragraph);
-    return true;
+  if (!isNewLineAnchor) {
+    const anchorNode = anchor.getNode();
+    textOffset = anchorOffset + anchorNode.getPreviousSiblings().reduce((offset, _node) => {
+      return offset + (lexical.$isLineBreakNode(_node) ? 0 : _node.getTextContentSize());
+    }, 0);
   }
 
-  setLanguage(language) {
-    const writable = this.getWritable();
-    writable.__language = mapToPrismLanguage(language);
-  }
+  const hasChanges = updateFn();
 
-  getLanguage() {
-    return this.getLatest().__language;
-  }
+  if (!hasChanges) {
+    return;
+  } // Non-text anchors only happen for line breaks, otherwise
+  // selection will be within text node (code highlight node)
 
-}
-function $createCodeNode(language) {
-  return new CodeNode(language);
-}
-function $isCodeNode(node) {
-  return node instanceof CodeNode;
-}
-function getFirstCodeHighlightNodeOfLine(anchor) {
-  let currentNode = null;
-  const previousSiblings = anchor.getPreviousSiblings();
-  previousSiblings.push(anchor);
 
-  while (previousSiblings.length > 0) {
-    const node = previousSiblings.pop();
+  if (isNewLineAnchor) {
+    anchor.getNode().select(anchorOffset, anchorOffset);
+    return;
+  } // If it was non-element anchor then we walk through child nodes
+  // and looking for a position of original text offset
 
-    if ($isCodeHighlightNode(node)) {
-      currentNode = node;
+
+  node.getChildren().some(_node => {
+    if (lexical.$isTextNode(_node)) {
+      const textContentSize = _node.getTextContentSize();
+
+      if (textContentSize >= textOffset) {
+        _node.select(textOffset, textOffset);
+
+        return true;
+      }
+
+      textOffset -= textContentSize;
     }
 
-    if (lexical.$isLineBreakNode(node)) {
+    return false;
+  });
+} // Finds minimal diff range between two nodes lists. It returns from/to range boundaries of prevNodes
+// that needs to be replaced with `nodes` (subset of nextNodes) to make prevNodes equal to nextNodes.
+
+
+function getDiffRange(prevNodes, nextNodes) {
+  let leadingMatch = 0;
+
+  while (leadingMatch < prevNodes.length) {
+    if (!isEqual(prevNodes[leadingMatch], nextNodes[leadingMatch])) {
       break;
     }
-  }
 
-  return currentNode;
-}
-function getLastCodeHighlightNodeOfLine(anchor) {
-  let currentNode = null;
-  const nextSiblings = anchor.getNextSiblings();
-  nextSiblings.unshift(anchor);
+    leadingMatch++;
+  }
 
-  while (nextSiblings.length > 0) {
-    const node = nextSiblings.shift();
+  const prevNodesLength = prevNodes.length;
+  const nextNodesLength = nextNodes.length;
+  const maxTrailingMatch = Math.min(prevNodesLength, nextNodesLength) - leadingMatch;
+  let trailingMatch = 0;
 
-    if ($isCodeHighlightNode(node)) {
-      currentNode = node;
-    }
+  while (trailingMatch < maxTrailingMatch) {
+    trailingMatch++;
 
-    if (lexical.$isLineBreakNode(node)) {
+    if (!isEqual(prevNodes[prevNodesLength - trailingMatch], nextNodes[nextNodesLength - trailingMatch])) {
+      trailingMatch--;
       break;
     }
   }
 
-  return currentNode;
+  const from = leadingMatch;
+  const to = prevNodesLength - trailingMatch;
+  const nodesForReplacement = nextNodes.slice(leadingMatch, nextNodesLength - trailingMatch);
+  return {
+    from,
+    nodesForReplacement,
+    to
+  };
 }
 
-function isSpaceOrTabChar(char) {
-  return char === ' ' || char === '\t';
-}
+function isEqual(nodeA, nodeB) {
+  // Only checking for code higlight nodes and linebreaks. If it's regular text node
+  // returning false so that it's transformed into code highlight node
+  if (code.$isCodeHighlightNode(nodeA) && code.$isCodeHighlightNode(nodeB)) {
+    return nodeA.__text === nodeB.__text && nodeA.__highlightType === nodeB.__highlightType;
+  }
 
-function findFirstNotSpaceOrTabCharAtText(text, isForward) {
-  const length = text.length;
-  let offset = -1;
-
-  if (isForward) {
-    for (let i = 0; i < length; i++) {
-      const char = text[i];
-
-      if (!isSpaceOrTabChar(char)) {
-        offset = i;
-        break;
-      }
-    }
-  } else {
-    for (let i = length - 1; i > -1; i--) {
-      const char = text[i];
-
-      if (!isSpaceOrTabChar(char)) {
-        offset = i;
-        break;
-      }
-    }
+  if (lexical.$isLineBreakNode(nodeA) && lexical.$isLineBreakNode(nodeB)) {
+    return true;
   }
 
-  return offset;
+  return false;
 }
 
-function getStartOfCodeInLine(anchor) {
-  let currentNode = null;
-  let currentNodeOffset = -1;
-  const previousSiblings = anchor.getPreviousSiblings();
-  previousSiblings.push(anchor);
+function handleMultilineIndent(type) {
+  const selection = lexical.$getSelection();
 
-  while (previousSiblings.length > 0) {
-    const node = previousSiblings.pop();
+  if (!lexical.$isRangeSelection(selection) || selection.isCollapsed()) {
+    return false;
+  } // Only run multiline indent logic on selections exclusively composed of code highlights and linebreaks
 
-    if ($isCodeHighlightNode(node)) {
-      const text = node.getTextContent();
-      const offset = findFirstNotSpaceOrTabCharAtText(text, true);
 
-      if (offset !== -1) {
-        currentNode = node;
-        currentNodeOffset = offset;
-      }
-    }
+  const nodes = selection.getNodes();
 
-    if (lexical.$isLineBreakNode(node)) {
-      break;
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+
+    if (!code.$isCodeHighlightNode(node) && !lexical.$isLineBreakNode(node)) {
+      return false;
     }
   }
 
-  if (currentNode === null) {
-    const nextSiblings = anchor.getNextSiblings();
+  const startOfLine = code.getFirstCodeHighlightNodeOfLine(nodes[0]);
 
-    while (nextSiblings.length > 0) {
-      const node = nextSiblings.shift();
-
-      if ($isCodeHighlightNode(node)) {
-        const text = node.getTextContent();
-        const offset = findFirstNotSpaceOrTabCharAtText(text, true);
+  if (startOfLine != null) {
+    doIndent(startOfLine, type);
+  }
 
-        if (offset !== -1) {
-          currentNode = node;
-          currentNodeOffset = offset;
-          break;
-        }
-      }
+  for (let i = 1; i < nodes.length; i++) {
+    const node = nodes[i];
 
-      if (lexical.$isLineBreakNode(node)) {
-        break;
-      }
+    if (lexical.$isLineBreakNode(nodes[i - 1]) && code.$isCodeHighlightNode(node)) {
+      doIndent(node, type);
     }
   }
 
-  return {
-    node: currentNode,
-    offset: currentNodeOffset
-  };
+  return true;
 }
-function getEndOfCodeInLine(anchor) {
-  let currentNode = null;
-  let currentNodeOffset = -1;
-  const nextSiblings = anchor.getNextSiblings();
-  nextSiblings.unshift(anchor);
 
-  while (nextSiblings.length > 0) {
-    const node = nextSiblings.shift();
-
-    if ($isCodeHighlightNode(node)) {
-      const text = node.getTextContent();
-      const offset = findFirstNotSpaceOrTabCharAtText(text, false);
+function doIndent(node, type) {
+  const text = node.getTextContent();
 
-      if (offset !== -1) {
-        currentNode = node;
-        currentNodeOffset = offset + 1;
-      }
+  if (type === lexical.INDENT_CONTENT_COMMAND) {
+    // If the codeblock node doesn't start with whitespace, we don't want to
+    // naively prepend a '\t'; Prism will then mangle all of our nodes when
+    // it separates the whitespace from the first non-whitespace node. This
+    // will lead to selection bugs when indenting lines that previously
+    // didn't start with a whitespace character
+    if (text.length > 0 && /\s/.test(text[0])) {
+      node.setTextContent('\t' + text);
+    } else {
+      const indentNode = code.$createCodeHighlightNode('\t');
+      node.insertBefore(indentNode);
     }
-
-    if (lexical.$isLineBreakNode(node)) {
-      break;
+  } else {
+    if (text.indexOf('\t') === 0) {
+      // Same as above - if we leave empty text nodes lying around, the resulting
+      // selection will be mangled
+      if (text.length === 1) {
+        node.remove();
+      } else {
+        node.setTextContent(text.substring(1));
+      }
     }
   }
+}
 
-  if (currentNode === null) {
-    const previousSiblings = anchor.getPreviousSiblings();
+function handleShiftLines(type, event) {
+  // We only care about the alt+arrow keys
+  const selection = lexical.$getSelection();
 
-    while (previousSiblings.length > 0) {
-      const node = previousSiblings.pop();
+  if (!lexical.$isRangeSelection(selection)) {
+    return false;
+  } // I'm not quite sure why, but it seems like calling anchor.getNode() collapses the selection here
+  // So first, get the anchor and the focus, then get their nodes
 
-      if ($isCodeHighlightNode(node)) {
-        const text = node.getTextContent();
-        const offset = findFirstNotSpaceOrTabCharAtText(text, false);
 
-        if (offset !== -1) {
-          currentNode = node;
-          currentNodeOffset = offset + 1;
-          break;
-        }
-      }
+  const {
+    anchor,
+    focus
+  } = selection;
+  const anchorOffset = anchor.offset;
+  const focusOffset = focus.offset;
+  const anchorNode = anchor.getNode();
+  const focusNode = focus.getNode();
+  const arrowIsUp = type === lexical.KEY_ARROW_UP_COMMAND; // Ensure the selection is within the codeblock
 
-      if (lexical.$isLineBreakNode(node)) {
-        break;
-      }
-    }
+  if (!code.$isCodeHighlightNode(anchorNode) || !code.$isCodeHighlightNode(focusNode)) {
+    return false;
   }
 
-  return {
-    node: currentNode,
-    offset: currentNodeOffset
-  };
-}
+  if (!event.altKey) {
+    // Handle moving selection out of the code block, given there are no
+    // sibling thats can natively take the selection.
+    if (selection.isCollapsed()) {
+      const codeNode = anchorNode.getParentOrThrow();
 
-function convertPreElement(domNode) {
-  return {
-    node: $createCodeNode()
-  };
-}
+      if (arrowIsUp && anchorOffset === 0 && anchorNode.getPreviousSibling() === null) {
+        const codeNodeSibling = codeNode.getPreviousSibling();
 
-function convertDivElement(domNode) {
-  // domNode is a <div> since we matched it by nodeName
-  const div = domNode;
-  return {
-    after: childLexicalNodes => {
-      const domParent = domNode.parentNode;
+        if (codeNodeSibling === null) {
+          codeNode.selectPrevious();
+          event.preventDefault();
+          return true;
+        }
+      } else if (!arrowIsUp && anchorOffset === anchorNode.getTextContentSize() && anchorNode.getNextSibling() === null) {
+        const codeNodeSibling = codeNode.getNextSibling();
 
-      if (domParent != null && domNode !== domParent.lastChild) {
-        childLexicalNodes.push(lexical.$createLineBreakNode());
+        if (codeNodeSibling === null) {
+          codeNode.selectNext();
+          event.preventDefault();
+          return true;
+        }
       }
+    }
 
-      return childLexicalNodes;
-    },
-    node: isCodeElement(div) ? $createCodeNode() : null
-  };
-}
+    return false;
+  }
 
-function convertTableElement() {
-  return {
-    node: $createCodeNode()
-  };
-}
+  const start = code.getFirstCodeHighlightNodeOfLine(anchorNode);
+  const end = code.getLastCodeHighlightNodeOfLine(focusNode);
 
-function convertCodeNoop() {
-  return {
-    node: null
-  };
-}
+  if (start == null || end == null) {
+    return false;
+  }
 
-function convertTableCellElement(domNode) {
-  // domNode is a <td> since we matched it by nodeName
-  const cell = domNode;
-  return {
-    after: childLexicalNodes => {
-      if (cell.parentNode && cell.parentNode.nextSibling) {
-        // Append newline between code lines
-        childLexicalNodes.push(lexical.$createLineBreakNode());
-      }
+  const range = start.getNodesBetween(end);
 
-      return childLexicalNodes;
-    },
-    node: null
-  };
-}
+  for (let i = 0; i < range.length; i++) {
+    const node = range[i];
 
-function isCodeElement(div) {
-  return div.style.fontFamily.match('monospace') !== null;
-}
+    if (!code.$isCodeHighlightNode(node) && !lexical.$isLineBreakNode(node)) {
+      return false;
+    }
+  } // After this point, we know the selection is within the codeblock. We may not be able to
+  // actually move the lines around, but we want to return true either way to prevent
+  // the event's default behavior
 
-function isGitHubCodeCell(cell) {
-  return cell.classList.contains('js-file-line');
-}
 
-function isGitHubCodeTable(table) {
-  return table.classList.contains('js-file-line-container');
-}
+  event.preventDefault();
+  event.stopPropagation(); // required to stop cursor movement under Firefox
 
-function textNodeTransform(node, editor) {
-  // Since CodeNode has flat children structure we only need to check
-  // if node's parent is a code node and run highlighting if so
-  const parentNode = node.getParent();
+  const linebreak = arrowIsUp ? start.getPreviousSibling() : end.getNextSibling();
 
-  if ($isCodeNode(parentNode)) {
-    codeNodeTransform(parentNode, editor);
-  } else if ($isCodeHighlightNode(node)) {
-    // When code block converted into paragraph or other element
-    // code highlight nodes converted back to normal text
-    node.replace(lexical.$createTextNode(node.__text));
+  if (!lexical.$isLineBreakNode(linebreak)) {
+    return true;
   }
-}
 
-function updateCodeGutter(node, editor) {
-  const codeElement = editor.getElementByKey(node.getKey());
+  const sibling = arrowIsUp ? linebreak.getPreviousSibling() : linebreak.getNextSibling();
 
-  if (codeElement === null) {
-    return;
+  if (sibling == null) {
+    return true;
   }
 
-  const children = node.getChildren();
-  const childrenLength = children.length; // @ts-ignore: internal field
+  const maybeInsertionPoint = arrowIsUp ? code.getFirstCodeHighlightNodeOfLine(sibling) : code.getLastCodeHighlightNodeOfLine(sibling);
+  let insertionPoint = maybeInsertionPoint != null ? maybeInsertionPoint : sibling;
+  linebreak.remove();
+  range.forEach(node => node.remove());
 
-  if (childrenLength === codeElement.__cachedChildrenLength) {
-    // Avoid updating the attribute if the children length hasn't changed.
-    return;
-  } // @ts-ignore:: internal field
+  if (type === lexical.KEY_ARROW_UP_COMMAND) {
+    range.forEach(node => insertionPoint.insertBefore(node));
+    insertionPoint.insertBefore(linebreak);
+  } else {
+    insertionPoint.insertAfter(linebreak);
+    insertionPoint = linebreak;
+    range.forEach(node => {
+      insertionPoint.insertAfter(node);
+      insertionPoint = node;
+    });
+  }
 
+  selection.setTextNodeRange(anchorNode, anchorOffset, focusNode, focusOffset);
+  return true;
+}
 
-  codeElement.__cachedChildrenLength = childrenLength;
-  let gutter = '1';
-  let count = 1;
+function handleMoveTo(type, event) {
+  const selection = lexical.$getSelection();
 
-  for (let i = 0; i < childrenLength; i++) {
-    if (lexical.$isLineBreakNode(children[i])) {
-      gutter += '\n' + ++count;
-    }
+  if (!lexical.$isRangeSelection(selection)) {
+    return false;
   }
 
-  codeElement.setAttribute('data-gutter', gutter);
-} // Using `skipTransforms` to prevent extra transforms since reformatting the code
-// will not affect code block content itself.
-//
-// Using extra flag (`isHighlighting`) since both CodeNode and CodeHighlightNode
-// trasnforms might be called at the same time (e.g. new CodeHighlight node inserted) and
-// in both cases we'll rerun whole reformatting over CodeNode, which is redundant.
-// Especially when pasting code into CodeBlock.
+  const {
+    anchor,
+    focus
+  } = selection;
+  const anchorNode = anchor.getNode();
+  const focusNode = focus.getNode();
+  const isMoveToStart = type === lexical.MOVE_TO_START;
 
+  if (!code.$isCodeHighlightNode(anchorNode) || !code.$isCodeHighlightNode(focusNode)) {
+    return false;
+  }
 
-let isHighlighting = false;
+  let node;
+  let offset;
 
-function codeNodeTransform(node, editor) {
-  if (isHighlighting) {
-    return;
+  if (isMoveToStart) {
+    ({
+      node,
+      offset
+    } = getStartOfCodeInLine(focusNode));
+  } else {
+    ({
+      node,
+      offset
+    } = getEndOfCodeInLine(focusNode));
   }
 
-  isHighlighting = true; // When new code block inserted it might not have language selected
+  if (node !== null && offset !== -1) {
+    selection.setTextNodeRange(node, offset, node, offset);
+  }
 
-  if (node.getLanguage() === undefined) {
-    node.setLanguage(DEFAULT_CODE_LANGUAGE);
-  } // Using nested update call to pass `skipTransforms` since we don't want
-  // each individual codehighlight node to be transformed again as it's already
-  // in its final state
+  event.preventDefault();
+  event.stopPropagation();
+  return true;
+}
 
+function registerCodeHighlighting(editor) {
+  if (!editor.hasNodes([code.CodeNode, code.CodeHighlightNode])) {
+    throw new Error('CodeHighlightPlugin: CodeNode or CodeHighlightNode not registered on editor');
+  }
 
-  editor.update(() => {
-    updateAndRetainSelection(node, () => {
-      const code = node.getTextContent();
-      const tokens = Prism.tokenize(code, Prism.languages[node.getLanguage() || ''] || Prism.languages[DEFAULT_CODE_LANGUAGE]);
-      const highlightNodes = getHighlightNodes(tokens);
-      const diffRange = getDiffRange(node.getChildren(), highlightNodes);
-      const {
-        from,
-        to,
-        nodesForReplacement
-      } = diffRange;
+  return utils.mergeRegister(editor.registerMutationListener(code.CodeNode, mutations => {
+    editor.update(() => {
+      for (const [key, type] of mutations) {
+        if (type !== 'destroyed') {
+          const node = lexical.$getNodeByKey(key);
 
-      if (from !== to || nodesForReplacement.length) {
-        node.splice(from, to - from, nodesForReplacement);
-        return true;
+          if (node !== null) {
+            updateCodeGutter(node, editor);
+          }
+        }
       }
-
-      return false;
     });
-  }, {
-    onUpdate: () => {
-      isHighlighting = false;
-    },
-    skipTransforms: true
-  });
+  }), editor.registerNodeTransform(code.CodeNode, node => codeNodeTransform(node, editor)), editor.registerNodeTransform(lexical.TextNode, node => textNodeTransform(node, editor)), editor.registerNodeTransform(code.CodeHighlightNode, node => textNodeTransform(node, editor)), editor.registerCommand(lexical.INDENT_CONTENT_COMMAND, payload => handleMultilineIndent(lexical.INDENT_CONTENT_COMMAND), lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical.OUTDENT_CONTENT_COMMAND, payload => handleMultilineIndent(lexical.OUTDENT_CONTENT_COMMAND), lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical.KEY_ARROW_UP_COMMAND, payload => handleShiftLines(lexical.KEY_ARROW_UP_COMMAND, payload), lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical.KEY_ARROW_DOWN_COMMAND, payload => handleShiftLines(lexical.KEY_ARROW_DOWN_COMMAND, payload), lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical.MOVE_TO_END, payload => handleMoveTo(lexical.MOVE_TO_END, payload), lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical.MOVE_TO_START, payload => handleMoveTo(lexical.MOVE_TO_START, payload), lexical.COMMAND_PRIORITY_LOW));
 }
 
-function getHighlightNodes(tokens) {
-  const nodes = [];
-  tokens.forEach(token => {
-    if (typeof token === 'string') {
-      const partials = token.split('\n');
+/**
+ * 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.
+ *
+ */
+const DEFAULT_CODE_LANGUAGE = 'javascript';
+const CODE_LANGUAGE_FRIENDLY_NAME_MAP = {
+  c: 'C',
+  clike: 'C-like',
+  css: 'CSS',
+  html: 'HTML',
+  js: 'JavaScript',
+  markdown: 'Markdown',
+  objc: 'Objective-C',
+  plain: 'Plain Text',
+  py: 'Python',
+  rust: 'Rust',
+  sql: 'SQL',
+  swift: 'Swift',
+  xml: 'XML'
+};
+const CODE_LANGUAGE_MAP = {
+  javascript: 'js',
+  md: 'markdown',
+  plaintext: 'plain',
+  python: 'py',
+  text: 'plain'
+};
+function normalizeCodeLang(lang) {
+  return CODE_LANGUAGE_MAP[lang] || lang;
+}
+function getLanguageFriendlyName(lang) {
+  const _lang = normalizeCodeLang(lang);
 
-      for (let i = 0; i < partials.length; i++) {
-        const text = partials[i];
+  return CODE_LANGUAGE_FRIENDLY_NAME_MAP[_lang] || _lang;
+}
+const getDefaultCodeLanguage = () => DEFAULT_CODE_LANGUAGE;
+const getCodeLanguages = () => Object.keys(Prism.languages).filter( // Prism has several language helpers mixed into languages object
+// so filtering them out here to get langs list
+language => typeof Prism.languages[language] !== 'function').sort();
+class CodeHighlightNode extends lexical.TextNode {
+  constructor(text, highlightType, key) {
+    super(text, key);
+    this.__highlightType = highlightType;
+  }
 
-        if (text.length) {
-          nodes.push($createCodeHighlightNode(text));
-        }
+  static getType() {
+    return 'code-highlight';
+  }
 
-        if (i < partials.length - 1) {
-          nodes.push(lexical.$createLineBreakNode());
-        }
-      }
-    } else {
-      const {
-        content
-      } = token;
+  static clone(node) {
+    return new CodeHighlightNode(node.__text, node.__highlightType || undefined, node.__key);
+  }
+
+  getHighlightType() {
+    const self = this.getLatest();
+    return self.__highlightType;
+  }
+
+  createDOM(config) {
+    const element = super.createDOM(config);
+    const className = getHighlightThemeClass(config.theme, this.__highlightType);
+    utils.addClassNamesToElement(element, className);
+    return element;
+  }
+
+  updateDOM(prevNode, dom, config) {
+    const update = super.updateDOM(prevNode, dom, config);
+    const prevClassName = getHighlightThemeClass(config.theme, prevNode.__highlightType);
+    const nextClassName = getHighlightThemeClass(config.theme, this.__highlightType);
+
+    if (prevClassName !== nextClassName) {
+      if (prevClassName) {
+        utils.removeClassNamesFromElement(dom, prevClassName);
+      }
 
-      if (typeof content === 'string') {
-        nodes.push($createCodeHighlightNode(content, token.type));
-      } else if (Array.isArray(content) && content.length === 1 && typeof content[0] === 'string') {
-        nodes.push($createCodeHighlightNode(content[0], token.type));
-      } else if (Array.isArray(content)) {
-        nodes.push(...getHighlightNodes(content));
+      if (nextClassName) {
+        utils.addClassNamesToElement(dom, nextClassName);
       }
     }
-  });
-  return nodes;
-} // Wrapping update function into selection retainer, that tries to keep cursor at the same
-// position as before.
-
-
-function updateAndRetainSelection(node, updateFn) {
-  const selection = lexical.$getSelection();
 
-  if (!lexical.$isRangeSelection(selection) || !selection.anchor) {
-    return;
+    return update;
   }
 
-  const anchor = selection.anchor;
-  const anchorOffset = anchor.offset;
-  const isNewLineAnchor = anchor.type === 'element' && lexical.$isLineBreakNode(node.getChildAtIndex(anchor.offset - 1));
-  let textOffset = 0; // Calculating previous text offset (all text node prior to anchor + anchor own text offset)
-
-  if (!isNewLineAnchor) {
-    const anchorNode = anchor.getNode();
-    textOffset = anchorOffset + anchorNode.getPreviousSiblings().reduce((offset, _node) => {
-      return offset + (lexical.$isLineBreakNode(_node) ? 0 : _node.getTextContentSize());
-    }, 0);
+  static importJSON(serializedNode) {
+    const node = $createCodeHighlightNode(serializedNode.text, serializedNode.highlightType);
+    node.setFormat(serializedNode.format);
+    node.setDetail(serializedNode.detail);
+    node.setMode(serializedNode.mode);
+    node.setStyle(serializedNode.style);
+    return node;
   }
 
-  const hasChanges = updateFn();
-
-  if (!hasChanges) {
-    return;
-  } // Non-text anchors only happen for line breaks, otherwise
-  // selection will be within text node (code highlight node)
+  exportJSON() {
+    return { ...super.exportJSON(),
+      highlightType: this.getHighlightType(),
+      type: 'code-highlight',
+      version: 1
+    };
+  } // Prevent formatting (bold, underline, etc)
 
 
-  if (isNewLineAnchor) {
-    anchor.getNode().select(anchorOffset, anchorOffset);
-    return;
-  } // If it was non-element anchor then we walk through child nodes
-  // and looking for a position of original text offset
+  setFormat(format) {
+    return this;
+  }
 
+}
 
-  node.getChildren().some(_node => {
-    if (lexical.$isTextNode(_node)) {
-      const textContentSize = _node.getTextContentSize();
+function getHighlightThemeClass(theme, highlightType) {
+  return highlightType && theme && theme.codeHighlight && theme.codeHighlight[highlightType];
+}
 
-      if (textContentSize >= textOffset) {
-        _node.select(textOffset, textOffset);
+function $createCodeHighlightNode(text, highlightType) {
+  return new CodeHighlightNode(text, highlightType);
+}
+function $isCodeHighlightNode(node) {
+  return node instanceof CodeHighlightNode;
+}
+function getFirstCodeHighlightNodeOfLine(anchor) {
+  let currentNode = null;
+  const previousSiblings = anchor.getPreviousSiblings();
+  previousSiblings.push(anchor);
 
-        return true;
-      }
+  while (previousSiblings.length > 0) {
+    const node = previousSiblings.pop();
 
-      textOffset -= textContentSize;
+    if ($isCodeHighlightNode(node)) {
+      currentNode = node;
     }
 
-    return false;
-  });
-} // Finds minimal diff range between two nodes lists. It returns from/to range boundaries of prevNodes
-// that needs to be replaced with `nodes` (subset of nextNodes) to make prevNodes equal to nextNodes.
-
-
-function getDiffRange(prevNodes, nextNodes) {
-  let leadingMatch = 0;
-
-  while (leadingMatch < prevNodes.length) {
-    if (!isEqual(prevNodes[leadingMatch], nextNodes[leadingMatch])) {
+    if (lexical.$isLineBreakNode(node)) {
       break;
     }
-
-    leadingMatch++;
   }
 
-  const prevNodesLength = prevNodes.length;
-  const nextNodesLength = nextNodes.length;
-  const maxTrailingMatch = Math.min(prevNodesLength, nextNodesLength) - leadingMatch;
-  let trailingMatch = 0;
+  return currentNode;
+}
+function getLastCodeHighlightNodeOfLine(anchor) {
+  let currentNode = null;
+  const nextSiblings = anchor.getNextSiblings();
+  nextSiblings.unshift(anchor);
 
-  while (trailingMatch < maxTrailingMatch) {
-    trailingMatch++;
+  while (nextSiblings.length > 0) {
+    const node = nextSiblings.shift();
 
-    if (!isEqual(prevNodes[prevNodesLength - trailingMatch], nextNodes[nextNodesLength - trailingMatch])) {
-      trailingMatch--;
+    if ($isCodeHighlightNode(node)) {
+      currentNode = node;
+    }
+
+    if (lexical.$isLineBreakNode(node)) {
       break;
     }
   }
 
-  const from = leadingMatch;
-  const to = prevNodesLength - trailingMatch;
-  const nodesForReplacement = nextNodes.slice(leadingMatch, nextNodesLength - trailingMatch);
-  return {
-    from,
-    nodesForReplacement,
-    to
-  };
+  return currentNode;
 }
 
-function isEqual(nodeA, nodeB) {
-  // Only checking for code higlight nodes and linebreaks. If it's regular text node
-  // returning false so that it's transformed into code highlight node
-  if ($isCodeHighlightNode(nodeA) && $isCodeHighlightNode(nodeB)) {
-    return nodeA.__text === nodeB.__text && nodeA.__highlightType === nodeB.__highlightType;
-  }
-
-  if (lexical.$isLineBreakNode(nodeA) && lexical.$isLineBreakNode(nodeB)) {
-    return 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.
+ *
+ */
 
-  return false;
-}
+const mapToPrismLanguage = language => {
+  // eslint-disable-next-line no-prototype-builtins
+  return language != null && Prism.languages.hasOwnProperty(language) ? language : undefined;
+};
 
-function handleMultilineIndent(type) {
-  const selection = lexical.$getSelection();
+const LANGUAGE_DATA_ATTRIBUTE = 'data-highlight-language';
+class CodeNode extends lexical.ElementNode {
+  static getType() {
+    return 'code';
+  }
 
-  if (!lexical.$isRangeSelection(selection) || selection.isCollapsed()) {
-    return false;
-  } // Only run multiline indent logic on selections exclusively composed of code highlights and linebreaks
+  static clone(node) {
+    return new CodeNode(node.__language, node.__key);
+  }
 
+  constructor(language, key) {
+    super(key);
+    this.__language = mapToPrismLanguage(language);
+  } // View
 
-  const nodes = selection.getNodes();
 
-  for (let i = 0; i < nodes.length; i++) {
-    const node = nodes[i];
+  createDOM(config) {
+    const element = document.createElement('code');
+    utils.addClassNamesToElement(element, config.theme.code);
+    element.setAttribute('spellcheck', 'false');
+    const language = this.getLanguage();
 
-    if (!$isCodeHighlightNode(node) && !lexical.$isLineBreakNode(node)) {
-      return false;
+    if (language) {
+      element.setAttribute(LANGUAGE_DATA_ATTRIBUTE, language);
     }
-  }
-
-  const startOfLine = getFirstCodeHighlightNodeOfLine(nodes[0]);
 
-  if (startOfLine != null) {
-    doIndent(startOfLine, type);
+    return element;
   }
 
-  for (let i = 1; i < nodes.length; i++) {
-    const node = nodes[i];
+  updateDOM(prevNode, dom) {
+    const language = this.__language;
+    const prevLanguage = prevNode.__language;
 
-    if (lexical.$isLineBreakNode(nodes[i - 1]) && $isCodeHighlightNode(node)) {
-      doIndent(node, type);
+    if (language) {
+      if (language !== prevLanguage) {
+        dom.setAttribute(LANGUAGE_DATA_ATTRIBUTE, language);
+      }
+    } else if (prevLanguage) {
+      dom.removeAttribute(LANGUAGE_DATA_ATTRIBUTE);
     }
+
+    return false;
   }
 
-  return true;
-}
+  static importDOM() {
+    return {
+      // Typically <pre> is used for code blocks, and <code> for inline code styles
+      // but if it's a multi line <code> we'll create a block. Pass through to
+      // inline format handled by TextNode otherwise
+      code: node => {
+        const isMultiLine = node.textContent != null && /\r?\n/.test(node.textContent);
+        return isMultiLine ? {
+          conversion: convertPreElement,
+          priority: 1
+        } : null;
+      },
+      div: node => ({
+        conversion: convertDivElement,
+        priority: 1
+      }),
+      pre: node => ({
+        conversion: convertPreElement,
+        priority: 0
+      }),
+      table: node => {
+        const table = node; // domNode is a <table> since we matched it by nodeName
 
-function doIndent(node, type) {
-  const text = node.getTextContent();
+        if (isGitHubCodeTable(table)) {
+          return {
+            conversion: convertTableElement,
+            priority: 4
+          };
+        }
 
-  if (type === lexical.INDENT_CONTENT_COMMAND) {
-    // If the codeblock node doesn't start with whitespace, we don't want to
-    // naively prepend a '\t'; Prism will then mangle all of our nodes when
-    // it separates the whitespace from the first non-whitespace node. This
-    // will lead to selection bugs when indenting lines that previously
-    // didn't start with a whitespace character
-    if (text.length > 0 && /\s/.test(text[0])) {
-      node.setTextContent('\t' + text);
-    } else {
-      const indentNode = $createCodeHighlightNode('\t');
-      node.insertBefore(indentNode);
-    }
-  } else {
-    if (text.indexOf('\t') === 0) {
-      // Same as above - if we leave empty text nodes lying around, the resulting
-      // selection will be mangled
-      if (text.length === 1) {
-        node.remove();
-      } else {
-        node.setTextContent(text.substring(1));
-      }
-    }
-  }
-}
+        return null;
+      },
+      td: node => {
+        // element is a <td> since we matched it by nodeName
+        const td = node;
+        const table = td.closest('table');
 
-function handleShiftLines(type, event) {
-  // We only care about the alt+arrow keys
-  const selection = lexical.$getSelection();
+        if (isGitHubCodeCell(td)) {
+          return {
+            conversion: convertTableCellElement,
+            priority: 4
+          };
+        }
 
-  if (!lexical.$isRangeSelection(selection)) {
-    return false;
-  } // I'm not quite sure why, but it seems like calling anchor.getNode() collapses the selection here
-  // So first, get the anchor and the focus, then get their nodes
+        if (table && isGitHubCodeTable(table)) {
+          // Return a no-op if it's a table cell in a code table, but not a code line.
+          // Otherwise it'll fall back to the T
+          return {
+            conversion: convertCodeNoop,
+            priority: 4
+          };
+        }
 
+        return null;
+      },
+      tr: node => {
+        // element is a <tr> since we matched it by nodeName
+        const tr = node;
+        const table = tr.closest('table');
 
-  const {
-    anchor,
-    focus
-  } = selection;
-  const anchorOffset = anchor.offset;
-  const focusOffset = focus.offset;
-  const anchorNode = anchor.getNode();
-  const focusNode = focus.getNode();
-  const arrowIsUp = type === lexical.KEY_ARROW_UP_COMMAND; // Ensure the selection is within the codeblock
+        if (table && isGitHubCodeTable(table)) {
+          return {
+            conversion: convertCodeNoop,
+            priority: 4
+          };
+        }
 
-  if (!$isCodeHighlightNode(anchorNode) || !$isCodeHighlightNode(focusNode)) {
-    return false;
+        return null;
+      }
+    };
   }
 
-  if (!event.altKey) {
-    // Handle moving selection out of the code block, given there are no
-    // sibling thats can natively take the selection.
-    if (selection.isCollapsed()) {
-      const codeNode = anchorNode.getParentOrThrow();
+  static importJSON(serializedNode) {
+    const node = $createCodeNode(serializedNode.language);
+    node.setFormat(serializedNode.format);
+    node.setIndent(serializedNode.indent);
+    node.setDirection(serializedNode.direction);
+    return node;
+  }
 
-      if (arrowIsUp && anchorOffset === 0 && anchorNode.getPreviousSibling() === null) {
-        const codeNodeSibling = codeNode.getPreviousSibling();
+  exportJSON() {
+    return { ...super.exportJSON(),
+      language: this.getLanguage(),
+      type: 'code',
+      version: 1
+    };
+  } // Mutation
 
-        if (codeNodeSibling === null) {
-          codeNode.selectPrevious();
-          event.preventDefault();
-          return true;
-        }
-      } else if (!arrowIsUp && anchorOffset === anchorNode.getTextContentSize() && anchorNode.getNextSibling() === null) {
-        const codeNodeSibling = codeNode.getNextSibling();
 
-        if (codeNodeSibling === null) {
-          codeNode.selectNext();
-          event.preventDefault();
-          return true;
-        }
-      }
-    }
+  insertNewAfter(selection) {
+    const children = this.getChildren();
+    const childrenLength = children.length;
 
-    return false;
-  }
+    if (childrenLength >= 2 && children[childrenLength - 1].getTextContent() === '\n' && children[childrenLength - 2].getTextContent() === '\n' && selection.isCollapsed() && selection.anchor.key === this.__key && selection.anchor.offset === childrenLength) {
+      children[childrenLength - 1].remove();
+      children[childrenLength - 2].remove();
+      const newElement = lexical.$createParagraphNode();
+      this.insertAfter(newElement);
+      return newElement;
+    } // If the selection is within the codeblock, find all leading tabs and
+    // spaces of the current line. Create a new line that has all those
+    // tabs and spaces, such that leading indentation is preserved.
 
-  const start = getFirstCodeHighlightNodeOfLine(anchorNode);
-  const end = getLastCodeHighlightNodeOfLine(focusNode);
 
-  if (start == null || end == null) {
-    return false;
-  }
+    const anchor = selection.anchor.getNode();
+    const firstNode = code.getFirstCodeHighlightNodeOfLine(anchor);
 
-  const range = start.getNodesBetween(end);
+    if (firstNode != null) {
+      let leadingWhitespace = 0;
+      const firstNodeText = firstNode.getTextContent();
 
-  for (let i = 0; i < range.length; i++) {
-    const node = range[i];
+      while (leadingWhitespace < firstNodeText.length && /[\t ]/.test(firstNodeText[leadingWhitespace])) {
+        leadingWhitespace += 1;
+      }
 
-    if (!$isCodeHighlightNode(node) && !lexical.$isLineBreakNode(node)) {
-      return false;
+      if (leadingWhitespace > 0) {
+        const whitespace = firstNodeText.substring(0, leadingWhitespace);
+        const indentedChild = code.$createCodeHighlightNode(whitespace);
+        anchor.insertAfter(indentedChild);
+        selection.insertNodes([lexical.$createLineBreakNode()]);
+        indentedChild.select();
+        return indentedChild;
+      }
     }
-  } // After this point, we know the selection is within the codeblock. We may not be able to
-  // actually move the lines around, but we want to return true either way to prevent
-  // the event's default behavior
 
+    return null;
+  }
 
-  event.preventDefault();
-  event.stopPropagation(); // required to stop cursor movement under Firefox
+  canInsertTab() {
+    const selection = lexical.$getSelection();
 
-  const linebreak = arrowIsUp ? start.getPreviousSibling() : end.getNextSibling();
+    if (!lexical.$isRangeSelection(selection) || !selection.isCollapsed()) {
+      return false;
+    }
 
-  if (!lexical.$isLineBreakNode(linebreak)) {
     return true;
   }
 
-  const sibling = arrowIsUp ? linebreak.getPreviousSibling() : linebreak.getNextSibling();
+  canIndent() {
+    return false;
+  }
 
-  if (sibling == null) {
+  collapseAtStart() {
+    const paragraph = lexical.$createParagraphNode();
+    const children = this.getChildren();
+    children.forEach(child => paragraph.append(child));
+    this.replace(paragraph);
     return true;
   }
 
-  const maybeInsertionPoint = arrowIsUp ? getFirstCodeHighlightNodeOfLine(sibling) : getLastCodeHighlightNodeOfLine(sibling);
-  let insertionPoint = maybeInsertionPoint != null ? maybeInsertionPoint : sibling;
-  linebreak.remove();
-  range.forEach(node => node.remove());
+  setLanguage(language) {
+    const writable = this.getWritable();
+    writable.__language = mapToPrismLanguage(language);
+  }
 
-  if (type === lexical.KEY_ARROW_UP_COMMAND) {
-    range.forEach(node => insertionPoint.insertBefore(node));
-    insertionPoint.insertBefore(linebreak);
-  } else {
-    insertionPoint.insertAfter(linebreak);
-    insertionPoint = linebreak;
-    range.forEach(node => {
-      insertionPoint.insertAfter(node);
-      insertionPoint = node;
-    });
+  getLanguage() {
+    return this.getLatest().__language;
   }
 
-  selection.setTextNodeRange(anchorNode, anchorOffset, focusNode, focusOffset);
-  return true;
+}
+function $createCodeNode(language) {
+  return new CodeNode(language);
+}
+function $isCodeNode(node) {
+  return node instanceof CodeNode;
 }
 
-function handleMoveTo(type, event) {
-  const selection = lexical.$getSelection();
+function convertPreElement(domNode) {
+  return {
+    node: $createCodeNode()
+  };
+}
 
-  if (!lexical.$isRangeSelection(selection)) {
-    return false;
-  }
+function convertDivElement(domNode) {
+  // domNode is a <div> since we matched it by nodeName
+  const div = domNode;
+  return {
+    after: childLexicalNodes => {
+      const domParent = domNode.parentNode;
 
-  const {
-    anchor,
-    focus
-  } = selection;
-  const anchorNode = anchor.getNode();
-  const focusNode = focus.getNode();
-  const isMoveToStart = type === lexical.MOVE_TO_START;
+      if (domParent != null && domNode !== domParent.lastChild) {
+        childLexicalNodes.push(lexical.$createLineBreakNode());
+      }
 
-  if (!$isCodeHighlightNode(anchorNode) || !$isCodeHighlightNode(focusNode)) {
-    return false;
-  }
+      return childLexicalNodes;
+    },
+    node: isCodeElement(div) ? $createCodeNode() : null
+  };
+}
 
-  let node;
-  let offset;
+function convertTableElement() {
+  return {
+    node: $createCodeNode()
+  };
+}
 
-  if (isMoveToStart) {
-    ({
-      node,
-      offset
-    } = getStartOfCodeInLine(focusNode));
-  } else {
-    ({
-      node,
-      offset
-    } = getEndOfCodeInLine(focusNode));
-  }
+function convertCodeNoop() {
+  return {
+    node: null
+  };
+}
 
-  if (node !== null && offset !== -1) {
-    selection.setTextNodeRange(node, offset, node, offset);
-  }
+function convertTableCellElement(domNode) {
+  // domNode is a <td> since we matched it by nodeName
+  const cell = domNode;
+  return {
+    after: childLexicalNodes => {
+      if (cell.parentNode && cell.parentNode.nextSibling) {
+        // Append newline between code lines
+        childLexicalNodes.push(lexical.$createLineBreakNode());
+      }
 
-  event.preventDefault();
-  event.stopPropagation();
-  return true;
+      return childLexicalNodes;
+    },
+    node: null
+  };
 }
 
-function registerCodeHighlighting(editor) {
-  if (!editor.hasNodes([CodeNode, CodeHighlightNode])) {
-    throw new Error('CodeHighlightPlugin: CodeNode or CodeHighlightNode not registered on editor');
-  }
+function isCodeElement(div) {
+  return div.style.fontFamily.match('monospace') !== null;
+}
 
-  return utils.mergeRegister(editor.registerMutationListener(CodeNode, mutations => {
-    editor.update(() => {
-      for (const [key, type] of mutations) {
-        if (type !== 'destroyed') {
-          const node = lexical.$getNodeByKey(key);
+function isGitHubCodeCell(cell) {
+  return cell.classList.contains('js-file-line');
+}
 
-          if (node !== null) {
-            updateCodeGutter(node, editor);
-          }
-        }
-      }
-    });
-  }), editor.registerNodeTransform(CodeNode, node => codeNodeTransform(node, editor)), editor.registerNodeTransform(lexical.TextNode, node => textNodeTransform(node, editor)), editor.registerNodeTransform(CodeHighlightNode, node => textNodeTransform(node, editor)), editor.registerCommand(lexical.INDENT_CONTENT_COMMAND, payload => handleMultilineIndent(lexical.INDENT_CONTENT_COMMAND), lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical.OUTDENT_CONTENT_COMMAND, payload => handleMultilineIndent(lexical.OUTDENT_CONTENT_COMMAND), lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical.KEY_ARROW_UP_COMMAND, payload => handleShiftLines(lexical.KEY_ARROW_UP_COMMAND, payload), lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical.KEY_ARROW_DOWN_COMMAND, payload => handleShiftLines(lexical.KEY_ARROW_DOWN_COMMAND, payload), lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical.MOVE_TO_END, payload => handleMoveTo(lexical.MOVE_TO_END, payload), lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical.MOVE_TO_START, payload => handleMoveTo(lexical.MOVE_TO_START, payload), lexical.COMMAND_PRIORITY_LOW));
+function isGitHubCodeTable(table) {
+  return table.classList.contains('js-file-line-container');
 }
 
 exports.$createCodeHighlightNode = $createCodeHighlightNode;
 exports.$createCodeNode = $createCodeNode;
 exports.$isCodeHighlightNode = $isCodeHighlightNode;
 exports.$isCodeNode = $isCodeNode;
+exports.CODE_LANGUAGE_FRIENDLY_NAME_MAP = CODE_LANGUAGE_FRIENDLY_NAME_MAP;
+exports.CODE_LANGUAGE_MAP = CODE_LANGUAGE_MAP;
 exports.CodeHighlightNode = CodeHighlightNode;
 exports.CodeNode = CodeNode;
+exports.DEFAULT_CODE_LANGUAGE = DEFAULT_CODE_LANGUAGE;
 exports.getCodeLanguages = getCodeLanguages;
 exports.getDefaultCodeLanguage = getDefaultCodeLanguage;
 exports.getEndOfCodeInLine = getEndOfCodeInLine;
 exports.getFirstCodeHighlightNodeOfLine = getFirstCodeHighlightNodeOfLine;
+exports.getLanguageFriendlyName = getLanguageFriendlyName;
 exports.getLastCodeHighlightNodeOfLine = getLastCodeHighlightNodeOfLine;
 exports.getStartOfCodeInLine = getStartOfCodeInLine;
+exports.normalizeCodeLang = normalizeCodeLang;
 exports.registerCodeHighlighting = registerCodeHighlighting;