lexical 0.1.4 → 0.1.8

package/LexicalAutoLinkNode.dev.js

@@ -0,0 +1,58 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var lexical = require('lexical');
+var LinkNode = require('lexical/LinkNode');
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+// allow typing within the link
+
+class AutoLinkNode extends LinkNode.LinkNode {
+  static getType() {
+    return 'autolink';
+  } // $FlowFixMe[incompatible-extend]
+
+
+  static clone(node) {
+    return new AutoLinkNode(node.__url, node.__key);
+  }
+
+  insertNewAfter(selection) {
+    const element = this.getParentOrThrow().insertNewAfter(selection);
+
+    if (lexical.$isElementNode(element)) {
+      const linkNode = $createAutoLinkNode(this.__url);
+      element.append(linkNode);
+      return linkNode;
+    }
+
+    return null;
+  }
+
+  canInsertTextAfter() {
+    return true;
+  }
+
+}
+function $createAutoLinkNode(url) {
+  return new AutoLinkNode(url);
+}
+function $isAutoLinkNode(node) {
+  return node instanceof AutoLinkNode;
+}
+
+exports.$createAutoLinkNode = $createAutoLinkNode;
+exports.$isAutoLinkNode = $isAutoLinkNode;
+exports.AutoLinkNode = AutoLinkNode;

package/LexicalAutoLinkNode.prod.js

@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';var b=require("lexical"),c=require("lexical/LinkNode");class e extends c.LinkNode{static getType(){return"autolink"}static clone(a){return new e(a.__url,a.__key)}insertNewAfter(a){a=this.getParentOrThrow().insertNewAfter(a);if(b.$isElementNode(a)){const d=f(this.__url);a.append(d);return d}return null}canInsertTextAfter(){return!0}}function f(a){return new e(a)}exports.$createAutoLinkNode=f;exports.$isAutoLinkNode=function(a){return a instanceof e};exports.AutoLinkNode=e;

package/LexicalCodeHighlightNode.dev.js

@@ -0,0 +1,100 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var lexical = require('lexical');
+
+/**
+ * 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 addClassNamesToElement(element, ...classNames) {
+  classNames.forEach(className => {
+    if (className != null && typeof className === 'string') {
+      element.classList.add(...className.split(' '));
+    }
+  });
+}
+function removeClassNamesFromElement(element, ...classNames) {
+  classNames.forEach(className => {
+    element.classList.remove(...className.split(' '));
+  });
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+class CodeHighlightNode extends lexical.TextNode {
+  constructor(text, highlightType, key) {
+    super(text, key);
+    this.__highlightType = highlightType;
+  }
+
+  static getType() {
+    return 'code-highlight';
+  }
+
+  static clone(node) {
+    return new CodeHighlightNode(node.__text, node.__highlightType || undefined, node.__key);
+  }
+
+  createDOM(config) {
+    const element = super.createDOM(config);
+    const className = getHighlightThemeClass(config.theme, this.__highlightType);
+    addClassNamesToElement(element, className);
+    return element;
+  }
+
+  updateDOM( // $FlowFixMe
+  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) {
+        removeClassNamesFromElement(dom, prevClassName);
+      }
+
+      if (nextClassName) {
+        addClassNamesToElement(dom, nextClassName);
+      }
+    }
+
+    return update;
+  } // Prevent formatting (bold, underline, etc)
+
+
+  setFormat(format) {
+    return this.getWritable();
+  }
+
+}
+
+function getHighlightThemeClass(theme, highlightType) {
+  return highlightType && theme && theme.codeHighlight && theme.codeHighlight[highlightType];
+}
+
+function $createCodeHighlightNode(text, highlightType) {
+  return new CodeHighlightNode(text, highlightType);
+}
+function $isCodeHighlightNode(node) {
+  return node instanceof CodeHighlightNode;
+}
+
+exports.$createCodeHighlightNode = $createCodeHighlightNode;
+exports.$isCodeHighlightNode = $isCodeHighlightNode;
+exports.CodeHighlightNode = CodeHighlightNode;

package/LexicalCodeHighlightNode.prod.js

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';var d=require("lexical");function e(a,...b){b.forEach(c=>{null!=c&&"string"===typeof c&&a.classList.add(...c.split(" "))})}function f(a,...b){b.forEach(c=>{a.classList.remove(...c.split(" "))})}
+class g extends d.TextNode{constructor(a,b,c){super(a,c);this.__highlightType=b}static getType(){return"code-highlight"}static clone(a){return new g(a.__text,a.__highlightType||void 0,a.__key)}createDOM(a){const b=super.createDOM(a);a=h(a.theme,this.__highlightType);e(b,a);return b}updateDOM(a,b,c){const k=super.updateDOM(a,b,c);a=h(c.theme,a.__highlightType);c=h(c.theme,this.__highlightType);a!==c&&(a&&f(b,a),c&&e(b,c));return k}setFormat(){return this.getWritable()}}
+function h(a,b){return b&&a&&a.codeHighlight&&a.codeHighlight[b]}exports.$createCodeHighlightNode=function(a,b){return new g(a,b)};exports.$isCodeHighlightNode=function(a){return a instanceof g};exports.CodeHighlightNode=g;

package/LexicalCodeNode.dev.js

@@ -0,0 +1,173 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var lexical = require('lexical');
+var CodeHighlightNode = require('lexical/CodeHighlightNode');
+
+/**
+ * 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 addClassNamesToElement(element, ...classNames) {
+  classNames.forEach(className => {
+    if (className != null && typeof className === 'string') {
+      element.classList.add(...className.split(' '));
+    }
+  });
+}
+
+/**
+ * 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.
+ *
+ * 
+ */
+class CodeNode extends lexical.ElementNode {
+  static getType() {
+    return 'code';
+  }
+
+  static clone(node) {
+    return new CodeNode(node.__language, node.__key);
+  }
+
+  constructor(language, key) {
+    super(key);
+    this.__language = language;
+  } // View
+
+
+  createDOM(config) {
+    const element = document.createElement('code');
+    addClassNamesToElement(element, config.theme.code);
+    element.setAttribute('spellcheck', 'false');
+    return element;
+  }
+
+  updateDOM(prevNode, dom) {
+    return false;
+  } // Mutation
+
+
+  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.
+
+
+    const anchor = selection.anchor.getNode();
+    const firstNode = getFirstCodeHighlightNodeOfLine(anchor);
+
+    if (firstNode != null) {
+      let leadingWhitespace = 0;
+      const firstNodeText = firstNode.getTextContent();
+
+      while (leadingWhitespace < firstNodeText.length && /[\t ]/.test(firstNodeText[leadingWhitespace])) {
+        leadingWhitespace += 1;
+      }
+
+      if (leadingWhitespace > 0) {
+        const whitespace = firstNodeText.substring(0, leadingWhitespace);
+        const indentedChild = CodeHighlightNode.$createCodeHighlightNode(whitespace);
+        anchor.insertAfter(indentedChild);
+        selection.insertNodes([lexical.$createLineBreakNode()]);
+        indentedChild.select();
+        return indentedChild;
+      }
+    }
+
+    return null;
+  }
+
+  canInsertTab() {
+    return true;
+  }
+
+  collapseAtStart() {
+    const paragraph = lexical.$createParagraphNode();
+    const children = this.getChildren();
+    children.forEach(child => paragraph.append(child));
+    this.replace(paragraph);
+    return true;
+  }
+
+  setLanguage(language) {
+    const writable = this.getWritable();
+    writable.__language = language;
+  }
+
+  getLanguage() {
+    return this.getLatest().__language;
+  }
+
+}
+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 (CodeHighlightNode.$isCodeHighlightNode(node)) {
+      currentNode = node;
+    }
+
+    if (lexical.$isLineBreakNode(node)) {
+      break;
+    }
+  }
+
+  return currentNode;
+}
+function getLastCodeHighlightNodeOfLine(anchor) {
+  let currentNode = null;
+  const nextSiblings = anchor.getNextSiblings();
+  nextSiblings.unshift(anchor);
+
+  while (nextSiblings.length > 0) {
+    const node = nextSiblings.shift();
+
+    if (CodeHighlightNode.$isCodeHighlightNode(node)) {
+      currentNode = node;
+    }
+
+    if (lexical.$isLineBreakNode(node)) {
+      break;
+    }
+  }
+
+  return currentNode;
+}
+
+exports.$createCodeNode = $createCodeNode;
+exports.$isCodeNode = $isCodeNode;
+exports.CodeNode = CodeNode;
+exports.getFirstCodeHighlightNodeOfLine = getFirstCodeHighlightNodeOfLine;
+exports.getLastCodeHighlightNodeOfLine = getLastCodeHighlightNodeOfLine;

package/LexicalCodeNode.prod.js

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';var d=require("lexical"),f=require("lexical/CodeHighlightNode");function g(a,...c){c.forEach(b=>{null!=b&&"string"===typeof b&&a.classList.add(...b.split(" "))})}
+class h extends d.ElementNode{static getType(){return"code"}static clone(a){return new h(a.__language,a.__key)}constructor(a,c){super(c);this.__language=a}createDOM(a){const c=document.createElement("code");g(c,a.theme.code);c.setAttribute("spellcheck","false");return c}updateDOM(){return!1}insertNewAfter(a){var c=this.getChildren(),b=c.length;if(2<=b&&"\n"===c[b-1].getTextContent()&&"\n"===c[b-2].getTextContent()&&a.isCollapsed()&&a.anchor.key===this.__key&&a.anchor.offset===b)return c[b-1].remove(),
+c[b-2].remove(),a=d.$createParagraphNode(),this.insertAfter(a),a;c=a.anchor.getNode();var e=k(c);if(null!=e){b=0;for(e=e.getTextContent();b<e.length&&/[\t ]/.test(e[b]);)b+=1;if(0<b)return b=e.substring(0,b),b=f.$createCodeHighlightNode(b),c.insertAfter(b),a.insertNodes([d.$createLineBreakNode()]),b.select(),b}return null}canInsertTab(){return!0}collapseAtStart(){const a=d.$createParagraphNode();this.getChildren().forEach(c=>a.append(c));this.replace(a);return!0}setLanguage(a){this.getWritable().__language=
+a}getLanguage(){return this.getLatest().__language}}function k(a){let c=null;const b=a.getPreviousSiblings();for(b.push(a);0<b.length&&(a=b.pop(),f.$isCodeHighlightNode(a)&&(c=a),!d.$isLineBreakNode(a)););return c}exports.$createCodeNode=function(a){return new h(a)};exports.$isCodeNode=function(a){return a instanceof h};exports.CodeNode=h;exports.getFirstCodeHighlightNodeOfLine=k;
+exports.getLastCodeHighlightNodeOfLine=function(a){let c=null;const b=a.getNextSiblings();for(b.unshift(a);0<b.length&&(a=b.shift(),f.$isCodeHighlightNode(a)&&(c=a),!d.$isLineBreakNode(a)););return c};

package/LexicalExtendedNode.js

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict'
+const LexicalExtendedNodes = process.env.NODE_ENV === 'development' ? require('./LexicalExtendedNodes.dev.js') : require('./LexicalExtendedNodes.prod.js')
+module.exports = LexicalExtendedNodes;

package/LexicalExtendedNodes.dev.js

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var list = require('@lexical/list');
+var AutoLinkNode = require('lexical/AutoLinkNode');
+var CodeHighlightNode = require('lexical/CodeHighlightNode');
+var CodeNode = require('lexical/CodeNode');
+var HashtagNode = require('lexical/HashtagNode');
+var HeadingNode = require('lexical/HeadingNode');
+var LinkNode = require('lexical/LinkNode');
+var OverflowNode = require('lexical/OverflowNode');
+var QuoteNode = require('lexical/QuoteNode');
+var TableCellNode = require('lexical/TableCellNode');
+var TableNode = require('lexical/TableNode');
+var TableRowNode = require('lexical/TableRowNode');
+
+/**
+ * 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 LexicalExtendedNodes = [HeadingNode.HeadingNode, list.ListNode, list.ListItemNode, QuoteNode.QuoteNode, CodeNode.CodeNode, TableNode.TableNode, TableCellNode.TableCellNode, TableRowNode.TableRowNode, HashtagNode.HashtagNode, CodeHighlightNode.CodeHighlightNode, AutoLinkNode.AutoLinkNode, LinkNode.LinkNode, OverflowNode.OverflowNode];
+
+module.exports = LexicalExtendedNodes;

package/LexicalExtendedNodes.prod.js

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';var a=require("@lexical/list"),b=require("lexical/AutoLinkNode"),c=require("lexical/CodeHighlightNode"),d=require("lexical/CodeNode"),e=require("lexical/HashtagNode"),f=require("lexical/HeadingNode"),g=require("lexical/LinkNode"),h=require("lexical/OverflowNode"),k=require("lexical/QuoteNode"),l=require("lexical/TableCellNode"),m=require("lexical/TableNode"),n=require("lexical/TableRowNode");
+module.exports=[f.HeadingNode,a.ListNode,a.ListItemNode,k.QuoteNode,d.CodeNode,m.TableNode,l.TableCellNode,n.TableRowNode,e.HashtagNode,c.CodeHighlightNode,b.AutoLinkNode,g.LinkNode,h.OverflowNode];

package/LexicalHashtagNode.dev.js

@@ -0,0 +1,111 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var lexical = require('lexical');
+
+/**
+ * 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 addClassNamesToElement(element, ...classNames) {
+  classNames.forEach(className => {
+    if (className != null && typeof className === 'string') {
+      element.classList.add(...className.split(' '));
+    }
+  });
+}
+
+/**
+ * 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.
+ *
+ * 
+ */
+class HashtagNode extends lexical.TextNode {
+  static getType() {
+    return 'hashtag';
+  }
+
+  static clone(node) {
+    return new HashtagNode(node.__text, node.__key);
+  }
+
+  constructor(text, key) {
+    super(text, key);
+  }
+
+  createDOM(config) {
+    const element = super.createDOM(config);
+    addClassNamesToElement(element, config.theme.hashtag);
+    return element;
+  }
+
+  setTextContent(text) {
+    let targetNode = super.setTextContent(text); // Handle hashtags
+
+    if (targetNode.getParent() !== null && !targetNode.isComposing()) {
+      const indexOfHash = text.indexOf('#');
+
+      if (indexOfHash === -1 || targetNode.getTextContent() === '#') {
+        targetNode = $toggleHashtag(targetNode);
+      } else if (indexOfHash > 0) {
+        [targetNode] = targetNode.splitText(indexOfHash);
+        targetNode = $toggleHashtag(targetNode);
+      } // Check for invalid characters
+
+
+      if (lexical.$isTextNode(targetNode) && targetNode.isAttached()) {
+        const targetTextContent = targetNode.getTextContent().slice(1);
+        const indexOfInvalidChar = targetTextContent.search(/[\s.,\\\/#!$%\^&\*;:{}=\-`~()@]/);
+
+        if (indexOfInvalidChar === 0) {
+          targetNode = $toggleHashtag(targetNode);
+        } else if (indexOfInvalidChar > 0) {
+          [targetNode] = targetNode.splitText(indexOfInvalidChar + 1);
+          targetNode = $toggleHashtag(targetNode);
+        }
+      }
+
+      return targetNode;
+    }
+
+    return this;
+  }
+
+  canInsertTextBefore() {
+    return false;
+  }
+
+  canInsertTextAfter() {
+    return true;
+  }
+
+}
+function $toggleHashtag(node) {
+  const text = node.getTextContent();
+  const replacement = !$isHashtagNode(node) ? $createHashtagNode(text) : lexical.$createTextNode(text);
+  node.replace(replacement);
+  return replacement;
+}
+function $createHashtagNode(text = '') {
+  return new HashtagNode(text);
+}
+function $isHashtagNode(node) {
+  return node instanceof HashtagNode;
+}
+
+exports.$createHashtagNode = $createHashtagNode;
+exports.$isHashtagNode = $isHashtagNode;
+exports.$toggleHashtag = $toggleHashtag;
+exports.HashtagNode = HashtagNode;

package/LexicalHashtagNode.prod.js

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';var c=require("lexical");function d(b,...a){a.forEach(f=>{null!=f&&"string"===typeof f&&b.classList.add(...f.split(" "))})}
+class e extends c.TextNode{static getType(){return"hashtag"}static clone(b){return new e(b.__text,b.__key)}constructor(b,a){super(b,a)}createDOM(b){const a=super.createDOM(b);d(a,b.theme.hashtag);return a}setTextContent(b){let a=super.setTextContent(b);return null===a.getParent()||a.isComposing()?this:(b=b.indexOf("#"),-1===b||"#"===a.getTextContent()?a=g(a):0<b&&([a]=a.splitText(b),a=g(a)),c.$isTextNode(a)&&a.isAttached()&&(b=a.getTextContent().slice(1).search(/[\s.,\\\/#!$%\^&\*;:{}=\-`~()@]/),
+0===b?a=g(a):0<b&&([a]=a.splitText(b+1),a=g(a))),a)}canInsertTextBefore(){return!1}canInsertTextAfter(){return!0}}function g(b){var a=b.getTextContent();a=h(b)?c.$createTextNode(a):k(a);b.replace(a);return a}function k(b=""){return new e(b)}function h(b){return b instanceof e}exports.$createHashtagNode=k;exports.$isHashtagNode=h;exports.$toggleHashtag=g;exports.HashtagNode=e;

package/LexicalHeadingNode.dev.js

@@ -0,0 +1,100 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var lexical = require('lexical');
+
+/**
+ * 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 addClassNamesToElement(element, ...classNames) {
+  classNames.forEach(className => {
+    if (className != null && typeof className === 'string') {
+      element.classList.add(...className.split(' '));
+    }
+  });
+}
+
+/**
+ * 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.
+ *
+ * 
+ */
+class HeadingNode extends lexical.ElementNode {
+  static getType() {
+    return 'heading';
+  }
+
+  static clone(node) {
+    return new HeadingNode(node.__tag, node.__key);
+  }
+
+  constructor(tag, key) {
+    super(key);
+    this.__tag = tag;
+  }
+
+  getTag() {
+    return this.__tag;
+  } // View
+
+
+  createDOM(config) {
+    const tag = this.__tag;
+    const element = document.createElement(tag);
+    const theme = config.theme;
+    const classNames = theme.heading;
+
+    if (classNames !== undefined) {
+      // $FlowFixMe: intentional cast
+      const className = classNames[tag];
+      addClassNamesToElement(element, className);
+    }
+
+    return element;
+  }
+
+  updateDOM(prevNode, dom) {
+    return false;
+  } // Mutation
+
+
+  insertNewAfter() {
+    const newElement = lexical.$createParagraphNode();
+    const direction = this.getDirection();
+    newElement.setDirection(direction);
+    this.insertAfter(newElement);
+    return newElement;
+  }
+
+  collapseAtStart() {
+    const paragraph = lexical.$createParagraphNode();
+    const children = this.getChildren();
+    children.forEach(child => paragraph.append(child));
+    this.replace(paragraph);
+    return true;
+  }
+
+}
+function $createHeadingNode(headingTag) {
+  return new HeadingNode(headingTag);
+}
+function $isHeadingNode(node) {
+  return node instanceof HeadingNode;
+}
+
+exports.$createHeadingNode = $createHeadingNode;
+exports.$isHeadingNode = $isHeadingNode;
+exports.HeadingNode = HeadingNode;

package/LexicalHeadingNode.prod.js

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';var d=require("lexical");function e(a,...b){b.forEach(c=>{null!=c&&"string"===typeof c&&a.classList.add(...c.split(" "))})}
+class f extends d.ElementNode{static getType(){return"heading"}static clone(a){return new f(a.__tag,a.__key)}constructor(a,b){super(b);this.__tag=a}getTag(){return this.__tag}createDOM(a){const b=this.__tag,c=document.createElement(b);a=a.theme.heading;void 0!==a&&e(c,a[b]);return c}updateDOM(){return!1}insertNewAfter(){const a=d.$createParagraphNode(),b=this.getDirection();a.setDirection(b);this.insertAfter(a);return a}collapseAtStart(){const a=d.$createParagraphNode();this.getChildren().forEach(b=>
+a.append(b));this.replace(a);return!0}}exports.$createHeadingNode=function(a){return new f(a)};exports.$isHeadingNode=function(a){return a instanceof f};exports.HeadingNode=f;