@lexical/html 0.44.1-nightly.20260519.0 → 0.45.1-dev.0

package/LexicalHtml.dev.js

@@ -1,914 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
-
-'use strict';
-
-var selection = require('@lexical/selection');
-var lexical = require('lexical');
-var extension = require('@lexical/extension');
-
-/**
- * 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.
- *
- */
-
-// Do not require this module directly! Use normal `invariant` calls.
-
-function formatDevErrorMessage(message) {
-  throw new Error(message);
-}
-
-/**
- * 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.
- *
- */
-
-let activeContext;
-
-/**
- * @experimental
- *
- * The LexicalEditor with context
- */
-
-/**
- * @experimental
- *
- * @param contextRecord The ContextRecord
- * @param cfg The configuration
- * @returns The value or defaultValue of cfg
- */
-function getContextValue(contextRecord, cfg) {
-  const {
-    key
-  } = cfg;
-  return contextRecord && key in contextRecord ? contextRecord[key] : cfg.defaultValue;
-}
-function getEditorContext(editor) {
-  return activeContext && activeContext.editor === editor ? activeContext : undefined;
-}
-
-/**
- * @experimental
- *
- * @param sym The symbol for this ContextRecord (e.g. DOMRenderContextSymbol)
- * @param editor The editor
- * @returns The current context or undefined
- */
-function getContextRecord(sym, editor) {
-  const editorContext = getEditorContext(editor);
-  return editorContext && editorContext[sym];
-}
-function toPair(contextRecord, pairOrUpdater) {
-  if ('cfg' in pairOrUpdater) {
-    const {
-      cfg,
-      updater
-    } = pairOrUpdater;
-    return [cfg, updater(getContextValue(contextRecord, cfg))];
-  }
-  return pairOrUpdater;
-}
-
-/**
- * Construct a new context from a parent context and pairs
- *
- * @param pairs The pairs and updaters to build the context from
- * @param parent The parent context
- * @returns The new context
- */
-function contextFromPairs(pairs, parent) {
-  let rval = parent;
-  for (const pairOrUpdater of pairs) {
-    const [k, v] = toPair(rval, pairOrUpdater);
-    const key = k.key;
-    if (rval === parent && getContextValue(rval, k) === v) {
-      continue;
-    }
-    const ctx = rval || createChildContext(parent);
-    ctx[key] = v;
-    rval = ctx;
-  }
-  return rval;
-}
-function createChildContext(parent) {
-  return Object.create(parent || null);
-}
-
-/**
- * Create a context config pair that sets a value in the render context.
- * @experimental
- */
-function contextValue(cfg, value) {
-  return [cfg, value];
-}
-
-/**
- * Create a context config updater that transforms a value in the render context.
- * @experimental
- */
-function contextUpdater(cfg, updater) {
-  return {
-    cfg,
-    updater
-  };
-}
-
-/**
- * @internal
- * @experimental
- * @__NO_SIDE_EFFECTS__
- */
-function $withFullContext(sym, contextRecord, f, editor = lexical.$getEditor()) {
-  const prevDOMContext = activeContext;
-  const parentEditorContext = getEditorContext(editor);
-  try {
-    activeContext = {
-      ...parentEditorContext,
-      editor,
-      [sym]: contextRecord
-    };
-    return f();
-  } finally {
-    activeContext = prevDOMContext;
-  }
-}
-
-/**
- * @internal
- * @experimental
- * @__NO_SIDE_EFFECTS__
- */
-function $withContext(sym, $defaults = () => undefined) {
-  return (cfg, editor = lexical.$getEditor()) => {
-    return f => {
-      const parentEditorContext = getEditorContext(editor);
-      const parentContextRecord = parentEditorContext && parentEditorContext[sym];
-      const contextRecord = contextFromPairs(cfg, parentContextRecord || $defaults(editor));
-      if (!contextRecord || contextRecord === parentContextRecord) {
-        return f();
-      }
-      return $withFullContext(sym, contextRecord, f, editor);
-    };
-  };
-}
-
-/**
- * @experimental
- * @internal
- * @__NO_SIDE_EFFECTS__
- */
-function createContextState(tag, name, getDefaultValue, isEqual) {
-  return Object.assign(lexical.createState(Symbol(name), {
-    isEqual,
-    parse: getDefaultValue
-  }), {
-    [tag]: true
-  });
-}
-
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
-const DOMRenderExtensionName = '@lexical/html/DOM';
-const DOMRenderContextSymbol = Symbol.for('@lexical/html/DOMExportContext');
-const ALWAYS_TRUE = () => true;
-
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
-/**
- * Create a context state to be used during render.
- *
- * Note that to support the ValueOrUpdater pattern you can not use a
- * function for V (but you may wrap it in an array or object).
- *
- * @experimental
- * @__NO_SIDE_EFFECTS__
- */
-function createRenderState(name, getDefaultValue, isEqual) {
-  return createContextState(DOMRenderContextSymbol, name, getDefaultValue, isEqual);
-}
-
-/**
- * Render context state that is true if the export was initiated from the root of the document.
- * @experimental
- */
-const RenderContextRoot = createRenderState('root', Boolean);
-
-/**
- * Render context state that is true if this is an export operation ($generateHtmlFromNodes).
- * @experimental
- */
-const RenderContextExport = createRenderState('isExport', Boolean);
-function getDefaultRenderContext(editor) {
-  const dep = extension.getPeerDependencyFromEditor(editor, DOMRenderExtensionName);
-  return dep ? dep.output.defaults : undefined;
-}
-function getRenderContext(editor) {
-  return getContextRecord(DOMRenderContextSymbol, editor) || getDefaultRenderContext(editor);
-}
-
-/**
- * Get a render context value during a DOM render or export operation.
- * @experimental
- */
-function $getRenderContextValue(cfg, editor = lexical.$getEditor()) {
-  return getContextValue(getRenderContext(editor), cfg);
-}
-
-/**
- * Execute a callback within a render context with the given config pairs.
- * @experimental
- */
-const $withRenderContext = $withContext(DOMRenderContextSymbol, getDefaultRenderContext);
-
-/**
- * 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.
- *
- */
-
-/**
- * A convenience function for type inference when constructing DOM overrides for
- * use with {@link DOMRenderExtension}.
- *
- * @experimental
- * @__NO_SIDE_EFFECTS__
- */
-
-function domOverride(nodes, config) {
-  return {
-    ...config,
-    nodes
-  };
-}
-
-function buildTypeTree(editorConfig) {
-  const t = {};
-  const {
-    nodes
-  } = extension.getKnownTypesAndNodes(editorConfig);
-  for (const klass of nodes) {
-    const type = klass.getType();
-    t[type] = {
-      klass,
-      types: {}
-    };
-  }
-  for (const baseRec of Object.values(t)) {
-    if (baseRec) {
-      const baseType = baseRec.klass.getType();
-      for (let {
-        klass
-      } = baseRec; lexical.$isLexicalNode(klass.prototype); klass = Object.getPrototypeOf(klass)) {
-        const {
-          ownNodeType
-        } = lexical.getStaticNodeConfig(klass);
-        const superRec = ownNodeType && t[ownNodeType];
-        if (superRec) {
-          superRec.types[baseType] = true;
-        }
-      }
-    }
-  }
-  return t;
-}
-function buildNodePredicate(klass) {
-  return node => node instanceof klass;
-}
-function getPredicate(typeTree, {
-  nodes
-}) {
-  if (nodes === '*') {
-    return ALWAYS_TRUE;
-  }
-  let types = {};
-  const predicates = [];
-  for (const klassOrPredicate of nodes) {
-    if ('getType' in klassOrPredicate) {
-      const type = klassOrPredicate.getType();
-      if (types) {
-        const tree = typeTree[type];
-        if (!(tree !== undefined)) {
-          formatDevErrorMessage(`Node class ${klassOrPredicate.name} with type ${type} not registered in editor`);
-        }
-        types = Object.assign(types, tree.types);
-      }
-      predicates.push(buildNodePredicate(klassOrPredicate));
-    } else {
-      types = undefined;
-      predicates.push(klassOrPredicate);
-    }
-  }
-  if (types) {
-    return types;
-  } else if (predicates.length === 1) {
-    return predicates[0];
-  }
-  return node => {
-    for (const predicate of predicates) {
-      if (predicate(node)) {
-        return true;
-      }
-    }
-    return false;
-  };
-}
-function makePrerender() {
-  return {
-    $createDOM: [],
-    $decorateDOM: [],
-    $exportDOM: [],
-    $extractWithChild: [],
-    $getDOMSlot: [],
-    $shouldExclude: [],
-    $shouldInclude: [],
-    $updateDOM: []
-  };
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-
-function ignoreNext2(acc) {
-  return (node, _$next, editor) => acc(node, editor);
-}
-function ignoreNext3(acc) {
-  return (node, a, _$next, editor) => acc(node, a, editor);
-}
-function ignoreNext4(acc) {
-  return (node, a, b, _$next, editor) => acc(node, a, b, editor);
-}
-function ignoreNext5(acc) {
-  return (node, a, b, c, _$next, editor) => acc(node, a, b, c, editor);
-}
-function merge2($acc, $getOverride) {
-  return (node, editor) => {
-    const $next = () => $acc(node, editor);
-    const $override = $getOverride(node);
-    return $override ? $override(node, $next, editor) : $next();
-  };
-}
-function merge3(acc, $getOverride) {
-  return (node, a, editor) => {
-    const $next = () => acc(node, a, editor);
-    const $override = $getOverride(node);
-    return $override ? $override(node, a, $next, editor) : $next();
-  };
-}
-function merge4($acc, $getOverride) {
-  return (node, a, b, editor) => {
-    const $next = () => $acc(node, a, b, editor);
-    const $override = $getOverride(node);
-    return $override ? $override(node, a, b, $next, editor) : $next();
-  };
-}
-function merge5(acc, $getOverride) {
-  return (node, a, b, c, editor) => {
-    const $next = () => acc(node, a, b, c, editor);
-    const $override = $getOverride(node);
-    return $override ? $override(node, a, b, c, $next, editor) : $next();
-  };
-}
-function sequence4($acc, $getOverride) {
-  return (node, a, b, editor) => {
-    $acc(node, a, b, editor);
-    const $override = $getOverride(node);
-    if ($override) {
-      $override(node, a, b, editor);
-    }
-  };
-}
-function compilePrerenderKey(prerender, k, defaults, mergeFunction, ignoreNextFunction) {
-  let acc = defaults[k];
-  for (const pair of prerender[k]) {
-    if (typeof pair[0] === 'function') {
-      const [$predicate, $override] = pair;
-      acc = mergeFunction(acc, node => $predicate(node) && $override || undefined);
-    } else {
-      const typeOverrides = pair[1];
-      const compiled = {};
-      for (const type in typeOverrides) {
-        const arr = typeOverrides[type];
-        if (arr) {
-          compiled[type] = arr.reduce(($acc, $override) => mergeFunction($acc, () => $override), acc);
-        }
-      }
-      acc = mergeFunction(acc, node => {
-        const f = compiled[node.getType()];
-        return f && ignoreNextFunction(f);
-      });
-    }
-  }
-  defaults[k] = acc;
-}
-function addOverride(prerender, k, predicateOrTypes, override) {
-  if (!override) {
-    return;
-  }
-  const arr = prerender[k];
-  if (typeof predicateOrTypes === 'function') {
-    arr.push([predicateOrTypes, override]);
-  } else {
-    const last = arr[arr.length - 1];
-    let types;
-    if (last && last[0] === 'types') {
-      types = last[1];
-    } else {
-      types = {};
-      arr.push(['types', types]);
-    }
-    for (const type in predicateOrTypes) {
-      const typeArr = types[type] || [];
-      types[type] = typeArr;
-      typeArr.push(override);
-    }
-  }
-}
-function isWildcard(override) {
-  return override.nodes === '*';
-}
-function sortedOverrides(overrides) {
-  const byWildcard = [];
-  const byPredicate = [];
-  const byNode = [];
-  for (const override of overrides) {
-    if (isWildcard(override)) {
-      byWildcard.push(override);
-    } else if (Array.isArray(override.nodes)) {
-      for (const klassOrPredicate of override.nodes) {
-        if (lexical.$isLexicalNode(klassOrPredicate.prototype)) {
-          byNode.push(override.nodes.length === 1 ? override : {
-            ...override,
-            nodes: [klassOrPredicate]
-          });
-        } else {
-          byPredicate.push(override.nodes.length === 1 ? override : {
-            ...override,
-            nodes: [klassOrPredicate]
-          });
-        }
-      }
-    }
-  }
-  const depths = new Map();
-  const depthOf = klass => {
-    let depth = depths.get(klass);
-    if (depth === undefined) {
-      depth = 0;
-      for (let k = klass; lexical.$isLexicalNode(k.prototype); k = Object.getPrototypeOf(k)) {
-        depth++;
-      }
-      depths.set(klass, depth);
-    }
-    return depth;
-  };
-  byNode.sort((a, b) => depthOf(a.nodes[0]) - depthOf(b.nodes[0]));
-  return [...byNode, ...byPredicate, ...byWildcard];
-}
-function precompileDOMRenderConfigOverrides(editorConfig, overrides) {
-  const typeTree = buildTypeTree(editorConfig);
-  const prerender = makePrerender();
-  for (const override of sortedOverrides(overrides)) {
-    const predicateOrTypes = getPredicate(typeTree, override);
-    for (const k_ in prerender) {
-      const k = k_;
-      addOverride(prerender, k, predicateOrTypes, override[k]);
-    }
-  }
-  return prerender;
-}
-function identity(v) {
-  return v;
-}
-function compileDOMRenderConfigOverrides(editorConfig, {
-  overrides
-}) {
-  const prerender = precompileDOMRenderConfigOverrides(editorConfig, overrides);
-  const dom = {
-    ...lexical.DEFAULT_EDITOR_DOM_CONFIG,
-    ...editorConfig.dom
-  };
-  compilePrerenderKey(prerender, '$createDOM', dom, merge2, ignoreNext2);
-  compilePrerenderKey(prerender, '$exportDOM', dom, merge2, ignoreNext2);
-  compilePrerenderKey(prerender, '$extractWithChild', dom, merge5, ignoreNext5);
-  compilePrerenderKey(prerender, '$getDOMSlot', dom, merge3, ignoreNext3);
-  compilePrerenderKey(prerender, '$shouldExclude', dom, merge3, ignoreNext3);
-  compilePrerenderKey(prerender, '$shouldInclude', dom, merge3, ignoreNext3);
-  compilePrerenderKey(prerender, '$updateDOM', dom, merge4, ignoreNext4);
-  compilePrerenderKey(prerender, '$decorateDOM', dom, sequence4, identity);
-  return dom;
-}
-
-/**
- * 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.
- *
- */
-
-
-/**
- * @experimental
- *
- * An extension that allows overriding the render and export behavior for an
- * editor. This is highly experimental and subject to change from one version
- * to the next.
- **/
-const DOMRenderExtension = lexical.defineExtension({
-  build(editor, config, state) {
-    return {
-      defaults: contextFromPairs(config.contextDefaults, undefined)
-    };
-  },
-  config: {
-    contextDefaults: [],
-    overrides: []
-  },
-  html: {
-    // Define a RootNode export for $generateDOMFromRoot
-    export: new Map([[lexical.RootNode, () => {
-      const element = document.createElement('div');
-      element.role = 'textbox';
-      return {
-        element
-      };
-    }]])
-  },
-  init(editorConfig, config) {
-    editorConfig.dom = compileDOMRenderConfigOverrides(editorConfig, config);
-  },
-  mergeConfig(config, partial) {
-    const merged = lexical.shallowMergeConfig(config, partial);
-    for (const k of ['overrides', 'contextDefaults']) {
-      if (partial[k]) {
-        merged[k] = [...config[k], ...partial[k]];
-      }
-    }
-    return merged;
-  },
-  name: DOMRenderExtensionName
-});
-
-function isStyleRule(rule) {
-  return rule.constructor.name === CSSStyleRule.name;
-}
-
-/**
- * Inlines CSS rules from <style> tags onto matching elements as inline styles.
- * This is needed because apps like Excel generate HTML where styles live in
- * class-based <style> rules (e.g. `.xl65 { background: #FFFF00; color: blue; }`)
- * rather than inline styles. Since Lexical's import converters read inline styles,
- * we resolve stylesheet rules into inline styles before conversion.
- *
- * Mutates the DOM in-place. Original inline styles always take precedence over
- * stylesheet rules (matching CSS specificity behavior).
- */
-function inlineStylesFromStyleSheets(doc) {
-  if (doc.querySelector('style') === null) {
-    return;
-  }
-  const originalInlineStyles = new Map();
-  function getOriginalInlineProps(el) {
-    let props = originalInlineStyles.get(el);
-    if (props === undefined) {
-      props = new Set();
-      for (let i = 0; i < el.style.length; i++) {
-        props.add(el.style[i]);
-      }
-      originalInlineStyles.set(el, props);
-    }
-    return props;
-  }
-  try {
-    for (const sheet of Array.from(doc.styleSheets)) {
-      let rules;
-      try {
-        rules = sheet.cssRules;
-      } catch (_unused) {
-        continue;
-      }
-      for (const rule of Array.from(rules)) {
-        if (!isStyleRule(rule)) {
-          continue;
-        }
-        let elements;
-        try {
-          elements = doc.querySelectorAll(rule.selectorText);
-        } catch (_unused2) {
-          continue;
-        }
-        for (const el of Array.from(elements)) {
-          if (!lexical.isHTMLElement(el)) {
-            continue;
-          }
-          const originalProps = getOriginalInlineProps(el);
-          for (let i = 0; i < rule.style.length; i++) {
-            const prop = rule.style[i];
-            if (!originalProps.has(prop)) {
-              el.style.setProperty(prop, rule.style.getPropertyValue(prop), rule.style.getPropertyPriority(prop));
-            }
-          }
-        }
-      }
-    }
-  } catch (_unused3) {
-    // styleSheets API not supported in this environment
-  }
-}
-const IGNORE_TAGS = new Set(['STYLE', 'SCRIPT']);
-
-/**
- * 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 equivalent library and pass in the document here.
- */
-function $generateNodesFromDOM(editor, dom) {
-  if (lexical.isDOMDocumentNode(dom)) {
-    inlineStylesFromStyleSheets(dom);
-  }
-  const elements = lexical.isDOMDocumentNode(dom) ? dom.body.childNodes : dom.childNodes;
-  const lexicalNodes = [];
-  const allArtificialNodes = [];
-  for (const element of elements) {
-    if (!IGNORE_TAGS.has(element.nodeName)) {
-      const lexicalNode = $createNodesFromDOM(element, editor, allArtificialNodes, false);
-      if (lexicalNode !== null) {
-        for (const node of lexicalNode) {
-          lexicalNodes.push(node);
-        }
-      }
-    }
-  }
-  $unwrapArtificialNodes(allArtificialNodes);
-  return lexicalNodes;
-}
-
-/**
- * Generate DOM nodes from the editor state into the given container element,
- * using the editor's {@link EditorDOMRenderConfig}.
- * @experimental
- */
-function $generateDOMFromNodes(container, selection = null, editor = lexical.$getEditor()) {
-  return $withRenderContext([contextValue(RenderContextExport, true)], editor)(() => {
-    const root = lexical.$getRoot();
-    const domConfig = lexical.$getEditorDOMRenderConfig(editor);
-    const parentElementAppend = container.append.bind(container);
-    for (const topLevelNode of root.getChildren()) {
-      $appendNodesToHTML(editor, topLevelNode, parentElementAppend, selection, domConfig);
-    }
-    return container;
-  });
-}
-
-/**
- * Generate DOM nodes from a root node into the given container element,
- * including the root node itself. Uses the editor's {@link EditorDOMRenderConfig}.
- * @experimental
- */
-function $generateDOMFromRoot(container, root = lexical.$getRoot()) {
-  const editor = lexical.$getEditor();
-  return $withRenderContext([contextValue(RenderContextExport, true), contextValue(RenderContextRoot, true)], editor)(() => {
-    const selection = null;
-    const domConfig = lexical.$getEditorDOMRenderConfig(editor);
-    const parentElementAppend = container.append.bind(container);
-    $appendNodesToHTML(editor, root, parentElementAppend, selection, domConfig);
-    return container;
-  });
-}
-function $generateHtmlFromNodes(editor, selection = null) {
-  if (typeof document === 'undefined' || typeof window === 'undefined' && typeof global.window === 'undefined') {
-    {
-      formatDevErrorMessage(`To use $generateHtmlFromNodes in headless mode please initialize a headless browser implementation such as JSDom or use withDOM from @lexical/headless/dom before calling this function.`);
-    }
-  }
-  return $generateDOMFromNodes(document.createElement('div'), selection, editor).innerHTML;
-}
-function $appendNodesToHTML(editor, currentNode, parentElementAppend, selection$1 = null, domConfig = lexical.$getEditorDOMRenderConfig(editor)) {
-  let shouldInclude = domConfig.$shouldInclude(currentNode, selection$1, editor);
-  const shouldExclude = domConfig.$shouldExclude(currentNode, selection$1, editor);
-  let target = currentNode;
-  if (selection$1 !== null && lexical.$isTextNode(currentNode)) {
-    target = selection.$sliceSelectedTextNodeContent(selection$1, currentNode, 'clone');
-  }
-  const exportProps = domConfig.$exportDOM(target, editor);
-  const {
-    element,
-    after,
-    append,
-    $getChildNodes
-  } = exportProps;
-  if (!element) {
-    return false;
-  }
-  const fragment = document.createDocumentFragment();
-  const children = $getChildNodes ? $getChildNodes() : lexical.$isElementNode(target) ? target.getChildren() : [];
-  const fragmentAppend = fragment.append.bind(fragment);
-  for (const childNode of children) {
-    const shouldIncludeChild = $appendNodesToHTML(editor, childNode, fragmentAppend, selection$1, domConfig);
-    if (!shouldInclude && shouldIncludeChild && domConfig.$extractWithChild(currentNode, childNode, selection$1, 'html', editor)) {
-      shouldInclude = true;
-    }
-  }
-  if (shouldInclude && !shouldExclude) {
-    if (lexical.isHTMLElement(element) || lexical.isDocumentFragment(element)) {
-      if (append) {
-        append(fragment);
-      } else {
-        element.append(fragment);
-      }
-    }
-    parentElementAppend(element);
-    if (after) {
-      const newElement = after.call(target, element);
-      if (newElement) {
-        if (lexical.isDocumentFragment(element)) {
-          element.replaceChildren(newElement);
-        } else {
-          element.replaceWith(newElement);
-        }
-      }
-    }
-  } else {
-    parentElementAppend(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 ||
-      // Given equal priority, prefer the last registered importer
-      // which is typically an application custom node or HTMLConfig['import']
-      (currentConversion.priority || 0) <= (domConversion.priority || 0))) {
-        currentConversion = domConversion;
-      }
-    }
-  }
-  return currentConversion !== null ? currentConversion.conversion : null;
-}
-function $createNodesFromDOM(node, editor, allArtificialNodes, hasBlockAncestorLexicalNode, forChildMap = new Map(), parentLexicalNode) {
-  const 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 = [];
-  const hasBlockAncestorLexicalNodeForChildren = currentLexicalNode != null && lexical.$isRootOrShadowRoot(currentLexicalNode) ? false : currentLexicalNode != null && lexical.$isBlockElementNode(currentLexicalNode) || hasBlockAncestorLexicalNode;
-  for (let i = 0; i < children.length; i++) {
-    childLexicalNodes.push(...$createNodesFromDOM(children[i], editor, allArtificialNodes, hasBlockAncestorLexicalNodeForChildren, new Map(forChildMap), currentLexicalNode));
-  }
-  if (postTransform != null) {
-    childLexicalNodes = postTransform(childLexicalNodes);
-  }
-  if (lexical.isBlockDomNode(node)) {
-    if (!hasBlockAncestorLexicalNodeForChildren) {
-      childLexicalNodes = wrapContinuousInlines(node, childLexicalNodes, lexical.$createParagraphNode);
-    } else {
-      childLexicalNodes = wrapContinuousInlines(node, childLexicalNodes, () => {
-        const artificialNode = new lexical.ArtificialNode__DO_NOT_USE();
-        allArtificialNodes.push(artificialNode);
-        return artificialNode;
-      });
-    }
-  }
-  if (currentLexicalNode == null) {
-    if (childLexicalNodes.length > 0) {
-      // If it hasn't been converted to a LexicalNode, we hoist its children
-      // up to the same level as it.
-      for (const childNode of childLexicalNodes) {
-        lexicalNodes.push(childNode);
-      }
-    } else {
-      if (lexical.isBlockDomNode(node) && isDomNodeBetweenTwoInlineNodes(node)) {
-        // Empty block dom node that hasnt been converted, we replace it with a linebreak if its between inline nodes
-        lexicalNodes.push(lexical.$createLineBreakNode());
-      }
-    }
-  } 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;
-}
-function wrapContinuousInlines(domNode, nodes, createWrapperFn) {
-  const textAlign = domNode.style.textAlign;
-  const out = [];
-  let continuousInlines = [];
-  // wrap contiguous inline child nodes in para
-  for (let i = 0; i < nodes.length; i++) {
-    const node = nodes[i];
-    if (lexical.$isBlockElementNode(node)) {
-      if (textAlign && !node.getFormat()) {
-        node.setFormat(textAlign);
-      }
-      out.push(node);
-    } else {
-      continuousInlines.push(node);
-      if (i === nodes.length - 1 || i < nodes.length - 1 && lexical.$isBlockElementNode(nodes[i + 1])) {
-        const wrapper = createWrapperFn();
-        wrapper.setFormat(textAlign);
-        wrapper.append(...continuousInlines);
-        out.push(wrapper);
-        continuousInlines = [];
-      }
-    }
-  }
-  return out;
-}
-function $unwrapArtificialNodes(allArtificialNodes) {
-  // Replace artificial node with its children, inserting a linebreak
-  // between adjacent artificial nodes
-  for (const node of allArtificialNodes) {
-    if (node.getParent() && node.getNextSibling() instanceof lexical.ArtificialNode__DO_NOT_USE) {
-      node.insertAfter(lexical.$createLineBreakNode());
-    }
-  }
-  for (const node of allArtificialNodes) {
-    const parent = node.getParent();
-    if (parent) {
-      parent.splice(node.getIndexWithinParent(), 1, node.getChildren());
-    }
-  }
-}
-function isDomNodeBetweenTwoInlineNodes(node) {
-  if (node.nextSibling == null || node.previousSibling == null) {
-    return false;
-  }
-  return lexical.isInlineDomNode(node.nextSibling) && lexical.isInlineDomNode(node.previousSibling);
-}
-
-exports.$generateDOMFromNodes = $generateDOMFromNodes;
-exports.$generateDOMFromRoot = $generateDOMFromRoot;
-exports.$generateHtmlFromNodes = $generateHtmlFromNodes;
-exports.$generateNodesFromDOM = $generateNodesFromDOM;
-exports.$getRenderContextValue = $getRenderContextValue;
-exports.$withRenderContext = $withRenderContext;
-exports.DOMRenderExtension = DOMRenderExtension;
-exports.RenderContextExport = RenderContextExport;
-exports.RenderContextRoot = RenderContextRoot;
-exports.contextUpdater = contextUpdater;
-exports.contextValue = contextValue;
-exports.createRenderState = createRenderState;
-exports.domOverride = domOverride;