grep-components 2.7.0-GREPF-2633.1 → 2.7.0

package/dist/index.js

@@ -1,7 +1,7 @@
 import dayjs from 'dayjs';
 import LocalizedFormatPlugin from 'dayjs/plugin/localizedFormat';
 import isBetweenPlugin from 'dayjs/plugin/isBetween';
-import { red, pink, purple, deepPurple, indigo, blue, lightBlue, cyan, teal, green, lightGreen, lime, yellow, amber, orange, deepOrange, brown, grey, blueGrey } from '@mui/material/colors';
+import { blueGrey, grey, brown, deepOrange, orange, amber, yellow, lime, lightGreen, green, teal, cyan, lightBlue, blue, indigo, deepPurple, purple, pink, red } from '@mui/material/colors';
 import * as React from 'react';
 import React__default, { useRef, useMemo as useMemo$1, createContext, useContext, forwardRef, createElement, useState, useCallback as useCallback$1, useEffect, useLayoutEffect } from 'react';
 import AccountCircle from '@mui/icons-material/AccountCircle';
@@ -39,25 +39,25 @@ import Close from '@mui/icons-material/Close';
 import Search from '@mui/icons-material/Search';
 import CircularProgress$1 from '@mui/material/CircularProgress';
 import Info from '@mui/icons-material/Info';
-import Grid from '@mui/material/Grid';
 import { AdapterDayjs } from '@mui/x-date-pickers/AdapterDayjs';
 import { LocalizationProvider, DesktopDatePicker } from '@mui/x-date-pickers';
+import Grid2 from '@mui/material/Grid2';
 import ListItem$1 from '@mui/material/ListItem';
 import Collapse$1 from '@mui/material/Collapse';
 import ExpandLess from '@mui/icons-material/ExpandLess';
 import Warning from '@mui/icons-material/Warning';
 import ReactDOM, { flushSync, createPortal } from 'react-dom';
-import { compose, bindActionCreators, createStore as createStore$1, applyMiddleware } from 'redux';
+import { bindActionCreators, createStore as createStore$1, compose, applyMiddleware } from 'redux';
 import { connect, Provider } from 'react-redux';
 import DragIndicator from '@mui/icons-material/DragIndicator';
 import { LexicalComposer } from '@lexical/react/LexicalComposer';
 import { RichTextPlugin } from '@lexical/react/LexicalRichTextPlugin';
 import { ContentEditable } from '@lexical/react/LexicalContentEditable';
 import { HistoryPlugin } from '@lexical/react/LexicalHistoryPlugin';
-import { LexicalErrorBoundary } from '@lexical/react/LexicalErrorBoundary';
+import LexicalErrorBoundary from '@lexical/react/LexicalErrorBoundary';
 import { OnChangePlugin } from '@lexical/react/LexicalOnChangePlugin';
 import { EditorRefPlugin } from '@lexical/react/LexicalEditorRefPlugin';
-import { $isElementNode, ArtificialNode__DO_NOT_USE, $createLineBreakNode, $isRootOrShadowRoot, $isBlockElementNode, isBlockDomNode, isInlineDomNode, $createParagraphNode, createCommand, ElementNode, isHTMLElement, setNodeIndentFromDOM, $applyNodeReplacement, FOCUS_COMMAND, COMMAND_PRIORITY_EDITOR, BLUR_COMMAND, TextNode, ParagraphNode, PASTE_COMMAND, $createTextNode, $insertNodes, LineBreakNode, RootNode, $getSelection, $isRangeSelection, $isTextNode, $isParagraphNode, SELECTION_CHANGE_COMMAND, COMMAND_PRIORITY_LOW, FORMAT_TEXT_COMMAND } from 'lexical';
+import require$$3, { BLUR_COMMAND, COMMAND_PRIORITY_EDITOR, FOCUS_COMMAND, TextNode, ParagraphNode, PASTE_COMMAND, $createTextNode, $insertNodes, RootNode, LineBreakNode, $getSelection, $isRangeSelection, $isTextNode, $isParagraphNode, SELECTION_CHANGE_COMMAND, COMMAND_PRIORITY_LOW, FORMAT_TEXT_COMMAND, $createParagraphNode } from 'lexical';
 import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
 import FormatBold from '@mui/icons-material/FormatBold';
 import FormatItalic from '@mui/icons-material/FormatItalic';
@@ -550,8 +550,6 @@ function memoize(fn) {
   };
 }
 
-var isDevelopment = false;
-
 var hyphenateRegex = /[A-Z]|^ms/g;
 var animationRegex = /_EMO_([^_]+?)_([^]*?)_EMO_/g;
 
@@ -592,8 +590,6 @@ var processStyleValue = function processStyleValue(key, value) {
   return value;
 };
 
-var noComponentSelectorMessage = 'Component selectors can only be used in conjunction with ' + '@emotion/babel-plugin, the swc Emotion plugin, or another Emotion-aware ' + 'compiler transform.';
-
 function handleInterpolation(mergedProps, registered, interpolation) {
   if (interpolation == null) {
     return '';
@@ -644,7 +640,6 @@ function handleInterpolation(mergedProps, registered, interpolation) {
           }
 
           var styles = serializedStyles.styles + ";";
-
           return styles;
         }
 
@@ -683,9 +678,6 @@ function createStringFromObject(mergedProps, registered, obj) {
           string += processStyleName(key) + ":" + processStyleValue(key, asString) + ";";
         }
       } else {
-        if (key === 'NO_COMPONENT_SELECTOR' && isDevelopment) {
-          throw new Error(noComponentSelectorMessage);
-        }
 
         if (Array.isArray(value) && typeof value[0] === 'string' && (registered == null || registered[value[0]] === undefined)) {
           for (var _i = 0; _i < value.length; _i++) {
@@ -718,10 +710,9 @@ function createStringFromObject(mergedProps, registered, obj) {
   return string;
 }
 
-var labelPattern = /label:\s*([^\s;\n{]+)\s*(;|$)/g;
+var labelPattern = /label:\s*([^\s;{]+)\s*(;|$)/g; // this is the cursor for keyframes
 // keyframes are stored on the SerializedStyles object as a linked list
 
-
 var cursor;
 function serializeStyles(args, registered, mergedProps) {
   if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null && args[0].styles !== undefined) {
@@ -751,7 +742,7 @@ function serializeStyles(args, registered, mergedProps) {
 
       styles += templateStringsArr[i];
     }
-  }
+  } // using a global regex with .exec is stateful so lastIndex has to be reset each time
 
 
   labelPattern.lastIndex = 0;
@@ -778,7 +769,7 @@ function getRegisteredStyles(registered, registeredStyles, classNames) {
   classNames.split(' ').forEach(function (className) {
     if (registered[className] !== undefined) {
       registeredStyles.push(registered[className] + ";");
-    } else {
+    } else if (className) {
       rawClassName += className + " ";
     }
   });
@@ -1113,7 +1104,6 @@ function createMakeStyles(params) {
                         css,
                         cx,
                         "name": name !== null && name !== void 0 ? name : "makeStyle no name",
-                        "idOfUseStyles": uniqId,
                         muiStyleOverridesParams,
                         // NOTE: If it's not a Mui Theme the plugin is resilient, it will not crash
                         "theme": theme
@@ -1987,10 +1977,12 @@ const useFooterStyles = makeStyles()((theme) => ({
 
 const Footer = ({ items, serviceNameText, udirLink, udirLogo, }) => {
     const { classes } = useFooterStyles();
-    const renderItem = (item) => item.onClickItem ? (React__default.createElement(Button, { className: classes.itemBtn.concat(' ' + classes.itemText), onClick: item.onClickItem }, item.label)) : (React__default.createElement(ListItemText, { className: classes.itemText, primary: item.label, primaryTypographyProps: {
-            style: { fontSize: 14, fontFamily: 'Montserrat', fontWeight: 400 },
+    const renderItem = (item) => item.onClickItem ? (React__default.createElement(Button, { className: classes.itemBtn.concat(' ' + classes.itemText), onClick: item.onClickItem }, item.label)) : (React__default.createElement(ListItemText, { className: classes.itemText, primary: item.label, slotProps: {
+            primary: {
+                style: { fontSize: 14, fontFamily: 'Montserrat', fontWeight: 400 },
+            },
         } }));
-    return (React__default.createElement(Box, { className: classes.footer, role: "contentinfo" },
+    return (React__default.createElement("footer", { className: classes.footer },
         React__default.createElement(Box, { className: classes.content },
             React__default.createElement("a", { href: udirLink },
                 React__default.createElement("img", { src: udirLogo, alt: "Utdanningsdirektoratet logo", style: { height: '43px', width: '150px' } })),
@@ -2000,9 +1992,8 @@ const Footer = ({ items, serviceNameText, udirLink, udirLogo, }) => {
                     paddingRight: '16px !important',
                 } },
                 React__default.createElement("span", { className: classes.serviceNameText }, serviceNameText),
-                React__default.createElement(List, { className: classes.list }, items.map((item, i) => (React__default.createElement(ListItem, { key: i, classes: {
+                React__default.createElement(List, { className: classes.list }, items.map((item, i) => (React__default.createElement(ListItem, { key: i + item.label, classes: {
                         root: classes.item,
-                        //button: onClickItem ? classes.itemBtn : undefined,
                     } }, item.render
                     ? item.render(() => renderItem(item))
                     : renderItem(item)))))))));
@@ -2012,9 +2003,11 @@ const LinkList = (props) => (React__default.createElement(Box$1, { width: "100%"
     React__default.createElement(Typography$1, { style: { fontSize: 24, color: Colors.black, marginBottom: 20 } }, props.title),
     React__default.createElement(List$1, null, props.pages.map((page) => (React__default.createElement(Box$1, { key: page.id },
         React__default.createElement(ListItemButton, { onClick: () => props.onPageClick(page), style: { padding: '12px 4px' } },
-            React__default.createElement(ListItemText$1, { primary: page.label, primaryTypographyProps: {
-                    color: 'primary',
-                    style: { fontSize: 18 },
+            React__default.createElement(ListItemText$1, { primary: page.label, slotProps: {
+                    primary: {
+                        color: 'primary',
+                        style: { fontSize: 18 },
+                    }
                 } }),
             React__default.createElement(ListItemIcon, { style: { justifyContent: 'flex-end' } },
                 React__default.createElement(ArrowForward, { color: "primary" }))),
@@ -2199,13 +2192,15 @@ const PaginationActions = ({ count, page, rowsPerPage, onPageChange }) => {
 
 const GrepTablePagination = (props) => {
     const { classes } = usePaginationStyles();
-    return (React__default.createElement(TablePagination, { classes: classes, rowsPerPageOptions: props.rowsPerPageOptions, SelectProps: {
-            inputProps: {
-                title: 'Velg antall elementer',
-            },
-            style: {
-                gridArea: 'left',
-                justifySelf: 'start',
+    return (React__default.createElement(TablePagination, { classes: classes, rowsPerPageOptions: props.rowsPerPageOptions, slotProps: {
+            select: {
+                inputProps: {
+                    title: 'Velg antall elementer',
+                },
+                style: {
+                    gridArea: 'left',
+                    justifySelf: 'start',
+                },
             },
         }, ActionsComponent: (actions) => (React__default.createElement(PaginationActions, { ...actions })), ...props }));
 };
@@ -2532,7 +2527,7 @@ const useStyles$a = makeStyles()({
 
 const SearchBar = (props) => {
     const inputRef = React.useRef(null);
-    const [value, setValue] = React.useState(props.initValue || '');
+    const [value, setValue] = React.useState(props.initValue ?? '');
     const { classes } = useStyles$a();
     React.useEffect(() => {
         if (props.autoFocus && inputRef.current) {
@@ -2554,14 +2549,16 @@ const SearchBar = (props) => {
             } },
             React.createElement(Box, { className: classes.icon },
                 React.createElement(Search, null)),
-            React.createElement(TextField, { id: props.id, role: "search", className: classes.input, value: value, variant: "standard", inputRef: inputRef, onChange: _handleChange, autoFocus: props.autoFocus, placeholder: props.placeholder, InputProps: {
-                    disableUnderline: true,
-                    fullWidth: true,
-                    inputProps: {
-                        title: props.title,
+            React.createElement(TextField, { id: props.id, role: "search", className: classes.input, value: value, variant: "standard", inputRef: inputRef, onChange: _handleChange, autoFocus: props.autoFocus, placeholder: props.placeholder, slotProps: {
+                    input: {
+                        disableUnderline: true,
+                        fullWidth: true,
+                        inputProps: {
+                            title: props.title,
+                        },
                     },
                 } }),
-            React.createElement(Box, { className: classes.icon, style: { cursor: 'pointer' } }, !!value.length && (React.createElement(Close, { "data-testid": "searchBarClearBtn", tabIndex: 0, onClick: _handleClear, onKeyPress: keyboard.onActivation(_handleClear) })))),
+            React.createElement(Box, { className: classes.icon, style: { cursor: 'pointer' } }, !!value.length && (React.createElement(Close, { "data-testid": "searchBarClearBtn", tabIndex: 0, onClick: _handleClear, onKeyDown: keyboard.onActivation(_handleClear) })))),
         React.createElement("div", { style: { display: 'flex', alignItems: 'center' } },
             props.helpText && (React.createElement(Typography, { className: classes.helptext }, props.helpText)),
             props.searchAllText && props.onSearchAll && (React.createElement(Button, { color: "primary", onClick: props.onSearchAll }, props.searchAllText)))));
@@ -2600,7 +2597,9 @@ const useStyles$8 = makeStyles()((theme) => ({
     },
 }));
 
-const renderField$1 = (id, label, value) => (React.createElement(TextField, { id: id, disabled: true, label: label, value: value, variant: "outlined", style: { margin: '10px 0' }, InputProps: { style: { color: 'rgb(84, 84, 84)' } } }));
+const renderField$1 = (id, label, value) => (React.createElement(TextField, { id: id, disabled: true, label: label, value: value, variant: "outlined", style: { margin: '10px 0' }, slotProps: {
+        input: { style: { color: 'rgb(84, 84, 84)' } }
+    } }));
 const ProfileInfo = (props) => {
     const { classes } = useStyles$8();
     return (React.createElement(Box, { className: classes.container },
@@ -2658,7 +2657,9 @@ const GDPR = ({ children }) => {
 const GrepInput = ({ variant = 'standard', ...props }) => {
     const { errorMessage, helperText, shrink, value, ...rest } = props;
     const error = errorMessage ? errorMessage.length > 0 : false;
-    return (React.createElement(TextField, { ...rest, variant: variant, helperText: errorMessage || helperText, value: value === null ? '' : value, InputLabelProps: { shrink }, error: error || rest.error }));
+    return (React.createElement(TextField, { ...rest, variant: variant, helperText: errorMessage ?? helperText, value: value === null ? '' : value, error: error || rest.error, slotProps: {
+            inputLabel: { shrink },
+        } }));
 };
 
 const GrepSelect = (props) => {
@@ -3229,10 +3230,10 @@ const GrepDateRange = ({ onChange, spacing = 3, style, fullWidth, from: fromProp
     const [to, setTo] = useDate(toProperties.value);
     const { minDate, maxDate, ...commonProperties } = properties;
     useEffect(() => onChange(new DateRangeValue(from, to)), [String(from), String(to)]);
-    return (React__default.createElement(Grid, { container: true, spacing: spacing, style: style },
-        React__default.createElement(Grid, { item: true, xs: 12, sm: fullWidth ? 12 : 6 },
+    return (React__default.createElement(Grid2, { container: true, spacing: spacing, style: style },
+        React__default.createElement(Grid2, { size: { xs: 12, sm: fullWidth ? 12 : 6 } },
             React__default.createElement(DatePicker, { id: String(fromProperties.label), fullWidth: true, minDate: minDate, ...commonProperties, ...fromProperties, value: from, maxDate: to?.subtract(1, 'day') || undefined, onChange: setFrom })),
-        React__default.createElement(Grid, { item: true, xs: 12, sm: fullWidth ? 12 : 6 },
+        React__default.createElement(Grid2, { size: { xs: 12, sm: fullWidth ? 12 : 6 } },
             React__default.createElement(DatePicker, { id: String(toProperties.label), fullWidth: true, maxDate: maxDate, ...commonProperties, ...toProperties, value: to, minDate: from?.add(1, 'day') || undefined, onChange: setTo }))));
 };
 
@@ -3404,6 +3405,48 @@ const ServiceMessage = ({ id, message, isPublic, onDismiss }) => {
             React.createElement(Close, { className: classes.close })))));
 };
 
+function areInputsEqual$1(newInputs, lastInputs) {
+  if (newInputs.length !== lastInputs.length) {
+    return false;
+  }
+
+  for (var i = 0; i < newInputs.length; i++) {
+    if (newInputs[i] !== lastInputs[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function useMemoOne(getResult, inputs) {
+  var initial = useState(function () {
+    return {
+      inputs: inputs,
+      result: getResult()
+    };
+  })[0];
+  var isFirstRun = useRef(true);
+  var committed = useRef(initial);
+  var useCache = isFirstRun.current || Boolean(inputs && committed.current.inputs && areInputsEqual$1(inputs, committed.current.inputs));
+  var cache = useCache ? committed.current : {
+    inputs: inputs,
+    result: getResult()
+  };
+  useEffect(function () {
+    isFirstRun.current = false;
+    committed.current = cache;
+  }, [cache]);
+  return cache.result;
+}
+function useCallbackOne(callback, inputs) {
+  return useMemoOne(function () {
+    return callback;
+  }, inputs);
+}
+var useMemo = useMemoOne;
+var useCallback = useCallbackOne;
+
 var isProduction$2 = process.env.NODE_ENV === 'production';
 var prefix$2 = 'Invariant failed';
 function invariant$1(condition, message) {
@@ -3564,6 +3607,56 @@ var getBox = function getBox(el) {
   return calculateBox(borderBox, styles);
 };
 
+var safeIsNaN = Number.isNaN ||
+    function ponyfill(value) {
+        return typeof value === 'number' && value !== value;
+    };
+function isEqual$2(first, second) {
+    if (first === second) {
+        return true;
+    }
+    if (safeIsNaN(first) && safeIsNaN(second)) {
+        return true;
+    }
+    return false;
+}
+function areInputsEqual(newInputs, lastInputs) {
+    if (newInputs.length !== lastInputs.length) {
+        return false;
+    }
+    for (var i = 0; i < newInputs.length; i++) {
+        if (!isEqual$2(newInputs[i], lastInputs[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+
+function memoizeOne(resultFn, isEqual) {
+    if (isEqual === void 0) { isEqual = areInputsEqual; }
+    var cache = null;
+    function memoized() {
+        var newArgs = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            newArgs[_i] = arguments[_i];
+        }
+        if (cache && cache.lastThis === this && isEqual(newArgs, cache.lastArgs)) {
+            return cache.lastResult;
+        }
+        var lastResult = resultFn.apply(this, newArgs);
+        cache = {
+            lastResult: lastResult,
+            lastArgs: newArgs,
+            lastThis: this,
+        };
+        return lastResult;
+    }
+    memoized.clear = function clear() {
+        cache = null;
+    };
+    return memoized;
+}
+
 var rafSchd = function rafSchd(fn) {
   var lastArgs = [];
   var frameId = null;
@@ -3813,49 +3906,6 @@ const preset = {
   onDragEnd
 };
 
-function isEqual$2(first, second) {
-  if (first === second) {
-    return true;
-  }
-  if (Number.isNaN(first) && Number.isNaN(second)) {
-    return true;
-  }
-  return false;
-}
-function areInputsEqual(newInputs, lastInputs) {
-  if (newInputs.length !== lastInputs.length) {
-    return false;
-  }
-  for (let i = 0; i < newInputs.length; i++) {
-    if (!isEqual$2(newInputs[i], lastInputs[i])) {
-      return false;
-    }
-  }
-  return true;
-}
-
-function useMemo(getResult, inputs) {
-  const initial = useState(() => ({
-    inputs,
-    result: getResult()
-  }))[0];
-  const isFirstRun = useRef(true);
-  const committed = useRef(initial);
-  const useCache = isFirstRun.current || Boolean(inputs && committed.current.inputs && areInputsEqual(inputs, committed.current.inputs));
-  const cache = useCache ? committed.current : {
-    inputs,
-    result: getResult()
-  };
-  useEffect(() => {
-    isFirstRun.current = false;
-    committed.current = cache;
-  }, [cache]);
-  return cache.result;
-}
-function useCallback(callback, inputs) {
-  return useMemo(() => callback, inputs);
-}
-
 const origin = {
   x: 0,
   y: 0
@@ -3999,26 +4049,6 @@ var scrollDroppable = (droppable, newScroll) => {
   return result;
 };
 
-function memoizeOne(resultFn, isEqual = areInputsEqual) {
-  let cache = null;
-  function memoized(...newArgs) {
-    if (cache && cache.lastThis === this && isEqual(newArgs, cache.lastArgs)) {
-      return cache.lastResult;
-    }
-    const lastResult = resultFn.apply(this, newArgs);
-    cache = {
-      lastResult,
-      lastArgs: newArgs,
-      lastThis: this
-    };
-    return lastResult;
-  }
-  memoized.clear = function clear() {
-    cache = null;
-  };
-  return memoized;
-}
-
 const toDroppableMap = memoizeOne(droppables => droppables.reduce((previous, current) => {
   previous[current.descriptor.id] = current;
   return previous;
@@ -5770,7 +5800,6 @@ var adjustAdditionsForScrollChanges = ({
     return moved;
   });
 };
-
 var publishWhileDraggingInVirtual = ({
   state,
   published
@@ -8383,7 +8412,9 @@ function useHiddenTextElement({
 var AppContext = React__default.createContext(null);
 
 var peerDependencies = {
-	react: "^18.0.0 || ^19.0.0"};
+	react: "^18.0.0",
+	"react-dom": "^18.0.0"
+};
 
 const semver = /(\d+)\.(\d+)\.(\d+)/;
 const getVersion = value => {
@@ -11099,6 +11130,7 @@ const ConnectedDroppable = connect(makeMapStateToProps, mapDispatchToProps, (sta
   context: StoreContext,
   areStatePropsEqual: isStrictEqual
 })(Droppable);
+var ConnectedDroppable$1 = ConnectedDroppable;
 
 const setDimensions = (el) => {
     const { width, height } = el.getBoundingClientRect();
@@ -11110,7 +11142,7 @@ const clearDimensions = (el) => {
     el.style.removeProperty('width');
 };
 function SortableTableCell({ locked, children, ...props }) {
-    const ref = useRef(null);
+    const ref = useRef();
     useMemo$1(() => {
         if (ref.current) {
             locked ? setDimensions(ref.current) : clearDimensions(ref.current);
@@ -11189,7 +11221,7 @@ const SortableTable = ({ columns, items, identify, headerValue, cellValue, disab
                     return (React__default.createElement(SortableTableCell, { key: `header-${index}`, locked: isDragging, ...properties }, value));
                 }))),
         React__default.createElement(DragDropContext, { onDragEnd: onDragEnd, onBeforeDragStart: onDragStart },
-            React__default.createElement(ConnectedDroppable, { droppableId: "droppable", direction: "vertical" }, (provided) => (React__default.createElement(TableBody, { ref: provided.innerRef, ...provided.droppableProps },
+            React__default.createElement(ConnectedDroppable$1, { droppableId: "droppable", direction: "vertical" }, (provided) => (React__default.createElement(TableBody, { ref: provided.innerRef, ...provided.droppableProps },
                 records.map((item, index) => {
                     const props = {
                         id: identify(item),
@@ -11203,174 +11235,3493 @@ const SortableTable = ({ columns, items, identify, headerValue, cellValue, disab
                 provided.placeholder))))));
 };
 
-/**
- * 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.
- *
- */
+var LexicalRichText_dev = {};
 
-function N$1(e,...t){const n=new URL("https://lexical.dev/docs/error"),o=new URLSearchParams;o.append("code",e);for(const e of t)o.append("v",e);throw n.search=o.toString(),Error(`Minified Lexical error #${e}; visit ${n.toString()} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`)}function b(e){if("text"===e.type)return e.offset===e.getNode().getTextContentSize();const t=e.getNode();return $isElementNode(t)||N$1(177),e.offset===t.getChildrenSize()}
+var LexicalClipboard_dev = {};
 
-/**
- * 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.
- *
- */
+var LexicalHtml_dev = {};
 
-const N="undefined"!=typeof window&&void 0!==window.document&&void 0!==window.document.createElement,P=N&&"documentMode"in document?document.documentMode:null;!(!N||!("InputEvent"in window)||P)&&"getTargetRanges"in new window.InputEvent("input");function H(...t){const e=[];for(const n of t)if(n&&"string"==typeof n)for(const[t]of n.matchAll(/\S+/g))e.push(t);return e}function $(...t){return ()=>{for(let e=t.length-1;e>=0;e--)t[e]();t.length=0;}}function et(t,...e){const n=H(...e);n.length>0&&t.classList.add(...n);}
+var LexicalSelection_dev = {};
 
 /**
  * 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 h(e,n){const t=n.body?n.body.childNodes:[];let o=[];const l=[];for(let n=0;n<t.length;n++){const r=t[n];if(!x.has(r.nodeName)){const n=y(r,e,l,!1);null!==n&&(o=o.concat(n));}}return function(e){for(const n of e)n.getNextSibling()instanceof ArtificialNode__DO_NOT_USE&&n.insertAfter($createLineBreakNode());for(const n of e){const e=n.getChildren();for(const t of e)n.insertBefore(t);n.remove();}}(l),o}const x=new Set(["STYLE","SCRIPT"]);function y(e,n,o,r,i=new Map,s){let h=[];if(x.has(e.nodeName))return h;let m=null;const g=function(e,n){const{nodeName:t}=e,o=n._htmlConversions.get(t.toLowerCase());let l=null;if(void 0!==o)for(const n of o){const t=n(e);null!==t&&(null===l||(l.priority||0)<=(t.priority||0))&&(l=t);}return null!==l?l.conversion:null}(e,n),b=g?g(e):null;let C=null;if(null!==b){C=b.after;const n=b.node;if(m=Array.isArray(n)?n[n.length-1]:n,null!==m){for(const[,e]of i)if(m=e(m,s),!m)break;m&&h.push(...Array.isArray(n)?n:[m]);}null!=b.forChild&&i.set(e.nodeName,b.forChild);}const S=e.childNodes;let v=[];const N=(null==m||!$isRootOrShadowRoot(m))&&(null!=m&&$isBlockElementNode(m)||r);for(let e=0;e<S.length;e++)v.push(...y(S[e],n,o,N,new Map(i),m));return null!=C&&(v=C(v)),isBlockDomNode(e)&&(v=w(e,v,N?()=>{const e=new ArtificialNode__DO_NOT_USE;return o.push(e),e}:$createParagraphNode)),null==m?v.length>0?h=h.concat(v):isBlockDomNode(e)&&function(e){if(null==e.nextSibling||null==e.previousSibling)return !1;return isInlineDomNode(e.nextSibling)&&isInlineDomNode(e.previousSibling)}(e)&&(h=h.concat($createLineBreakNode())):$isElementNode(m)&&m.append(...v),h}function w(e,n,t){const o=e.style.textAlign,l=[];let r=[];for(let e=0;e<n.length;e++){const i=n[e];if($isBlockElementNode(i))o&&!i.getFormat()&&i.setFormat(o),l.push(i);else if(r.push(i),e===n.length-1||e<n.length-1&&$isBlockElementNode(n[e+1])){const e=t();e.setFormat(o),e.append(...r),l.push(e),r=[];}}return l}
+var hasRequiredLexicalSelection_dev;
 
-/**
- * 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 requireLexicalSelection_dev () {
+	if (hasRequiredLexicalSelection_dev) return LexicalSelection_dev;
+	hasRequiredLexicalSelection_dev = 1;
 
-const dt="undefined"!=typeof window&&void 0!==window.document&&void 0!==window.document.createElement,mt=dt&&"documentMode"in document?document.documentMode:null;!(!dt||!("InputEvent"in window)||mt)&&"getTargetRanges"in new window.InputEvent("input");createCommand("DRAG_DROP_PASTE_FILE");class wt extends ElementNode{static getType(){return "heading"}static clone(t){return new wt(t.__tag,t.__key)}constructor(t,e){super(e),this.__tag=t;}getTag(){return this.__tag}setTag(t){const e=this.getWritable();return this.__tag=t,e}createDOM(t){const e=this.__tag,n=document.createElement(e),r=t.theme.heading;if(void 0!==r){const t=r[e];et(n,t);}return n}updateDOM(t,e,n){return t.__tag!==this.__tag}static importDOM(){return {h1:t=>({conversion:Et,priority:0}),h2:t=>({conversion:Et,priority:0}),h3:t=>({conversion:Et,priority:0}),h4:t=>({conversion:Et,priority:0}),h5:t=>({conversion:Et,priority:0}),h6:t=>({conversion:Et,priority:0}),p:t=>{const e=t.firstChild;return null!==e&&Nt(e)?{conversion:()=>({node:null}),priority:3}:null},span:t=>Nt(t)?{conversion:t=>({node:Tt("h1")}),priority:3}:null}}exportDOM(t){const{element:e}=super.exportDOM(t);if(isHTMLElement(e)){this.isEmpty()&&e.append(document.createElement("br"));const t=this.getFormatType();e.style.textAlign=t;const n=this.getDirection();n&&(e.dir=n);}return {element:e}}static importJSON(t){return Tt(t.tag).updateFromJSON(t)}updateFromJSON(t){return super.updateFromJSON(t).setTag(t.tag)}exportJSON(){return {...super.exportJSON(),tag:this.getTag()}}insertNewAfter(t,e=!0){const n=t?t.anchor.offset:0,r=this.getLastDescendant(),o=!r||t&&t.anchor.key===r.getKey()&&n===r.getTextContentSize()||!t?$createParagraphNode():Tt(this.getTag()),i=this.getDirection();if(o.setDirection(i),this.insertAfter(o,e),0===n&&!this.isEmpty()&&t){const t=$createParagraphNode();t.select(),this.replace(t,!0);}return o}collapseAtStart(){const t=this.isEmpty()?$createParagraphNode():Tt(this.getTag());return this.getChildren().forEach((e=>t.append(e))),this.replace(t),!0}extractWithChild(){return !0}}function Nt(t){return "span"===t.nodeName.toLowerCase()&&"26pt"===t.style.fontSize}function Et(t){const e=t.nodeName.toLowerCase();let n=null;return "h1"!==e&&"h2"!==e&&"h3"!==e&&"h4"!==e&&"h5"!==e&&"h6"!==e||(n=Tt(e),null!==t.style&&(setNodeIndentFromDOM(t,n),n.setFormat(t.style.textAlign))),{node:n}}function Tt(t="h1"){return $applyNodeReplacement(new wt(t))}
+	var lexical = require$$3;
 
-const useEditorStyles = makeStyles()((theme, { hasFocus, hasContent, readOnly, hasCustomToolbar }) => ({
-    root: {
-        position: 'relative',
-        display: 'inline-flex',
-        flexDirection: hasCustomToolbar ? 'column-reverse' : 'column',
-        minWidth: '100%', // TODO
-    },
-    legend: {
-        position: 'absolute',
-        top: -5,
-        left: 0,
-        right: 0,
-        bottom: 0,
-        lineHeight: '11px',
-        zIndex: hasFocus ? 0 : 1,
-        paddingLeft: 10,
-        borderStyle: 'solid',
-        borderRadius: theme.shape.borderRadius,
-        borderWidth: hasFocus ? 2 : 1,
-        borderColor: hasFocus
-            ? theme.palette.primary.main
-            : hex2rgba('#000', 0.23),
-        '&:hover': {
-            borderColor: hasFocus
-                ? theme.palette.primary.main
-                : theme.palette.text.primary,
-        },
-        transition: theme.transitions.create(['border-color'], {
-            duration: theme.transitions.duration.shorter,
-            easing: theme.transitions.easing.easeOut,
-        }),
-    },
-    editor: {
-        padding: '.8rem 1rem',
-        position: 'relative',
-        zIndex: hasFocus || readOnly ? 1 : 0,
-        '& .unstyled': {
-            margin: '.5rem 0',
-        },
-    },
-    label: {
-        position: 'absolute',
-        top: 0,
-        left: 0,
-        zIndex: 1,
-        transform: hasFocus || hasContent
-            ? 'translate(6px, -14px) scale(0.75)'
-            : 'translate(6px, 12px) scale(1)',
-        transformOrigin: 'top left',
-        transition: theme.transitions.create(['color', 'transform'], {
-            duration: theme.transitions.duration.shorter,
-            easing: theme.transitions.easing.easeOut,
-        }),
-        color: hasFocus
-            ? theme.palette.primary[theme.palette.mode === 'light' ? 'dark' : 'light']
-            : theme.palette.text.secondary,
-        fontSize: '1.1428571428571428rem',
-        // hack @todo when time
-        backgroundColor: 'white',
-        padding: '2px 10px',
-    },
-    helpertext: {
-        margin: 0,
-        opacity: hasFocus ? 1 : 0,
-        transition: theme.transitions.create(['opacity'], {
-            duration: theme.transitions.duration.shorter,
-            easing: theme.transitions.easing.easeOut,
-        }),
-        fontSize: 'small',
-        // hack @todo when time
-        backgroundColor: 'white',
-        padding: '2px 10px',
-    },
-    charcount: {
-        margin: 0,
-        transition: theme.transitions.create(['opacity'], {
-            duration: theme.transitions.duration.shorter,
-            easing: theme.transitions.easing.easeOut,
-        }),
-        fontSize: 'small',
-        // hack @todo when time
-        backgroundColor: 'white',
-        padding: '2px 10px',
-    },
-}));
+	/**
+	 * 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 CSS_TO_STYLES = new Map();
 
-function r(e){var t,f,n="";if("string"==typeof e||"number"==typeof e)n+=e;else if("object"==typeof e)if(Array.isArray(e)){var o=e.length;for(t=0;t<o;t++)e[t]&&(f=r(e[t]))&&(n&&(n+=" "),n+=f);}else for(f in e)e[f]&&(n&&(n+=" "),n+=f);return n}function clsx(){for(var e,t,f=0,n="",o=arguments.length;f<o;f++)(e=arguments[f])&&(t=r(e))&&(n&&(n+=" "),n+=t);return 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.
+	 *
+	 */
+	function getDOMTextNode(element) {
+	  let node = element;
+	  while (node != null) {
+	    if (node.nodeType === Node.TEXT_NODE) {
+	      return node;
+	    }
+	    node = node.firstChild;
+	  }
+	  return null;
+	}
+	function getDOMIndexWithinParent(node) {
+	  const parent = node.parentNode;
+	  if (parent == null) {
+	    throw new Error('Should never happen');
+	  }
+	  return [parent, Array.from(parent.childNodes).indexOf(node)];
+	}
 
-function StyleWrapperPlugin({ showCharcount, helperText, readOnly, classes, label, children, autoFocus, toolbarAnchor, hasCustomToolbar, }) {
-    const [editor] = useLexicalComposerContext();
-    const [hasFocus, setFocused] = useState(() => {
-        return editor.getRootElement() === document.activeElement;
-    });
-    const [charCount, setCharCount] = useState(0);
-    useEffect(() => {
-        return $(editor.registerCommand(BLUR_COMMAND, () => {
-            setFocused(editor.getRootElement() === document.activeElement);
-            return false;
-        }, COMMAND_PRIORITY_EDITOR), editor.registerCommand(FOCUS_COMMAND, () => {
-            setFocused(editor.getRootElement() === document.activeElement);
-            return false;
-        }, COMMAND_PRIORITY_EDITOR));
-    }, []);
-    const { classes: styles } = useEditorStyles({
-        hasFocus,
-        hasContent: charCount > 0,
-        readOnly,
-        hasCustomToolbar: hasCustomToolbar,
-    });
-    // Autofocus, makes sure the editor is focused as soon as it it rendered.
-    useEffect(() => {
-        autoFocus &&
-            editor.focus(() => {
-                const activeElement = document.activeElement;
-                const rootElement = editor.getRootElement();
-                if (rootElement !== null &&
-                    (activeElement === null || !rootElement.contains(activeElement))) {
-                    // Note: preventScroll won't work in Webkit.
-                    rootElement.focus({ preventScroll: true });
-                }
-            });
-    }, [autoFocus]);
-    useEffect(() => {
-        editor.registerTextContentListener((content) => {
-            // For some reason a newline "Enter" inserts two \n characters.
-            const newCount = content.replaceAll('\n\n', '\n').length;
-            setCharCount((prevCount) => {
-                return prevCount !== newCount ? newCount : prevCount;
+	/**
+	 * Creates a selection range for the DOM.
+	 * @param editor - The lexical editor.
+	 * @param anchorNode - The anchor node of a selection.
+	 * @param _anchorOffset - The amount of space offset from the anchor to the focus.
+	 * @param focusNode - The current focus.
+	 * @param _focusOffset - The amount of space offset from the focus to the anchor.
+	 * @returns The range of selection for the DOM that was created.
+	 */
+	function createDOMRange(editor, anchorNode, _anchorOffset, focusNode, _focusOffset) {
+	  const anchorKey = anchorNode.getKey();
+	  const focusKey = focusNode.getKey();
+	  const range = document.createRange();
+	  let anchorDOM = editor.getElementByKey(anchorKey);
+	  let focusDOM = editor.getElementByKey(focusKey);
+	  let anchorOffset = _anchorOffset;
+	  let focusOffset = _focusOffset;
+	  if (lexical.$isTextNode(anchorNode)) {
+	    anchorDOM = getDOMTextNode(anchorDOM);
+	  }
+	  if (lexical.$isTextNode(focusNode)) {
+	    focusDOM = getDOMTextNode(focusDOM);
+	  }
+	  if (anchorNode === undefined || focusNode === undefined || anchorDOM === null || focusDOM === null) {
+	    return null;
+	  }
+	  if (anchorDOM.nodeName === 'BR') {
+	    [anchorDOM, anchorOffset] = getDOMIndexWithinParent(anchorDOM);
+	  }
+	  if (focusDOM.nodeName === 'BR') {
+	    [focusDOM, focusOffset] = getDOMIndexWithinParent(focusDOM);
+	  }
+	  const firstChild = anchorDOM.firstChild;
+	  if (anchorDOM === focusDOM && firstChild != null && firstChild.nodeName === 'BR' && anchorOffset === 0 && focusOffset === 0) {
+	    focusOffset = 1;
+	  }
+	  try {
+	    range.setStart(anchorDOM, anchorOffset);
+	    range.setEnd(focusDOM, focusOffset);
+	  } catch (e) {
+	    return null;
+	  }
+	  if (range.collapsed && (anchorOffset !== focusOffset || anchorKey !== focusKey)) {
+	    // Range is backwards, we need to reverse it
+	    range.setStart(focusDOM, focusOffset);
+	    range.setEnd(anchorDOM, anchorOffset);
+	  }
+	  return range;
+	}
+
+	/**
+	 * Creates DOMRects, generally used to help the editor find a specific location on the screen.
+	 * @param editor - The lexical editor
+	 * @param range - A fragment of a document that can contain nodes and parts of text nodes.
+	 * @returns The selectionRects as an array.
+	 */
+	function createRectsFromDOMRange(editor, range) {
+	  const rootElement = editor.getRootElement();
+	  if (rootElement === null) {
+	    return [];
+	  }
+	  const rootRect = rootElement.getBoundingClientRect();
+	  const computedStyle = getComputedStyle(rootElement);
+	  const rootPadding = parseFloat(computedStyle.paddingLeft) + parseFloat(computedStyle.paddingRight);
+	  const selectionRects = Array.from(range.getClientRects());
+	  let selectionRectsLength = selectionRects.length;
+	  //sort rects from top left to bottom right.
+	  selectionRects.sort((a, b) => {
+	    const top = a.top - b.top;
+	    // Some rects match position closely, but not perfectly,
+	    // so we give a 3px tolerance.
+	    if (Math.abs(top) <= 3) {
+	      return a.left - b.left;
+	    }
+	    return top;
+	  });
+	  let prevRect;
+	  for (let i = 0; i < selectionRectsLength; i++) {
+	    const selectionRect = selectionRects[i];
+	    // Exclude rects that overlap preceding Rects in the sorted list.
+	    const isOverlappingRect = prevRect && prevRect.top <= selectionRect.top && prevRect.top + prevRect.height > selectionRect.top && prevRect.left + prevRect.width > selectionRect.left;
+	    // Exclude selections that span the entire element
+	    const selectionSpansElement = selectionRect.width + rootPadding === rootRect.width;
+	    if (isOverlappingRect || selectionSpansElement) {
+	      selectionRects.splice(i--, 1);
+	      selectionRectsLength--;
+	      continue;
+	    }
+	    prevRect = selectionRect;
+	  }
+	  return selectionRects;
+	}
+
+	/**
+	 * Creates an object containing all the styles and their values provided in the CSS string.
+	 * @param css - The CSS string of styles and their values.
+	 * @returns The styleObject containing all the styles and their values.
+	 */
+	function getStyleObjectFromRawCSS(css) {
+	  const styleObject = {};
+	  const styles = css.split(';');
+	  for (const style of styles) {
+	    if (style !== '') {
+	      const [key, value] = style.split(/:([^]+)/); // split on first colon
+	      if (key && value) {
+	        styleObject[key.trim()] = value.trim();
+	      }
+	    }
+	  }
+	  return styleObject;
+	}
+
+	/**
+	 * Given a CSS string, returns an object from the style cache.
+	 * @param css - The CSS property as a string.
+	 * @returns The value of the given CSS property.
+	 */
+	function getStyleObjectFromCSS(css) {
+	  let value = CSS_TO_STYLES.get(css);
+	  if (value === undefined) {
+	    value = getStyleObjectFromRawCSS(css);
+	    CSS_TO_STYLES.set(css, value);
+	  }
+	  {
+	    // Freeze the value in DEV to prevent accidental mutations
+	    Object.freeze(value);
+	  }
+	  return value;
+	}
+
+	/**
+	 * Gets the CSS styles from the style object.
+	 * @param styles - The style object containing the styles to get.
+	 * @returns A string containing the CSS styles and their values.
+	 */
+	function getCSSFromStyleObject(styles) {
+	  let css = '';
+	  for (const style in styles) {
+	    if (style) {
+	      css += `${style}: ${styles[style]};`;
+	    }
+	  }
+	  return css;
+	}
+
+	/**
+	 * 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 $updateElementNodeProperties(target, source) {
+	  target.__first = source.__first;
+	  target.__last = source.__last;
+	  target.__size = source.__size;
+	  target.__format = source.__format;
+	  target.__indent = source.__indent;
+	  target.__dir = source.__dir;
+	  return target;
+	}
+	function $updateTextNodeProperties(target, source) {
+	  target.__format = source.__format;
+	  target.__style = source.__style;
+	  target.__mode = source.__mode;
+	  target.__detail = source.__detail;
+	  return target;
+	}
+
+	/**
+	 * Returns a copy of a node, but generates a new key for the copy.
+	 * @param node - The node to be cloned.
+	 * @returns The clone of the node.
+	 */
+	function $cloneWithProperties(node) {
+	  const constructor = node.constructor;
+	  // @ts-expect-error
+	  const clone = constructor.clone(node);
+	  clone.__parent = node.__parent;
+	  clone.__next = node.__next;
+	  clone.__prev = node.__prev;
+	  if (lexical.$isElementNode(node) && lexical.$isElementNode(clone)) {
+	    return $updateElementNodeProperties(clone, node);
+	  }
+	  if (lexical.$isTextNode(node) && lexical.$isTextNode(clone)) {
+	    return $updateTextNodeProperties(clone, node);
+	  }
+	  return clone;
+	}
+
+	/**
+	 * Generally used to append text content to HTML and JSON. Grabs the text content and "slices"
+	 * it to be generated into the new TextNode.
+	 * @param selection - The selection containing the node whose TextNode is to be edited.
+	 * @param textNode - The TextNode to be edited.
+	 * @returns The updated TextNode.
+	 */
+	function $sliceSelectedTextNodeContent(selection, textNode) {
+	  const anchorAndFocus = selection.getStartEndPoints();
+	  if (textNode.isSelected(selection) && !textNode.isSegmented() && !textNode.isToken() && anchorAndFocus !== null) {
+	    const [anchor, focus] = anchorAndFocus;
+	    const isBackward = selection.isBackward();
+	    const anchorNode = anchor.getNode();
+	    const focusNode = focus.getNode();
+	    const isAnchor = textNode.is(anchorNode);
+	    const isFocus = textNode.is(focusNode);
+	    if (isAnchor || isFocus) {
+	      const [anchorOffset, focusOffset] = lexical.$getCharacterOffsets(selection);
+	      const isSame = anchorNode.is(focusNode);
+	      const isFirst = textNode.is(isBackward ? focusNode : anchorNode);
+	      const isLast = textNode.is(isBackward ? anchorNode : focusNode);
+	      let startOffset = 0;
+	      let endOffset = undefined;
+	      if (isSame) {
+	        startOffset = anchorOffset > focusOffset ? focusOffset : anchorOffset;
+	        endOffset = anchorOffset > focusOffset ? anchorOffset : focusOffset;
+	      } else if (isFirst) {
+	        const offset = isBackward ? focusOffset : anchorOffset;
+	        startOffset = offset;
+	        endOffset = undefined;
+	      } else if (isLast) {
+	        const offset = isBackward ? anchorOffset : focusOffset;
+	        startOffset = 0;
+	        endOffset = offset;
+	      }
+	      textNode.__text = textNode.__text.slice(startOffset, endOffset);
+	      return textNode;
+	    }
+	  }
+	  return textNode;
+	}
+
+	/**
+	 * Determines if the current selection is at the end of the node.
+	 * @param point - The point of the selection to test.
+	 * @returns true if the provided point offset is in the last possible position, false otherwise.
+	 */
+	function $isAtNodeEnd(point) {
+	  if (point.type === 'text') {
+	    return point.offset === point.getNode().getTextContentSize();
+	  }
+	  const node = point.getNode();
+	  if (!lexical.$isElementNode(node)) {
+	    throw Error(`isAtNodeEnd: node must be a TextNode or ElementNode`);
+	  }
+	  return point.offset === node.getChildrenSize();
+	}
+
+	/**
+	 * Trims text from a node in order to shorten it, eg. to enforce a text's max length. If it deletes text
+	 * that is an ancestor of the anchor then it will leave 2 indents, otherwise, if no text content exists, it deletes
+	 * the TextNode. It will move the focus to either the end of any left over text or beginning of a new TextNode.
+	 * @param editor - The lexical editor.
+	 * @param anchor - The anchor of the current selection, where the selection should be pointing.
+	 * @param delCount - The amount of characters to delete. Useful as a dynamic variable eg. textContentSize - maxLength;
+	 */
+	function trimTextContentFromAnchor(editor, anchor, delCount) {
+	  // Work from the current selection anchor point
+	  let currentNode = anchor.getNode();
+	  let remaining = delCount;
+	  if (lexical.$isElementNode(currentNode)) {
+	    const descendantNode = currentNode.getDescendantByIndex(anchor.offset);
+	    if (descendantNode !== null) {
+	      currentNode = descendantNode;
+	    }
+	  }
+	  while (remaining > 0 && currentNode !== null) {
+	    if (lexical.$isElementNode(currentNode)) {
+	      const lastDescendant = currentNode.getLastDescendant();
+	      if (lastDescendant !== null) {
+	        currentNode = lastDescendant;
+	      }
+	    }
+	    let nextNode = currentNode.getPreviousSibling();
+	    let additionalElementWhitespace = 0;
+	    if (nextNode === null) {
+	      let parent = currentNode.getParentOrThrow();
+	      let parentSibling = parent.getPreviousSibling();
+	      while (parentSibling === null) {
+	        parent = parent.getParent();
+	        if (parent === null) {
+	          nextNode = null;
+	          break;
+	        }
+	        parentSibling = parent.getPreviousSibling();
+	      }
+	      if (parent !== null) {
+	        additionalElementWhitespace = parent.isInline() ? 0 : 2;
+	        nextNode = parentSibling;
+	      }
+	    }
+	    let text = currentNode.getTextContent();
+	    // If the text is empty, we need to consider adding in two line breaks to match
+	    // the content if we were to get it from its parent.
+	    if (text === '' && lexical.$isElementNode(currentNode) && !currentNode.isInline()) {
+	      // TODO: should this be handled in core?
+	      text = '\n\n';
+	    }
+	    const currentNodeSize = text.length;
+	    if (!lexical.$isTextNode(currentNode) || remaining >= currentNodeSize) {
+	      const parent = currentNode.getParent();
+	      currentNode.remove();
+	      if (parent != null && parent.getChildrenSize() === 0 && !lexical.$isRootNode(parent)) {
+	        parent.remove();
+	      }
+	      remaining -= currentNodeSize + additionalElementWhitespace;
+	      currentNode = nextNode;
+	    } else {
+	      const key = currentNode.getKey();
+	      // See if we can just revert it to what was in the last editor state
+	      const prevTextContent = editor.getEditorState().read(() => {
+	        const prevNode = lexical.$getNodeByKey(key);
+	        if (lexical.$isTextNode(prevNode) && prevNode.isSimpleText()) {
+	          return prevNode.getTextContent();
+	        }
+	        return null;
+	      });
+	      const offset = currentNodeSize - remaining;
+	      const slicedText = text.slice(0, offset);
+	      if (prevTextContent !== null && prevTextContent !== text) {
+	        const prevSelection = lexical.$getPreviousSelection();
+	        let target = currentNode;
+	        if (!currentNode.isSimpleText()) {
+	          const textNode = lexical.$createTextNode(prevTextContent);
+	          currentNode.replace(textNode);
+	          target = textNode;
+	        } else {
+	          currentNode.setTextContent(prevTextContent);
+	        }
+	        if (lexical.$isRangeSelection(prevSelection) && prevSelection.isCollapsed()) {
+	          const prevOffset = prevSelection.anchor.offset;
+	          target.select(prevOffset, prevOffset);
+	        }
+	      } else if (currentNode.isSimpleText()) {
+	        // Split text
+	        const isSelected = anchor.key === key;
+	        let anchorOffset = anchor.offset;
+	        // Move offset to end if it's less than the remaining number, otherwise
+	        // we'll have a negative splitStart.
+	        if (anchorOffset < remaining) {
+	          anchorOffset = currentNodeSize;
+	        }
+	        const splitStart = isSelected ? anchorOffset - remaining : 0;
+	        const splitEnd = isSelected ? anchorOffset : offset;
+	        if (isSelected && splitStart === 0) {
+	          const [excessNode] = currentNode.splitText(splitStart, splitEnd);
+	          excessNode.remove();
+	        } else {
+	          const [, excessNode] = currentNode.splitText(splitStart, splitEnd);
+	          excessNode.remove();
+	        }
+	      } else {
+	        const textNode = lexical.$createTextNode(slicedText);
+	        currentNode.replace(textNode);
+	      }
+	      remaining = 0;
+	    }
+	  }
+	}
+
+	/**
+	 * Gets the TextNode's style object and adds the styles to the CSS.
+	 * @param node - The TextNode to add styles to.
+	 */
+	function $addNodeStyle(node) {
+	  const CSSText = node.getStyle();
+	  const styles = getStyleObjectFromRawCSS(CSSText);
+	  CSS_TO_STYLES.set(CSSText, styles);
+	}
+	function $patchStyle(target, patch) {
+	  const prevStyles = getStyleObjectFromCSS('getStyle' in target ? target.getStyle() : target.style);
+	  const newStyles = Object.entries(patch).reduce((styles, [key, value]) => {
+	    if (value instanceof Function) {
+	      styles[key] = value(prevStyles[key]);
+	    } else if (value === null) {
+	      delete styles[key];
+	    } else {
+	      styles[key] = value;
+	    }
+	    return styles;
+	  }, {
+	    ...prevStyles
+	  } || {});
+	  const newCSSText = getCSSFromStyleObject(newStyles);
+	  target.setStyle(newCSSText);
+	  CSS_TO_STYLES.set(newCSSText, newStyles);
+	}
+
+	/**
+	 * Applies the provided styles to the TextNodes in the provided Selection.
+	 * Will update partially selected TextNodes by splitting the TextNode and applying
+	 * the styles to the appropriate one.
+	 * @param selection - The selected node(s) to update.
+	 * @param patch - The patch to apply, which can include multiple styles. { CSSProperty: value }. Can also accept a function that returns the new property value.
+	 */
+	function $patchStyleText(selection, patch) {
+	  const selectedNodes = selection.getNodes();
+	  const selectedNodesLength = selectedNodes.length;
+	  const anchorAndFocus = selection.getStartEndPoints();
+	  if (anchorAndFocus === null) {
+	    return;
+	  }
+	  const [anchor, focus] = anchorAndFocus;
+	  const lastIndex = selectedNodesLength - 1;
+	  let firstNode = selectedNodes[0];
+	  let lastNode = selectedNodes[lastIndex];
+	  if (selection.isCollapsed() && lexical.$isRangeSelection(selection)) {
+	    $patchStyle(selection, patch);
+	    return;
+	  }
+	  const firstNodeText = firstNode.getTextContent();
+	  const firstNodeTextLength = firstNodeText.length;
+	  const focusOffset = focus.offset;
+	  let anchorOffset = anchor.offset;
+	  const isBefore = anchor.isBefore(focus);
+	  let startOffset = isBefore ? anchorOffset : focusOffset;
+	  let endOffset = isBefore ? focusOffset : anchorOffset;
+	  const startType = isBefore ? anchor.type : focus.type;
+	  const endType = isBefore ? focus.type : anchor.type;
+	  const endKey = isBefore ? focus.key : anchor.key;
+
+	  // This is the case where the user only selected the very end of the
+	  // first node so we don't want to include it in the formatting change.
+	  if (lexical.$isTextNode(firstNode) && startOffset === firstNodeTextLength) {
+	    const nextSibling = firstNode.getNextSibling();
+	    if (lexical.$isTextNode(nextSibling)) {
+	      // we basically make the second node the firstNode, changing offsets accordingly
+	      anchorOffset = 0;
+	      startOffset = 0;
+	      firstNode = nextSibling;
+	    }
+	  }
+
+	  // This is the case where we only selected a single node
+	  if (selectedNodes.length === 1) {
+	    if (lexical.$isTextNode(firstNode) && firstNode.canHaveFormat()) {
+	      startOffset = startType === 'element' ? 0 : anchorOffset > focusOffset ? focusOffset : anchorOffset;
+	      endOffset = endType === 'element' ? firstNodeTextLength : anchorOffset > focusOffset ? anchorOffset : focusOffset;
+
+	      // No actual text is selected, so do nothing.
+	      if (startOffset === endOffset) {
+	        return;
+	      }
+
+	      // The entire node is selected, so just format it
+	      if (startOffset === 0 && endOffset === firstNodeTextLength) {
+	        $patchStyle(firstNode, patch);
+	        firstNode.select(startOffset, endOffset);
+	      } else {
+	        // The node is partially selected, so split it into two nodes
+	        // and style the selected one.
+	        const splitNodes = firstNode.splitText(startOffset, endOffset);
+	        const replacement = startOffset === 0 ? splitNodes[0] : splitNodes[1];
+	        $patchStyle(replacement, patch);
+	        replacement.select(0, endOffset - startOffset);
+	      }
+	    } // multiple nodes selected.
+	  } else {
+	    if (lexical.$isTextNode(firstNode) && startOffset < firstNode.getTextContentSize() && firstNode.canHaveFormat()) {
+	      if (startOffset !== 0) {
+	        // the entire first node isn't selected, so split it
+	        firstNode = firstNode.splitText(startOffset)[1];
+	        startOffset = 0;
+	        anchor.set(firstNode.getKey(), startOffset, 'text');
+	      }
+	      $patchStyle(firstNode, patch);
+	    }
+	    if (lexical.$isTextNode(lastNode) && lastNode.canHaveFormat()) {
+	      const lastNodeText = lastNode.getTextContent();
+	      const lastNodeTextLength = lastNodeText.length;
+
+	      // The last node might not actually be the end node
+	      //
+	      // If not, assume the last node is fully-selected unless the end offset is
+	      // zero.
+	      if (lastNode.__key !== endKey && endOffset !== 0) {
+	        endOffset = lastNodeTextLength;
+	      }
+
+	      // if the entire last node isn't selected, split it
+	      if (endOffset !== lastNodeTextLength) {
+	        [lastNode] = lastNode.splitText(endOffset);
+	      }
+	      if (endOffset !== 0 || endType === 'element') {
+	        $patchStyle(lastNode, patch);
+	      }
+	    }
+
+	    // style all the text nodes in between
+	    for (let i = 1; i < lastIndex; i++) {
+	      const selectedNode = selectedNodes[i];
+	      const selectedNodeKey = selectedNode.getKey();
+	      if (lexical.$isTextNode(selectedNode) && selectedNode.canHaveFormat() && selectedNodeKey !== firstNode.getKey() && selectedNodeKey !== lastNode.getKey() && !selectedNode.isToken()) {
+	        $patchStyle(selectedNode, patch);
+	      }
+	    }
+	  }
+	}
+
+	/**
+	 * 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.
+	 *
+	 */
+
+	/**
+	 * Converts all nodes in the selection that are of one block type to another.
+	 * @param selection - The selected blocks to be converted.
+	 * @param createElement - The function that creates the node. eg. $createParagraphNode.
+	 */
+	function $setBlocksType(selection, createElement) {
+	  if (selection === null) {
+	    return;
+	  }
+	  const anchorAndFocus = selection.getStartEndPoints();
+	  const anchor = anchorAndFocus ? anchorAndFocus[0] : null;
+	  if (anchor !== null && anchor.key === 'root') {
+	    const element = createElement();
+	    const root = lexical.$getRoot();
+	    const firstChild = root.getFirstChild();
+	    if (firstChild) {
+	      firstChild.replace(element, true);
+	    } else {
+	      root.append(element);
+	    }
+	    return;
+	  }
+	  const nodes = selection.getNodes();
+	  const firstSelectedBlock = anchor !== null ? $getAncestor(anchor.getNode(), INTERNAL_$isBlock) : false;
+	  if (firstSelectedBlock && nodes.indexOf(firstSelectedBlock) === -1) {
+	    nodes.push(firstSelectedBlock);
+	  }
+	  for (let i = 0; i < nodes.length; i++) {
+	    const node = nodes[i];
+	    if (!INTERNAL_$isBlock(node)) {
+	      continue;
+	    }
+	    if (!lexical.$isElementNode(node)) {
+	      throw Error(`Expected block node to be an ElementNode`);
+	    }
+	    const targetElement = createElement();
+	    targetElement.setFormat(node.getFormatType());
+	    targetElement.setIndent(node.getIndent());
+	    node.replace(targetElement, true);
+	  }
+	}
+	function isPointAttached(point) {
+	  return point.getNode().isAttached();
+	}
+	function $removeParentEmptyElements(startingNode) {
+	  let node = startingNode;
+	  while (node !== null && !lexical.$isRootOrShadowRoot(node)) {
+	    const latest = node.getLatest();
+	    const parentNode = node.getParent();
+	    if (latest.getChildrenSize() === 0) {
+	      node.remove(true);
+	    }
+	    node = parentNode;
+	  }
+	}
+
+	/**
+	 * @deprecated
+	 * Wraps all nodes in the selection into another node of the type returned by createElement.
+	 * @param selection - The selection of nodes to be wrapped.
+	 * @param createElement - A function that creates the wrapping ElementNode. eg. $createParagraphNode.
+	 * @param wrappingElement - An element to append the wrapped selection and its children to.
+	 */
+	function $wrapNodes(selection, createElement, wrappingElement = null) {
+	  const anchorAndFocus = selection.getStartEndPoints();
+	  const anchor = anchorAndFocus ? anchorAndFocus[0] : null;
+	  const nodes = selection.getNodes();
+	  const nodesLength = nodes.length;
+	  if (anchor !== null && (nodesLength === 0 || nodesLength === 1 && anchor.type === 'element' && anchor.getNode().getChildrenSize() === 0)) {
+	    const target = anchor.type === 'text' ? anchor.getNode().getParentOrThrow() : anchor.getNode();
+	    const children = target.getChildren();
+	    let element = createElement();
+	    element.setFormat(target.getFormatType());
+	    element.setIndent(target.getIndent());
+	    children.forEach(child => element.append(child));
+	    if (wrappingElement) {
+	      element = wrappingElement.append(element);
+	    }
+	    target.replace(element);
+	    return;
+	  }
+	  let topLevelNode = null;
+	  let descendants = [];
+	  for (let i = 0; i < nodesLength; i++) {
+	    const node = nodes[i];
+	    // Determine whether wrapping has to be broken down into multiple chunks. This can happen if the
+	    // user selected multiple Root-like nodes that have to be treated separately as if they are
+	    // their own branch. I.e. you don't want to wrap a whole table, but rather the contents of each
+	    // of each of the cell nodes.
+	    if (lexical.$isRootOrShadowRoot(node)) {
+	      $wrapNodesImpl(selection, descendants, descendants.length, createElement, wrappingElement);
+	      descendants = [];
+	      topLevelNode = node;
+	    } else if (topLevelNode === null || topLevelNode !== null && lexical.$hasAncestor(node, topLevelNode)) {
+	      descendants.push(node);
+	    } else {
+	      $wrapNodesImpl(selection, descendants, descendants.length, createElement, wrappingElement);
+	      descendants = [node];
+	    }
+	  }
+	  $wrapNodesImpl(selection, descendants, descendants.length, createElement, wrappingElement);
+	}
+
+	/**
+	 * Wraps each node into a new ElementNode.
+	 * @param selection - The selection of nodes to wrap.
+	 * @param nodes - An array of nodes, generally the descendants of the selection.
+	 * @param nodesLength - The length of nodes.
+	 * @param createElement - A function that creates the wrapping ElementNode. eg. $createParagraphNode.
+	 * @param wrappingElement - An element to wrap all the nodes into.
+	 * @returns
+	 */
+	function $wrapNodesImpl(selection, nodes, nodesLength, createElement, wrappingElement = null) {
+	  if (nodes.length === 0) {
+	    return;
+	  }
+	  const firstNode = nodes[0];
+	  const elementMapping = new Map();
+	  const elements = [];
+	  // The below logic is to find the right target for us to
+	  // either insertAfter/insertBefore/append the corresponding
+	  // elements to. This is made more complicated due to nested
+	  // structures.
+	  let target = lexical.$isElementNode(firstNode) ? firstNode : firstNode.getParentOrThrow();
+	  if (target.isInline()) {
+	    target = target.getParentOrThrow();
+	  }
+	  let targetIsPrevSibling = false;
+	  while (target !== null) {
+	    const prevSibling = target.getPreviousSibling();
+	    if (prevSibling !== null) {
+	      target = prevSibling;
+	      targetIsPrevSibling = true;
+	      break;
+	    }
+	    target = target.getParentOrThrow();
+	    if (lexical.$isRootOrShadowRoot(target)) {
+	      break;
+	    }
+	  }
+	  const emptyElements = new Set();
+
+	  // Find any top level empty elements
+	  for (let i = 0; i < nodesLength; i++) {
+	    const node = nodes[i];
+	    if (lexical.$isElementNode(node) && node.getChildrenSize() === 0) {
+	      emptyElements.add(node.getKey());
+	    }
+	  }
+	  const movedNodes = new Set();
+
+	  // Move out all leaf nodes into our elements array.
+	  // If we find a top level empty element, also move make
+	  // an element for that.
+	  for (let i = 0; i < nodesLength; i++) {
+	    const node = nodes[i];
+	    let parent = node.getParent();
+	    if (parent !== null && parent.isInline()) {
+	      parent = parent.getParent();
+	    }
+	    if (parent !== null && lexical.$isLeafNode(node) && !movedNodes.has(node.getKey())) {
+	      const parentKey = parent.getKey();
+	      if (elementMapping.get(parentKey) === undefined) {
+	        const targetElement = createElement();
+	        targetElement.setFormat(parent.getFormatType());
+	        targetElement.setIndent(parent.getIndent());
+	        elements.push(targetElement);
+	        elementMapping.set(parentKey, targetElement);
+	        // Move node and its siblings to the new
+	        // element.
+	        parent.getChildren().forEach(child => {
+	          targetElement.append(child);
+	          movedNodes.add(child.getKey());
+	          if (lexical.$isElementNode(child)) {
+	            // Skip nested leaf nodes if the parent has already been moved
+	            child.getChildrenKeys().forEach(key => movedNodes.add(key));
+	          }
+	        });
+	        $removeParentEmptyElements(parent);
+	      }
+	    } else if (emptyElements.has(node.getKey())) {
+	      if (!lexical.$isElementNode(node)) {
+	        throw Error(`Expected node in emptyElements to be an ElementNode`);
+	      }
+	      const targetElement = createElement();
+	      targetElement.setFormat(node.getFormatType());
+	      targetElement.setIndent(node.getIndent());
+	      elements.push(targetElement);
+	      node.remove(true);
+	    }
+	  }
+	  if (wrappingElement !== null) {
+	    for (let i = 0; i < elements.length; i++) {
+	      const element = elements[i];
+	      wrappingElement.append(element);
+	    }
+	  }
+	  let lastElement = null;
+
+	  // If our target is Root-like, let's see if we can re-adjust
+	  // so that the target is the first child instead.
+	  if (lexical.$isRootOrShadowRoot(target)) {
+	    if (targetIsPrevSibling) {
+	      if (wrappingElement !== null) {
+	        target.insertAfter(wrappingElement);
+	      } else {
+	        for (let i = elements.length - 1; i >= 0; i--) {
+	          const element = elements[i];
+	          target.insertAfter(element);
+	        }
+	      }
+	    } else {
+	      const firstChild = target.getFirstChild();
+	      if (lexical.$isElementNode(firstChild)) {
+	        target = firstChild;
+	      }
+	      if (firstChild === null) {
+	        if (wrappingElement) {
+	          target.append(wrappingElement);
+	        } else {
+	          for (let i = 0; i < elements.length; i++) {
+	            const element = elements[i];
+	            target.append(element);
+	            lastElement = element;
+	          }
+	        }
+	      } else {
+	        if (wrappingElement !== null) {
+	          firstChild.insertBefore(wrappingElement);
+	        } else {
+	          for (let i = 0; i < elements.length; i++) {
+	            const element = elements[i];
+	            firstChild.insertBefore(element);
+	            lastElement = element;
+	          }
+	        }
+	      }
+	    }
+	  } else {
+	    if (wrappingElement) {
+	      target.insertAfter(wrappingElement);
+	    } else {
+	      for (let i = elements.length - 1; i >= 0; i--) {
+	        const element = elements[i];
+	        target.insertAfter(element);
+	        lastElement = element;
+	      }
+	    }
+	  }
+	  const prevSelection = lexical.$getPreviousSelection();
+	  if (lexical.$isRangeSelection(prevSelection) && isPointAttached(prevSelection.anchor) && isPointAttached(prevSelection.focus)) {
+	    lexical.$setSelection(prevSelection.clone());
+	  } else if (lastElement !== null) {
+	    lastElement.selectEnd();
+	  } else {
+	    selection.dirty = true;
+	  }
+	}
+
+	/**
+	 * Determines if the default character selection should be overridden. Used with DecoratorNodes
+	 * @param selection - The selection whose default character selection may need to be overridden.
+	 * @param isBackward - Is the selection backwards (the focus comes before the anchor)?
+	 * @returns true if it should be overridden, false if not.
+	 */
+	function $shouldOverrideDefaultCharacterSelection(selection, isBackward) {
+	  const possibleNode = lexical.$getAdjacentNode(selection.focus, isBackward);
+	  return lexical.$isDecoratorNode(possibleNode) && !possibleNode.isIsolated() || lexical.$isElementNode(possibleNode) && !possibleNode.isInline() && !possibleNode.canBeEmpty();
+	}
+
+	/**
+	 * Moves the selection according to the arguments.
+	 * @param selection - The selected text or nodes.
+	 * @param isHoldingShift - Is the shift key being held down during the operation.
+	 * @param isBackward - Is the selection selected backwards (the focus comes before the anchor)?
+	 * @param granularity - The distance to adjust the current selection.
+	 */
+	function $moveCaretSelection(selection, isHoldingShift, isBackward, granularity) {
+	  selection.modify(isHoldingShift ? 'extend' : 'move', isBackward, granularity);
+	}
+
+	/**
+	 * Tests a parent element for right to left direction.
+	 * @param selection - The selection whose parent is to be tested.
+	 * @returns true if the selections' parent element has a direction of 'rtl' (right to left), false otherwise.
+	 */
+	function $isParentElementRTL(selection) {
+	  const anchorNode = selection.anchor.getNode();
+	  const parent = lexical.$isRootNode(anchorNode) ? anchorNode : anchorNode.getParentOrThrow();
+	  return parent.getDirection() === 'rtl';
+	}
+
+	/**
+	 * Moves selection by character according to arguments.
+	 * @param selection - The selection of the characters to move.
+	 * @param isHoldingShift - Is the shift key being held down during the operation.
+	 * @param isBackward - Is the selection backward (the focus comes before the anchor)?
+	 */
+	function $moveCharacter(selection, isHoldingShift, isBackward) {
+	  const isRTL = $isParentElementRTL(selection);
+	  $moveCaretSelection(selection, isHoldingShift, isBackward ? !isRTL : isRTL, 'character');
+	}
+
+	/**
+	 * Expands the current Selection to cover all of the content in the editor.
+	 * @param selection - The current selection.
+	 */
+	function $selectAll(selection) {
+	  const anchor = selection.anchor;
+	  const focus = selection.focus;
+	  const anchorNode = anchor.getNode();
+	  const topParent = anchorNode.getTopLevelElementOrThrow();
+	  const root = topParent.getParentOrThrow();
+	  let firstNode = root.getFirstDescendant();
+	  let lastNode = root.getLastDescendant();
+	  let firstType = 'element';
+	  let lastType = 'element';
+	  let lastOffset = 0;
+	  if (lexical.$isTextNode(firstNode)) {
+	    firstType = 'text';
+	  } else if (!lexical.$isElementNode(firstNode) && firstNode !== null) {
+	    firstNode = firstNode.getParentOrThrow();
+	  }
+	  if (lexical.$isTextNode(lastNode)) {
+	    lastType = 'text';
+	    lastOffset = lastNode.getTextContentSize();
+	  } else if (!lexical.$isElementNode(lastNode) && lastNode !== null) {
+	    lastNode = lastNode.getParentOrThrow();
+	  }
+	  if (firstNode && lastNode) {
+	    anchor.set(firstNode.getKey(), 0, firstType);
+	    focus.set(lastNode.getKey(), lastOffset, lastType);
+	  }
+	}
+
+	/**
+	 * Returns the current value of a CSS property for Nodes, if set. If not set, it returns the defaultValue.
+	 * @param node - The node whose style value to get.
+	 * @param styleProperty - The CSS style property.
+	 * @param defaultValue - The default value for the property.
+	 * @returns The value of the property for node.
+	 */
+	function $getNodeStyleValueForProperty(node, styleProperty, defaultValue) {
+	  const css = node.getStyle();
+	  const styleObject = getStyleObjectFromCSS(css);
+	  if (styleObject !== null) {
+	    return styleObject[styleProperty] || defaultValue;
+	  }
+	  return defaultValue;
+	}
+
+	/**
+	 * Returns the current value of a CSS property for TextNodes in the Selection, if set. If not set, it returns the defaultValue.
+	 * If all TextNodes do not have the same value, it returns an empty string.
+	 * @param selection - The selection of TextNodes whose value to find.
+	 * @param styleProperty - The CSS style property.
+	 * @param defaultValue - The default value for the property, defaults to an empty string.
+	 * @returns The value of the property for the selected TextNodes.
+	 */
+	function $getSelectionStyleValueForProperty(selection, styleProperty, defaultValue = '') {
+	  let styleValue = null;
+	  const nodes = selection.getNodes();
+	  const anchor = selection.anchor;
+	  const focus = selection.focus;
+	  const isBackward = selection.isBackward();
+	  const endOffset = isBackward ? focus.offset : anchor.offset;
+	  const endNode = isBackward ? focus.getNode() : anchor.getNode();
+	  if (selection.isCollapsed() && selection.style !== '') {
+	    const css = selection.style;
+	    const styleObject = getStyleObjectFromCSS(css);
+	    if (styleObject !== null && styleProperty in styleObject) {
+	      return styleObject[styleProperty];
+	    }
+	  }
+	  for (let i = 0; i < nodes.length; i++) {
+	    const node = nodes[i];
+
+	    // if no actual characters in the end node are selected, we don't
+	    // include it in the selection for purposes of determining style
+	    // value
+	    if (i !== 0 && endOffset === 0 && node.is(endNode)) {
+	      continue;
+	    }
+	    if (lexical.$isTextNode(node)) {
+	      const nodeStyleValue = $getNodeStyleValueForProperty(node, styleProperty, defaultValue);
+	      if (styleValue === null) {
+	        styleValue = nodeStyleValue;
+	      } else if (styleValue !== nodeStyleValue) {
+	        // multiple text nodes are in the selection and they don't all
+	        // have the same style.
+	        styleValue = '';
+	        break;
+	      }
+	    }
+	  }
+	  return styleValue === null ? defaultValue : styleValue;
+	}
+
+	/**
+	 * This function is for internal use of the library.
+	 * Please do not use it as it may change in the future.
+	 */
+	function INTERNAL_$isBlock(node) {
+	  if (lexical.$isDecoratorNode(node)) {
+	    return false;
+	  }
+	  if (!lexical.$isElementNode(node) || lexical.$isRootOrShadowRoot(node)) {
+	    return false;
+	  }
+	  const firstChild = node.getFirstChild();
+	  const isLeafElement = firstChild === null || lexical.$isLineBreakNode(firstChild) || lexical.$isTextNode(firstChild) || firstChild.isInline();
+	  return !node.isInline() && node.canBeEmpty() !== false && isLeafElement;
+	}
+	function $getAncestor(node, predicate) {
+	  let parent = node;
+	  while (parent !== null && parent.getParent() !== null && !predicate(parent)) {
+	    parent = parent.getParentOrThrow();
+	  }
+	  return predicate(parent) ? parent : null;
+	}
+
+	LexicalSelection_dev.$addNodeStyle = $addNodeStyle;
+	LexicalSelection_dev.$cloneWithProperties = $cloneWithProperties;
+	LexicalSelection_dev.$getSelectionStyleValueForProperty = $getSelectionStyleValueForProperty;
+	LexicalSelection_dev.$isAtNodeEnd = $isAtNodeEnd;
+	LexicalSelection_dev.$isParentElementRTL = $isParentElementRTL;
+	LexicalSelection_dev.$moveCaretSelection = $moveCaretSelection;
+	LexicalSelection_dev.$moveCharacter = $moveCharacter;
+	LexicalSelection_dev.$patchStyleText = $patchStyleText;
+	LexicalSelection_dev.$selectAll = $selectAll;
+	LexicalSelection_dev.$setBlocksType = $setBlocksType;
+	LexicalSelection_dev.$shouldOverrideDefaultCharacterSelection = $shouldOverrideDefaultCharacterSelection;
+	LexicalSelection_dev.$sliceSelectedTextNodeContent = $sliceSelectedTextNodeContent;
+	LexicalSelection_dev.$wrapNodes = $wrapNodes;
+	LexicalSelection_dev.createDOMRange = createDOMRange;
+	LexicalSelection_dev.createRectsFromDOMRange = createRectsFromDOMRange;
+	LexicalSelection_dev.getStyleObjectFromCSS = getStyleObjectFromCSS;
+	LexicalSelection_dev.trimTextContentFromAnchor = trimTextContentFromAnchor;
+	return LexicalSelection_dev;
+}
+
+var LexicalSelection_prod = {};
+
+/**
+ * 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.
+ */
+
+var hasRequiredLexicalSelection_prod;
+
+function requireLexicalSelection_prod () {
+	if (hasRequiredLexicalSelection_prod) return LexicalSelection_prod;
+	hasRequiredLexicalSelection_prod = 1;
+var k=require$$3;let v=new Map;function w(a){for(;null!=a;){if(a.nodeType===Node.TEXT_NODE)return a;a=a.firstChild;}return null}function x(a){let b=a.parentNode;if(null==b)throw Error("Should never happen");return [b,Array.from(b.childNodes).indexOf(a)]}function y(a){let b={};a=a.split(";");for(let c of a)if(""!==c){let [e,d]=c.split(/:([^]+)/);e&&d&&(b[e.trim()]=d.trim());}return b}function z(a){let b=v.get(a);void 0===b&&(b=y(a),v.set(a,b));return b}
+	function A(a){let b="";for(let c in a)c&&(b+=`${c}: ${a[c]};`);return b}function B(a,b){let c=z("getStyle"in a?a.getStyle():a.style);b=Object.entries(b).reduce((d,[g,h])=>{h instanceof Function?d[g]=h(c[g]):null===h?delete d[g]:d[g]=h;return d},{...c});let e=A(b);a.setStyle(e);v.set(e,b);}function C(a){for(;null!==a&&!k.$isRootOrShadowRoot(a);){let b=a.getLatest(),c=a.getParent();0===b.getChildrenSize()&&a.remove(true);a=c;}}
+	function D(a,b,c,e,d=null){if(0!==b.length){var g=b[0],h=new Map,f=[];g=k.$isElementNode(g)?g:g.getParentOrThrow();g.isInline()&&(g=g.getParentOrThrow());for(var l=false;null!==g;){var m=g.getPreviousSibling();if(null!==m){g=m;l=true;break}g=g.getParentOrThrow();if(k.$isRootOrShadowRoot(g))break}m=new Set;for(var p=0;p<c;p++){var q=b[p];k.$isElementNode(q)&&0===q.getChildrenSize()&&m.add(q.getKey());}var n=new Set;for(p=0;p<c;p++){q=b[p];var r=q.getParent();null!==r&&r.isInline()&&(r=r.getParent());if(null!==
+	r&&k.$isLeafNode(q)&&!n.has(q.getKey())){if(q=r.getKey(),void 0===h.get(q)){let t=e();t.setFormat(r.getFormatType());t.setIndent(r.getIndent());f.push(t);h.set(q,t);r.getChildren().forEach(u=>{t.append(u);n.add(u.getKey());k.$isElementNode(u)&&u.getChildrenKeys().forEach(H=>n.add(H));});C(r);}}else if(m.has(q.getKey())){if(!k.$isElementNode(q))throw Error("Expected node in emptyElements to be an ElementNode");r=e();r.setFormat(q.getFormatType());r.setIndent(q.getIndent());f.push(r);q.remove(true);}}if(null!==
+	d)for(b=0;b<f.length;b++)d.append(f[b]);b=null;if(k.$isRootOrShadowRoot(g))if(l)if(null!==d)g.insertAfter(d);else for(d=f.length-1;0<=d;d--)g.insertAfter(f[d]);else if(l=g.getFirstChild(),k.$isElementNode(l)&&(g=l),null===l)if(d)g.append(d);else for(d=0;d<f.length;d++)l=f[d],g.append(l),b=l;else if(null!==d)l.insertBefore(d);else for(g=0;g<f.length;g++)d=f[g],l.insertBefore(d),b=d;else if(d)g.insertAfter(d);else for(d=f.length-1;0<=d;d--)l=f[d],g.insertAfter(l),b=l;f=k.$getPreviousSelection();k.$isRangeSelection(f)&&
+	f.anchor.getNode().isAttached()&&f.focus.getNode().isAttached()?k.$setSelection(f.clone()):null!==b?b.selectEnd():a.dirty=true;}}function E(a,b,c,e){a.modify(b?"extend":"move",c,e);}function F(a){a=a.anchor.getNode();return "rtl"===(k.$isRootNode(a)?a:a.getParentOrThrow()).getDirection()}
+	function G(a){if(k.$isDecoratorNode(a)||!k.$isElementNode(a)||k.$isRootOrShadowRoot(a))return  false;var b=a.getFirstChild();b=null===b||k.$isLineBreakNode(b)||k.$isTextNode(b)||b.isInline();return !a.isInline()&&false!==a.canBeEmpty()&&b}LexicalSelection_prod.$addNodeStyle=function(a){a=a.getStyle();let b=y(a);v.set(a,b);};
+	LexicalSelection_prod.$cloneWithProperties=function(a){let b=a.constructor.clone(a);b.__parent=a.__parent;b.__next=a.__next;b.__prev=a.__prev;if(k.$isElementNode(a)&&k.$isElementNode(b))return b.__first=a.__first,b.__last=a.__last,b.__size=a.__size,b.__format=a.__format,b.__indent=a.__indent,b.__dir=a.__dir,b;k.$isTextNode(a)&&k.$isTextNode(b)&&(b.__format=a.__format,b.__style=a.__style,b.__mode=a.__mode,b.__detail=a.__detail);return b};
+	LexicalSelection_prod.$getSelectionStyleValueForProperty=function(a,b,c=""){let e=null,d=a.getNodes();var g=a.anchor,h=a.focus,f=a.isBackward();let l=f?h.offset:g.offset;g=f?h.getNode():g.getNode();if(a.isCollapsed()&&""!==a.style&&(a=z(a.style),null!==a&&b in a))return a[b];for(a=0;a<d.length;a++){var m=d[a];if((0===a||0!==l||!m.is(g))&&k.$isTextNode(m))if(h=b,f=c,m=m.getStyle(),m=z(m),h=null!==m?m[h]||f:f,null===e)e=h;else if(e!==h){e="";break}}return null===e?c:e};
+	LexicalSelection_prod.$isAtNodeEnd=function(a){if("text"===a.type)return a.offset===a.getNode().getTextContentSize();let b=a.getNode();if(!k.$isElementNode(b))throw Error("isAtNodeEnd: node must be a TextNode or ElementNode");return a.offset===b.getChildrenSize()};LexicalSelection_prod.$isParentElementRTL=F;LexicalSelection_prod.$moveCaretSelection=E;LexicalSelection_prod.$moveCharacter=function(a,b,c){let e=F(a);E(a,b,c?!e:e,"character");};
+	LexicalSelection_prod.$patchStyleText=function(a,b){var c=a.getNodes(),e=c.length,d=a.getStartEndPoints();if(null!==d){var [g,h]=d;--e;d=c[0];var f=c[e];if(a.isCollapsed()&&k.$isRangeSelection(a))B(a,b);else {var l=d.getTextContent().length,m=h.offset,p=g.offset,q=g.isBefore(h),n=q?p:m;a=q?m:p;var r=q?g.type:h.type,t=q?h.type:g.type;q=q?h.key:g.key;if(k.$isTextNode(d)&&n===l){let u=d.getNextSibling();k.$isTextNode(u)&&(n=p=0,d=u);}if(1===c.length)k.$isTextNode(d)&&d.canHaveFormat()&&(n="element"===r?0:p>m?m:p,a=
+	"element"===t?l:p>m?p:m,n!==a&&(0===n&&a===l?(B(d,b),d.select(n,a)):(c=d.splitText(n,a),c=0===n?c[0]:c[1],B(c,b),c.select(0,a-n))));else for(k.$isTextNode(d)&&n<d.getTextContentSize()&&d.canHaveFormat()&&(0!==n&&(d=d.splitText(n)[1],n=0,g.set(d.getKey(),n,"text")),B(d,b)),k.$isTextNode(f)&&f.canHaveFormat()&&(n=f.getTextContent().length,f.__key!==q&&0!==a&&(a=n),a!==n&&([f]=f.splitText(a)),0===a&&"element"!==t||B(f,b)),a=1;a<e;a++)n=c[a],t=n.getKey(),k.$isTextNode(n)&&n.canHaveFormat()&&t!==d.getKey()&&
+	t!==f.getKey()&&!n.isToken()&&B(n,b);}}};LexicalSelection_prod.$selectAll=function(a){let b=a.anchor;a=a.focus;var c=b.getNode().getTopLevelElementOrThrow().getParentOrThrow();let e=c.getFirstDescendant();c=c.getLastDescendant();let d="element",g="element",h=0;k.$isTextNode(e)?d="text":k.$isElementNode(e)||null===e||(e=e.getParentOrThrow());k.$isTextNode(c)?(g="text",h=c.getTextContentSize()):k.$isElementNode(c)||null===c||(c=c.getParentOrThrow());e&&c&&(b.set(e.getKey(),0,d),a.set(c.getKey(),h,g));};
+	LexicalSelection_prod.$setBlocksType=function(a,b){if(null!==a){var c=a.getStartEndPoints();c=c?c[0]:null;if(null!==c&&"root"===c.key)b=b(),a=k.$getRoot(),(c=a.getFirstChild())?c.replace(b,true):a.append(b);else {a=a.getNodes();if(null!==c){for(c=c.getNode();null!==c&&null!==c.getParent()&&!G(c);)c=c.getParentOrThrow();c=G(c)?c:null;}else c=false;c&&-1===a.indexOf(c)&&a.push(c);for(c=0;c<a.length;c++){let e=a[c];if(!G(e))continue;if(!k.$isElementNode(e))throw Error("Expected block node to be an ElementNode");let d=b();
+	d.setFormat(e.getFormatType());d.setIndent(e.getIndent());e.replace(d,true);}}}};LexicalSelection_prod.$shouldOverrideDefaultCharacterSelection=function(a,b){a=k.$getAdjacentNode(a.focus,b);return k.$isDecoratorNode(a)&&!a.isIsolated()||k.$isElementNode(a)&&!a.isInline()&&!a.canBeEmpty()};
+	LexicalSelection_prod.$sliceSelectedTextNodeContent=function(a,b){var c=a.getStartEndPoints();if(b.isSelected(a)&&!b.isSegmented()&&!b.isToken()&&null!==c){let [f,l]=c;c=a.isBackward();var e=f.getNode(),d=l.getNode(),g=b.is(e),h=b.is(d);if(g||h){let [m,p]=k.$getCharacterOffsets(a);a=e.is(d);g=b.is(c?d:e);d=b.is(c?e:d);e=0;h=void 0;a?(e=m>p?p:m,h=m>p?m:p):g?(e=c?p:m,h=void 0):d&&(c=c?m:p,e=0,h=c);b.__text=b.__text.slice(e,h);}}return b};
+	LexicalSelection_prod.$wrapNodes=function(a,b,c=null){var e=a.getStartEndPoints(),d=e?e[0]:null;e=a.getNodes();let g=e.length;if(null!==d&&(0===g||1===g&&"element"===d.type&&0===d.getNode().getChildrenSize())){a="text"===d.type?d.getNode().getParentOrThrow():d.getNode();e=a.getChildren();let f=b();f.setFormat(a.getFormatType());f.setIndent(a.getIndent());e.forEach(l=>f.append(l));c&&(f=c.append(f));a.replace(f);}else {d=null;var h=[];for(let f=0;f<g;f++){let l=e[f];k.$isRootOrShadowRoot(l)?(D(a,h,h.length,b,c),h=
+	[],d=l):null===d||null!==d&&k.$hasAncestor(l,d)?h.push(l):(D(a,h,h.length,b,c),h=[l]);}D(a,h,h.length,b,c);}};
+	LexicalSelection_prod.createDOMRange=function(a,b,c,e,d){let g=b.getKey(),h=e.getKey(),f=document.createRange(),l=a.getElementByKey(g);a=a.getElementByKey(h);k.$isTextNode(b)&&(l=w(l));k.$isTextNode(e)&&(a=w(a));if(void 0===b||void 0===e||null===l||null===a)return null;"BR"===l.nodeName&&([l,c]=x(l));"BR"===a.nodeName&&([a,d]=x(a));b=l.firstChild;l===a&&null!=b&&"BR"===b.nodeName&&0===c&&0===d&&(d=1);try{f.setStart(l,c),f.setEnd(a,d);}catch(m){return null}!f.collapsed||c===d&&g===h||(f.setStart(a,d),f.setEnd(l,
+	c));return f};LexicalSelection_prod.createRectsFromDOMRange=function(a,b){var c=a.getRootElement();if(null===c)return [];a=c.getBoundingClientRect();c=getComputedStyle(c);c=parseFloat(c.paddingLeft)+parseFloat(c.paddingRight);b=Array.from(b.getClientRects());let e=b.length;b.sort((g,h)=>{let f=g.top-h.top;return 3>=Math.abs(f)?g.left-h.left:f});let d;for(let g=0;g<e;g++){let h=b[g],f=h.width+c===a.width;d&&d.top<=h.top&&d.top+d.height>h.top&&d.left+d.width>h.left||f?(b.splice(g--,1),e--):d=h;}return b};
+	LexicalSelection_prod.getStyleObjectFromCSS=z;
+	LexicalSelection_prod.trimTextContentFromAnchor=function(a,b,c){let e=b.getNode();if(k.$isElementNode(e)){var d=e.getDescendantByIndex(b.offset);null!==d&&(e=d);}for(;0<c&&null!==e;){k.$isElementNode(e)&&(d=e.getLastDescendant(),null!==d&&(e=d));var g=e.getPreviousSibling(),h=0;if(null===g){d=e.getParentOrThrow();for(var f=d.getPreviousSibling();null===f;){d=d.getParent();if(null===d){g=null;break}f=d.getPreviousSibling();}null!==d&&(h=d.isInline()?0:2,g=f);}f=e.getTextContent();""===f&&k.$isElementNode(e)&&!e.isInline()&&
+	(f="\n\n");d=f.length;if(!k.$isTextNode(e)||c>=d)f=e.getParent(),e.remove(),null==f||0!==f.getChildrenSize()||k.$isRootNode(f)||f.remove(),c-=d+h,e=g;else {let l=e.getKey();h=a.getEditorState().read(()=>{const p=k.$getNodeByKey(l);return k.$isTextNode(p)&&p.isSimpleText()?p.getTextContent():null});g=d-c;let m=f.slice(0,g);null!==h&&h!==f?(c=k.$getPreviousSelection(),d=e,e.isSimpleText()?e.setTextContent(h):(d=k.$createTextNode(h),e.replace(d)),k.$isRangeSelection(c)&&c.isCollapsed()&&(c=c.anchor.offset,
+	d.select(c,c))):e.isSimpleText()?(h=b.key===l,f=b.offset,f<c&&(f=d),c=h?f-c:0,d=h?f:g,h&&0===c?([c]=e.splitText(c,d),c.remove()):([,c]=e.splitText(c,d),c.remove())):(c=k.$createTextNode(m),e.replace(c));c=0;}}};
+	return LexicalSelection_prod;
+}
+
+/**
+ * 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.
+ */
+
+var LexicalSelection_1;
+var hasRequiredLexicalSelection;
+
+function requireLexicalSelection () {
+	if (hasRequiredLexicalSelection) return LexicalSelection_1;
+	hasRequiredLexicalSelection = 1;
+	const LexicalSelection = process.env.NODE_ENV === 'development' ? requireLexicalSelection_dev() : requireLexicalSelection_prod();
+	LexicalSelection_1 = LexicalSelection;
+	return LexicalSelection_1;
+}
+
+var LexicalUtils_dev = {};
+
+/**
+ * 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.
+ */
+
+var hasRequiredLexicalUtils_dev;
+
+function requireLexicalUtils_dev () {
+	if (hasRequiredLexicalUtils_dev) return LexicalUtils_dev;
+	hasRequiredLexicalUtils_dev = 1;
+
+	var selection = requireLexicalSelection();
+	var lexical = require$$3;
+
+	/**
+	 * Copyright (c) Meta Platforms, Inc. and affiliates.
+	 *
+	 * This source code is licensed under the MIT license found in the
+	 * LICENSE file in the root directory of this source tree.
+	 *
+	 */
+
+	/**
+	 * Returns a function that will execute all functions passed when called. It is generally used
+	 * to register multiple lexical listeners and then tear them down with a single function call, such
+	 * as React's useEffect hook.
+	 * @example
+	 * ```ts
+	 * useEffect(() => {
+	 *   return mergeRegister(
+	 *     editor.registerCommand(...registerCommand1 logic),
+	 *     editor.registerCommand(...registerCommand2 logic),
+	 *     editor.registerCommand(...registerCommand3 logic)
+	 *   )
+	 * }, [editor])
+	 * ```
+	 * In this case, useEffect is returning the function returned by mergeRegister as a cleanup
+	 * function to be executed after either the useEffect runs again (due to one of its dependencies
+	 * updating) or the component it resides in unmounts.
+	 * Note the functions don't neccesarily need to be in an array as all arguements
+	 * are considered to be the func argument and spread from there.
+	 * @param func - An array of functions meant to be executed by the returned function.
+	 * @returns the function which executes all the passed register command functions.
+	 */
+	function mergeRegister(...func) {
+	  return () => {
+	    func.forEach(f => f());
+	  };
+	}
+
+	/**
+	 * 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 px(value) {
+	  return `${value}px`;
+	}
+
+	/**
+	 * 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 mutationObserverConfig = {
+	  attributes: true,
+	  characterData: true,
+	  childList: true,
+	  subtree: true
+	};
+	function positionNodeOnRange(editor, range, onReposition) {
+	  let rootDOMNode = null;
+	  let parentDOMNode = null;
+	  let observer = null;
+	  let lastNodes = [];
+	  const wrapperNode = document.createElement('div');
+	  function position() {
+	    if (!(rootDOMNode !== null)) {
+	      throw Error(`Unexpected null rootDOMNode`);
+	    }
+	    if (!(parentDOMNode !== null)) {
+	      throw Error(`Unexpected null parentDOMNode`);
+	    }
+	    const {
+	      left: rootLeft,
+	      top: rootTop
+	    } = rootDOMNode.getBoundingClientRect();
+	    const parentDOMNode_ = parentDOMNode;
+	    const rects = selection.createRectsFromDOMRange(editor, range);
+	    if (!wrapperNode.isConnected) {
+	      parentDOMNode_.append(wrapperNode);
+	    }
+	    let hasRepositioned = false;
+	    for (let i = 0; i < rects.length; i++) {
+	      const rect = rects[i];
+	      // Try to reuse the previously created Node when possible, no need to
+	      // remove/create on the most common case reposition case
+	      const rectNode = lastNodes[i] || document.createElement('div');
+	      const rectNodeStyle = rectNode.style;
+	      if (rectNodeStyle.position !== 'absolute') {
+	        rectNodeStyle.position = 'absolute';
+	        hasRepositioned = true;
+	      }
+	      const left = px(rect.left - rootLeft);
+	      if (rectNodeStyle.left !== left) {
+	        rectNodeStyle.left = left;
+	        hasRepositioned = true;
+	      }
+	      const top = px(rect.top - rootTop);
+	      if (rectNodeStyle.top !== top) {
+	        rectNode.style.top = top;
+	        hasRepositioned = true;
+	      }
+	      const width = px(rect.width);
+	      if (rectNodeStyle.width !== width) {
+	        rectNode.style.width = width;
+	        hasRepositioned = true;
+	      }
+	      const height = px(rect.height);
+	      if (rectNodeStyle.height !== height) {
+	        rectNode.style.height = height;
+	        hasRepositioned = true;
+	      }
+	      if (rectNode.parentNode !== wrapperNode) {
+	        wrapperNode.append(rectNode);
+	        hasRepositioned = true;
+	      }
+	      lastNodes[i] = rectNode;
+	    }
+	    while (lastNodes.length > rects.length) {
+	      lastNodes.pop();
+	    }
+	    if (hasRepositioned) {
+	      onReposition(lastNodes);
+	    }
+	  }
+	  function stop() {
+	    parentDOMNode = null;
+	    rootDOMNode = null;
+	    if (observer !== null) {
+	      observer.disconnect();
+	    }
+	    observer = null;
+	    wrapperNode.remove();
+	    for (const node of lastNodes) {
+	      node.remove();
+	    }
+	    lastNodes = [];
+	  }
+	  function restart() {
+	    const currentRootDOMNode = editor.getRootElement();
+	    if (currentRootDOMNode === null) {
+	      return stop();
+	    }
+	    const currentParentDOMNode = currentRootDOMNode.parentElement;
+	    if (!(currentParentDOMNode instanceof HTMLElement)) {
+	      return stop();
+	    }
+	    stop();
+	    rootDOMNode = currentRootDOMNode;
+	    parentDOMNode = currentParentDOMNode;
+	    observer = new MutationObserver(mutations => {
+	      const nextRootDOMNode = editor.getRootElement();
+	      const nextParentDOMNode = nextRootDOMNode && nextRootDOMNode.parentElement;
+	      if (nextRootDOMNode !== rootDOMNode || nextParentDOMNode !== parentDOMNode) {
+	        return restart();
+	      }
+	      for (const mutation of mutations) {
+	        if (!wrapperNode.contains(mutation.target)) {
+	          // TODO throttle
+	          return position();
+	        }
+	      }
+	    });
+	    observer.observe(currentParentDOMNode, mutationObserverConfig);
+	    position();
+	  }
+	  const removeRootListener = editor.registerRootListener(restart);
+	  return () => {
+	    removeRootListener();
+	    stop();
+	  };
+	}
+
+	/**
+	 * 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 markSelection(editor, onReposition) {
+	  let previousAnchorNode = null;
+	  let previousAnchorOffset = null;
+	  let previousFocusNode = null;
+	  let previousFocusOffset = null;
+	  let removeRangeListener = () => {};
+	  function compute(editorState) {
+	    editorState.read(() => {
+	      const selection = lexical.$getSelection();
+	      if (!lexical.$isRangeSelection(selection)) {
+	        // TODO
+	        previousAnchorNode = null;
+	        previousAnchorOffset = null;
+	        previousFocusNode = null;
+	        previousFocusOffset = null;
+	        removeRangeListener();
+	        removeRangeListener = () => {};
+	        return;
+	      }
+	      const {
+	        anchor,
+	        focus
+	      } = selection;
+	      const currentAnchorNode = anchor.getNode();
+	      const currentAnchorNodeKey = currentAnchorNode.getKey();
+	      const currentAnchorOffset = anchor.offset;
+	      const currentFocusNode = focus.getNode();
+	      const currentFocusNodeKey = currentFocusNode.getKey();
+	      const currentFocusOffset = focus.offset;
+	      const currentAnchorNodeDOM = editor.getElementByKey(currentAnchorNodeKey);
+	      const currentFocusNodeDOM = editor.getElementByKey(currentFocusNodeKey);
+	      const differentAnchorDOM = previousAnchorNode === null || currentAnchorNodeDOM === null || currentAnchorOffset !== previousAnchorOffset || currentAnchorNodeKey !== previousAnchorNode.getKey() || currentAnchorNode !== previousAnchorNode && (!(previousAnchorNode instanceof lexical.TextNode) || currentAnchorNode.updateDOM(previousAnchorNode, currentAnchorNodeDOM, editor._config));
+	      const differentFocusDOM = previousFocusNode === null || currentFocusNodeDOM === null || currentFocusOffset !== previousFocusOffset || currentFocusNodeKey !== previousFocusNode.getKey() || currentFocusNode !== previousFocusNode && (!(previousFocusNode instanceof lexical.TextNode) || currentFocusNode.updateDOM(previousFocusNode, currentFocusNodeDOM, editor._config));
+	      if (differentAnchorDOM || differentFocusDOM) {
+	        const anchorHTMLElement = editor.getElementByKey(anchor.getNode().getKey());
+	        const focusHTMLElement = editor.getElementByKey(focus.getNode().getKey());
+	        // TODO handle selection beyond the common TextNode
+	        if (anchorHTMLElement !== null && focusHTMLElement !== null && anchorHTMLElement.tagName === 'SPAN' && focusHTMLElement.tagName === 'SPAN') {
+	          const range = document.createRange();
+	          let firstHTMLElement;
+	          let firstOffset;
+	          let lastHTMLElement;
+	          let lastOffset;
+	          if (focus.isBefore(anchor)) {
+	            firstHTMLElement = focusHTMLElement;
+	            firstOffset = focus.offset;
+	            lastHTMLElement = anchorHTMLElement;
+	            lastOffset = anchor.offset;
+	          } else {
+	            firstHTMLElement = anchorHTMLElement;
+	            firstOffset = anchor.offset;
+	            lastHTMLElement = focusHTMLElement;
+	            lastOffset = focus.offset;
+	          }
+	          const firstTextNode = firstHTMLElement.firstChild;
+	          if (!(firstTextNode !== null)) {
+	            throw Error(`Expected text node to be first child of span`);
+	          }
+	          const lastTextNode = lastHTMLElement.firstChild;
+	          if (!(lastTextNode !== null)) {
+	            throw Error(`Expected text node to be first child of span`);
+	          }
+	          range.setStart(firstTextNode, firstOffset);
+	          range.setEnd(lastTextNode, lastOffset);
+	          removeRangeListener();
+	          removeRangeListener = positionNodeOnRange(editor, range, domNodes => {
+	            for (const domNode of domNodes) {
+	              const domNodeStyle = domNode.style;
+	              if (domNodeStyle.background !== 'Highlight') {
+	                domNodeStyle.background = 'Highlight';
+	              }
+	              if (domNodeStyle.color !== 'HighlightText') {
+	                domNodeStyle.color = 'HighlightText';
+	              }
+	              if (domNodeStyle.zIndex !== '-1') {
+	                domNodeStyle.zIndex = '-1';
+	              }
+	              if (domNodeStyle.pointerEvents !== 'none') {
+	                domNodeStyle.pointerEvents = 'none';
+	              }
+	              if (domNodeStyle.marginTop !== px(-1.5)) {
+	                domNodeStyle.marginTop = px(-1.5);
+	              }
+	              if (domNodeStyle.paddingTop !== px(4)) {
+	                domNodeStyle.paddingTop = px(4);
+	              }
+	              if (domNodeStyle.paddingBottom !== px(0)) {
+	                domNodeStyle.paddingBottom = px(0);
+	              }
+	            }
+	            if (onReposition !== undefined) {
+	              onReposition(domNodes);
+	            }
+	          });
+	        }
+	      }
+	      previousAnchorNode = currentAnchorNode;
+	      previousAnchorOffset = currentAnchorOffset;
+	      previousFocusNode = currentFocusNode;
+	      previousFocusOffset = currentFocusOffset;
+	    });
+	  }
+	  compute(editor.getEditorState());
+	  return mergeRegister(editor.registerUpdateListener(({
+	    editorState
+	  }) => compute(editorState)), removeRangeListener, () => {
+	    removeRangeListener();
+	  });
+	}
+
+	/** @module @lexical/utils */
+	/**
+	 * Takes an HTML element and adds the classNames passed within an array,
+	 * ignoring any non-string types. A space can be used to add multiple classes
+	 * eg. addClassNamesToElement(element, ['element-inner active', true, null])
+	 * will add both 'element-inner' and 'active' as classes to that element.
+	 * @param element - The element in which the classes are added
+	 * @param classNames - An array defining the class names to add to the element
+	 */
+	function addClassNamesToElement(element, ...classNames) {
+	  classNames.forEach(className => {
+	    if (typeof className === 'string') {
+	      const classesToAdd = className.split(' ').filter(n => n !== '');
+	      element.classList.add(...classesToAdd);
+	    }
+	  });
+	}
+
+	/**
+	 * Takes an HTML element and removes the classNames passed within an array,
+	 * ignoring any non-string types. A space can be used to remove multiple classes
+	 * eg. removeClassNamesFromElement(element, ['active small', true, null])
+	 * will remove both the 'active' and 'small' classes from that element.
+	 * @param element - The element in which the classes are removed
+	 * @param classNames - An array defining the class names to remove from the element
+	 */
+	function removeClassNamesFromElement(element, ...classNames) {
+	  classNames.forEach(className => {
+	    if (typeof className === 'string') {
+	      element.classList.remove(...className.split(' '));
+	    }
+	  });
+	}
+
+	/**
+	 * Returns true if the file type matches the types passed within the acceptableMimeTypes array, false otherwise.
+	 * The types passed must be strings and are CASE-SENSITIVE.
+	 * eg. if file is of type 'text' and acceptableMimeTypes = ['TEXT', 'IMAGE'] the function will return false.
+	 * @param file - The file you want to type check.
+	 * @param acceptableMimeTypes - An array of strings of types which the file is checked against.
+	 * @returns true if the file is an acceptable mime type, false otherwise.
+	 */
+	function isMimeType(file, acceptableMimeTypes) {
+	  for (const acceptableType of acceptableMimeTypes) {
+	    if (file.type.startsWith(acceptableType)) {
+	      return true;
+	    }
+	  }
+	  return false;
+	}
+
+	/**
+	 * Lexical File Reader with:
+	 *  1. MIME type support
+	 *  2. batched results (HistoryPlugin compatibility)
+	 *  3. Order aware (respects the order when multiple Files are passed)
+	 *
+	 * const filesResult = await mediaFileReader(files, ['image/']);
+	 * filesResult.forEach(file => editor.dispatchCommand('INSERT_IMAGE', {
+	 *   src: file.result,
+	 * }));
+	 */
+	function mediaFileReader(files, acceptableMimeTypes) {
+	  const filesIterator = files[Symbol.iterator]();
+	  return new Promise((resolve, reject) => {
+	    const processed = [];
+	    const handleNextFile = () => {
+	      const {
+	        done,
+	        value: file
+	      } = filesIterator.next();
+	      if (done) {
+	        return resolve(processed);
+	      }
+	      const fileReader = new FileReader();
+	      fileReader.addEventListener('error', reject);
+	      fileReader.addEventListener('load', () => {
+	        const result = fileReader.result;
+	        if (typeof result === 'string') {
+	          processed.push({
+	            file,
+	            result
+	          });
+	        }
+	        handleNextFile();
+	      });
+	      if (isMimeType(file, acceptableMimeTypes)) {
+	        fileReader.readAsDataURL(file);
+	      } else {
+	        handleNextFile();
+	      }
+	    };
+	    handleNextFile();
+	  });
+	}
+
+	/**
+	 * "Depth-First Search" starts at the root/top node of a tree and goes as far as it can down a branch end
+	 * before backtracking and finding a new path. Consider solving a maze by hugging either wall, moving down a
+	 * branch until you hit a dead-end (leaf) and backtracking to find the nearest branching path and repeat.
+	 * It will then return all the nodes found in the search in an array of objects.
+	 * @param startingNode - The node to start the search, if ommitted, it will start at the root node.
+	 * @param endingNode - The node to end the search, if ommitted, it will find all descendants of the startingNode.
+	 * @returns An array of objects of all the nodes found by the search, including their depth into the tree.
+	 * {depth: number, node: LexicalNode} It will always return at least 1 node (the ending node) so long as it exists
+	 */
+	function $dfs(startingNode, endingNode) {
+	  const nodes = [];
+	  const start = (startingNode || lexical.$getRoot()).getLatest();
+	  const end = endingNode || (lexical.$isElementNode(start) ? start.getLastDescendant() : start);
+	  let node = start;
+	  let depth = $getDepth(node);
+	  while (node !== null && !node.is(end)) {
+	    nodes.push({
+	      depth,
+	      node
+	    });
+	    if (lexical.$isElementNode(node) && node.getChildrenSize() > 0) {
+	      node = node.getFirstChild();
+	      depth++;
+	    } else {
+	      // Find immediate sibling or nearest parent sibling
+	      let sibling = null;
+	      while (sibling === null && node !== null) {
+	        sibling = node.getNextSibling();
+	        if (sibling === null) {
+	          node = node.getParent();
+	          depth--;
+	        } else {
+	          node = sibling;
+	        }
+	      }
+	    }
+	  }
+	  if (node !== null && node.is(end)) {
+	    nodes.push({
+	      depth,
+	      node
+	    });
+	  }
+	  return nodes;
+	}
+	function $getDepth(node) {
+	  let innerNode = node;
+	  let depth = 0;
+	  while ((innerNode = innerNode.getParent()) !== null) {
+	    depth++;
+	  }
+	  return depth;
+	}
+
+	/**
+	 * Takes a node and traverses up its ancestors (toward the root node)
+	 * in order to find a specific type of node.
+	 * @param node - the node to begin searching.
+	 * @param klass - an instance of the type of node to look for.
+	 * @returns the node of type klass that was passed, or null if none exist.
+	 */
+	function $getNearestNodeOfType(node, klass) {
+	  let parent = node;
+	  while (parent != null) {
+	    if (parent instanceof klass) {
+	      return parent;
+	    }
+	    parent = parent.getParent();
+	  }
+	  return null;
+	}
+
+	/**
+	 * Returns the element node of the nearest ancestor, otherwise throws an error.
+	 * @param startNode - The starting node of the search
+	 * @returns The ancestor node found
+	 */
+	function $getNearestBlockElementAncestorOrThrow(startNode) {
+	  const blockNode = $findMatchingParent(startNode, node => lexical.$isElementNode(node) && !node.isInline());
+	  if (!lexical.$isElementNode(blockNode)) {
+	    {
+	      throw Error(`Expected node ${startNode.__key} to have closest block element node.`);
+	    }
+	  }
+	  return blockNode;
+	}
+	/**
+	 * Starts with a node and moves up the tree (toward the root node) to find a matching node based on
+	 * the search parameters of the findFn. (Consider JavaScripts' .find() function where a testing function must be
+	 * passed as an argument. eg. if( (node) => node.__type === 'div') ) return true; otherwise return false
+	 * @param startingNode - The node where the search starts.
+	 * @param findFn - A testing function that returns true if the current node satisfies the testing parameters.
+	 * @returns A parent node that matches the findFn parameters, or null if one wasn't found.
+	 */
+	const $findMatchingParent = (startingNode, findFn) => {
+	  let curr = startingNode;
+	  while (curr !== lexical.$getRoot() && curr != null) {
+	    if (findFn(curr)) {
+	      return curr;
+	    }
+	    curr = curr.getParent();
+	  }
+	  return null;
+	};
+
+	/**
+	 * Attempts to resolve nested element nodes of the same type into a single node of that type.
+	 * It is generally used for marks/commenting
+	 * @param editor - The lexical editor
+	 * @param targetNode - The target for the nested element to be extracted from.
+	 * @param cloneNode - See {@link $createMarkNode}
+	 * @param handleOverlap - Handles any overlap between the node to extract and the targetNode
+	 * @returns The lexical editor
+	 */
+	function registerNestedElementResolver(editor, targetNode, cloneNode, handleOverlap) {
+	  const $isTargetNode = node => {
+	    return node instanceof targetNode;
+	  };
+	  const $findMatch = node => {
+	    // First validate we don't have any children that are of the target,
+	    // as we need to handle them first.
+	    const children = node.getChildren();
+	    for (let i = 0; i < children.length; i++) {
+	      const child = children[i];
+	      if ($isTargetNode(child)) {
+	        return null;
+	      }
+	    }
+	    let parentNode = node;
+	    let childNode = node;
+	    while (parentNode !== null) {
+	      childNode = parentNode;
+	      parentNode = parentNode.getParent();
+	      if ($isTargetNode(parentNode)) {
+	        return {
+	          child: childNode,
+	          parent: parentNode
+	        };
+	      }
+	    }
+	    return null;
+	  };
+	  const elementNodeTransform = node => {
+	    const match = $findMatch(node);
+	    if (match !== null) {
+	      const {
+	        child,
+	        parent
+	      } = match;
+
+	      // Simple path, we can move child out and siblings into a new parent.
+
+	      if (child.is(node)) {
+	        handleOverlap(parent, node);
+	        const nextSiblings = child.getNextSiblings();
+	        const nextSiblingsLength = nextSiblings.length;
+	        parent.insertAfter(child);
+	        if (nextSiblingsLength !== 0) {
+	          const newParent = cloneNode(parent);
+	          child.insertAfter(newParent);
+	          for (let i = 0; i < nextSiblingsLength; i++) {
+	            newParent.append(nextSiblings[i]);
+	          }
+	        }
+	        if (!parent.canBeEmpty() && parent.getChildrenSize() === 0) {
+	          parent.remove();
+	        }
+	      }
+	    }
+	  };
+	  return editor.registerNodeTransform(targetNode, elementNodeTransform);
+	}
+
+	/**
+	 * Clones the editor and marks it as dirty to be reconciled. If there was a selection,
+	 * it would be set back to its previous state, or null otherwise.
+	 * @param editor - The lexical editor
+	 * @param editorState - The editor's state
+	 */
+	function $restoreEditorState(editor, editorState) {
+	  const FULL_RECONCILE = 2;
+	  const nodeMap = new Map();
+	  const activeEditorState = editor._pendingEditorState;
+	  for (const [key, node] of editorState._nodeMap) {
+	    const clone = selection.$cloneWithProperties(node);
+	    if (lexical.$isTextNode(clone)) {
+	      if (!lexical.$isTextNode(node)) {
+	        throw Error(`Expected node be a TextNode`);
+	      }
+	      clone.__text = node.__text;
+	    }
+	    nodeMap.set(key, clone);
+	  }
+	  if (activeEditorState) {
+	    activeEditorState._nodeMap = nodeMap;
+	  }
+	  editor._dirtyType = FULL_RECONCILE;
+	  const selection$1 = editorState._selection;
+	  lexical.$setSelection(selection$1 === null ? null : selection$1.clone());
+	}
+
+	/**
+	 * If the selected insertion area is the root/shadow root node (see {@link lexical!$isRootOrShadowRoot}),
+	 * the node will be appended there, otherwise, it will be inserted before the insertion area.
+	 * If there is no selection where the node is to be inserted, it will be appended after any current nodes
+	 * within the tree, as a child of the root node. A paragraph node will then be added after the inserted node and selected.
+	 * @param node - The node to be inserted
+	 * @returns The node after its insertion
+	 */
+	function $insertNodeToNearestRoot(node) {
+	  const selection = lexical.$getSelection() || lexical.$getPreviousSelection();
+	  if (lexical.$isRangeSelection(selection)) {
+	    const {
+	      focus
+	    } = selection;
+	    const focusNode = focus.getNode();
+	    const focusOffset = focus.offset;
+	    if (lexical.$isRootOrShadowRoot(focusNode)) {
+	      const focusChild = focusNode.getChildAtIndex(focusOffset);
+	      if (focusChild == null) {
+	        focusNode.append(node);
+	      } else {
+	        focusChild.insertBefore(node);
+	      }
+	      node.selectNext();
+	    } else {
+	      let splitNode;
+	      let splitOffset;
+	      if (lexical.$isTextNode(focusNode)) {
+	        splitNode = focusNode.getParentOrThrow();
+	        splitOffset = focusNode.getIndexWithinParent();
+	        if (focusOffset > 0) {
+	          splitOffset += 1;
+	          focusNode.splitText(focusOffset);
+	        }
+	      } else {
+	        splitNode = focusNode;
+	        splitOffset = focusOffset;
+	      }
+	      const [, rightTree] = lexical.$splitNode(splitNode, splitOffset);
+	      rightTree.insertBefore(node);
+	      rightTree.selectStart();
+	    }
+	  } else {
+	    if (selection != null) {
+	      const nodes = selection.getNodes();
+	      nodes[nodes.length - 1].getTopLevelElementOrThrow().insertAfter(node);
+	    } else {
+	      const root = lexical.$getRoot();
+	      root.append(node);
+	    }
+	    const paragraphNode = lexical.$createParagraphNode();
+	    node.insertAfter(paragraphNode);
+	    paragraphNode.select();
+	  }
+	  return node.getLatest();
+	}
+
+	/**
+	 * Wraps the node into another node created from a createElementNode function, eg. $createParagraphNode
+	 * @param node - Node to be wrapped.
+	 * @param createElementNode - Creates a new lexical element to wrap the to-be-wrapped node and returns it.
+	 * @returns A new lexical element with the previous node appended within (as a child, including its children).
+	 */
+	function $wrapNodeInElement(node, createElementNode) {
+	  const elementNode = createElementNode();
+	  node.replace(elementNode);
+	  elementNode.append(node);
+	  return elementNode;
+	}
+
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+	/**
+	 * @param object = The instance of the type
+	 * @param objectClass = The class of the type
+	 * @returns Whether the object is has the same Klass of the objectClass, ignoring the difference across window (e.g. different iframs)
+	 */
+	function objectKlassEquals(object, objectClass) {
+	  return object !== null ? Object.getPrototypeOf(object).constructor.name === objectClass.name : false;
+	}
+
+	/**
+	 * Filter the nodes
+	 * @param nodes Array of nodes that needs to be filtered
+	 * @param filterFn A filter function that returns node if the current node satisfies the condition otherwise null
+	 * @returns Array of filtered nodes
+	 */
+
+	function $filter(nodes, filterFn) {
+	  const result = [];
+	  for (let i = 0; i < nodes.length; i++) {
+	    const node = filterFn(nodes[i]);
+	    if (node !== null) {
+	      result.push(node);
+	    }
+	  }
+	  return result;
+	}
+	/**
+	 * Appends the node before the first child of the parent node
+	 * @param parent A parent node
+	 * @param node Node that needs to be appended
+	 */
+	function $insertFirst(parent, node) {
+	  const firstChild = parent.getFirstChild();
+	  if (firstChild !== null) {
+	    firstChild.insertBefore(node);
+	  } else {
+	    parent.append(node);
+	  }
+	}
+
+	LexicalUtils_dev.$splitNode = lexical.$splitNode;
+	LexicalUtils_dev.isHTMLAnchorElement = lexical.isHTMLAnchorElement;
+	LexicalUtils_dev.isHTMLElement = lexical.isHTMLElement;
+	LexicalUtils_dev.$dfs = $dfs;
+	LexicalUtils_dev.$filter = $filter;
+	LexicalUtils_dev.$findMatchingParent = $findMatchingParent;
+	LexicalUtils_dev.$getNearestBlockElementAncestorOrThrow = $getNearestBlockElementAncestorOrThrow;
+	LexicalUtils_dev.$getNearestNodeOfType = $getNearestNodeOfType;
+	LexicalUtils_dev.$insertFirst = $insertFirst;
+	LexicalUtils_dev.$insertNodeToNearestRoot = $insertNodeToNearestRoot;
+	LexicalUtils_dev.$restoreEditorState = $restoreEditorState;
+	LexicalUtils_dev.$wrapNodeInElement = $wrapNodeInElement;
+	LexicalUtils_dev.addClassNamesToElement = addClassNamesToElement;
+	LexicalUtils_dev.isMimeType = isMimeType;
+	LexicalUtils_dev.markSelection = markSelection;
+	LexicalUtils_dev.mediaFileReader = mediaFileReader;
+	LexicalUtils_dev.mergeRegister = mergeRegister;
+	LexicalUtils_dev.objectKlassEquals = objectKlassEquals;
+	LexicalUtils_dev.positionNodeOnRange = positionNodeOnRange;
+	LexicalUtils_dev.registerNestedElementResolver = registerNestedElementResolver;
+	LexicalUtils_dev.removeClassNamesFromElement = removeClassNamesFromElement;
+	return LexicalUtils_dev;
+}
+
+var LexicalUtils_prod = {};
+
+/**
+ * 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.
+ */
+
+var hasRequiredLexicalUtils_prod;
+
+function requireLexicalUtils_prod () {
+	if (hasRequiredLexicalUtils_prod) return LexicalUtils_prod;
+	hasRequiredLexicalUtils_prod = 1;
+var h=requireLexicalSelection(),B=require$$3;function C(a){let b=new URLSearchParams;b.append("code",a);for(let c=1;c<arguments.length;c++)b.append("v",arguments[c]);throw Error(`Minified Lexical error #${a}; visit https://lexical.dev/docs/error?${b} for the full message or `+"use the non-minified dev environment for full errors and additional helpful warnings.");}function D(...a){return ()=>{a.forEach(b=>b());}}let E={attributes:true,characterData:true,childList:true,subtree:true};
+	function F(a,b,c){function e(){if(null===g)throw Error("Unexpected null rootDOMNode");if(null===n)throw Error("Unexpected null parentDOMNode");let {left:p,top:z}=g.getBoundingClientRect();var q=n;let r=h.createRectsFromDOMRange(a,b);t.isConnected||q.append(t);q=false;for(let x=0;x<r.length;x++){var w=r[x];let u=k[x]||document.createElement("div"),y=u.style;"absolute"!==y.position&&(y.position="absolute",q=true);var l=`${w.left-p}px`;y.left!==l&&(y.left=l,q=true);l=`${w.top-z}px`;y.top!==l&&(u.style.top=
+	l,q=true);l=`${w.width}px`;y.width!==l&&(u.style.width=l,q=true);w=`${w.height}px`;y.height!==w&&(u.style.height=w,q=true);u.parentNode!==t&&(t.append(u),q=true);k[x]=u;}for(;k.length>r.length;)k.pop();q&&c(k);}function d(){g=n=null;null!==m&&m.disconnect();m=null;t.remove();for(let p of k)p.remove();k=[];}function f(){let p=a.getRootElement();if(null===p)return d();let z=p.parentElement;if(!(z instanceof HTMLElement))return d();d();g=p;n=z;m=new MutationObserver(q=>{let r=a.getRootElement(),w=r&&r.parentElement;
+	if(r!==g||w!==n)return f();for(let l of q)if(!t.contains(l.target))return e()});m.observe(z,E);e();}let g=null,n=null,m=null,k=[],t=document.createElement("div"),A=a.registerRootListener(f);return ()=>{A();d();}}function G(a,b){for(let c of b)if(a.type.startsWith(c))return  true;return  false}let H=(a,b)=>{for(;a!==B.$getRoot()&&null!=a;){if(b(a))return a;a=a.getParent();}return null};LexicalUtils_prod.$splitNode=B.$splitNode;LexicalUtils_prod.isHTMLAnchorElement=B.isHTMLAnchorElement;LexicalUtils_prod.isHTMLElement=B.isHTMLElement;
+	LexicalUtils_prod.$dfs=function(a,b){let c=[];a=(a||B.$getRoot()).getLatest();b=b||(B.$isElementNode(a)?a.getLastDescendant():a);for(var e=a,d=0;null!==(e=e.getParent());)d++;for(e=d;null!==a&&!a.is(b);)if(c.push({depth:e,node:a}),B.$isElementNode(a)&&0<a.getChildrenSize())a=a.getFirstChild(),e++;else for(d=null;null===d&&null!==a;)d=a.getNextSibling(),null===d?(a=a.getParent(),e--):a=d;null!==a&&a.is(b)&&c.push({depth:e,node:a});return c};
+	LexicalUtils_prod.$filter=function(a,b){let c=[];for(let e=0;e<a.length;e++){let d=b(a[e]);null!==d&&c.push(d);}return c};LexicalUtils_prod.$findMatchingParent=H;LexicalUtils_prod.$getNearestBlockElementAncestorOrThrow=function(a){let b=H(a,c=>B.$isElementNode(c)&&!c.isInline());B.$isElementNode(b)||C(4,a.__key);return b};LexicalUtils_prod.$getNearestNodeOfType=function(a,b){for(;null!=a;){if(a instanceof b)return a;a=a.getParent();}return null};LexicalUtils_prod.$insertFirst=function(a,b){let c=a.getFirstChild();null!==c?c.insertBefore(b):a.append(b);};
+	LexicalUtils_prod.$insertNodeToNearestRoot=function(a){var b=B.$getSelection()||B.$getPreviousSelection();if(B.$isRangeSelection(b)){var {focus:c}=b;b=c.getNode();c=c.offset;if(B.$isRootOrShadowRoot(b))c=b.getChildAtIndex(c),null==c?b.append(a):c.insertBefore(a),a.selectNext();else {let e,d;B.$isTextNode(b)?(e=b.getParentOrThrow(),d=b.getIndexWithinParent(),0<c&&(d+=1,b.splitText(c))):(e=b,d=c);[,b]=B.$splitNode(e,d);b.insertBefore(a);b.selectStart();}}else null!=b?(b=b.getNodes(),b[b.length-1].getTopLevelElementOrThrow().insertAfter(a)):
+	B.$getRoot().append(a),b=B.$createParagraphNode(),a.insertAfter(b),b.select();return a.getLatest()};LexicalUtils_prod.$restoreEditorState=function(a,b){let c=new Map,e=a._pendingEditorState;for(let [d,f]of b._nodeMap){let g=h.$cloneWithProperties(f);if(B.$isTextNode(g)){if(!B.$isTextNode(f))throw Error("Expected node be a TextNode");g.__text=f.__text;}c.set(d,g);}e&&(e._nodeMap=c);a._dirtyType=2;a=b._selection;B.$setSelection(null===a?null:a.clone());};
+	LexicalUtils_prod.$wrapNodeInElement=function(a,b){b=b();a.replace(b);b.append(a);return b};LexicalUtils_prod.addClassNamesToElement=function(a,...b){b.forEach(c=>{"string"===typeof c&&(c=c.split(" ").filter(e=>""!==e),a.classList.add(...c));});};LexicalUtils_prod.isMimeType=G;
+	LexicalUtils_prod.markSelection=function(a,b){function c(m){m.read(()=>{var k=B.$getSelection();if(B.$isRangeSelection(k)){var {anchor:t,focus:A}=k;k=t.getNode();var p=k.getKey(),z=t.offset,q=A.getNode(),r=q.getKey(),w=A.offset,l=a.getElementByKey(p),x=a.getElementByKey(r);p=null===e||null===l||z!==d||p!==e.getKey()||k!==e&&(!(e instanceof B.TextNode)||k.updateDOM(e,l,a._config));r=null===f||null===x||w!==g||r!==f.getKey()||q!==f&&(!(f instanceof B.TextNode)||q.updateDOM(f,x,a._config));if(p||r){l=a.getElementByKey(t.getNode().getKey());
+	var u=a.getElementByKey(A.getNode().getKey());if(null!==l&&null!==u&&"SPAN"===l.tagName&&"SPAN"===u.tagName){r=document.createRange();A.isBefore(t)?(p=u,x=A.offset,u=l,l=t.offset):(p=l,x=t.offset,l=A.offset);p=p.firstChild;if(null===p)throw Error("Expected text node to be first child of span");u=u.firstChild;if(null===u)throw Error("Expected text node to be first child of span");r.setStart(p,x);r.setEnd(u,l);n();n=F(a,r,y=>{for(let I of y){let v=I.style;"Highlight"!==v.background&&(v.background="Highlight");
+	"HighlightText"!==v.color&&(v.color="HighlightText");"-1"!==v.zIndex&&(v.zIndex="-1");"none"!==v.pointerEvents&&(v.pointerEvents="none");"-1.5px"!==v.marginTop&&(v.marginTop="-1.5px");"4px"!==v.paddingTop&&(v.paddingTop="4px");"0px"!==v.paddingBottom&&(v.paddingBottom="0px");} void 0!==b&&b(y);});}}e=k;d=z;f=q;g=w;}else g=f=d=e=null,n(),n=()=>{};});}let e=null,d=null,f=null,g=null,n=()=>{};c(a.getEditorState());return D(a.registerUpdateListener(({editorState:m})=>c(m)),n,()=>{n();})};
+	LexicalUtils_prod.mediaFileReader=function(a,b){let c=a[Symbol.iterator]();return new Promise((e,d)=>{let f=[],g=()=>{const {done:n,value:m}=c.next();if(n)return e(f);const k=new FileReader;k.addEventListener("error",d);k.addEventListener("load",()=>{const t=k.result;"string"===typeof t&&f.push({file:m,result:t});g();});G(m,b)?k.readAsDataURL(m):g();};g();})};LexicalUtils_prod.mergeRegister=D;LexicalUtils_prod.objectKlassEquals=function(a,b){return null!==a?Object.getPrototypeOf(a).constructor.name===b.name:false};
+	LexicalUtils_prod.positionNodeOnRange=F;
+	LexicalUtils_prod.registerNestedElementResolver=function(a,b,c,e){return a.registerNodeTransform(b,d=>{a:{var f=d.getChildren();for(var g=0;g<f.length;g++)if(f[g]instanceof b){f=null;break a}for(f=d;null!==f;)if(g=f,f=f.getParent(),f instanceof b){f={child:g,parent:f};break a}f=null;}if(null!==f){const {child:n,parent:m}=f;if(n.is(d)){e(m,d);d=n.getNextSiblings();f=d.length;m.insertAfter(n);if(0!==f){g=c(m);n.insertAfter(g);for(let k=0;k<f;k++)g.append(d[k]);}m.canBeEmpty()||0!==m.getChildrenSize()||m.remove();}}})};
+	LexicalUtils_prod.removeClassNamesFromElement=function(a,...b){b.forEach(c=>{"string"===typeof c&&a.classList.remove(...c.split(" "));});};
+	return LexicalUtils_prod;
+}
+
+/**
+ * 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.
+ */
+
+var LexicalUtils_1;
+var hasRequiredLexicalUtils;
+
+function requireLexicalUtils () {
+	if (hasRequiredLexicalUtils) return LexicalUtils_1;
+	hasRequiredLexicalUtils = 1;
+	const LexicalUtils = process.env.NODE_ENV === 'development' ? requireLexicalUtils_dev() : requireLexicalUtils_prod();
+	LexicalUtils_1 = LexicalUtils;
+	return LexicalUtils_1;
+}
+
+/**
+ * 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.
+ */
+
+var hasRequiredLexicalHtml_dev;
+
+function requireLexicalHtml_dev () {
+	if (hasRequiredLexicalHtml_dev) return LexicalHtml_dev;
+	hasRequiredLexicalHtml_dev = 1;
+
+	var selection = requireLexicalSelection();
+	var utils = requireLexicalUtils();
+	var lexical = require$$3;
+
+	/** @module @lexical/html */
+
+	/**
+	 * How you parse your html string to get a document is left up to you. In the browser you can use the native
+	 * DOMParser API to generate a document (see clipboard.ts), but to use in a headless environment you can use JSDom
+	 * or an equivilant library and pass in the document here.
+	 */
+	function $generateNodesFromDOM(editor, dom) {
+	  const elements = dom.body ? dom.body.childNodes : [];
+	  let lexicalNodes = [];
+	  for (let i = 0; i < elements.length; i++) {
+	    const element = elements[i];
+	    if (!IGNORE_TAGS.has(element.nodeName)) {
+	      const lexicalNode = $createNodesFromDOM(element, editor);
+	      if (lexicalNode !== null) {
+	        lexicalNodes = lexicalNodes.concat(lexicalNode);
+	      }
+	    }
+	  }
+	  return lexicalNodes;
+	}
+	function $generateHtmlFromNodes(editor, selection) {
+	  if (typeof document === 'undefined' || typeof window === 'undefined' && typeof commonjsGlobal.window === 'undefined') {
+	    throw new Error('To use $generateHtmlFromNodes in headless mode please initialize a headless browser implementation such as JSDom before calling this function.');
+	  }
+	  const container = document.createElement('div');
+	  const root = lexical.$getRoot();
+	  const topLevelChildren = root.getChildren();
+	  for (let i = 0; i < topLevelChildren.length; i++) {
+	    const topLevelNode = topLevelChildren[i];
+	    $appendNodesToHTML(editor, topLevelNode, container, selection);
+	  }
+	  return container.innerHTML;
+	}
+	function $appendNodesToHTML(editor, currentNode, parentElement, selection$1 = null) {
+	  let shouldInclude = selection$1 !== null ? currentNode.isSelected(selection$1) : true;
+	  const shouldExclude = lexical.$isElementNode(currentNode) && currentNode.excludeFromCopy('html');
+	  let target = currentNode;
+	  if (selection$1 !== null) {
+	    let clone = selection.$cloneWithProperties(currentNode);
+	    clone = lexical.$isTextNode(clone) && selection$1 !== null ? selection.$sliceSelectedTextNodeContent(selection$1, clone) : clone;
+	    target = clone;
+	  }
+	  const children = lexical.$isElementNode(target) ? target.getChildren() : [];
+	  const registeredNode = editor._nodes.get(target.getType());
+	  let exportOutput;
+
+	  // Use HTMLConfig overrides, if available.
+	  if (registeredNode && registeredNode.exportDOM !== undefined) {
+	    exportOutput = registeredNode.exportDOM(editor, target);
+	  } else {
+	    exportOutput = target.exportDOM(editor);
+	  }
+	  const {
+	    element,
+	    after
+	  } = exportOutput;
+	  if (!element) {
+	    return false;
+	  }
+	  const fragment = document.createDocumentFragment();
+	  for (let i = 0; i < children.length; i++) {
+	    const childNode = children[i];
+	    const shouldIncludeChild = $appendNodesToHTML(editor, childNode, fragment, selection$1);
+	    if (!shouldInclude && lexical.$isElementNode(currentNode) && shouldIncludeChild && currentNode.extractWithChild(childNode, selection$1, 'html')) {
+	      shouldInclude = true;
+	    }
+	  }
+	  if (shouldInclude && !shouldExclude) {
+	    if (utils.isHTMLElement(element)) {
+	      element.append(fragment);
+	    }
+	    parentElement.append(element);
+	    if (after) {
+	      const newElement = after.call(target, element);
+	      if (newElement) element.replaceWith(newElement);
+	    }
+	  } else {
+	    parentElement.append(fragment);
+	  }
+	  return shouldInclude;
+	}
+	function getConversionFunction(domNode, editor) {
+	  const {
+	    nodeName
+	  } = domNode;
+	  const cachedConversions = editor._htmlConversions.get(nodeName.toLowerCase());
+	  let currentConversion = null;
+	  if (cachedConversions !== undefined) {
+	    for (const cachedConversion of cachedConversions) {
+	      const domConversion = cachedConversion(domNode);
+	      if (domConversion !== null && (currentConversion === null || (currentConversion.priority || 0) < (domConversion.priority || 0))) {
+	        currentConversion = domConversion;
+	      }
+	    }
+	  }
+	  return currentConversion !== null ? currentConversion.conversion : null;
+	}
+	const IGNORE_TAGS = new Set(['STYLE', 'SCRIPT']);
+	function $createNodesFromDOM(node, editor, forChildMap = new Map(), parentLexicalNode) {
+	  let lexicalNodes = [];
+	  if (IGNORE_TAGS.has(node.nodeName)) {
+	    return lexicalNodes;
+	  }
+	  let currentLexicalNode = null;
+	  const transformFunction = getConversionFunction(node, editor);
+	  const transformOutput = transformFunction ? transformFunction(node) : null;
+	  let postTransform = null;
+	  if (transformOutput !== null) {
+	    postTransform = transformOutput.after;
+	    const transformNodes = transformOutput.node;
+	    currentLexicalNode = Array.isArray(transformNodes) ? transformNodes[transformNodes.length - 1] : transformNodes;
+	    if (currentLexicalNode !== null) {
+	      for (const [, forChildFunction] of forChildMap) {
+	        currentLexicalNode = forChildFunction(currentLexicalNode, parentLexicalNode);
+	        if (!currentLexicalNode) {
+	          break;
+	        }
+	      }
+	      if (currentLexicalNode) {
+	        lexicalNodes.push(...(Array.isArray(transformNodes) ? transformNodes : [currentLexicalNode]));
+	      }
+	    }
+	    if (transformOutput.forChild != null) {
+	      forChildMap.set(node.nodeName, transformOutput.forChild);
+	    }
+	  }
+
+	  // If the DOM node doesn't have a transformer, we don't know what
+	  // to do with it but we still need to process any childNodes.
+	  const children = node.childNodes;
+	  let childLexicalNodes = [];
+	  for (let i = 0; i < children.length; i++) {
+	    childLexicalNodes.push(...$createNodesFromDOM(children[i], editor, new Map(forChildMap), currentLexicalNode));
+	  }
+	  if (postTransform != null) {
+	    childLexicalNodes = postTransform(childLexicalNodes);
+	  }
+	  if (currentLexicalNode == null) {
+	    // If it hasn't been converted to a LexicalNode, we hoist its children
+	    // up to the same level as it.
+	    lexicalNodes = lexicalNodes.concat(childLexicalNodes);
+	  } else {
+	    if (lexical.$isElementNode(currentLexicalNode)) {
+	      // If the current node is a ElementNode after conversion,
+	      // we can append all the children to it.
+	      currentLexicalNode.append(...childLexicalNodes);
+	    }
+	  }
+	  return lexicalNodes;
+	}
+
+	LexicalHtml_dev.$generateHtmlFromNodes = $generateHtmlFromNodes;
+	LexicalHtml_dev.$generateNodesFromDOM = $generateNodesFromDOM;
+	return LexicalHtml_dev;
+}
+
+var LexicalHtml_prod = {};
+
+/**
+ * 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.
+ */
+
+var hasRequiredLexicalHtml_prod;
+
+function requireLexicalHtml_prod () {
+	if (hasRequiredLexicalHtml_prod) return LexicalHtml_prod;
+	hasRequiredLexicalHtml_prod = 1;
+var m=requireLexicalSelection(),p=requireLexicalUtils(),q=require$$3;
+	function u(c,e,h,a=null){let f=null!==a?e.isSelected(a):true,k=q.$isElementNode(e)&&e.excludeFromCopy("html");var d=e;null!==a&&(d=m.$cloneWithProperties(e),d=q.$isTextNode(d)&&null!==a?m.$sliceSelectedTextNodeContent(a,d):d);let g=q.$isElementNode(d)?d.getChildren():[];var b=c._nodes.get(d.getType());b=b&&void 0!==b.exportDOM?b.exportDOM(c,d):d.exportDOM(c);let {element:l,after:r}=b;if(!l)return  false;b=document.createDocumentFragment();for(let n=0;n<g.length;n++){let t=g[n],x=u(c,t,b,a);!f&&q.$isElementNode(e)&&
+	x&&e.extractWithChild(t,a,"html")&&(f=true);}f&&!k?(p.isHTMLElement(l)&&l.append(b),h.append(l),r&&(c=r.call(d,l))&&l.replaceWith(c)):h.append(b);return f}let v=new Set(["STYLE","SCRIPT"]);
+	function w(c,e,h=new Map,a){let f=[];if(v.has(c.nodeName))return f;let k=null;var d,{nodeName:g}=c,b=e._htmlConversions.get(g.toLowerCase());g=null;if(void 0!==b)for(d of b)b=d(c),null!==b&&(null===g||(g.priority||0)<(b.priority||0))&&(g=b);g=(d=null!==g?g.conversion:null)?d(c):null;d=null;if(null!==g){d=g.after;b=g.node;k=Array.isArray(b)?b[b.length-1]:b;if(null!==k){for(var [,l]of h)if(k=l(k,a),!k)break;k&&f.push(...(Array.isArray(b)?b:[k]));}null!=g.forChild&&h.set(c.nodeName,g.forChild);}c=c.childNodes;
+	a=[];for(l=0;l<c.length;l++)a.push(...w(c[l],e,new Map(h),k));null!=d&&(a=d(a));null==k?f=f.concat(a):q.$isElementNode(k)&&k.append(...a);return f}
+	LexicalHtml_prod.$generateHtmlFromNodes=function(c,e){if("undefined"===typeof document||"undefined"===typeof window&&"undefined"===typeof commonjsGlobal.window)throw Error("To use $generateHtmlFromNodes in headless mode please initialize a headless browser implementation such as JSDom before calling this function.");let h=document.createElement("div"),a=q.$getRoot().getChildren();for(let f=0;f<a.length;f++)u(c,a[f],h,e);return h.innerHTML};
+	LexicalHtml_prod.$generateNodesFromDOM=function(c,e){e=e.body?e.body.childNodes:[];let h=[];for(let f=0;f<e.length;f++){var a=e[f];v.has(a.nodeName)||(a=w(a,c),null!==a&&(h=h.concat(a)));}return h};
+	return LexicalHtml_prod;
+}
+
+/**
+ * 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.
+ */
+
+var LexicalHtml_1;
+var hasRequiredLexicalHtml;
+
+function requireLexicalHtml () {
+	if (hasRequiredLexicalHtml) return LexicalHtml_1;
+	hasRequiredLexicalHtml = 1;
+	const LexicalHtml = process.env.NODE_ENV === 'development' ? requireLexicalHtml_dev() : requireLexicalHtml_prod();
+	LexicalHtml_1 = LexicalHtml;
+	return LexicalHtml_1;
+}
+
+/**
+ * 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.
+ */
+
+var hasRequiredLexicalClipboard_dev;
+
+function requireLexicalClipboard_dev () {
+	if (hasRequiredLexicalClipboard_dev) return LexicalClipboard_dev;
+	hasRequiredLexicalClipboard_dev = 1;
+
+	var html = requireLexicalHtml();
+	var selection = requireLexicalSelection();
+	var utils = requireLexicalUtils();
+	var lexical = require$$3;
+
+	/**
+	 * 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 CAN_USE_DOM = typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined';
+
+	/**
+	 * 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 getDOMSelection = targetWindow => CAN_USE_DOM ? (targetWindow || window).getSelection() : null;
+
+	/**
+	 * Returns the *currently selected* Lexical content as an HTML string, relying on the
+	 * logic defined in the exportDOM methods on the LexicalNode classes. Note that
+	 * this will not return the HTML content of the entire editor (unless all the content is included
+	 * in the current selection).
+	 *
+	 * @param editor - LexicalEditor instance to get HTML content from
+	 * @returns a string of HTML content
+	 */
+	function $getHtmlContent(editor) {
+	  const selection = lexical.$getSelection();
+	  if (selection == null) {
+	    {
+	      throw Error(`Expected valid LexicalSelection`);
+	    }
+	  }
+
+	  // If we haven't selected anything
+	  if (lexical.$isRangeSelection(selection) && selection.isCollapsed() || selection.getNodes().length === 0) {
+	    return '';
+	  }
+	  return html.$generateHtmlFromNodes(editor, selection);
+	}
+
+	/**
+	 * Returns the *currently selected* Lexical content as a JSON string, relying on the
+	 * logic defined in the exportJSON methods on the LexicalNode classes. Note that
+	 * this will not return the JSON content of the entire editor (unless all the content is included
+	 * in the current selection).
+	 *
+	 * @param editor  - LexicalEditor instance to get the JSON content from
+	 * @returns
+	 */
+	function $getLexicalContent(editor) {
+	  const selection = lexical.$getSelection();
+	  if (selection == null) {
+	    {
+	      throw Error(`Expected valid LexicalSelection`);
+	    }
+	  }
+
+	  // If we haven't selected anything
+	  if (lexical.$isRangeSelection(selection) && selection.isCollapsed() || selection.getNodes().length === 0) {
+	    return null;
+	  }
+	  return JSON.stringify($generateJSONFromSelectedNodes(editor, selection));
+	}
+
+	/**
+	 * Attempts to insert content of the mime-types text/plain or text/uri-list from
+	 * the provided DataTransfer object into the editor at the provided selection.
+	 * text/uri-list is only used if text/plain is not also provided.
+	 *
+	 * @param dataTransfer an object conforming to the [DataTransfer interface] (https://html.spec.whatwg.org/multipage/dnd.html#the-datatransfer-interface)
+	 * @param selection the selection to use as the insertion point for the content in the DataTransfer object
+	 */
+	function $insertDataTransferForPlainText(dataTransfer, selection) {
+	  const text = dataTransfer.getData('text/plain') || dataTransfer.getData('text/uri-list');
+	  if (text != null) {
+	    selection.insertRawText(text);
+	  }
+	}
+
+	/**
+	 * Attempts to insert content of the mime-types application/x-lexical-editor, text/html,
+	 * text/plain, or text/uri-list (in descending order of priority) from the provided DataTransfer
+	 * object into the editor at the provided selection.
+	 *
+	 * @param dataTransfer an object conforming to the [DataTransfer interface] (https://html.spec.whatwg.org/multipage/dnd.html#the-datatransfer-interface)
+	 * @param selection the selection to use as the insertion point for the content in the DataTransfer object
+	 * @param editor the LexicalEditor the content is being inserted into.
+	 */
+	function $insertDataTransferForRichText(dataTransfer, selection, editor) {
+	  const lexicalString = dataTransfer.getData('application/x-lexical-editor');
+	  if (lexicalString) {
+	    try {
+	      const payload = JSON.parse(lexicalString);
+	      if (payload.namespace === editor._config.namespace && Array.isArray(payload.nodes)) {
+	        const nodes = $generateNodesFromSerializedNodes(payload.nodes);
+	        return $insertGeneratedNodes(editor, nodes, selection);
+	      }
+	    } catch (_unused) {
+	      // Fail silently.
+	    }
+	  }
+	  const htmlString = dataTransfer.getData('text/html');
+	  if (htmlString) {
+	    try {
+	      const parser = new DOMParser();
+	      const dom = parser.parseFromString(htmlString, 'text/html');
+	      const nodes = html.$generateNodesFromDOM(editor, dom);
+	      return $insertGeneratedNodes(editor, nodes, selection);
+	    } catch (_unused2) {
+	      // Fail silently.
+	    }
+	  }
+
+	  // Multi-line plain text in rich text mode pasted as separate paragraphs
+	  // instead of single paragraph with linebreaks.
+	  // Webkit-specific: Supports read 'text/uri-list' in clipboard.
+	  const text = dataTransfer.getData('text/plain') || dataTransfer.getData('text/uri-list');
+	  if (text != null) {
+	    if (lexical.$isRangeSelection(selection)) {
+	      const parts = text.split(/(\r?\n|\t)/);
+	      if (parts[parts.length - 1] === '') {
+	        parts.pop();
+	      }
+	      for (let i = 0; i < parts.length; i++) {
+	        const part = parts[i];
+	        if (part === '\n' || part === '\r\n') {
+	          selection.insertParagraph();
+	        } else if (part === '\t') {
+	          selection.insertNodes([lexical.$createTabNode()]);
+	        } else {
+	          selection.insertText(part);
+	        }
+	      }
+	    } else {
+	      selection.insertRawText(text);
+	    }
+	  }
+	}
+
+	/**
+	 * Inserts Lexical nodes into the editor using different strategies depending on
+	 * some simple selection-based heuristics. If you're looking for a generic way to
+	 * to insert nodes into the editor at a specific selection point, you probably want
+	 * {@link lexical.$insertNodes}
+	 *
+	 * @param editor LexicalEditor instance to insert the nodes into.
+	 * @param nodes The nodes to insert.
+	 * @param selection The selection to insert the nodes into.
+	 */
+	function $insertGeneratedNodes(editor, nodes, selection) {
+	  if (!editor.dispatchCommand(lexical.SELECTION_INSERT_CLIPBOARD_NODES_COMMAND, {
+	    nodes,
+	    selection
+	  })) {
+	    selection.insertNodes(nodes);
+	  }
+	  return;
+	}
+	function exportNodeToJSON(node) {
+	  const serializedNode = node.exportJSON();
+	  const nodeClass = node.constructor;
+	  if (serializedNode.type !== nodeClass.getType()) {
+	    {
+	      throw Error(`LexicalNode: Node ${nodeClass.name} does not implement .exportJSON().`);
+	    }
+	  }
+	  if (lexical.$isElementNode(node)) {
+	    const serializedChildren = serializedNode.children;
+	    if (!Array.isArray(serializedChildren)) {
+	      {
+	        throw Error(`LexicalNode: Node ${nodeClass.name} is an element but .exportJSON() does not have a children array.`);
+	      }
+	    }
+	  }
+	  return serializedNode;
+	}
+	function $appendNodesToJSON(editor, selection$1, currentNode, targetArray = []) {
+	  let shouldInclude = selection$1 !== null ? currentNode.isSelected(selection$1) : true;
+	  const shouldExclude = lexical.$isElementNode(currentNode) && currentNode.excludeFromCopy('html');
+	  let target = currentNode;
+	  if (selection$1 !== null) {
+	    let clone = selection.$cloneWithProperties(currentNode);
+	    clone = lexical.$isTextNode(clone) && selection$1 !== null ? selection.$sliceSelectedTextNodeContent(selection$1, clone) : clone;
+	    target = clone;
+	  }
+	  const children = lexical.$isElementNode(target) ? target.getChildren() : [];
+	  const serializedNode = exportNodeToJSON(target);
+
+	  // TODO: TextNode calls getTextContent() (NOT node.__text) within it's exportJSON method
+	  // which uses getLatest() to get the text from the original node with the same key.
+	  // This is a deeper issue with the word "clone" here, it's still a reference to the
+	  // same node as far as the LexicalEditor is concerned since it shares a key.
+	  // We need a way to create a clone of a Node in memory with it's own key, but
+	  // until then this hack will work for the selected text extract use case.
+	  if (lexical.$isTextNode(target)) {
+	    const text = target.__text;
+	    // If an uncollapsed selection ends or starts at the end of a line of specialized,
+	    // TextNodes, such as code tokens, we will get a 'blank' TextNode here, i.e., one
+	    // with text of length 0. We don't want this, it makes a confusing mess. Reset!
+	    if (text.length > 0) {
+	      serializedNode.text = text;
+	    } else {
+	      shouldInclude = false;
+	    }
+	  }
+	  for (let i = 0; i < children.length; i++) {
+	    const childNode = children[i];
+	    const shouldIncludeChild = $appendNodesToJSON(editor, selection$1, childNode, serializedNode.children);
+	    if (!shouldInclude && lexical.$isElementNode(currentNode) && shouldIncludeChild && currentNode.extractWithChild(childNode, selection$1, 'clone')) {
+	      shouldInclude = true;
+	    }
+	  }
+	  if (shouldInclude && !shouldExclude) {
+	    targetArray.push(serializedNode);
+	  } else if (Array.isArray(serializedNode.children)) {
+	    for (let i = 0; i < serializedNode.children.length; i++) {
+	      const serializedChildNode = serializedNode.children[i];
+	      targetArray.push(serializedChildNode);
+	    }
+	  }
+	  return shouldInclude;
+	}
+
+	// TODO why $ function with Editor instance?
+	/**
+	 * Gets the Lexical JSON of the nodes inside the provided Selection.
+	 *
+	 * @param editor LexicalEditor to get the JSON content from.
+	 * @param selection Selection to get the JSON content from.
+	 * @returns an object with the editor namespace and a list of serializable nodes as JavaScript objects.
+	 */
+	function $generateJSONFromSelectedNodes(editor, selection) {
+	  const nodes = [];
+	  const root = lexical.$getRoot();
+	  const topLevelChildren = root.getChildren();
+	  for (let i = 0; i < topLevelChildren.length; i++) {
+	    const topLevelNode = topLevelChildren[i];
+	    $appendNodesToJSON(editor, selection, topLevelNode, nodes);
+	  }
+	  return {
+	    namespace: editor._config.namespace,
+	    nodes
+	  };
+	}
+
+	/**
+	 * This method takes an array of objects conforming to the BaseSeralizedNode interface and returns
+	 * an Array containing instances of the corresponding LexicalNode classes registered on the editor.
+	 * Normally, you'd get an Array of BaseSerialized nodes from {@link $generateJSONFromSelectedNodes}
+	 *
+	 * @param serializedNodes an Array of objects conforming to the BaseSerializedNode interface.
+	 * @returns an Array of Lexical Node objects.
+	 */
+	function $generateNodesFromSerializedNodes(serializedNodes) {
+	  const nodes = [];
+	  for (let i = 0; i < serializedNodes.length; i++) {
+	    const serializedNode = serializedNodes[i];
+	    const node = lexical.$parseSerializedNode(serializedNode);
+	    if (lexical.$isTextNode(node)) {
+	      selection.$addNodeStyle(node);
+	    }
+	    nodes.push(node);
+	  }
+	  return nodes;
+	}
+	const EVENT_LATENCY = 50;
+	let clipboardEventTimeout = null;
+
+	// TODO custom selection
+	// TODO potentially have a node customizable version for plain text
+	/**
+	 * Copies the content of the current selection to the clipboard in
+	 * text/plain, text/html, and application/x-lexical-editor (Lexical JSON)
+	 * formats.
+	 *
+	 * @param editor the LexicalEditor instance to copy content from
+	 * @param event the native browser ClipboardEvent to add the content to.
+	 * @returns
+	 */
+	async function copyToClipboard(editor, event) {
+	  if (clipboardEventTimeout !== null) {
+	    // Prevent weird race conditions that can happen when this function is run multiple times
+	    // synchronously. In the future, we can do better, we can cancel/override the previously running job.
+	    return false;
+	  }
+	  if (event !== null) {
+	    return new Promise((resolve, reject) => {
+	      editor.update(() => {
+	        resolve($copyToClipboardEvent(editor, event));
+	      });
+	    });
+	  }
+	  const rootElement = editor.getRootElement();
+	  const windowDocument = editor._window == null ? window.document : editor._window.document;
+	  const domSelection = getDOMSelection(editor._window);
+	  if (rootElement === null || domSelection === null) {
+	    return false;
+	  }
+	  const element = windowDocument.createElement('span');
+	  element.style.cssText = 'position: fixed; top: -1000px;';
+	  element.append(windowDocument.createTextNode('#'));
+	  rootElement.append(element);
+	  const range = new Range();
+	  range.setStart(element, 0);
+	  range.setEnd(element, 1);
+	  domSelection.removeAllRanges();
+	  domSelection.addRange(range);
+	  return new Promise((resolve, reject) => {
+	    const removeListener = editor.registerCommand(lexical.COPY_COMMAND, secondEvent => {
+	      if (utils.objectKlassEquals(secondEvent, ClipboardEvent)) {
+	        removeListener();
+	        if (clipboardEventTimeout !== null) {
+	          window.clearTimeout(clipboardEventTimeout);
+	          clipboardEventTimeout = null;
+	        }
+	        resolve($copyToClipboardEvent(editor, secondEvent));
+	      }
+	      // Block the entire copy flow while we wait for the next ClipboardEvent
+	      return true;
+	    }, lexical.COMMAND_PRIORITY_CRITICAL);
+	    // If the above hack execCommand hack works, this timeout code should never fire. Otherwise,
+	    // the listener will be quickly freed so that the user can reuse it again
+	    clipboardEventTimeout = window.setTimeout(() => {
+	      removeListener();
+	      clipboardEventTimeout = null;
+	      resolve(false);
+	    }, EVENT_LATENCY);
+	    windowDocument.execCommand('copy');
+	    element.remove();
+	  });
+	}
+
+	// TODO shouldn't pass editor (pass namespace directly)
+	function $copyToClipboardEvent(editor, event) {
+	  const domSelection = getDOMSelection(editor._window);
+	  if (!domSelection) {
+	    return false;
+	  }
+	  const anchorDOM = domSelection.anchorNode;
+	  const focusDOM = domSelection.focusNode;
+	  if (anchorDOM !== null && focusDOM !== null && !lexical.isSelectionWithinEditor(editor, anchorDOM, focusDOM)) {
+	    return false;
+	  }
+	  event.preventDefault();
+	  const clipboardData = event.clipboardData;
+	  const selection = lexical.$getSelection();
+	  if (clipboardData === null || selection === null) {
+	    return false;
+	  }
+	  const htmlString = $getHtmlContent(editor);
+	  const lexicalString = $getLexicalContent(editor);
+	  let plainString = '';
+	  if (selection !== null) {
+	    plainString = selection.getTextContent();
+	  }
+	  if (htmlString !== null) {
+	    clipboardData.setData('text/html', htmlString);
+	  }
+	  if (lexicalString !== null) {
+	    clipboardData.setData('application/x-lexical-editor', lexicalString);
+	  }
+	  clipboardData.setData('text/plain', plainString);
+	  return true;
+	}
+
+	LexicalClipboard_dev.$generateJSONFromSelectedNodes = $generateJSONFromSelectedNodes;
+	LexicalClipboard_dev.$generateNodesFromSerializedNodes = $generateNodesFromSerializedNodes;
+	LexicalClipboard_dev.$getHtmlContent = $getHtmlContent;
+	LexicalClipboard_dev.$getLexicalContent = $getLexicalContent;
+	LexicalClipboard_dev.$insertDataTransferForPlainText = $insertDataTransferForPlainText;
+	LexicalClipboard_dev.$insertDataTransferForRichText = $insertDataTransferForRichText;
+	LexicalClipboard_dev.$insertGeneratedNodes = $insertGeneratedNodes;
+	LexicalClipboard_dev.copyToClipboard = copyToClipboard;
+	return LexicalClipboard_dev;
+}
+
+var LexicalClipboard_prod = {};
+
+/**
+ * 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.
+ */
+
+var hasRequiredLexicalClipboard_prod;
+
+function requireLexicalClipboard_prod () {
+	if (hasRequiredLexicalClipboard_prod) return LexicalClipboard_prod;
+	hasRequiredLexicalClipboard_prod = 1;
+var f=requireLexicalHtml(),m=requireLexicalSelection(),q=requireLexicalUtils(),r=require$$3;function t(a){let b=new URLSearchParams;b.append("code",a);for(let c=1;c<arguments.length;c++)b.append("v",arguments[c]);throw Error(`Minified Lexical error #${a}; visit https://lexical.dev/docs/error?${b} for the full message or `+"use the non-minified dev environment for full errors and additional helpful warnings.");}
+	let u="undefined"!==typeof window&&"undefined"!==typeof window.document&&"undefined"!==typeof window.document.createElement;function v(a){let b=r.$getSelection();if(null==b)throw Error("Expected valid LexicalSelection");return r.$isRangeSelection(b)&&b.isCollapsed()||0===b.getNodes().length?"":f.$generateHtmlFromNodes(a,b)}
+	function w(a){let b=r.$getSelection();if(null==b)throw Error("Expected valid LexicalSelection");return r.$isRangeSelection(b)&&b.isCollapsed()||0===b.getNodes().length?null:JSON.stringify(x(a,b))}function y(a,b,c){a.dispatchCommand(r.SELECTION_INSERT_CLIPBOARD_NODES_COMMAND,{nodes:b,selection:c})||c.insertNodes(b);}
+	function z(a,b,c,d=[]){let e=null!==b?c.isSelected(b):true,h=r.$isElementNode(c)&&c.excludeFromCopy("html");var g=c;if(null!==b){var k=m.$cloneWithProperties(c);g=k=r.$isTextNode(k)&&null!==b?m.$sliceSelectedTextNodeContent(b,k):k;}let n=r.$isElementNode(g)?g.getChildren():[];var l=g;k=l.exportJSON();var p=l.constructor;k.type!==p.getType()&&t(58,p.name);r.$isElementNode(l)&&(Array.isArray(k.children)||t(59,p.name));r.$isTextNode(g)&&(g=g.__text,0<g.length?k.text=g:e=false);for(g=0;g<n.length;g++)l=n[g],
+	p=z(a,b,l,k.children),!e&&r.$isElementNode(c)&&p&&c.extractWithChild(l,b,"clone")&&(e=true);if(e&&!h)d.push(k);else if(Array.isArray(k.children))for(a=0;a<k.children.length;a++)d.push(k.children[a]);return e}function x(a,b){let c=[],d=r.$getRoot().getChildren();for(let e=0;e<d.length;e++)z(a,b,d[e],c);return {namespace:a._config.namespace,nodes:c}}function A(a){let b=[];for(let c=0;c<a.length;c++){let d=r.$parseSerializedNode(a[c]);r.$isTextNode(d)&&m.$addNodeStyle(d);b.push(d);}return b}let B=null;
+	function C(a,b){var c=u?(a._window||window).getSelection():null;if(!c)return  false;var d=c.anchorNode;c=c.focusNode;if(null!==d&&null!==c&&!r.isSelectionWithinEditor(a,d,c))return  false;b.preventDefault();b=b.clipboardData;d=r.$getSelection();if(null===b||null===d)return  false;c=v(a);a=w(a);let e="";null!==d&&(e=d.getTextContent());null!==c&&b.setData("text/html",c);null!==a&&b.setData("application/x-lexical-editor",a);b.setData("text/plain",e);return  true}LexicalClipboard_prod.$generateJSONFromSelectedNodes=x;
+	LexicalClipboard_prod.$generateNodesFromSerializedNodes=A;LexicalClipboard_prod.$getHtmlContent=v;LexicalClipboard_prod.$getLexicalContent=w;LexicalClipboard_prod.$insertDataTransferForPlainText=function(a,b){a=a.getData("text/plain")||a.getData("text/uri-list");null!=a&&b.insertRawText(a);};
+	LexicalClipboard_prod.$insertDataTransferForRichText=function(a,b,c){var d=a.getData("application/x-lexical-editor");if(d)try{let h=JSON.parse(d);if(h.namespace===c._config.namespace&&Array.isArray(h.nodes)){let g=A(h.nodes);return y(c,g,b)}}catch(h){}if(d=a.getData("text/html"))try{var e=(new DOMParser).parseFromString(d,"text/html");let h=f.$generateNodesFromDOM(c,e);return y(c,h,b)}catch(h){}a=a.getData("text/plain")||a.getData("text/uri-list");if(null!=a)if(r.$isRangeSelection(b))for(a=a.split(/(\r?\n|\t)/),
+	""===a[a.length-1]&&a.pop(),c=0;c<a.length;c++)e=a[c],"\n"===e||"\r\n"===e?b.insertParagraph():"\t"===e?b.insertNodes([r.$createTabNode()]):b.insertText(e);else b.insertRawText(a);};LexicalClipboard_prod.$insertGeneratedNodes=y;
+	LexicalClipboard_prod.copyToClipboard=async function(a,b){if(null!==B)return  false;if(null!==b)return new Promise(g=>{a.update(()=>{g(C(a,b));});});var c=a.getRootElement();let d=null==a._window?window.document:a._window.document,e=u?(a._window||window).getSelection():null;if(null===c||null===e)return  false;let h=d.createElement("span");h.style.cssText="position: fixed; top: -1000px;";h.append(d.createTextNode("#"));c.append(h);c=new Range;c.setStart(h,0);c.setEnd(h,1);e.removeAllRanges();e.addRange(c);return new Promise(g=>
+	{let k=a.registerCommand(r.COPY_COMMAND,n=>{q.objectKlassEquals(n,ClipboardEvent)&&(k(),null!==B&&(window.clearTimeout(B),B=null),g(C(a,n)));return  true},r.COMMAND_PRIORITY_CRITICAL);B=window.setTimeout(()=>{k();B=null;g(false);},50);d.execCommand("copy");h.remove();})};
+	return LexicalClipboard_prod;
+}
+
+/**
+ * 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.
+ */
+
+var LexicalClipboard_1;
+var hasRequiredLexicalClipboard;
+
+function requireLexicalClipboard () {
+	if (hasRequiredLexicalClipboard) return LexicalClipboard_1;
+	hasRequiredLexicalClipboard = 1;
+	const LexicalClipboard = process.env.NODE_ENV === 'development' ? requireLexicalClipboard_dev() : requireLexicalClipboard_prod();
+	LexicalClipboard_1 = LexicalClipboard;
+	return LexicalClipboard_1;
+}
+
+/**
+ * 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.
+ */
+
+var hasRequiredLexicalRichText_dev;
+
+function requireLexicalRichText_dev () {
+	if (hasRequiredLexicalRichText_dev) return LexicalRichText_dev;
+	hasRequiredLexicalRichText_dev = 1;
+
+	var clipboard = requireLexicalClipboard();
+	var selection = requireLexicalSelection();
+	var utils = requireLexicalUtils();
+	var lexical = require$$3;
+
+	/**
+	 * 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 caretFromPoint(x, y) {
+	  if (typeof document.caretRangeFromPoint !== 'undefined') {
+	    const range = document.caretRangeFromPoint(x, y);
+	    if (range === null) {
+	      return null;
+	    }
+	    return {
+	      node: range.startContainer,
+	      offset: range.startOffset
+	    };
+	    // @ts-ignore
+	  } else if (document.caretPositionFromPoint !== 'undefined') {
+	    // @ts-ignore FF - no types
+	    const range = document.caretPositionFromPoint(x, y);
+	    if (range === null) {
+	      return null;
+	    }
+	    return {
+	      node: range.offsetNode,
+	      offset: range.offset
+	    };
+	  } else {
+	    // Gracefully handle IE
+	    return null;
+	  }
+	}
+
+	/**
+	 * Copyright (c) Meta Platforms, Inc. and affiliates.
+	 *
+	 * This source code is licensed under the MIT license found in the
+	 * LICENSE file in the root directory of this source tree.
+	 *
+	 */
+
+	const CAN_USE_DOM = typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined';
+
+	/**
+	 * 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 documentMode = CAN_USE_DOM && 'documentMode' in document ? document.documentMode : null;
+	const CAN_USE_BEFORE_INPUT = CAN_USE_DOM && 'InputEvent' in window && !documentMode ? 'getTargetRanges' in new window.InputEvent('input') : false;
+	const IS_SAFARI = CAN_USE_DOM && /Version\/[\d.]+.*Safari/.test(navigator.userAgent);
+	const IS_IOS = CAN_USE_DOM && /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream;
+
+	// Keep these in case we need to use them in the future.
+	// export const IS_WINDOWS: boolean = CAN_USE_DOM && /Win/.test(navigator.platform);
+	const IS_CHROME = CAN_USE_DOM && /^(?=.*Chrome).*/i.test(navigator.userAgent);
+	// export const canUseTextInputEvent: boolean = CAN_USE_DOM && 'TextEvent' in window && !documentMode;
+
+	const IS_APPLE_WEBKIT = CAN_USE_DOM && /AppleWebKit\/[\d.]+/.test(navigator.userAgent) && !IS_CHROME;
+
+	/** @module @lexical/rich-text */
+	const DRAG_DROP_PASTE = lexical.createCommand('DRAG_DROP_PASTE_FILE');
+	/** @noInheritDoc */
+	class QuoteNode extends lexical.ElementNode {
+	  static getType() {
+	    return 'quote';
+	  }
+	  static clone(node) {
+	    return new QuoteNode(node.__key);
+	  }
+	  constructor(key) {
+	    super(key);
+	  }
+
+	  // View
+
+	  createDOM(config) {
+	    const element = document.createElement('blockquote');
+	    utils.addClassNamesToElement(element, config.theme.quote);
+	    return element;
+	  }
+	  updateDOM(prevNode, dom) {
+	    return false;
+	  }
+	  static importDOM() {
+	    return {
+	      blockquote: node => ({
+	        conversion: convertBlockquoteElement,
+	        priority: 0
+	      })
+	    };
+	  }
+	  exportDOM(editor) {
+	    const {
+	      element
+	    } = super.exportDOM(editor);
+	    if (element && utils.isHTMLElement(element)) {
+	      if (this.isEmpty()) element.append(document.createElement('br'));
+	      const formatType = this.getFormatType();
+	      element.style.textAlign = formatType;
+	      const direction = this.getDirection();
+	      if (direction) {
+	        element.dir = direction;
+	      }
+	    }
+	    return {
+	      element
+	    };
+	  }
+	  static importJSON(serializedNode) {
+	    const node = $createQuoteNode();
+	    node.setFormat(serializedNode.format);
+	    node.setIndent(serializedNode.indent);
+	    node.setDirection(serializedNode.direction);
+	    return node;
+	  }
+	  exportJSON() {
+	    return {
+	      ...super.exportJSON(),
+	      type: 'quote'
+	    };
+	  }
+
+	  // Mutation
+
+	  insertNewAfter(_, restoreSelection) {
+	    const newBlock = lexical.$createParagraphNode();
+	    const direction = this.getDirection();
+	    newBlock.setDirection(direction);
+	    this.insertAfter(newBlock, restoreSelection);
+	    return newBlock;
+	  }
+	  collapseAtStart() {
+	    const paragraph = lexical.$createParagraphNode();
+	    const children = this.getChildren();
+	    children.forEach(child => paragraph.append(child));
+	    this.replace(paragraph);
+	    return true;
+	  }
+	}
+	function $createQuoteNode() {
+	  return lexical.$applyNodeReplacement(new QuoteNode());
+	}
+	function $isQuoteNode(node) {
+	  return node instanceof QuoteNode;
+	}
+	/** @noInheritDoc */
+	class HeadingNode extends lexical.ElementNode {
+	  /** @internal */
+
+	  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) {
+	      const className = classNames[tag];
+	      utils.addClassNamesToElement(element, className);
+	    }
+	    return element;
+	  }
+	  updateDOM(prevNode, dom) {
+	    return false;
+	  }
+	  static importDOM() {
+	    return {
+	      h1: node => ({
+	        conversion: convertHeadingElement,
+	        priority: 0
+	      }),
+	      h2: node => ({
+	        conversion: convertHeadingElement,
+	        priority: 0
+	      }),
+	      h3: node => ({
+	        conversion: convertHeadingElement,
+	        priority: 0
+	      }),
+	      h4: node => ({
+	        conversion: convertHeadingElement,
+	        priority: 0
+	      }),
+	      h5: node => ({
+	        conversion: convertHeadingElement,
+	        priority: 0
+	      }),
+	      h6: node => ({
+	        conversion: convertHeadingElement,
+	        priority: 0
+	      }),
+	      p: node => {
+	        // domNode is a <p> since we matched it by nodeName
+	        const paragraph = node;
+	        const firstChild = paragraph.firstChild;
+	        if (firstChild !== null && isGoogleDocsTitle(firstChild)) {
+	          return {
+	            conversion: () => ({
+	              node: null
+	            }),
+	            priority: 3
+	          };
+	        }
+	        return null;
+	      },
+	      span: node => {
+	        if (isGoogleDocsTitle(node)) {
+	          return {
+	            conversion: domNode => {
+	              return {
+	                node: $createHeadingNode('h1')
+	              };
+	            },
+	            priority: 3
+	          };
+	        }
+	        return null;
+	      }
+	    };
+	  }
+	  exportDOM(editor) {
+	    const {
+	      element
+	    } = super.exportDOM(editor);
+	    if (element && utils.isHTMLElement(element)) {
+	      if (this.isEmpty()) element.append(document.createElement('br'));
+	      const formatType = this.getFormatType();
+	      element.style.textAlign = formatType;
+	      const direction = this.getDirection();
+	      if (direction) {
+	        element.dir = direction;
+	      }
+	    }
+	    return {
+	      element
+	    };
+	  }
+	  static importJSON(serializedNode) {
+	    const node = $createHeadingNode(serializedNode.tag);
+	    node.setFormat(serializedNode.format);
+	    node.setIndent(serializedNode.indent);
+	    node.setDirection(serializedNode.direction);
+	    return node;
+	  }
+	  exportJSON() {
+	    return {
+	      ...super.exportJSON(),
+	      tag: this.getTag(),
+	      type: 'heading',
+	      version: 1
+	    };
+	  }
+
+	  // Mutation
+	  insertNewAfter(selection, restoreSelection = true) {
+	    const anchorOffet = selection ? selection.anchor.offset : 0;
+	    const newElement = anchorOffet === this.getTextContentSize() || !selection ? lexical.$createParagraphNode() : $createHeadingNode(this.getTag());
+	    const direction = this.getDirection();
+	    newElement.setDirection(direction);
+	    this.insertAfter(newElement, restoreSelection);
+	    if (anchorOffet === 0 && !this.isEmpty() && selection) {
+	      const paragraph = lexical.$createParagraphNode();
+	      paragraph.select();
+	      this.replace(paragraph, true);
+	    }
+	    return newElement;
+	  }
+	  collapseAtStart() {
+	    const newElement = !this.isEmpty() ? $createHeadingNode(this.getTag()) : lexical.$createParagraphNode();
+	    const children = this.getChildren();
+	    children.forEach(child => newElement.append(child));
+	    this.replace(newElement);
+	    return true;
+	  }
+	  extractWithChild() {
+	    return true;
+	  }
+	}
+	function isGoogleDocsTitle(domNode) {
+	  if (domNode.nodeName.toLowerCase() === 'span') {
+	    return domNode.style.fontSize === '26pt';
+	  }
+	  return false;
+	}
+	function convertHeadingElement(element) {
+	  const nodeName = element.nodeName.toLowerCase();
+	  let node = null;
+	  if (nodeName === 'h1' || nodeName === 'h2' || nodeName === 'h3' || nodeName === 'h4' || nodeName === 'h5' || nodeName === 'h6') {
+	    node = $createHeadingNode(nodeName);
+	    if (element.style !== null) {
+	      node.setFormat(element.style.textAlign);
+	    }
+	  }
+	  return {
+	    node
+	  };
+	}
+	function convertBlockquoteElement(element) {
+	  const node = $createQuoteNode();
+	  if (element.style !== null) {
+	    node.setFormat(element.style.textAlign);
+	  }
+	  return {
+	    node
+	  };
+	}
+	function $createHeadingNode(headingTag) {
+	  return lexical.$applyNodeReplacement(new HeadingNode(headingTag));
+	}
+	function $isHeadingNode(node) {
+	  return node instanceof HeadingNode;
+	}
+	function onPasteForRichText(event, editor) {
+	  event.preventDefault();
+	  editor.update(() => {
+	    const selection = lexical.$getSelection();
+	    const clipboardData = event instanceof InputEvent || event instanceof KeyboardEvent ? null : event.clipboardData;
+	    if (clipboardData != null && selection !== null) {
+	      clipboard.$insertDataTransferForRichText(clipboardData, selection, editor);
+	    }
+	  }, {
+	    tag: 'paste'
+	  });
+	}
+	async function onCutForRichText(event, editor) {
+	  await clipboard.copyToClipboard(editor, utils.objectKlassEquals(event, ClipboardEvent) ? event : null);
+	  editor.update(() => {
+	    const selection = lexical.$getSelection();
+	    if (lexical.$isRangeSelection(selection)) {
+	      selection.removeText();
+	    } else if (lexical.$isNodeSelection(selection)) {
+	      selection.getNodes().forEach(node => node.remove());
+	    }
+	  });
+	}
+
+	// Clipboard may contain files that we aren't allowed to read. While the event is arguably useless,
+	// in certain occasions, we want to know whether it was a file transfer, as opposed to text. We
+	// control this with the first boolean flag.
+	function eventFiles(event) {
+	  let dataTransfer = null;
+	  if (event instanceof DragEvent) {
+	    dataTransfer = event.dataTransfer;
+	  } else if (event instanceof ClipboardEvent) {
+	    dataTransfer = event.clipboardData;
+	  }
+	  if (dataTransfer === null) {
+	    return [false, [], false];
+	  }
+	  const types = dataTransfer.types;
+	  const hasFiles = types.includes('Files');
+	  const hasContent = types.includes('text/html') || types.includes('text/plain');
+	  return [hasFiles, Array.from(dataTransfer.files), hasContent];
+	}
+	function handleIndentAndOutdent(indentOrOutdent) {
+	  const selection = lexical.$getSelection();
+	  if (!lexical.$isRangeSelection(selection)) {
+	    return false;
+	  }
+	  const alreadyHandled = new Set();
+	  const nodes = selection.getNodes();
+	  for (let i = 0; i < nodes.length; i++) {
+	    const node = nodes[i];
+	    const key = node.getKey();
+	    if (alreadyHandled.has(key)) {
+	      continue;
+	    }
+	    const parentBlock = utils.$getNearestBlockElementAncestorOrThrow(node);
+	    const parentKey = parentBlock.getKey();
+	    if (parentBlock.canIndent() && !alreadyHandled.has(parentKey)) {
+	      alreadyHandled.add(parentKey);
+	      indentOrOutdent(parentBlock);
+	    }
+	  }
+	  return alreadyHandled.size > 0;
+	}
+	function $isTargetWithinDecorator(target) {
+	  const node = lexical.$getNearestNodeFromDOMNode(target);
+	  return lexical.$isDecoratorNode(node);
+	}
+	function $isSelectionAtEndOfRoot(selection) {
+	  const focus = selection.focus;
+	  return focus.key === 'root' && focus.offset === lexical.$getRoot().getChildrenSize();
+	}
+	function registerRichText(editor) {
+	  const removeListener = utils.mergeRegister(editor.registerCommand(lexical.CLICK_COMMAND, payload => {
+	    const selection = lexical.$getSelection();
+	    if (lexical.$isNodeSelection(selection)) {
+	      selection.clear();
+	      return true;
+	    }
+	    return false;
+	  }, 0), editor.registerCommand(lexical.DELETE_CHARACTER_COMMAND, isBackward => {
+	    const selection = lexical.$getSelection();
+	    if (!lexical.$isRangeSelection(selection)) {
+	      return false;
+	    }
+	    selection.deleteCharacter(isBackward);
+	    return true;
+	  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.DELETE_WORD_COMMAND, isBackward => {
+	    const selection = lexical.$getSelection();
+	    if (!lexical.$isRangeSelection(selection)) {
+	      return false;
+	    }
+	    selection.deleteWord(isBackward);
+	    return true;
+	  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.DELETE_LINE_COMMAND, isBackward => {
+	    const selection = lexical.$getSelection();
+	    if (!lexical.$isRangeSelection(selection)) {
+	      return false;
+	    }
+	    selection.deleteLine(isBackward);
+	    return true;
+	  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.CONTROLLED_TEXT_INSERTION_COMMAND, eventOrText => {
+	    const selection = lexical.$getSelection();
+	    if (typeof eventOrText === 'string') {
+	      if (selection !== null) {
+	        selection.insertText(eventOrText);
+	      }
+	    } else {
+	      if (selection === null) {
+	        return false;
+	      }
+	      const dataTransfer = eventOrText.dataTransfer;
+	      if (dataTransfer != null) {
+	        clipboard.$insertDataTransferForRichText(dataTransfer, selection, editor);
+	      } else if (lexical.$isRangeSelection(selection)) {
+	        const data = eventOrText.data;
+	        if (data) {
+	          selection.insertText(data);
+	        }
+	        return true;
+	      }
+	    }
+	    return true;
+	  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.REMOVE_TEXT_COMMAND, () => {
+	    const selection = lexical.$getSelection();
+	    if (!lexical.$isRangeSelection(selection)) {
+	      return false;
+	    }
+	    selection.removeText();
+	    return true;
+	  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.FORMAT_TEXT_COMMAND, format => {
+	    const selection = lexical.$getSelection();
+	    if (!lexical.$isRangeSelection(selection)) {
+	      return false;
+	    }
+	    selection.formatText(format);
+	    return true;
+	  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.FORMAT_ELEMENT_COMMAND, format => {
+	    const selection = lexical.$getSelection();
+	    if (!lexical.$isRangeSelection(selection) && !lexical.$isNodeSelection(selection)) {
+	      return false;
+	    }
+	    const nodes = selection.getNodes();
+	    for (const node of nodes) {
+	      const element = utils.$findMatchingParent(node, parentNode => lexical.$isElementNode(parentNode) && !parentNode.isInline());
+	      if (element !== null) {
+	        element.setFormat(format);
+	      }
+	    }
+	    return true;
+	  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.INSERT_LINE_BREAK_COMMAND, selectStart => {
+	    const selection = lexical.$getSelection();
+	    if (!lexical.$isRangeSelection(selection)) {
+	      return false;
+	    }
+	    selection.insertLineBreak(selectStart);
+	    return true;
+	  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.INSERT_PARAGRAPH_COMMAND, () => {
+	    const selection = lexical.$getSelection();
+	    if (!lexical.$isRangeSelection(selection)) {
+	      return false;
+	    }
+	    selection.insertParagraph();
+	    return true;
+	  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.INSERT_TAB_COMMAND, () => {
+	    lexical.$insertNodes([lexical.$createTabNode()]);
+	    return true;
+	  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.INDENT_CONTENT_COMMAND, () => {
+	    return handleIndentAndOutdent(block => {
+	      const indent = block.getIndent();
+	      block.setIndent(indent + 1);
+	    });
+	  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.OUTDENT_CONTENT_COMMAND, () => {
+	    return handleIndentAndOutdent(block => {
+	      const indent = block.getIndent();
+	      if (indent > 0) {
+	        block.setIndent(indent - 1);
+	      }
+	    });
+	  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.KEY_ARROW_UP_COMMAND, event => {
+	    const selection = lexical.$getSelection();
+	    if (lexical.$isNodeSelection(selection) && !$isTargetWithinDecorator(event.target)) {
+	      // If selection is on a node, let's try and move selection
+	      // back to being a range selection.
+	      const nodes = selection.getNodes();
+	      if (nodes.length > 0) {
+	        nodes[0].selectPrevious();
+	        return true;
+	      }
+	    } else if (lexical.$isRangeSelection(selection)) {
+	      const possibleNode = lexical.$getAdjacentNode(selection.focus, true);
+	      if (!event.shiftKey && lexical.$isDecoratorNode(possibleNode) && !possibleNode.isIsolated() && !possibleNode.isInline()) {
+	        possibleNode.selectPrevious();
+	        event.preventDefault();
+	        return true;
+	      }
+	    }
+	    return false;
+	  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.KEY_ARROW_DOWN_COMMAND, event => {
+	    const selection = lexical.$getSelection();
+	    if (lexical.$isNodeSelection(selection)) {
+	      // If selection is on a node, let's try and move selection
+	      // back to being a range selection.
+	      const nodes = selection.getNodes();
+	      if (nodes.length > 0) {
+	        nodes[0].selectNext(0, 0);
+	        return true;
+	      }
+	    } else if (lexical.$isRangeSelection(selection)) {
+	      if ($isSelectionAtEndOfRoot(selection)) {
+	        event.preventDefault();
+	        return true;
+	      }
+	      const possibleNode = lexical.$getAdjacentNode(selection.focus, false);
+	      if (!event.shiftKey && lexical.$isDecoratorNode(possibleNode) && !possibleNode.isIsolated() && !possibleNode.isInline()) {
+	        possibleNode.selectNext();
+	        event.preventDefault();
+	        return true;
+	      }
+	    }
+	    return false;
+	  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.KEY_ARROW_LEFT_COMMAND, event => {
+	    const selection$1 = lexical.$getSelection();
+	    if (lexical.$isNodeSelection(selection$1)) {
+	      // If selection is on a node, let's try and move selection
+	      // back to being a range selection.
+	      const nodes = selection$1.getNodes();
+	      if (nodes.length > 0) {
+	        event.preventDefault();
+	        nodes[0].selectPrevious();
+	        return true;
+	      }
+	    }
+	    if (!lexical.$isRangeSelection(selection$1)) {
+	      return false;
+	    }
+	    if (selection.$shouldOverrideDefaultCharacterSelection(selection$1, true)) {
+	      const isHoldingShift = event.shiftKey;
+	      event.preventDefault();
+	      selection.$moveCharacter(selection$1, isHoldingShift, true);
+	      return true;
+	    }
+	    return false;
+	  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.KEY_ARROW_RIGHT_COMMAND, event => {
+	    const selection$1 = lexical.$getSelection();
+	    if (lexical.$isNodeSelection(selection$1) && !$isTargetWithinDecorator(event.target)) {
+	      // If selection is on a node, let's try and move selection
+	      // back to being a range selection.
+	      const nodes = selection$1.getNodes();
+	      if (nodes.length > 0) {
+	        event.preventDefault();
+	        nodes[0].selectNext(0, 0);
+	        return true;
+	      }
+	    }
+	    if (!lexical.$isRangeSelection(selection$1)) {
+	      return false;
+	    }
+	    const isHoldingShift = event.shiftKey;
+	    if (selection.$shouldOverrideDefaultCharacterSelection(selection$1, false)) {
+	      event.preventDefault();
+	      selection.$moveCharacter(selection$1, isHoldingShift, false);
+	      return true;
+	    }
+	    return false;
+	  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.KEY_BACKSPACE_COMMAND, event => {
+	    if ($isTargetWithinDecorator(event.target)) {
+	      return false;
+	    }
+	    const selection = lexical.$getSelection();
+	    if (!lexical.$isRangeSelection(selection)) {
+	      return false;
+	    }
+	    event.preventDefault();
+	    const {
+	      anchor
+	    } = selection;
+	    const anchorNode = anchor.getNode();
+	    if (selection.isCollapsed() && anchor.offset === 0 && !lexical.$isRootNode(anchorNode)) {
+	      const element = utils.$getNearestBlockElementAncestorOrThrow(anchorNode);
+	      if (element.getIndent() > 0) {
+	        return editor.dispatchCommand(lexical.OUTDENT_CONTENT_COMMAND, undefined);
+	      }
+	    }
+	    return editor.dispatchCommand(lexical.DELETE_CHARACTER_COMMAND, true);
+	  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.KEY_DELETE_COMMAND, event => {
+	    if ($isTargetWithinDecorator(event.target)) {
+	      return false;
+	    }
+	    const selection = lexical.$getSelection();
+	    if (!lexical.$isRangeSelection(selection)) {
+	      return false;
+	    }
+	    event.preventDefault();
+	    return editor.dispatchCommand(lexical.DELETE_CHARACTER_COMMAND, false);
+	  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.KEY_ENTER_COMMAND, event => {
+	    const selection = lexical.$getSelection();
+	    if (!lexical.$isRangeSelection(selection)) {
+	      return false;
+	    }
+	    if (event !== null) {
+	      // If we have beforeinput, then we can avoid blocking
+	      // the default behavior. This ensures that the iOS can
+	      // intercept that we're actually inserting a paragraph,
+	      // and autocomplete, autocapitalize etc work as intended.
+	      // This can also cause a strange performance issue in
+	      // Safari, where there is a noticeable pause due to
+	      // preventing the key down of enter.
+	      if ((IS_IOS || IS_SAFARI || IS_APPLE_WEBKIT) && CAN_USE_BEFORE_INPUT) {
+	        return false;
+	      }
+	      event.preventDefault();
+	      if (event.shiftKey) {
+	        return editor.dispatchCommand(lexical.INSERT_LINE_BREAK_COMMAND, false);
+	      }
+	    }
+	    return editor.dispatchCommand(lexical.INSERT_PARAGRAPH_COMMAND, undefined);
+	  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.KEY_ESCAPE_COMMAND, () => {
+	    const selection = lexical.$getSelection();
+	    if (!lexical.$isRangeSelection(selection)) {
+	      return false;
+	    }
+	    editor.blur();
+	    return true;
+	  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.DROP_COMMAND, event => {
+	    const [, files] = eventFiles(event);
+	    if (files.length > 0) {
+	      const x = event.clientX;
+	      const y = event.clientY;
+	      const eventRange = caretFromPoint(x, y);
+	      if (eventRange !== null) {
+	        const {
+	          offset: domOffset,
+	          node: domNode
+	        } = eventRange;
+	        const node = lexical.$getNearestNodeFromDOMNode(domNode);
+	        if (node !== null) {
+	          const selection = lexical.$createRangeSelection();
+	          if (lexical.$isTextNode(node)) {
+	            selection.anchor.set(node.getKey(), domOffset, 'text');
+	            selection.focus.set(node.getKey(), domOffset, 'text');
+	          } else {
+	            const parentKey = node.getParentOrThrow().getKey();
+	            const offset = node.getIndexWithinParent() + 1;
+	            selection.anchor.set(parentKey, offset, 'element');
+	            selection.focus.set(parentKey, offset, 'element');
+	          }
+	          const normalizedSelection = lexical.$normalizeSelection__EXPERIMENTAL(selection);
+	          lexical.$setSelection(normalizedSelection);
+	        }
+	        editor.dispatchCommand(DRAG_DROP_PASTE, files);
+	      }
+	      event.preventDefault();
+	      return true;
+	    }
+	    const selection = lexical.$getSelection();
+	    if (lexical.$isRangeSelection(selection)) {
+	      return true;
+	    }
+	    return false;
+	  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.DRAGSTART_COMMAND, event => {
+	    const [isFileTransfer] = eventFiles(event);
+	    const selection = lexical.$getSelection();
+	    if (isFileTransfer && !lexical.$isRangeSelection(selection)) {
+	      return false;
+	    }
+	    return true;
+	  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.DRAGOVER_COMMAND, event => {
+	    const [isFileTransfer] = eventFiles(event);
+	    const selection = lexical.$getSelection();
+	    if (isFileTransfer && !lexical.$isRangeSelection(selection)) {
+	      return false;
+	    }
+	    const x = event.clientX;
+	    const y = event.clientY;
+	    const eventRange = caretFromPoint(x, y);
+	    if (eventRange !== null) {
+	      const node = lexical.$getNearestNodeFromDOMNode(eventRange.node);
+	      if (lexical.$isDecoratorNode(node)) {
+	        // Show browser caret as the user is dragging the media across the screen. Won't work
+	        // for DecoratorNode nor it's relevant.
+	        event.preventDefault();
+	      }
+	    }
+	    return true;
+	  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.SELECT_ALL_COMMAND, () => {
+	    lexical.$selectAll();
+	    return true;
+	  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.COPY_COMMAND, event => {
+	    clipboard.copyToClipboard(editor, utils.objectKlassEquals(event, ClipboardEvent) ? event : null);
+	    return true;
+	  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.CUT_COMMAND, event => {
+	    onCutForRichText(event, editor);
+	    return true;
+	  }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.PASTE_COMMAND, event => {
+	    const [, files, hasTextContent] = eventFiles(event);
+	    if (files.length > 0 && !hasTextContent) {
+	      editor.dispatchCommand(DRAG_DROP_PASTE, files);
+	      return true;
+	    }
+
+	    // if inputs then paste within the input ignore creating a new node on paste event
+	    if (lexical.isSelectionCapturedInDecoratorInput(event.target)) {
+	      return false;
+	    }
+	    const selection = lexical.$getSelection();
+	    if (selection !== null) {
+	      onPasteForRichText(event, editor);
+	      return true;
+	    }
+	    return false;
+	  }, lexical.COMMAND_PRIORITY_EDITOR));
+	  return removeListener;
+	}
+
+	LexicalRichText_dev.$createHeadingNode = $createHeadingNode;
+	LexicalRichText_dev.$createQuoteNode = $createQuoteNode;
+	LexicalRichText_dev.$isHeadingNode = $isHeadingNode;
+	LexicalRichText_dev.$isQuoteNode = $isQuoteNode;
+	LexicalRichText_dev.DRAG_DROP_PASTE = DRAG_DROP_PASTE;
+	LexicalRichText_dev.HeadingNode = HeadingNode;
+	LexicalRichText_dev.QuoteNode = QuoteNode;
+	LexicalRichText_dev.eventFiles = eventFiles;
+	LexicalRichText_dev.registerRichText = registerRichText;
+	return LexicalRichText_dev;
+}
+
+var LexicalRichText_prod = {};
+
+/**
+ * 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.
+ */
+
+var hasRequiredLexicalRichText_prod;
+
+function requireLexicalRichText_prod () {
+	if (hasRequiredLexicalRichText_prod) return LexicalRichText_prod;
+	hasRequiredLexicalRichText_prod = 1;
+var c=requireLexicalClipboard(),g=requireLexicalSelection(),h=requireLexicalUtils(),k=require$$3;function l(b,a){return "undefined"!==typeof document.caretRangeFromPoint?(b=document.caretRangeFromPoint(b,a),null===b?null:{node:b.startContainer,offset:b.startOffset}):"undefined"!==document.caretPositionFromPoint?(b=document.caretPositionFromPoint(b,a),null===b?null:{node:b.offsetNode,offset:b.offset}):null}
+	let n="undefined"!==typeof window&&"undefined"!==typeof window.document&&"undefined"!==typeof window.document.createElement,p=n&&"documentMode"in document?document.documentMode:null;let q=n&&"InputEvent"in window&&!p?"getTargetRanges"in new window.InputEvent("input"):false,r=n&&/Version\/[\d.]+.*Safari/.test(navigator.userAgent),t=n&&/iPad|iPhone|iPod/.test(navigator.userAgent)&&!window.MSStream;
+let u=n&&/^(?=.*Chrome).*/i.test(navigator.userAgent),v=n&&/AppleWebKit\/[\d.]+/.test(navigator.userAgent)&&!u,w=k.createCommand("DRAG_DROP_PASTE_FILE");
+	class x extends k.ElementNode{static getType(){return "quote"}static clone(b){return new x(b.__key)}constructor(b){super(b);}createDOM(b){let a=document.createElement("blockquote");h.addClassNamesToElement(a,b.theme.quote);return a}updateDOM(){return  false}static importDOM(){return {blockquote:()=>({conversion:y,priority:0})}}exportDOM(b){({element:b}=super.exportDOM(b));if(b&&h.isHTMLElement(b)){this.isEmpty()&&b.append(document.createElement("br"));var a=this.getFormatType();b.style.textAlign=a;if(a=this.getDirection())b.dir=
+	a;}return {element:b}}static importJSON(b){let a=z();a.setFormat(b.format);a.setIndent(b.indent);a.setDirection(b.direction);return a}exportJSON(){return {...super.exportJSON(),type:"quote"}}insertNewAfter(b,a){b=k.$createParagraphNode();let d=this.getDirection();b.setDirection(d);this.insertAfter(b,a);return b}collapseAtStart(){let b=k.$createParagraphNode();this.getChildren().forEach(a=>b.append(a));this.replace(b);return  true}}function z(){return k.$applyNodeReplacement(new x)}
+	class B extends k.ElementNode{static getType(){return "heading"}static clone(b){return new B(b.__tag,b.__key)}constructor(b,a){super(a);this.__tag=b;}getTag(){return this.__tag}createDOM(b){let a=this.__tag,d=document.createElement(a);b=b.theme.heading;void 0!==b&&h.addClassNamesToElement(d,b[a]);return d}updateDOM(){return  false}static importDOM(){return {h1:()=>({conversion:C,priority:0}),h2:()=>({conversion:C,priority:0}),h3:()=>({conversion:C,priority:0}),h4:()=>({conversion:C,priority:0}),h5:()=>({conversion:C,
+	priority:0}),h6:()=>({conversion:C,priority:0}),p:b=>{b=b.firstChild;return null!==b&&D(b)?{conversion:()=>({node:null}),priority:3}:null},span:b=>D(b)?{conversion:()=>({node:E("h1")}),priority:3}:null}}exportDOM(b){({element:b}=super.exportDOM(b));if(b&&h.isHTMLElement(b)){this.isEmpty()&&b.append(document.createElement("br"));var a=this.getFormatType();b.style.textAlign=a;if(a=this.getDirection())b.dir=a;}return {element:b}}static importJSON(b){let a=E(b.tag);a.setFormat(b.format);a.setIndent(b.indent);
+	a.setDirection(b.direction);return a}exportJSON(){return {...super.exportJSON(),tag:this.getTag(),type:"heading",version:1}}insertNewAfter(b,a=true){let d=b?b.anchor.offset:0,e=d!==this.getTextContentSize()&&b?E(this.getTag()):k.$createParagraphNode(),f=this.getDirection();e.setDirection(f);this.insertAfter(e,a);0===d&&!this.isEmpty()&&b&&(b=k.$createParagraphNode(),b.select(),this.replace(b,true));return e}collapseAtStart(){let b=this.isEmpty()?k.$createParagraphNode():E(this.getTag());this.getChildren().forEach(a=>
+	b.append(a));this.replace(b);return  true}extractWithChild(){return  true}}function D(b){return "span"===b.nodeName.toLowerCase()?"26pt"===b.style.fontSize:false}function C(b){let a=b.nodeName.toLowerCase(),d=null;if("h1"===a||"h2"===a||"h3"===a||"h4"===a||"h5"===a||"h6"===a)d=E(a),null!==b.style&&d.setFormat(b.style.textAlign);return {node:d}}function y(b){let a=z();null!==b.style&&a.setFormat(b.style.textAlign);return {node:a}}function E(b){return k.$applyNodeReplacement(new B(b))}
+	function F(b,a){b.preventDefault();a.update(()=>{let d=k.$getSelection(),e=b instanceof InputEvent||b instanceof KeyboardEvent?null:b.clipboardData;null!=e&&null!==d&&c.$insertDataTransferForRichText(e,d,a);},{tag:"paste"});}async function G(b,a){await c.copyToClipboard(a,h.objectKlassEquals(b,ClipboardEvent)?b:null);a.update(()=>{let d=k.$getSelection();k.$isRangeSelection(d)?d.removeText():k.$isNodeSelection(d)&&d.getNodes().forEach(e=>e.remove());});}
+	function H(b){let a=null;b instanceof DragEvent?a=b.dataTransfer:b instanceof ClipboardEvent&&(a=b.clipboardData);if(null===a)return [false,[],false];var d=a.types;b=d.includes("Files");d=d.includes("text/html")||d.includes("text/plain");return [b,Array.from(a.files),d]}
+	function I(b){var a=k.$getSelection();if(!k.$isRangeSelection(a))return  false;let d=new Set;a=a.getNodes();for(let m=0;m<a.length;m++){var e=a[m],f=e.getKey();d.has(f)||(e=h.$getNearestBlockElementAncestorOrThrow(e),f=e.getKey(),e.canIndent()&&!d.has(f)&&(d.add(f),b(e)));}return 0<d.size}function J(b){b=k.$getNearestNodeFromDOMNode(b);return k.$isDecoratorNode(b)}LexicalRichText_prod.$createHeadingNode=E;LexicalRichText_prod.$createQuoteNode=z;LexicalRichText_prod.$isHeadingNode=function(b){return b instanceof B};
+	LexicalRichText_prod.$isQuoteNode=function(b){return b instanceof x};LexicalRichText_prod.DRAG_DROP_PASTE=w;LexicalRichText_prod.HeadingNode=B;LexicalRichText_prod.QuoteNode=x;LexicalRichText_prod.eventFiles=H;
+	LexicalRichText_prod.registerRichText=function(b){return h.mergeRegister(b.registerCommand(k.CLICK_COMMAND,()=>{const a=k.$getSelection();return k.$isNodeSelection(a)?(a.clear(),true):false},0),b.registerCommand(k.DELETE_CHARACTER_COMMAND,a=>{const d=k.$getSelection();if(!k.$isRangeSelection(d))return  false;d.deleteCharacter(a);return  true},k.COMMAND_PRIORITY_EDITOR),b.registerCommand(k.DELETE_WORD_COMMAND,a=>{const d=k.$getSelection();if(!k.$isRangeSelection(d))return  false;d.deleteWord(a);return  true},k.COMMAND_PRIORITY_EDITOR),
+	b.registerCommand(k.DELETE_LINE_COMMAND,a=>{const d=k.$getSelection();if(!k.$isRangeSelection(d))return  false;d.deleteLine(a);return  true},k.COMMAND_PRIORITY_EDITOR),b.registerCommand(k.CONTROLLED_TEXT_INSERTION_COMMAND,a=>{const d=k.$getSelection();if("string"===typeof a)null!==d&&d.insertText(a);else {if(null===d)return  false;const e=a.dataTransfer;null!=e?c.$insertDataTransferForRichText(e,d,b):k.$isRangeSelection(d)&&(a=a.data)&&d.insertText(a);}return  true},k.COMMAND_PRIORITY_EDITOR),b.registerCommand(k.REMOVE_TEXT_COMMAND,
+	()=>{const a=k.$getSelection();if(!k.$isRangeSelection(a))return  false;a.removeText();return  true},k.COMMAND_PRIORITY_EDITOR),b.registerCommand(k.FORMAT_TEXT_COMMAND,a=>{const d=k.$getSelection();if(!k.$isRangeSelection(d))return  false;d.formatText(a);return  true},k.COMMAND_PRIORITY_EDITOR),b.registerCommand(k.FORMAT_ELEMENT_COMMAND,a=>{var d=k.$getSelection();if(!k.$isRangeSelection(d)&&!k.$isNodeSelection(d))return  false;d=d.getNodes();for(const e of d)d=h.$findMatchingParent(e,f=>k.$isElementNode(f)&&!f.isInline()),
+	null!==d&&d.setFormat(a);return  true},k.COMMAND_PRIORITY_EDITOR),b.registerCommand(k.INSERT_LINE_BREAK_COMMAND,a=>{const d=k.$getSelection();if(!k.$isRangeSelection(d))return  false;d.insertLineBreak(a);return  true},k.COMMAND_PRIORITY_EDITOR),b.registerCommand(k.INSERT_PARAGRAPH_COMMAND,()=>{const a=k.$getSelection();if(!k.$isRangeSelection(a))return  false;a.insertParagraph();return  true},k.COMMAND_PRIORITY_EDITOR),b.registerCommand(k.INSERT_TAB_COMMAND,()=>{k.$insertNodes([k.$createTabNode()]);return  true},k.COMMAND_PRIORITY_EDITOR),
+	b.registerCommand(k.INDENT_CONTENT_COMMAND,()=>I(a=>{const d=a.getIndent();a.setIndent(d+1);}),k.COMMAND_PRIORITY_EDITOR),b.registerCommand(k.OUTDENT_CONTENT_COMMAND,()=>I(a=>{const d=a.getIndent();0<d&&a.setIndent(d-1);}),k.COMMAND_PRIORITY_EDITOR),b.registerCommand(k.KEY_ARROW_UP_COMMAND,a=>{var d=k.$getSelection();if(k.$isNodeSelection(d)&&!J(a.target)){if(a=d.getNodes(),0<a.length)return a[0].selectPrevious(),true}else if(k.$isRangeSelection(d)&&(d=k.$getAdjacentNode(d.focus,true),!a.shiftKey&&k.$isDecoratorNode(d)&&
+	!d.isIsolated()&&!d.isInline()))return d.selectPrevious(),a.preventDefault(),true;return  false},k.COMMAND_PRIORITY_EDITOR),b.registerCommand(k.KEY_ARROW_DOWN_COMMAND,a=>{var d=k.$getSelection();if(k.$isNodeSelection(d)){if(a=d.getNodes(),0<a.length)return a[0].selectNext(0,0),true}else if(k.$isRangeSelection(d)){let e=d.focus;if("root"===e.key&&e.offset===k.$getRoot().getChildrenSize())return a.preventDefault(),true;d=k.$getAdjacentNode(d.focus,false);if(!a.shiftKey&&k.$isDecoratorNode(d)&&!d.isIsolated()&&!d.isInline())return d.selectNext(),
+	a.preventDefault(),true}return  false},k.COMMAND_PRIORITY_EDITOR),b.registerCommand(k.KEY_ARROW_LEFT_COMMAND,a=>{const d=k.$getSelection();if(k.$isNodeSelection(d)){var e=d.getNodes();if(0<e.length)return a.preventDefault(),e[0].selectPrevious(),true}return k.$isRangeSelection(d)?g.$shouldOverrideDefaultCharacterSelection(d,true)?(e=a.shiftKey,a.preventDefault(),g.$moveCharacter(d,e,true),true):false:false},k.COMMAND_PRIORITY_EDITOR),b.registerCommand(k.KEY_ARROW_RIGHT_COMMAND,a=>{const d=k.$getSelection();if(k.$isNodeSelection(d)&&
+	!J(a.target)){var e=d.getNodes();if(0<e.length)return a.preventDefault(),e[0].selectNext(0,0),true}if(!k.$isRangeSelection(d))return  false;e=a.shiftKey;return g.$shouldOverrideDefaultCharacterSelection(d,false)?(a.preventDefault(),g.$moveCharacter(d,e,false),true):false},k.COMMAND_PRIORITY_EDITOR),b.registerCommand(k.KEY_BACKSPACE_COMMAND,a=>{if(J(a.target))return  false;const d=k.$getSelection();if(!k.$isRangeSelection(d))return  false;a.preventDefault();({anchor:a}=d);const e=a.getNode();return d.isCollapsed()&&0===a.offset&&
+	!k.$isRootNode(e)&&0<h.$getNearestBlockElementAncestorOrThrow(e).getIndent()?b.dispatchCommand(k.OUTDENT_CONTENT_COMMAND,void 0):b.dispatchCommand(k.DELETE_CHARACTER_COMMAND,true)},k.COMMAND_PRIORITY_EDITOR),b.registerCommand(k.KEY_DELETE_COMMAND,a=>{if(J(a.target))return  false;const d=k.$getSelection();if(!k.$isRangeSelection(d))return  false;a.preventDefault();return b.dispatchCommand(k.DELETE_CHARACTER_COMMAND,false)},k.COMMAND_PRIORITY_EDITOR),b.registerCommand(k.KEY_ENTER_COMMAND,a=>{const d=k.$getSelection();
+	if(!k.$isRangeSelection(d))return  false;if(null!==a){if((t||r||v)&&q)return  false;a.preventDefault();if(a.shiftKey)return b.dispatchCommand(k.INSERT_LINE_BREAK_COMMAND,false)}return b.dispatchCommand(k.INSERT_PARAGRAPH_COMMAND,void 0)},k.COMMAND_PRIORITY_EDITOR),b.registerCommand(k.KEY_ESCAPE_COMMAND,()=>{const a=k.$getSelection();if(!k.$isRangeSelection(a))return  false;b.blur();return  true},k.COMMAND_PRIORITY_EDITOR),b.registerCommand(k.DROP_COMMAND,a=>{const [,d]=H(a);if(0<d.length){var e=l(a.clientX,a.clientY);
+	if(null!==e){const {offset:m,node:K}=e;var f=k.$getNearestNodeFromDOMNode(K);if(null!==f){e=k.$createRangeSelection();if(k.$isTextNode(f))e.anchor.set(f.getKey(),m,"text"),e.focus.set(f.getKey(),m,"text");else {const A=f.getParentOrThrow().getKey();f=f.getIndexWithinParent()+1;e.anchor.set(A,f,"element");e.focus.set(A,f,"element");}e=k.$normalizeSelection__EXPERIMENTAL(e);k.$setSelection(e);}b.dispatchCommand(w,d);}a.preventDefault();return  true}a=k.$getSelection();return k.$isRangeSelection(a)?true:false},k.COMMAND_PRIORITY_EDITOR),
+	b.registerCommand(k.DRAGSTART_COMMAND,a=>{[a]=H(a);const d=k.$getSelection();return a&&!k.$isRangeSelection(d)?false:true},k.COMMAND_PRIORITY_EDITOR),b.registerCommand(k.DRAGOVER_COMMAND,a=>{var [d]=H(a);const e=k.$getSelection();if(d&&!k.$isRangeSelection(e))return  false;d=l(a.clientX,a.clientY);null!==d&&(d=k.$getNearestNodeFromDOMNode(d.node),k.$isDecoratorNode(d)&&a.preventDefault());return  true},k.COMMAND_PRIORITY_EDITOR),b.registerCommand(k.SELECT_ALL_COMMAND,()=>{k.$selectAll();return  true},k.COMMAND_PRIORITY_EDITOR),
+	b.registerCommand(k.COPY_COMMAND,a=>{c.copyToClipboard(b,h.objectKlassEquals(a,ClipboardEvent)?a:null);return  true},k.COMMAND_PRIORITY_EDITOR),b.registerCommand(k.CUT_COMMAND,a=>{G(a,b);return  true},k.COMMAND_PRIORITY_EDITOR),b.registerCommand(k.PASTE_COMMAND,a=>{const [,d,e]=H(a);return 0<d.length&&!e?(b.dispatchCommand(w,d),true):k.isSelectionCapturedInDecoratorInput(a.target)?false:null!==k.$getSelection()?(F(a,b),true):false},k.COMMAND_PRIORITY_EDITOR))};
+	return LexicalRichText_prod;
+}
+
+/**
+ * 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.
+ */
+
+var LexicalRichText_1;
+var hasRequiredLexicalRichText;
+
+function requireLexicalRichText () {
+	if (hasRequiredLexicalRichText) return LexicalRichText_1;
+	hasRequiredLexicalRichText = 1;
+	const LexicalRichText = process.env.NODE_ENV === 'development' ? requireLexicalRichText_dev() : requireLexicalRichText_prod();
+	LexicalRichText_1 = LexicalRichText;
+	return LexicalRichText_1;
+}
+
+var LexicalRichTextExports = requireLexicalRichText();
+
+const useEditorStyles = makeStyles()((theme, { hasFocus, hasContent, readOnly, hasCustomToolbar }) => ({
+    root: {
+        position: 'relative',
+        display: 'inline-flex',
+        flexDirection: hasCustomToolbar ? 'column-reverse' : 'column',
+        minWidth: '100%', // TODO
+    },
+    legend: {
+        position: 'absolute',
+        top: -5,
+        left: 0,
+        right: 0,
+        bottom: 0,
+        lineHeight: '11px',
+        zIndex: hasFocus ? 0 : 1,
+        paddingLeft: 10,
+        borderStyle: 'solid',
+        borderRadius: theme.shape.borderRadius,
+        borderWidth: hasFocus ? 2 : 1,
+        borderColor: hasFocus
+            ? theme.palette.primary.main
+            : hex2rgba('#000', 0.23),
+        '&:hover': {
+            borderColor: hasFocus
+                ? theme.palette.primary.main
+                : theme.palette.text.primary,
+        },
+        transition: theme.transitions.create(['border-color'], {
+            duration: theme.transitions.duration.shorter,
+            easing: theme.transitions.easing.easeOut,
+        }),
+    },
+    editor: {
+        padding: '.8rem 1rem',
+        position: 'relative',
+        zIndex: hasFocus || readOnly ? 1 : 0,
+        '& .unstyled': {
+            margin: '.5rem 0',
+        },
+    },
+    label: {
+        position: 'absolute',
+        top: 0,
+        left: 0,
+        zIndex: 1,
+        transform: hasFocus || hasContent
+            ? 'translate(6px, -14px) scale(0.75)'
+            : 'translate(6px, 12px) scale(1)',
+        transformOrigin: 'top left',
+        transition: theme.transitions.create(['color', 'transform'], {
+            duration: theme.transitions.duration.shorter,
+            easing: theme.transitions.easing.easeOut,
+        }),
+        color: hasFocus
+            ? theme.palette.primary[theme.palette.mode === 'light' ? 'dark' : 'light']
+            : theme.palette.text.secondary,
+        fontSize: '1.1428571428571428rem',
+        // hack @todo when time
+        backgroundColor: 'white',
+        padding: '2px 10px',
+    },
+    helpertext: {
+        margin: 0,
+        opacity: hasFocus ? 1 : 0,
+        transition: theme.transitions.create(['opacity'], {
+            duration: theme.transitions.duration.shorter,
+            easing: theme.transitions.easing.easeOut,
+        }),
+        fontSize: 'small',
+        // hack @todo when time
+        backgroundColor: 'white',
+        padding: '2px 10px',
+    },
+    charcount: {
+        margin: 0,
+        transition: theme.transitions.create(['opacity'], {
+            duration: theme.transitions.duration.shorter,
+            easing: theme.transitions.easing.easeOut,
+        }),
+        fontSize: 'small',
+        // hack @todo when time
+        backgroundColor: 'white',
+        padding: '2px 10px',
+    },
+}));
+
+function r(e){var t,f,n="";if("string"==typeof e||"number"==typeof e)n+=e;else if("object"==typeof e)if(Array.isArray(e)){var o=e.length;for(t=0;t<o;t++)e[t]&&(f=r(e[t]))&&(n&&(n+=" "),n+=f);}else for(f in e)e[f]&&(n&&(n+=" "),n+=f);return n}function clsx(){for(var e,t,f=0,n="",o=arguments.length;f<o;f++)(e=arguments[f])&&(t=r(e))&&(n&&(n+=" "),n+=t);return n}
+
+var LexicalUtilsExports = requireLexicalUtils();
+
+function StyleWrapperPlugin({ showCharcount, helperText, readOnly, classes, label, children, autoFocus, toolbarAnchor, hasCustomToolbar, }) {
+    const [editor] = useLexicalComposerContext();
+    const [hasFocus, setFocused] = useState(() => {
+        return editor.getRootElement() === document.activeElement;
+    });
+    const [charCount, setCharCount] = useState(0);
+    useEffect(() => {
+        return LexicalUtilsExports.mergeRegister(editor.registerCommand(BLUR_COMMAND, () => {
+            setFocused(editor.getRootElement() === document.activeElement);
+            return false;
+        }, COMMAND_PRIORITY_EDITOR), editor.registerCommand(FOCUS_COMMAND, () => {
+            setFocused(editor.getRootElement() === document.activeElement);
+            return false;
+        }, COMMAND_PRIORITY_EDITOR));
+    }, []);
+    const { classes: styles } = useEditorStyles({
+        hasFocus,
+        hasContent: charCount > 0,
+        readOnly,
+        hasCustomToolbar: hasCustomToolbar,
+    });
+    // Autofocus, makes sure the editor is focused as soon as it it rendered.
+    useEffect(() => {
+        autoFocus &&
+            editor.focus(() => {
+                const activeElement = document.activeElement;
+                const rootElement = editor.getRootElement();
+                if (rootElement !== null &&
+                    (activeElement === null || !rootElement.contains(activeElement))) {
+                    // Note: preventScroll won't work in Webkit.
+                    rootElement.focus({ preventScroll: true });
+                }
+            });
+    }, [autoFocus]);
+    useEffect(() => {
+        editor.registerTextContentListener((content) => {
+            // For some reason a newline "Enter" inserts two \n characters.
+            const newCount = content.replaceAll('\n\n', '\n').length;
+            setCharCount((prevCount) => {
+                return prevCount !== newCount ? newCount : prevCount;
             });
         });
     }, []);
@@ -11420,7 +14771,7 @@ const htmlExportMap = new Map([
         },
     ],
     [
-        wt,
+        LexicalRichTextExports.HeadingNode,
         (editor, node) => {
             const headingNode = node;
             const element = headingNode.createDOM(editor._config);
@@ -11484,7 +14835,7 @@ function ModifyPastePlugin({ blockPasting, stripPastedStyles, }) {
 function PreventNewlinesPlugin({ disableNewlines, }) {
     const [editor] = useLexicalComposerContext();
     if (disableNewlines) {
-        $(editor.registerNodeTransform(RootNode, (rootNode) => {
+        LexicalUtilsExports.mergeRegister(editor.registerNodeTransform(RootNode, (rootNode) => {
             if (rootNode.getChildrenSize() <= 1)
                 return;
             rootNode.getLastChild()?.remove();
@@ -11578,6 +14929,8 @@ function getDOMRangeRect(nativeSelection, rootElement) {
     return rect;
 }
 
+var LexicalSelectionExports = requireLexicalSelection();
+
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
@@ -11595,10 +14948,10 @@ function getSelectedNode(selection) {
     }
     const isBackward = selection.isBackward();
     if (isBackward) {
-        return b(focus) ? anchorNode : focusNode;
+        return LexicalSelectionExports.$isAtNodeEnd(focus) ? anchorNode : focusNode;
     }
     else {
-        return b(anchor) ? anchorNode : focusNode;
+        return LexicalSelectionExports.$isAtNodeEnd(anchor) ? anchorNode : focusNode;
     }
 }
 
@@ -11683,7 +15036,7 @@ function TextFormatFloatingToolbar({ editor, anchorElem, isBold, isItalic, butto
         editor.getEditorState().read(() => {
             updateTextFormatFloatingToolbar();
         });
-        return $(editor.registerUpdateListener(({ editorState }) => {
+        return LexicalUtilsExports.mergeRegister(editor.registerUpdateListener(({ editorState }) => {
             editorState.read(() => {
                 updateTextFormatFloatingToolbar();
             });
@@ -11749,7 +15102,7 @@ function useFloatingTextFormatToolbar(editor, anchorElem, buttons, CustomToolbar
         };
     }, [updatePopup]);
     useEffect(() => {
-        return $(editor.registerUpdateListener(() => {
+        return LexicalUtilsExports.mergeRegister(editor.registerUpdateListener(() => {
             updatePopup();
         }), editor.registerRootListener(() => {
             if (editor.getRootElement() === null) {
@@ -11776,6 +15129,8 @@ function FloatingTextFormatToolbarPlugin({ anchorElem, buttons, CustomToolbar, }
     return useFloatingTextFormatToolbar(editor, anchorElem, buttons, CustomToolbar);
 }
 
+var LexicalHtmlExports = requireLexicalHtml();
+
 function InsertDataPlugin({ html }) {
     const [editor] = useLexicalComposerContext();
     const parser = new DOMParser();
@@ -11786,7 +15141,7 @@ function InsertDataPlugin({ html }) {
         }
         const dom = parser.parseFromString(html, 'text/html');
         editor.update(() => {
-            const nodes = h(editor, dom);
+            const nodes = LexicalHtmlExports.$generateNodesFromDOM(editor, dom);
             $insertNodes(nodes);
         });
     }, []);
@@ -11809,12 +15164,12 @@ function HeadingPlugin({ html }) {
         // Only replace if tag is heading.
         if (tag) {
             editor.registerNodeTransform(ParagraphNode, (node) => {
-                node.replace(Tt(`${tag}`));
+                node.replace(LexicalRichTextExports.$createHeadingNode(`${tag}`));
             });
         }
         else {
             // Replace a heading with paragraph
-            editor.registerNodeTransform(wt, (node) => {
+            editor.registerNodeTransform(LexicalRichTextExports.HeadingNode, (node) => {
                 node.replace($createParagraphNode(), true);
             });
         }
@@ -11965,7 +15320,7 @@ function Editor({ html, label, classes, autoFocus, helperText, showCharCount, al
         theme,
         editable: !readOnly,
         onError,
-        nodes: [wt],
+        nodes: [LexicalRichTextExports.HeadingNode],
         html: {
             export: htmlExportMap,
         },
@@ -11976,7 +15331,7 @@ function Editor({ html, label, classes, autoFocus, helperText, showCharCount, al
             setFloatingAnchorElem(_floatingAnchorElem);
         }
     };
-    if (!editorRef) {
+    if (editorRef === undefined) {
         editorRef = useRef(null);
     }
     const canStyle = allowedStyles === undefined || allowedStyles.length > 0;
@@ -12003,13 +15358,8 @@ const GrepEditor = ({ ...props }) => {
 };
 
 const dimensions = {
-    breadcrumbsFontSize: 16,
-    contentWidth: 1028,
-    footerHeight: 50,
-    inputBoxHeight: 61,
     toolbarHeight: 80,
     toolbarHeightMobile: 40,
-    toolbarWidth: 1260,
     toolbarMenuWidth: 1028,
     toolbarMenuHeight: 50,
 };
@@ -12387,7 +15737,7 @@ const ConfirmationDialog = ({ open, title, description, warning, onSubmit, onCan
         React__default.createElement(DialogContent$1, null,
             React__default.createElement(DialogContentText$1, null, description)),
         React__default.createElement(DialogActions$1, null,
-            React__default.createElement(Button, { color: "primary", onClick: onCancel }, cancelText),
+            React__default.createElement(Button, { color: "inherit", onClick: onCancel }, cancelText),
             React__default.createElement(Button, { className: warning ? classes.discard : '', onClick: onSubmit }, confirmText))));
 };
 
@@ -12395,7 +15745,7 @@ const ConfirmationServiceContext = React__default.createContext(Promise.reject);
 const ConfirmationServiceProvider = ({ children, }) => {
     const [confirmationState, setConfirmationState] = React__default.useState(null);
     const [dialogOpen, setDialogOpen] = React__default.useState(false);
-    const awaitingPromiseRef = React__default.useRef(null);
+    const awaitingPromiseRef = React__default.useRef();
     const openDialog = (options) => {
         setConfirmationState(options);
         setDialogOpen(true);