lexical 0.3.1 → 0.3.4

package/Lexical.dev.js

@@ -6,6 +6,58 @@
  */
 'use strict';
 
+/**
+ * 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.
+ *
+ */
+function createCommand() {
+  return {};
+}
+const SELECTION_CHANGE_COMMAND = createCommand();
+const CLICK_COMMAND = createCommand();
+const DELETE_CHARACTER_COMMAND = createCommand();
+const INSERT_LINE_BREAK_COMMAND = createCommand();
+const INSERT_PARAGRAPH_COMMAND = createCommand();
+const CONTROLLED_TEXT_INSERTION_COMMAND = createCommand();
+const PASTE_COMMAND = createCommand();
+const REMOVE_TEXT_COMMAND = createCommand();
+const DELETE_WORD_COMMAND = createCommand();
+const DELETE_LINE_COMMAND = createCommand();
+const FORMAT_TEXT_COMMAND = createCommand();
+const UNDO_COMMAND = createCommand();
+const REDO_COMMAND = createCommand();
+const KEY_ARROW_RIGHT_COMMAND = createCommand();
+const MOVE_TO_END = createCommand();
+const KEY_ARROW_LEFT_COMMAND = createCommand();
+const MOVE_TO_START = createCommand();
+const KEY_ARROW_UP_COMMAND = createCommand();
+const KEY_ARROW_DOWN_COMMAND = createCommand();
+const KEY_ENTER_COMMAND = createCommand();
+const KEY_SPACE_COMMAND = createCommand();
+const KEY_BACKSPACE_COMMAND = createCommand();
+const KEY_ESCAPE_COMMAND = createCommand();
+const KEY_DELETE_COMMAND = createCommand();
+const KEY_TAB_COMMAND = createCommand();
+const INDENT_CONTENT_COMMAND = createCommand();
+const OUTDENT_CONTENT_COMMAND = createCommand();
+const DROP_COMMAND = createCommand();
+const FORMAT_ELEMENT_COMMAND = createCommand();
+const DRAGSTART_COMMAND = createCommand();
+const DRAGOVER_COMMAND = createCommand();
+const DRAGEND_COMMAND = createCommand();
+const COPY_COMMAND = createCommand();
+const CUT_COMMAND = createCommand();
+const CLEAR_EDITOR_COMMAND = createCommand();
+const CLEAR_HISTORY_COMMAND = createCommand();
+const CAN_REDO_COMMAND = createCommand();
+const CAN_UNDO_COMMAND = createCommand();
+const FOCUS_COMMAND = createCommand();
+const BLUR_COMMAND = createCommand();
+const KEY_MODIFIER_COMMAND = createCommand();
+
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
@@ -173,12 +225,25 @@ function handleTextMutation(target, node, editor) {
   $updateTextNodeFromDOMContent(node, text, anchorOffset, focusOffset, false);
 }
 
+function shouldUpdateTextNodeFromMutation(selection, targetDOM, targetNode) {
+  if ($isRangeSelection(selection)) {
+    const anchorNode = selection.anchor.getNode();
+
+    if (anchorNode.is(targetNode) && selection.format !== anchorNode.getFormat()) {
+      return false;
+    }
+  }
+
+  return targetDOM.nodeType === DOM_TEXT_TYPE && targetNode.isAttached();
+}
+
 function $flushMutations$1(editor, mutations, observer) {
   isProcessingMutations = true;
   const shouldFlushTextMutations = performance.now() - lastTextEntryTimeStamp > TEXT_MUTATION_VARIANCE;
 
   try {
     updateEditor(editor, () => {
+      const selection = $getSelection() || getLastSelection(editor);
       const badDOMTargets = new Map();
       const rootElement = editor.getRootElement(); // We use the current edtior state, as that reflects what is
       // actually "on screen".
@@ -200,7 +265,7 @@ function $flushMutations$1(editor, mutations, observer) {
         if (type === 'characterData') {
           // Text mutations are deferred and passed to mutation listeners to be
           // processed outside of the Lexical engine.
-          if (shouldFlushTextMutations && targetDOM.nodeType === DOM_TEXT_TYPE && $isTextNode(targetNode) && targetNode.isAttached()) {
+          if (shouldFlushTextMutations && $isTextNode(targetNode) && shouldUpdateTextNodeFromMutation(selection, targetDOM, targetNode)) {
             handleTextMutation( // nodeType === DOM_TEXT_TYPE is a Text DOM node
             targetDOM, targetNode);
           }
@@ -315,8 +380,6 @@ function $flushMutations$1(editor, mutations, observer) {
         observer.takeRecords();
       }
 
-      const selection = $getSelection() || getLastSelection(editor);
-
       if (selection !== null) {
         if (shouldRevertSelection) {
           selection.dirty = true;
@@ -664,7 +727,6 @@ function $setSelection(selection) {
   const editorState = getActiveEditorState();
 
   if (selection !== null) {
-    // @ts-ignore
     {
       if (Object.isFrozen(selection)) {
         {
@@ -1173,11 +1235,12 @@ function scrollIntoViewIfNeeded(editor, anchor, rootElement, tags) {
     } else if (rect.top < 0) {
       element.scrollIntoView();
     } else {
-      const rootRect = rootElement.getBoundingClientRect();
+      const rootRect = rootElement.getBoundingClientRect(); // Rects can returning decimal numbers that differ due to rounding
+      // differences. So let's normalize the values.
 
-      if (rect.bottom > rootRect.bottom) {
+      if (Math.floor(rect.bottom) > Math.floor(rootRect.bottom)) {
         element.scrollIntoView(false);
-      } else if (rect.top < rootRect.top) {
+      } else if (Math.floor(rect.top) < Math.floor(rootRect.top)) {
         element.scrollIntoView();
       }
     }
@@ -1473,7 +1536,7 @@ function createNode(key, parentDOM, insertDOM) {
     const text = node.getTextContent();
 
     if ($isDecoratorNode(node)) {
-      const decorator = node.decorate(activeEditor$1);
+      const decorator = node.decorate(activeEditor$1, activeEditorConfig);
 
       if (decorator !== null) {
         reconcileDecorator(key, decorator);
@@ -1513,8 +1576,7 @@ function createNode(key, parentDOM, insertDOM) {
         parentDOM.appendChild(dom);
       }
     }
-  } // @ts-ignore
-
+  }
 
   {
     // Freeze the node in DEV to prevent accidental mutations
@@ -1789,7 +1851,7 @@ function reconcileNode(key, parentDOM) {
     const text = nextNode.getTextContent();
 
     if ($isDecoratorNode(nextNode)) {
-      const decorator = nextNode.decorate(activeEditor$1);
+      const decorator = nextNode.decorate(activeEditor$1, activeEditorConfig);
 
       if (decorator !== null) {
         reconcileDecorator(key, decorator);
@@ -1810,8 +1872,7 @@ function reconcileNode(key, parentDOM) {
     // Cache the latest text content.
     nextNode = nextNode.getWritable();
     nextNode.__cachedText = editorTextContent;
-  } // @ts-ignore
-
+  }
 
   {
     // Freeze the node in DEV to prevent accidental mutations
@@ -1970,58 +2031,6 @@ function getPrevElementByKeyOrThrow(key) {
   return element;
 }
 
-/**
- * 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.
- *
- */
-function createCommand() {
-  return {};
-}
-const SELECTION_CHANGE_COMMAND = createCommand();
-const CLICK_COMMAND = createCommand();
-const DELETE_CHARACTER_COMMAND = createCommand();
-const INSERT_LINE_BREAK_COMMAND = createCommand();
-const INSERT_PARAGRAPH_COMMAND = createCommand();
-const CONTROLLED_TEXT_INSERTION_COMMAND = createCommand();
-const PASTE_COMMAND = createCommand();
-const REMOVE_TEXT_COMMAND = createCommand();
-const DELETE_WORD_COMMAND = createCommand();
-const DELETE_LINE_COMMAND = createCommand();
-const FORMAT_TEXT_COMMAND = createCommand();
-const UNDO_COMMAND = createCommand();
-const REDO_COMMAND = createCommand();
-const KEY_ARROW_RIGHT_COMMAND = createCommand();
-const MOVE_TO_END = createCommand();
-const KEY_ARROW_LEFT_COMMAND = createCommand();
-const MOVE_TO_START = createCommand();
-const KEY_ARROW_UP_COMMAND = createCommand();
-const KEY_ARROW_DOWN_COMMAND = createCommand();
-const KEY_ENTER_COMMAND = createCommand();
-const KEY_SPACE_COMMAND = createCommand();
-const KEY_BACKSPACE_COMMAND = createCommand();
-const KEY_ESCAPE_COMMAND = createCommand();
-const KEY_DELETE_COMMAND = createCommand();
-const KEY_TAB_COMMAND = createCommand();
-const INDENT_CONTENT_COMMAND = createCommand();
-const OUTDENT_CONTENT_COMMAND = createCommand();
-const DROP_COMMAND = createCommand();
-const FORMAT_ELEMENT_COMMAND = createCommand();
-const DRAGSTART_COMMAND = createCommand();
-const DRAGOVER_COMMAND = createCommand();
-const DRAGEND_COMMAND = createCommand();
-const COPY_COMMAND = createCommand();
-const CUT_COMMAND = createCommand();
-const CLEAR_EDITOR_COMMAND = createCommand();
-const CLEAR_HISTORY_COMMAND = createCommand();
-const CAN_REDO_COMMAND = createCommand();
-const CAN_UNDO_COMMAND = createCommand();
-const FOCUS_COMMAND = createCommand();
-const BLUR_COMMAND = createCommand();
-const KEY_MODIFIER_COMMAND = createCommand();
-
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
@@ -2038,6 +2047,7 @@ if (CAN_USE_BEFORE_INPUT) {
 }
 
 let lastKeyDownTimeStamp = 0;
+let lastKeyCode = 0;
 let rootElementsRegistered = 0;
 let isSelectionChangeFromDOMUpdate = false;
 let isInsertLineBreak = false;
@@ -2179,6 +2189,10 @@ function $canRemoveText(anchorNode, focusNode) {
   return anchorNode !== focusNode || $isElementNode(anchorNode) || $isElementNode(focusNode) || !$isTokenOrInert(anchorNode) || !$isTokenOrInert(focusNode);
 }
 
+function isPossiblyAndroidKeyPress(timeStamp) {
+  return lastKeyCode === 229 && timeStamp < lastKeyDownTimeStamp + ANDROID_COMPOSITION_LATENCY;
+}
+
 function onBeforeInput(event, editor) {
   const inputType = event.inputType; // We let the browser do its own thing for composition.
 
@@ -2195,7 +2209,9 @@ function onBeforeInput(event, editor) {
     // during composition and see if the previous text contains
     // part of the composed text to work out the actual text that
     // we need to insert.
-    const composedText = event.data;
+    const composedText = event.data; // TODO: evaluate if this is Android only. It doesn't always seem
+    // to have any real impact, so could probably be refactored or removed
+    // for an alternative approach.
 
     if (composedText) {
       updateEditor(editor, () => {
@@ -2239,20 +2255,32 @@ function onBeforeInput(event, editor) {
         }
 
         $setSelection(prevSelection.clone());
-      } // Used for Android
+      }
 
+      if ($isRangeSelection(selection)) {
+        // Used for handling backspace in Android.
+        if (isPossiblyAndroidKeyPress(event.timeStamp) && selection.anchor.key === selection.focus.key) {
+          $setCompositionKey(null);
+          lastKeyDownTimeStamp = 0; // Fixes an Android bug where selection flickers when backspacing
 
-      $setCompositionKey(null);
-      event.preventDefault();
-      lastKeyDownTimeStamp = 0;
-      dispatchCommand(editor, DELETE_CHARACTER_COMMAND, true); // Fixes an Android bug where selection flickers when backspacing
+          setTimeout(() => {
+            updateEditor(editor, () => {
+              $setCompositionKey(null);
+            });
+          }, ANDROID_COMPOSITION_LATENCY);
 
-      setTimeout(() => {
-        updateEditor(editor, () => {
-          $setCompositionKey(null);
-        });
-      }, ANDROID_COMPOSITION_LATENCY);
-      return;
+          if ($isRangeSelection(selection)) {
+            const anchorNode = selection.anchor.getNode();
+            anchorNode.markDirty();
+            selection.format = anchorNode.getFormat();
+          }
+        } else {
+          event.preventDefault();
+          dispatchCommand(editor, DELETE_CHARACTER_COMMAND, false);
+        }
+
+        return;
+      }
     }
 
     if (!$isRangeSelection(selection)) {
@@ -2438,9 +2466,8 @@ function onInput(event, editor) {
   updateEditor(editor, () => {
     const selection = $getSelection();
     const data = event.data;
-    const possibleTextReplacement = event.inputType === 'insertText' && data != null && data.length > 1 && !doesContainGrapheme(data);
 
-    if (data != null && $isRangeSelection(selection) && (possibleTextReplacement || $shouldPreventDefaultAndInsertText(selection, data))) {
+    if (data != null && $isRangeSelection(selection) && $shouldPreventDefaultAndInsertText(selection, data)) {
       // Given we're over-riding the default behavior, we will need
       // to ensure to disable composition before dispatching the
       // insertText command for when changing the sequence for FF.
@@ -2449,24 +2476,7 @@ function onInput(event, editor) {
         isFirefoxEndingComposition = false;
       }
 
-      dispatchCommand(editor, CONTROLLED_TEXT_INSERTION_COMMAND, data);
-
-      if (possibleTextReplacement) {
-        // If the DOM selection offset is higher than the existing
-        // offset, then restore the offset as it's likely correct
-        // in the case of text replacements.
-        const {
-          anchorOffset
-        } = window.getSelection();
-        const anchor = selection.anchor;
-        const focus = selection.focus;
-
-        if (anchorOffset > anchor.offset) {
-          anchor.set(anchor.key, anchorOffset, anchor.type);
-          focus.set(anchor.key, anchorOffset, anchor.type);
-        }
-      } // This ensures consistency on Android.
-
+      dispatchCommand(editor, CONTROLLED_TEXT_INSERTION_COMMAND, data); // This ensures consistency on Android.
 
       if (!IS_SAFARI && !IS_IOS && editor.isComposing()) {
         lastKeyDownTimeStamp = 0;
@@ -2565,6 +2575,7 @@ function onCompositionEnd(event, editor) {
 
 function onKeyDown(event, editor) {
   lastKeyDownTimeStamp = event.timeStamp;
+  lastKeyCode = event.keyCode;
 
   if (editor.isComposing()) {
     return;
@@ -2647,12 +2658,18 @@ function onKeyDown(event, editor) {
   } else if (isRedo(keyCode, shiftKey, metaKey, ctrlKey)) {
     event.preventDefault();
     dispatchCommand(editor, REDO_COMMAND, undefined);
-  } else if (isCopy(keyCode, shiftKey, metaKey, ctrlKey)) {
-    event.preventDefault();
-    dispatchCommand(editor, COPY_COMMAND, event);
-  } else if (isCut(keyCode, shiftKey, metaKey, ctrlKey)) {
-    event.preventDefault();
-    dispatchCommand(editor, CUT_COMMAND, event);
+  } else {
+    const prevSelection = editor._editorState._selection;
+
+    if ($isNodeSelection(prevSelection)) {
+      if (isCopy(keyCode, shiftKey, metaKey, ctrlKey)) {
+        event.preventDefault();
+        dispatchCommand(editor, COPY_COMMAND, event);
+      } else if (isCut(keyCode, shiftKey, metaKey, ctrlKey)) {
+        event.preventDefault();
+        dispatchCommand(editor, CUT_COMMAND, event);
+      }
+    }
   }
 
   if (isModifier(ctrlKey, shiftKey, altKey, metaKey)) {
@@ -2824,7 +2841,6 @@ function markCollapsedSelectionFormat(format, offset, key, timeStamp) {
  * LICENSE file in the root directory of this source tree.
  *
  */
-
 class Point {
   constructor(key, offset, type) {
     this._selection = null;
@@ -3461,6 +3477,7 @@ class RangeSelection {
 
       if (!$isTextNode(nextSibling) || $isTokenOrInertOrSegmented(nextSibling)) {
         nextSibling = $createTextNode();
+        nextSibling.setFormat(format);
 
         if (!firstNodeParent.canInsertTextAfter()) {
           firstNodeParent.insertAfter(nextSibling);
@@ -3481,6 +3498,7 @@ class RangeSelection {
 
       if (!$isTextNode(prevSibling) || $isTokenOrInertOrSegmented(prevSibling)) {
         prevSibling = $createTextNode();
+        prevSibling.setFormat(format);
 
         if (!firstNodeParent.canInsertTextBefore()) {
           firstNodeParent.insertBefore(prevSibling);
@@ -3498,6 +3516,7 @@ class RangeSelection {
       }
     } else if (firstNode.isSegmented() && startOffset !== firstNodeTextLength) {
       const textNode = $createTextNode(firstNode.getTextContent());
+      textNode.setFormat(format);
       firstNode.replace(textNode);
       firstNode = textNode;
     } else if (!this.isCollapsed() && text !== '') {
@@ -3555,10 +3574,14 @@ class RangeSelection {
 
       if (firstNode.getTextContent() === '') {
         firstNode.remove();
-      } else if (firstNode.isComposing() && this.anchor.type === 'text') {
-        // When composing, we need to adjust the anchor offset so that
-        // we correctly replace that right range.
-        this.anchor.offset -= text.length;
+      } else if (this.anchor.type === 'text') {
+        if (firstNode.isComposing()) {
+          // When composing, we need to adjust the anchor offset so that
+          // we correctly replace that right range.
+          this.anchor.offset -= text.length;
+        } else {
+          this.format = firstNodeFormat;
+        }
       }
     } else {
       const markedNodeKeysForKeep = new Set([...firstNode.getParentKeys(), ...lastNode.getParentKeys()]); // We have to get the parent elements before the next section,
@@ -4757,15 +4780,15 @@ function internalMakeRangeSelection(anchorKey, anchorOffset, focusKey, focusOffs
   editorState._selection = selection;
   return selection;
 }
-function $createEmptyRangeSelection() {
+function $createRangeSelection() {
   const anchor = $createPoint('root', 0, 'element');
   const focus = $createPoint('root', 0, 'element');
   return new RangeSelection(anchor, focus, 0);
 }
-function $createEmptyObjectSelection() {
+function $createNodeSelection() {
   return new NodeSelection(new Set());
 }
-function $createEmptyGridSelection() {
+function $createGridSelection() {
   const anchor = $createPoint('root', 0, 'element');
   const focus = $createPoint('root', 0, 'element');
   return new GridSelection('root', anchor, focus);
@@ -5359,7 +5382,7 @@ function parseEditorState(serializedEditorState, editor, updateFn) {
     } // Make the editorState immutable
 
 
-    editorState._readOnly = true; // @ts-ignore
+    editorState._readOnly = true;
 
     {
       handleDEVOnlyPendingUpdateGuarantees(editorState);
@@ -5464,6 +5487,9 @@ function commitPendingUpdates(editor) {
         isAttemptingToRecoverFromReconcilerError = true;
         commitPendingUpdates(editor);
         isAttemptingToRecoverFromReconcilerError = false;
+      } else {
+        // To avoid a possible situation of infinite loops, lets throw
+        throw error;
       }
 
       return;
@@ -5480,7 +5506,7 @@ function commitPendingUpdates(editor) {
     }
   }
 
-  pendingEditorState._readOnly = true; // @ts-ignore
+  pendingEditorState._readOnly = true;
 
   {
     handleDEVOnlyPendingUpdateGuarantees(pendingEditorState);
@@ -5821,8 +5847,17 @@ function updateEditor(editor, updateFn, options) {
     beginUpdate(editor, updateFn, options);
   }
 }
+function internalGetActiveEditor() {
+  return activeEditor;
+}
 
-/* eslint-disable no-constant-condition */
+/**
+ * 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.
+ *
+ */
 function removeNode(nodeToRemove, restoreSelection, preserveEmptyParent) {
   errorOnReadOnly();
   const key = nodeToRemove.__key;
@@ -5889,6 +5924,7 @@ function $getNodeByKeyOrThrow(key) {
   return node;
 }
 class LexicalNode {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   // Flow doesn't support abstract classes unfortunately, so we can't _force_
   // subclasses of Node to implement statics. All subclasses of Node should have
   // a static getType and clone method though. We define getType and clone here so we can call it
@@ -5910,7 +5946,7 @@ class LexicalNode {
     // @ts-expect-error
     this.__type = this.constructor.getType();
     this.__parent = null;
-    $setNodeKey(this, key); // @ts-ignore
+    $setNodeKey(this, key);
 
     {
       if (this.__type !== 'root') {
@@ -6379,52 +6415,11 @@ class LexicalNode {
 
   exportDOM(editor) {
     const element = this.createDOM(editor._config, editor);
-    const serializedNode = this.exportJSON();
-    element.setAttribute('data-lexical-node-type', this.__type);
-    element.setAttribute('data-lexical-node-json', JSON.stringify(serializedNode));
-    element.setAttribute('data-lexical-editor-key', editor._key);
     return {
       element
     };
   }
 
-  static importDOM() {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const proto = this.prototype.constructor;
-    return {
-      // Catch-all key because we don't know the nodeName of the element returned by exportDOM.
-      '*': domNode => {
-        if (!(domNode instanceof HTMLElement)) return null;
-        const editorKey = domNode.getAttribute('data-lexical-editor-key');
-        const nodeType = domNode.getAttribute('data-lexical-node-type');
-        if (editorKey == null || nodeType == null) return null;
-        const editor = getActiveEditor();
-
-        if (editorKey === editor.getKey() && nodeType === proto.getType()) {
-          try {
-            const json = domNode.getAttribute('data-lexical-node-json');
-
-            if (json != null) {
-              const serializedNode = JSON.parse(json);
-              const node = proto.importJSON(serializedNode);
-              return {
-                conversion: () => ({
-                  node
-                }),
-                // Max priority because of the 'data-lexical-node-type' attribute
-                // matching the one on node klass guarantees a match.
-                priority: 4
-              }; // eslint-disable-next-line no-empty
-            } // eslint-disable-next-line no-empty
-
-          } catch {}
-        }
-
-        return null;
-      }
-    };
-  }
-
   exportJSON() {
     {
       throw Error(`exportJSON: base method not extended`);
@@ -6643,7 +6638,7 @@ class DecoratorNode extends LexicalNode {
     super(key);
   }
 
-  decorate(editor) {
+  decorate(editor, config) {
     {
       throw Error(`decorate: base method not extended`);
     }
@@ -7112,7 +7107,7 @@ class ElementNode extends LexicalNode {
     return false;
   }
 
-  excludeFromCopy() {
+  excludeFromCopy(destination) {
     return false;
   }
 
@@ -7555,7 +7550,9 @@ function setTextContent(nextText, dom, node) {
     dom.textContent = text;
   } else {
     const nodeValue = firstChild.nodeValue;
-    if (nodeValue !== text) if (isComposing) {
+    if (nodeValue !== text) if (isComposing || IS_FIREFOX) {
+      // We also use the diff composed text for general text in FF to avoid
+      // the spellcheck red line from flickering.
       const [index, remove, insert] = diffComposedText(nodeValue, text);
 
       if (remove !== 0) {
@@ -8164,8 +8161,21 @@ function convertBringAttentionToElement(domNode) {
 }
 
 function convertTextDOMNode(domNode) {
+  const {
+    parentElement,
+    textContent
+  } = domNode;
+  const textContentTrim = textContent.trim();
+  const isPre = parentElement != null && parentElement.tagName.toLowerCase() === 'pre';
+
+  if (!isPre && textContentTrim.length === 0 && textContent.includes('\n')) {
+    return {
+      node: null
+    };
+  }
+
   return {
-    node: $createTextNode(domNode.textContent)
+    node: $createTextNode(textContent)
   };
 }
 
@@ -8378,10 +8388,11 @@ function initializeConversionCache(nodes) {
   const conversionCache = new Map();
   const handledConversions = new Set();
   nodes.forEach(node => {
-    // @ts-expect-error TODO Replace Class utility type with InstanceType
-    const importDOM = node.klass.importDOM.bind(node.klass); // debugger;
+    const importDOM = // @ts-expect-error TODO Replace Class utility type with InstanceType
+    node.klass.importDOM != null ? // @ts-expect-error TODO Replace Class utility type with InstanceType
+    node.klass.importDOM.bind(node.klass) : null;
 
-    if (handledConversions.has(importDOM)) {
+    if (importDOM == null || handledConversions.has(importDOM)) {
       return;
     }
 
@@ -8404,69 +8415,77 @@ function initializeConversionCache(nodes) {
   return conversionCache;
 }
 
-function createEditor(editorConfig = {}) {
-  const config = editorConfig;
+function createEditor(editorConfig) {
+  const config = editorConfig || {};
+  const activeEditor = internalGetActiveEditor();
   const theme = config.theme || {};
-  const parentEditor = config.parentEditor || null;
+  const parentEditor = editorConfig === undefined ? activeEditor : config.parentEditor || null;
   const disableEvents = config.disableEvents || false;
   const editorState = createEmptyEditorState();
+  const namespace = config.namespace || (parentEditor !== null ? parentEditor._config.namespace : createUID());
   const initialEditorState = config.editorState;
   const nodes = [RootNode, TextNode, LineBreakNode, ParagraphNode, ...(config.nodes || [])];
   const onError = config.onError;
   const isReadOnly = config.readOnly || false;
-  const registeredNodes = new Map();
+  let registeredNodes;
 
-  for (let i = 0; i < nodes.length; i++) {
-    const klass = nodes[i]; // Ensure custom nodes implement required methods.
-    // @ts-ignore
+  if (editorConfig === undefined && activeEditor !== null) {
+    registeredNodes = activeEditor._nodes;
+  } else {
+    registeredNodes = new Map();
 
-    {
-      const name = klass.name;
-
-      if (name !== 'RootNode') {
-        const proto = klass.prototype;
-        ['getType', 'clone'].forEach(method => {
-          // eslint-disable-next-line no-prototype-builtins
-          if (!klass.hasOwnProperty(method)) {
-            console.warn(`${name} must implement static "${method}" method`);
-          }
-        });
+    for (let i = 0; i < nodes.length; i++) {
+      const klass = nodes[i]; // Ensure custom nodes implement required methods.
 
-        if ( // eslint-disable-next-line no-prototype-builtins
-        !klass.hasOwnProperty('importDOM') && // eslint-disable-next-line no-prototype-builtins
-        klass.hasOwnProperty('exportDOM') && process.env.NODE_ENV !== 'test') {
-          console.warn(`${name} should implement "importDOM" if using a custom "exportDOM" method to ensure HTML serialization (important for copy & paste) works as expected`);
-        }
+      {
+        const name = klass.name;
+
+        if (name !== 'RootNode') {
+          const proto = klass.prototype;
+          ['getType', 'clone'].forEach(method => {
+            // eslint-disable-next-line no-prototype-builtins
+            if (!klass.hasOwnProperty(method)) {
+              console.warn(`${name} must implement static "${method}" method`);
+            }
+          });
 
-        if (proto instanceof DecoratorNode) {
-          // eslint-disable-next-line no-prototype-builtins
-          if (!proto.hasOwnProperty('decorate')) {
-            console.warn(`${this.constructor.name} must implement "decorate" method`);
+          if ( // eslint-disable-next-line no-prototype-builtins
+          !klass.hasOwnProperty('importDOM') && // eslint-disable-next-line no-prototype-builtins
+          klass.hasOwnProperty('exportDOM')) {
+            console.warn(`${name} should implement "importDOM" if using a custom "exportDOM" method to ensure HTML serialization (important for copy & paste) works as expected`);
           }
-        }
 
-        if ( // eslint-disable-next-line no-prototype-builtins
-        !klass.hasOwnProperty('importJSON') && process.env.NODE_ENV !== 'test') {
-          console.warn(`${name} should implement "importJSON" method to ensure JSON and default HTML serialization works as expected`);
-        }
+          if (proto instanceof DecoratorNode) {
+            // eslint-disable-next-line no-prototype-builtins
+            if (!proto.hasOwnProperty('decorate')) {
+              console.warn(`${this.constructor.name} must implement "decorate" method`);
+            }
+          }
 
-        if ( // eslint-disable-next-line no-prototype-builtins
-        !proto.hasOwnProperty('exportJSON') && process.env.NODE_ENV !== 'test') {
-          console.warn(`${name} should implement "exportJSON" method to ensure JSON and default HTML serialization works as expected`);
+          if ( // eslint-disable-next-line no-prototype-builtins
+          !klass.hasOwnProperty('importJSON')) {
+            console.warn(`${name} should implement "importJSON" method to ensure JSON and default HTML serialization works as expected`);
+          }
+
+          if ( // eslint-disable-next-line no-prototype-builtins
+          !proto.hasOwnProperty('exportJSON')) {
+            console.warn(`${name} should implement "exportJSON" method to ensure JSON and default HTML serialization works as expected`);
+          }
         }
-      }
-    } // @ts-expect-error TODO Replace Class utility type with InstanceType
+      } // @ts-expect-error TODO Replace Class utility type with InstanceType
 
 
-    const type = klass.getType();
-    registeredNodes.set(type, {
-      klass,
-      transforms: new Set()
-    });
+      const type = klass.getType();
+      registeredNodes.set(type, {
+        klass,
+        transforms: new Set()
+      });
+    }
   }
 
   const editor = new LexicalEditor(editorState, parentEditor, registeredNodes, {
     disableEvents,
+    namespace,
     theme
   }, onError, initializeConversionCache(registeredNodes), isReadOnly);
 
@@ -8623,9 +8642,7 @@ class LexicalEditor {
     };
   }
 
-  registerNodeTransform( // There's no Flow-safe way to preserve the T in Transform<T>, but <T = LexicalNode> in the
-  // declaration below guarantees these are LexicalNodes.
-  klass, listener) {
+  registerNodeTransform(klass, listener) {
     // @ts-expect-error TODO Replace Class utility type with InstanceType
     const type = klass.getType();
 
@@ -8647,7 +8664,7 @@ class LexicalEditor {
 
   hasNodes(nodes) {
     for (let i = 0; i < nodes.length; i++) {
-      const klass = nodes[i]; // @ts-expect-error TODO Replace Class utility type with InstanceType
+      const klass = nodes[i]; // @ts-expect-error
 
       const type = klass.getType();
 
@@ -8816,7 +8833,7 @@ class LexicalEditor {
 
   toJSON() {
     return {
-      editorState: this._editorState
+      editorState: this._editorState.toJSON()
     };
   }
 
@@ -8829,7 +8846,7 @@ class LexicalEditor {
  * LICENSE file in the root directory of this source tree.
  *
  */
-const VERSION = '0.3.1';
+const VERSION = '0.3.4';
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -8879,11 +8896,11 @@ function $isGridRowNode(node) {
   return node instanceof GridRowNode;
 }
 
-exports.$createGridSelection = $createEmptyGridSelection;
+exports.$createGridSelection = $createGridSelection;
 exports.$createLineBreakNode = $createLineBreakNode;
-exports.$createNodeSelection = $createEmptyObjectSelection;
+exports.$createNodeSelection = $createNodeSelection;
 exports.$createParagraphNode = $createParagraphNode;
-exports.$createRangeSelection = $createEmptyRangeSelection;
+exports.$createRangeSelection = $createRangeSelection;
 exports.$createTextNode = $createTextNode;
 exports.$getDecoratorNode = $getDecoratorNode;
 exports.$getNearestNodeFromDOMNode = $getNearestNodeFromDOMNode;