diff --git a/rust/DESIGN.md b/rust/DESIGN.md
index d34ffb52ac6..51778504c6d 100644
--- a/rust/DESIGN.md
+++ b/rust/DESIGN.md
@@ -165,6 +165,17 @@ model of jsdom's"), since the vectors record what jsdom does:
   Unlike jsdom it keeps most values it can't parse, collapsing their
   whitespace, as Swift's does; it rejects a shadow of nothing but
   identifiers, as jsdom does.
+- **The nodes' DOM hooks are `LexicalNode` methods** behind the feature:
+  `create_dom(this, config, editor)`, `export_dom(this, editor)` and
+  `import_dom()` (the class's static `importDOM`, read from a default
+  value when the class registers). Like the other hooks they get the
+  node's value and its handle, so an export can run on a value that isn't
+  in the editor state (the text a selection cuts short). The base classes'
+  behavior is the hooks' defaults (`TextNode` renders its text,
+  `ElementNode` adds the indent and direction), as for
+  `get_text_content`. The theme is the JSON of `EditorThemeClasses`
+  (`CreateEditorArgs.theme`), and a `DOMConversionMap` is a list of
+  name and importer pairs in the order JS's object keys would be.
 - **`DOMParser` is a WHATWG tokenizer and tree builder**, checked against
   jsdom's by the `html/parse` and `html/entities` vectors. As in Swift it
   leaves out templates, framesets, the `<select>` and `<ruby>` insertion
@@ -215,7 +226,7 @@ Each milestone ends with green CI and a report to the Space.
 | P | Desktop playgrounds (`apps/`): `lexical-playground-rune` on Rune, then `lexical-playground-gpui` on GPUI, sharing `lexical-playground-core`; they grow with each milestone below | the vectors, replayed in the app; a session exported from the app replays in JS (`replay.test.ts`); in CI, a GPUI session typed in a real window replays in JS | both apps run on macOS with typing, Return, deletion, formatting, input methods and the Parity panel; they grow with each milestone |
 | M2 | `rich-text` (headings, quotes, and the command handlers a text surface dispatches: typing, Enter, Backspace, formatting) and `history` (undo), which the playgrounds need first; then the node packages `list`, `link`, `code`, `overflow`, `hashtag`, with `selection` and `utils` | `serialization/*`, `property/documents` (JSON and text), `entities/hashtag-*`, `scripts/history` | done (every vector it names passes): `history` is done (`scripts/history` passes); `rich-text`'s nodes and `registerRichText`'s model command handlers are done (`scripts/rich-text` and `scripts/rich-text-commands` pass, with the heading and quote cases of `property/documents`); `plain-text`'s model command handlers are done (`scripts/plain-text` passes); `list`'s nodes, `registerList` and the model part of `registerCheckList` are done (`scripts/list` and `serialization/list` pass, with the list cases of `property/documents`); `link`'s nodes, `$toggleLink` and `registerLink`'s model handlers are done (`scripts/link` and `serialization/link` pass, with the link cases of `property/documents` that need no other package), `registerAutoLink` and its matchers are done behind `autolink` (`scripts/autolink` and `entities/autolink-match` pass); `selection`'s `$setBlocksType` is done (`scripts/set-blocks-type` passes); `code`'s nodes, `FlatStructureUtils.ts`, `CodeExtension`'s transform and `registerCodeIndentation`'s model handlers are done (`scripts/code` and `serialization/code` pass, with the code cases of `property/documents` that need no other package); `overflow`'s `OverflowNode` is done (`scripts/overflow` and `serialization/overflow` pass, with the overflow cases of `property/documents` that need no other package); `hashtag`'s `HashtagNode`, its matcher (generated character tables, no `regex`) and `registerLexicalHashtag`, with `text`'s `registerLexicalTextEntity`, are done (`entities/hashtag-match`, `entities/hashtag-documents` and `entities/hashtag-typing` pass, with the last waiting cases of `property/documents`), so M2's node packages are done |
 | M3 | The commands `property/sequences` dispatches | `property/sequences` | |
-| M4 | `html`: a DOM abstraction over an HTML parser, CSS declarations, export and import | `html/*`, `css/*`, `property/documents` (HTML) | in progress: the DOM (`dom`: nodes, `DOMParser`, the serializer, the inline style declaration and its tables) and `getStyleObjectFromCSS` are done (`html/parse`, `html/entities`, `css/properties` and `css/values` pass); next, the core nodes' DOM hooks and `@lexical/html`'s export and import |
+| M4 | `html`: a DOM abstraction over an HTML parser, CSS declarations, export and import | `html/*`, `css/*`, `property/documents` (HTML) | in progress: the DOM (`dom`: nodes, `DOMParser`, the serializer, the inline style declaration and its tables), `getStyleObjectFromCSS`, the core nodes' DOM hooks and `@lexical/html`'s export and import are done (every `html/*` and `css/*` file passes); next, the node packages' DOM parts (list, link, code, overflow, hashtag, rich text, the decorators) and `property/documents`' HTML |
 | M5 | `markdown` | `markdown/import-export`, `property/documents` (Markdown) | |
 | M6 | `yjs`: a port of `@lexical/yjs` on `yrs` (behind the feature), with new JS vectors for the binding (sevki/lexical-rs's `lexical-yjs` and jpcamara/yrby's `lexical-yjs-html` only as cross-checks) | the new collab vectors | |
 | M7 | Releases: the mirror, changesets, a name tmm settles | | |
diff --git a/rust/PARITY.md b/rust/PARITY.md
index bb4c097cc4c..5bcf62d8837 100644
--- a/rust/PARITY.md
+++ b/rust/PARITY.md
@@ -47,6 +47,8 @@ updated with each milestone.
 | `registerLexicalTextEntity` (the `text` feature) | `packages/lexical-text/src/registerLexicalTextEntity.ts`: `EntityMatch`, `registerLexicalTextEntity` (the `TextNode` transform and `$reverseNodeTransform`, `$replaceWithSimpleText`, `$wasTurnedIntoText`, `getFirstMatchAfter`, `isNextTextEntity`, `isTextAfterOutsideSource`, `isEntityAfter`, `$checkNextSibling`, `$moveSelectionIntoEntity`, `$wouldMerge`, `MAX_MATCHES_PASSED`, `MAX_TURNED_INTO_TEXT`, the per-update `markedInUpdate` and `turnedIntoTextInUpdate`); from the core `INTERNAL_getActiveEditorState` | `text`, `updates` | `entities/hashtag-documents`, `entities/hashtag-typing` |
 | `$setBlocksType` (the `selection` feature) | `packages/lexical-selection/src/range-selection.ts` (`$setBlocksType`, with its default `$afterCreateElement`, `$copyBlockFormatIndent`, and `$isPointAtBlockEdge`), through `LexicalNode.replace` and `ListItemNode.replace` | `selection` | `scripts/set-blocks-type`, the block-decorator case of `scripts/decorator` |
 | The DOM (the `html` feature) | what a browser or jsdom gives JS: `Node` (`nodeType`, `nodeName`, `parentNode`, `childNodes`, siblings, `textContent`, `insertBefore`, `appendChild`, `append`, `prepend`, `removeChild`, `replaceChild`, `remove`, `replaceWith`, `replaceChildren`, `contains`, `cloneNode`), `Element` (attributes in order, `id`, `dir`, `className`, `classList`, `style`, `innerHTML`, `outerHTML`, `getElementsByTagName`), `Text`, `Comment`, `DocumentFragment`, `Document` (`createElement` and the other factories, `head`, `body`), `DOMTokenList`, `CSSStyleDeclaration` (`setProperty`, `getPropertyValue`, `getPropertyPriority`, `removeProperty`, `cssText`, `item`) with jsdom's normalization, `DOMParser.parseFromString`, the HTML fragment serialization algorithm; ported from the Swift port's `DOM/` | `dom` | `html/parse`, `html/entities`, `css/properties`, `css/values` |
+| Core DOM hooks (the `html` feature) | `LexicalNode.createDOM`, `exportDOM` and the static `importDOM` as node hooks (`create_dom`, `export_dom`, `import_dom`), `ElementNode.exportDOM` (indent as `padding-inline-start` and `data-lexical-indent`, `dir`); `DOMExportOutput`, `DOMConversionOutput`, `DOMChildConversion`, `DOMConversion`, `DOMConversionFn`, `DOMConversionMap`; `createEditor`'s `theme` and `html` (`export` overrides, `import` conversions), `editor._config`, `initializeConversionCache`; `DEFAULT_EDITOR_DOM_CONFIG` (`$createDOM`, `$exportDOM`, `$extractWithChild`, `$shouldExclude`, `$shouldInclude`); `LexicalNode.isSelected`; `TextNode` (`createDOM` with `getElementOuterTag`, `getElementInnerTag`, `$createTextInnerDOM` and `setTextThemeClassNames`; `exportDOM`; `importDOM` with `$convertTextDOMNode`, `findParentPreDOMNode`, `findTextInLine`, `convertSpanElement`, `convertBringAttentionToElement`, `convertTextFormatElement`, `applyTextFormatFromStyle`), `TabNode.createDOM`, `LineBreakNode` (`createDOM`, `importDOM`), `ParagraphNode` (`createDOM`, `exportDOM`, `importDOM` with `$convertParagraphElement`, `extractWithChild`), `ArtificialNode__DO_NOT_USE`; from `LexicalUtils.ts` `isInlineDomNode`, `isBlockDomNode`, `getCachedClassNameArray`, `removeEmptyDOMAttribute`, `setNodeIndentFromDOM`, `$setDirectionFromDOM`, `$setFormatFromDOM`, `isOnlyChildInBlockNode`, `isLastChildInBlockNode`; `utils/classNames.ts` | `lexical_dom`, `node`, `nodes::*`, `editor` | `html/export`, `html/import` |
+| `@lexical/html` (the `html` feature) | `packages/lexical-html/src/index.ts`: `$generateHtmlFromNodes`, `$generateDOMFromNodes`, `$generateDOMFromRoot`, `$appendNodeToHTML` (`$appendNodesToHTML` with `$appendTerminatingLineBreak`, and `@lexical/selection`'s `$sliceSelectedTextNodeContent` for a selection), `$generateNodesFromDOM` (`IGNORE_TAGS`, `getConversionFunction`, `$createNodesFromDOM`, `wrapContinuousInlines`, `$unwrapArtificialNodes`, `isDomNodeBetweenTwoInlineNodes`) | `html` | `html/export`, `html/import` |
 | Inline CSS text | `utils/setDOMStyle.ts` (`getStyleObjectFromCSS`, with JS's property order; with the `html` feature `setDOMStyleObject` and `setDOMStyleFromCSS`) | `set_dom_style` | through `css/values`; unit tests against JS's output |
 | UTF-16 offsets | `String#length`, `String#slice` | `utf16` | through the text methods; unit tests against Node |
 | Upstream version | `meta.json` | `UPSTREAM_VERSION` | `meta` |
@@ -133,9 +135,9 @@ touches:
   DOM. What `NodeStructureExtension` does for links where it enforces node
   structure (lifting blocks, merging equal adjacent links, which
   `$linkNodeTransform` then leaves to it) isn't ported, so the transform
-  always does both. `extractWithChild` is a node hook that nothing calls
-  yet: its caller is `@lexical/html`'s copy. `HeadingNode`'s override is
-  ported; `ParagraphNode`'s, which reads the selection, comes with `html`. In a headless editor,
+  always does both. `extractWithChild` is a node hook that `@lexical/html`'s
+  export calls (the `html` feature). `HeadingNode`'s override is
+  ported, and so is `ParagraphNode`'s, which reads the selection. In a headless editor,
   `LinkNode.canInsertTextBefore` and `canInsertTextAfter` change nothing a
   vector can see: `insertText` at the edge of an inline parent's text puts
   the text outside the parent either way, and
@@ -234,6 +236,16 @@ touches:
   its blocks) is ported but no vector reaches it: headless JS needs the
   DOM's `Selection.modify` to get there and throws, which `scripts/rich-text`
   records.
+- Of `@lexical/html` and the core's DOM side (the `html` feature): the
+  `DOMImportExtension` and `DOMRenderExtension` pipelines (import rules,
+  `CoreImportRules`, selectors, the render context and render config
+  overrides), `BlockIdHTMLExtension`, and `$inlineStylesFromStyleSheets`,
+  which needs a CSS parser and a selector engine (Swift's leans on its
+  import-rule selectors); `$generateNodesFromDOM` leaves `<style>` rules
+  alone, where JS would copy their declarations onto the elements they
+  match. No vector has a `<style>`. Also `updateDOM`, `getDOMSlot` and the
+  rest of what only the reconciler calls, and `$setTextContent`'s
+  composition suffix (nothing composes headless).
 - Composition, the DOM reconciler, mutation listeners, selection-change
   notifications and `$onUpdate` callbacks (none of which a headless editor
   runs, except `$onUpdate`), and `RootNode.__cachedText`. So `history` passes
diff --git a/rust/conformance/src/scripts.rs b/rust/conformance/src/scripts.rs
index 6aaa5b6e334..c4771df75f9 100644
--- a/rust/conformance/src/scripts.rs
+++ b/rust/conformance/src/scripts.rs
@@ -1082,7 +1082,10 @@ impl Session {
         if with_extension {
             nodes.extend(lexical::extension::extension_nodes());
         }
-        let editor = create_editor(CreateEditorArgs { nodes });
+        let editor = create_editor(CreateEditorArgs {
+            nodes,
+            ..Default::default()
+        });
         let ctx = Rc::new(Ctx::default());
         if rich_text {
             let _unregister = lexical::rich_text::register_rich_text(&editor);
diff --git a/rust/conformance/src/suites/entities.rs b/rust/conformance/src/suites/entities.rs
index b6a0eac2bab..c875e722c64 100644
--- a/rust/conformance/src/suites/entities.rs
+++ b/rust/conformance/src/suites/entities.rs
@@ -61,6 +61,7 @@ pub fn check_hashtag_match(case: &Value, _file: &Value) -> Result<Outcome, Strin
 fn build() -> Editor {
     let editor = create_editor(CreateEditorArgs {
         nodes: hashtag_nodes(),
+        ..Default::default()
     });
     let _unregister = register_lexical_hashtag(&editor, HashtagConfig::default());
     editor
diff --git a/rust/conformance/src/suites/html.rs b/rust/conformance/src/suites/html.rs
index 00665f88cd8..3d9a9aa2ac8 100644
--- a/rust/conformance/src/suites/html.rs
+++ b/rust/conformance/src/suites/html.rs
@@ -1,6 +1,10 @@
 use crate::case::{Case, Outcome, same};
 use lexical::dom::{DomNode, is_legacy_entity_name, named_entity, parse_from_string};
+use lexical::html::{generate_html_from_nodes, generate_nodes_from_dom};
 use lexical::json::Value;
+use lexical::{CreateEditorArgs, NodeRef, UpdateOptions, create_editor};
+use std::cell::RefCell;
+use std::rc::Rc;
 
 /// `html/parse`: `DOMParser` builds the same document as jsdom's, compared
 /// by the `innerHTML` of its head and body.
@@ -46,3 +50,66 @@ pub fn check_entity(case: &Value, file: &Value) -> Result<Outcome, String> {
     same("textContent", body.text_content(), expected)?;
     Ok(Outcome::Pass)
 }
+
+/// `html/export`: `$generateHtmlFromNodes` writes the HTML jsdom gave for
+/// the document, with the case's theme.
+pub fn check_export(case: &Value, _file: &Value) -> Result<Outcome, String> {
+    let theme = match case.get("theme") {
+        Some(Value::Object(theme)) => theme.clone(),
+        _ => lexical::json::Object::new(),
+    };
+    let editor = create_editor(CreateEditorArgs {
+        theme,
+        ..Default::default()
+    });
+    let state = editor
+        .parse_editor_state(case.str("editorState")?)
+        .map_err(|e| format!("editorState: {e}"))?;
+    editor
+        .set_editor_state(&state, None)
+        .map_err(|e| e.to_string())?;
+    let html = editor
+        .read(|| generate_html_from_nodes(&editor, None))
+        .and_then(|html| html)
+        .map_err(|e| e.to_string())?;
+    same("html", html.as_str(), case.str("html")?)?;
+    Ok(Outcome::Pass)
+}
+
+/// A node and its subtree as JSON, as `exportJSON` writes each node
+/// (`$nodeToJSON`).
+fn node_to_json(node: &NodeRef) -> Value {
+    let mut json = node.export_json(false);
+    if node.is_element() {
+        json.insert(
+            "children",
+            Value::Array(node.get_children().iter().map(node_to_json).collect()),
+        );
+    }
+    Value::Object(json)
+}
+
+/// `html/import`: `$generateNodesFromDOM` makes the nodes jsdom's import
+/// made of the parsed HTML.
+pub fn check_import(case: &Value, _file: &Value) -> Result<Outcome, String> {
+    let editor = create_editor(CreateEditorArgs::default());
+    let dom = parse_from_string(case.str("html")?);
+    let nodes = Rc::new(RefCell::new(String::new()));
+    let (out, update_editor) = (nodes.clone(), editor.clone());
+    editor
+        .update(
+            move || {
+                let nodes = generate_nodes_from_dom(&update_editor, &dom)?;
+                *out.borrow_mut() =
+                    Value::Array(nodes.iter().map(node_to_json).collect()).to_string();
+                Ok(())
+            },
+            UpdateOptions {
+                discrete: true,
+                ..UpdateOptions::default()
+            },
+        )
+        .map_err(|e| e.to_string())?;
+    same("nodes", nodes.borrow().as_str(), case.str("nodes")?)?;
+    Ok(Outcome::Pass)
+}
diff --git a/rust/conformance/src/suites/mod.rs b/rust/conformance/src/suites/mod.rs
index 43f7c484d43..779ed3dcd05 100644
--- a/rust/conformance/src/suites/mod.rs
+++ b/rust/conformance/src/suites/mod.rs
@@ -32,6 +32,16 @@ pub fn all() -> Vec<Suite> {
             variant: None,
             check: html::check_entity,
         },
+        Suite {
+            file: "html/export",
+            variant: None,
+            check: html::check_export,
+        },
+        Suite {
+            file: "html/import",
+            variant: None,
+            check: html::check_import,
+        },
         Suite {
             file: "html/parse",
             variant: None,
diff --git a/rust/conformance/src/suites/property.rs b/rust/conformance/src/suites/property.rs
index 353f2d5d4cb..f8d51d308ee 100644
--- a/rust/conformance/src/suites/property.rs
+++ b/rust/conformance/src/suites/property.rs
@@ -38,6 +38,7 @@ pub fn check_document(case: &Value, _file: &Value) -> Result<Outcome, String> {
             lexical::hashtag::hashtag_nodes(),
         ]
         .concat(),
+        ..Default::default()
     });
     let parsed = editor.parse_editor_state(input);
     if case.get("error").is_some() {
diff --git a/rust/conformance/src/suites/serialization.rs b/rust/conformance/src/suites/serialization.rs
index 5f9c8c50f5c..ad0dd33be57 100644
--- a/rust/conformance/src/suites/serialization.rs
+++ b/rust/conformance/src/suites/serialization.rs
@@ -17,6 +17,7 @@ pub fn check(case: &Value, _file: &Value) -> Result<Outcome, String> {
             lexical::hashtag::hashtag_nodes(),
         ]
         .concat(),
+        ..Default::default()
     });
     for (form, input) in [("legacy", legacy), ("compact", compact)] {
         let state = editor
diff --git a/rust/lexical-editor/src/code/flat_structure_utils.rs b/rust/lexical-editor/src/code/flat_structure_utils.rs
index aa69aabc4e7..e9ce56b5529 100644
--- a/rust/lexical-editor/src/code/flat_structure_utils.rs
+++ b/rust/lexical-editor/src/code/flat_structure_utils.rs
@@ -302,6 +302,7 @@ mod tests {
         reset_random_key();
         let editor = create_editor(CreateEditorArgs {
             nodes: code_nodes(),
+            ..Default::default()
         });
         editor
             .update(
diff --git a/rust/lexical-editor/src/editor.rs b/rust/lexical-editor/src/editor.rs
index 15202dd3b5f..5094b3dbcd7 100644
--- a/rust/lexical-editor/src/editor.rs
+++ b/rust/lexical-editor/src/editor.rs
@@ -8,8 +8,8 @@ use crate::lexical_utils::set_node_key;
 use crate::node::{LexicalNode, NodeKey, NodeRef};
 use crate::node_state::{RequiredNodeStateConfig, SharedNodeState, create_shared_node_state};
 use crate::nodes::{
-    line_break::LineBreakNode, paragraph::ParagraphNode, root::RootNode, tab::TabNode,
-    text::TextNode,
+    artificial::ArtificialNode, line_break::LineBreakNode, paragraph::ParagraphNode,
+    root::RootNode, tab::TabNode, text::TextNode,
 };
 use crate::ordered::{OrderedMap, OrderedSet};
 use crate::selection_deletion::SelectionMovement;
@@ -32,6 +32,14 @@ pub struct NodeClass {
     pub(crate) import_json: fn(&Object) -> Result<NodeRef, LexicalError>,
     /// The `stateConfigs` of the class's `$config`.
     pub(crate) state_configs: fn() -> Vec<RequiredNodeStateConfig>,
+    /// The class's own static `importDOM` (`None` when it inherits one).
+    #[cfg(feature = "html")]
+    pub(crate) import_dom: fn() -> Option<crate::lexical_dom::DomConversionMap>,
+}
+
+#[cfg(feature = "html")]
+fn import_dom_of<T: LexicalNode + Default>() -> Option<crate::lexical_dom::DomConversionMap> {
+    T::default().import_dom()
 }
 
 fn state_configs_of<T: LexicalNode + Default>() -> Vec<RequiredNodeStateConfig> {
@@ -54,6 +62,8 @@ impl NodeClass {
             node_type: T::default().get_type(),
             import_json: import_default::<T>,
             state_configs: state_configs_of::<T>,
+            #[cfg(feature = "html")]
+            import_dom: import_dom_of::<T>,
         }
     }
 
@@ -66,6 +76,8 @@ impl NodeClass {
             node_type,
             import_json,
             state_configs: Vec::new,
+            #[cfg(feature = "html")]
+            import_dom: || None,
         }
     }
 
@@ -100,10 +112,26 @@ pub const COMPOSITION_START_TAG: &str = "composition-start";
 /// method composition.
 pub const COMPOSITION_END_TAG: &str = "composition-end";
 
-/// `CreateEditorArgs`: the node classes to register besides the core ones.
+/// `CreateEditorArgs`: the node classes to register besides the core ones,
+/// the theme, and (with the `html` feature) the HTML import and export
+/// overrides.
 #[derive(Clone, Default)]
 pub struct CreateEditorArgs {
     pub nodes: Vec<NodeClass>,
+    /// `theme`: class names by node kind (`EditorThemeClasses`), as JSON:
+    /// a string or an array of strings, or (for `text`) an object of them
+    /// by format.
+    pub theme: Object,
+    /// `html`: export overrides by node type and extra import conversions.
+    #[cfg(feature = "html")]
+    pub html: crate::lexical_dom::HtmlConfig,
+}
+
+/// `EditorConfig` (`editor._config`): what `createDOM` reads.
+#[derive(Clone, Debug, Default)]
+pub struct EditorConfig {
+    /// `theme`.
+    pub theme: Object,
 }
 
 /// `EditorUpdateOptions`. `onUpdate` and `event` come with their users.
@@ -266,10 +294,19 @@ pub(crate) struct EditorInner {
     next_id: Cell<u64>,
     /// Stands in for the DOM's `Selection.modify` (no JS field).
     selection_movement: RefCell<Option<Rc<dyn SelectionMovement>>>,
+    /// `_config`.
+    config: EditorConfig,
+    /// `_htmlConversions`: the import conversions by lower-case DOM node
+    /// name, in registration order.
+    #[cfg(feature = "html")]
+    pub(crate) html_conversions: HashMap<String, Vec<crate::lexical_dom::DomImporter>>,
+    /// The `exportDOM` overrides of `html.export`, by node type.
+    #[cfg(feature = "html")]
+    pub(crate) html_export: HashMap<&'static str, crate::lexical_dom::ExportOverride>,
 }
 
 /// `createEditor(config)`: registers the core nodes (root, text, line
-/// break, tab, paragraph) and `args.nodes`.
+/// break, tab, paragraph, artificial) and `args.nodes`.
 pub fn create_editor(args: CreateEditorArgs) -> Editor {
     let core = [
         NodeClass::with_import_json("root", RootNode::import_json),
@@ -277,10 +314,14 @@ pub fn create_editor(args: CreateEditorArgs) -> Editor {
         NodeClass::of::<LineBreakNode>(),
         NodeClass::of::<TabNode>(),
         NodeClass::of::<ParagraphNode>(),
+        NodeClass::of::<ArtificialNode>(),
     ];
-    let nodes: HashMap<&'static str, NodeClass> = core
+    let ordered: Vec<NodeClass> = core.into_iter().chain(args.nodes).collect();
+    #[cfg(feature = "html")]
+    let html_conversions =
+        crate::lexical_dom::initialize_conversion_cache(&ordered, &args.html.import);
+    let nodes: HashMap<&'static str, NodeClass> = ordered
         .into_iter()
-        .chain(args.nodes)
         .map(|class| (class.node_type, class))
         .collect();
     let shared_node_states = nodes
@@ -307,10 +348,20 @@ pub fn create_editor(args: CreateEditorArgs) -> Editor {
         commands: RefCell::new(HashMap::new()),
         next_id: Cell::new(1),
         selection_movement: RefCell::new(None),
+        config: EditorConfig { theme: args.theme },
+        #[cfg(feature = "html")]
+        html_conversions,
+        #[cfg(feature = "html")]
+        html_export: args.html.export.into_iter().collect(),
     }))
 }
 
 impl Editor {
+    /// `editor._config`.
+    pub fn config(&self) -> &EditorConfig {
+        &self.0.config
+    }
+
     pub(crate) fn registered_nodes(&self) -> &HashMap<&'static str, NodeClass> {
         &self.0.nodes
     }
diff --git a/rust/lexical-editor/src/html.rs b/rust/lexical-editor/src/html.rs
new file mode 100644
index 00000000000..f8183dfa3e8
--- /dev/null
+++ b/rust/lexical-editor/src/html.rs
@@ -0,0 +1,447 @@
+//! `@lexical/html` (the `html` feature): HTML from an editor state
+//! ([`generate_html_from_nodes`]) and Lexical nodes from a DOM
+//! ([`generate_nodes_from_dom`]), through the nodes' `exportDOM` and
+//! `importDOM` and the editor's `html` config. The DOM is
+//! [`crate::dom`]; parse HTML into it with [`crate::dom::parse_from_string`].
+//!
+//! From `packages/lexical-html/src/index.ts`. Not ported: the
+//! `DOMImportExtension` and `DOMRenderExtension` pipelines and their rules,
+//! the render context, and `$inlineStylesFromStyleSheets`, which needs a CSS
+//! selector engine (rust/PARITY.md).
+
+use crate::dom::DomNode;
+use crate::lexical_dom::{
+    DomChildConversion, DomConversionNode, export_dom, extract_with_child, get_conversion_function,
+    get_document, is_block_dom_node, is_inline_dom_node, should_exclude, should_include,
+};
+use crate::lexical_selection::SelectionRef;
+use crate::node::{LexicalNode, NodeRef};
+use crate::nodes::artificial::{create_artificial_node, is_artificial_node};
+use crate::nodes::line_break::create_line_break_node;
+use crate::nodes::paragraph::create_paragraph_node;
+use crate::{Editor, LexicalError, get_root};
+use std::rc::Rc;
+
+/// `IGNORE_TAGS`.
+const IGNORE_TAGS: [&str; 2] = ["STYLE", "SCRIPT"];
+
+/// `$generateNodesFromDOM(editor, dom)`: the Lexical nodes for a document's
+/// body (or a node's children), made by the editor's import conversions.
+/// Inline content outside a block goes into paragraphs. Call it inside an
+/// update.
+pub fn generate_nodes_from_dom(
+    editor: &Editor,
+    dom: &DomNode,
+) -> Result<Vec<NodeRef>, LexicalError> {
+    let elements = if dom.is_document() {
+        dom.body().map(|b| b.child_nodes()).unwrap_or_default()
+    } else {
+        dom.child_nodes()
+    };
+    let mut lexical_nodes = Vec::new();
+    let mut all_artificial_nodes = Vec::new();
+    for element in elements {
+        if !IGNORE_TAGS.contains(&element.node_name().as_str()) {
+            lexical_nodes.extend(create_nodes_from_dom(
+                &element,
+                editor,
+                &mut all_artificial_nodes,
+                false,
+                ForChildMap::default(),
+                None,
+            )?);
+        }
+    }
+    unwrap_artificial_nodes(&all_artificial_nodes)?;
+    Ok(lexical_nodes)
+}
+
+/// `$generateDOMFromNodes(container, selection, editor)`: appends the DOM
+/// of the root's children (or of what `selection` covers) to `container`.
+pub fn generate_dom_from_nodes(
+    container: &DomNode,
+    selection: Option<&SelectionRef>,
+    editor: &Editor,
+) -> Result<(), LexicalError> {
+    for top_level_node in get_root().get_children() {
+        append_nodes_to_html(editor, &top_level_node, container, selection)?;
+    }
+    Ok(())
+}
+
+/// `$generateDOMFromRoot(container, root)`: appends the DOM of `root`,
+/// itself included, to `container`.
+pub fn generate_dom_from_root(
+    container: &DomNode,
+    root: &NodeRef,
+    editor: &Editor,
+) -> Result<(), LexicalError> {
+    append_nodes_to_html(editor, root, container, None).map(|_| ())
+}
+
+/// `$generateHtmlFromNodes(editor, selection)`: the HTML of the editor
+/// state (or of what `selection` covers). Call it inside
+/// [`Editor::read`] or an update.
+pub fn generate_html_from_nodes(
+    editor: &Editor,
+    selection: Option<&SelectionRef>,
+) -> Result<String, LexicalError> {
+    let container = get_document().create_element("div");
+    generate_dom_from_nodes(&container, selection, editor)?;
+    Ok(container.inner_html())
+}
+
+/// `$appendNodeToHTML(editor, node, parentElement, selection)`: appends
+/// the DOM of one node and its subtree, as the exporter does for each node
+/// it walks. Returns whether the node was included.
+pub fn append_node_to_html(
+    editor: &Editor,
+    node: &NodeRef,
+    parent_element: &DomNode,
+    selection: Option<&SelectionRef>,
+) -> Result<bool, LexicalError> {
+    append_nodes_to_html(editor, node, parent_element, selection)
+}
+
+/// `$appendTerminatingLineBreak(element, lastIncludedChild)`: a block
+/// whose last child is a line break gets the managed `<br>` the reconciler
+/// adds, since a browser doesn't render a block's last `<br>`.
+fn append_terminating_line_break(element: &DomNode, last_included_child: Option<&NodeRef>) {
+    let is_line_break = last_included_child.is_some_and(|n| n.get_type() == "linebreak");
+    if is_line_break
+        && element.is_element()
+        && is_block_dom_node(element)
+        && element.last_child().is_some_and(|c| c.node_name() == "BR")
+    {
+        let br = get_document().create_element("br");
+        br.set_attribute("data-lexical-managed-linebreak", "true");
+        element.append_child(&br);
+    }
+}
+
+/// `$sliceSelectedTextNodeContent(selection, textNode, 'clone')`
+/// (`@lexical/selection`): the text node's value, cut to the part the
+/// selection covers when an end of the selection is in it.
+fn slice_selected_text_node_content(
+    selection: &SelectionRef,
+    text_node: &NodeRef,
+) -> Result<Rc<dyn LexicalNode>, LexicalError> {
+    let latest = text_node.get_latest();
+    let Some(range) = selection.range() else {
+        return Ok(latest);
+    };
+    let key = text_node.get_key();
+    let (anchor, focus) = (&range.anchor, &range.focus);
+    if (anchor.key != key && focus.key != key)
+        || !text_node.is_selected(Some(selection))?
+        || text_node.is_token()
+        || text_node.is_segmented()
+    {
+        return Ok(latest);
+    }
+    let (start, end) = if selection.is_backward()? {
+        (focus, anchor)
+    } else {
+        (anchor, focus)
+    };
+    let text = &latest.text().expect("a text node").text;
+    let (start_offset, end_offset) = if start.point_type == crate::PointType::Element
+        || end.point_type == crate::PointType::Element
+    {
+        let slices = crate::caret_range_from_selection(&range)?.get_text_slices();
+        match crate::get_text_point_caret_slice_for_node(&slices, text_node) {
+            Some(slice) => {
+                let (s, e) = slice.get_slice_indices();
+                (s, Some(e))
+            }
+            None => (
+                if start.key == key { start.offset } else { 0 },
+                (end.key == key).then_some(end.offset),
+            ),
+        }
+    } else {
+        (
+            if start.key == key { start.offset } else { 0 },
+            (end.key == key).then_some(end.offset),
+        )
+    };
+    // JS's slice clamps its ends and takes an empty slice when they cross.
+    let len = crate::utf16::len(text);
+    let end_offset = end_offset.unwrap_or(len).min(len);
+    let start_offset = start_offset.min(end_offset);
+    let sliced = crate::utf16::slice(text, start_offset, end_offset);
+    if sliced == *text {
+        return Ok(latest);
+    }
+    let mut clone = latest.clone_node();
+    clone.text_mut().expect("a text node").text = sliced;
+    Ok(Rc::from(clone))
+}
+
+/// `$appendNodesToHTML(editor, currentNode, parentElementAppend,
+/// selection, domConfig)`: appends the node's DOM, with its children's,
+/// to `parent`, or only its children's when the node isn't included.
+/// Returns whether it was included.
+fn append_nodes_to_html(
+    editor: &Editor,
+    current_node: &NodeRef,
+    parent: &DomNode,
+    selection: Option<&SelectionRef>,
+) -> Result<bool, LexicalError> {
+    let mut include = should_include(current_node, selection)?;
+    let exclude = should_exclude(current_node);
+    let target = match selection {
+        Some(selection) if current_node.is_text() => {
+            slice_selected_text_node_content(selection, current_node)?
+        }
+        _ => current_node.get_latest(),
+    };
+    let export_props = export_dom(&*target, current_node, editor)?;
+    let Some(element) = export_props.element else {
+        return Ok(false);
+    };
+    let fragment = get_document().create_document_fragment();
+    let children = match export_props.get_child_nodes {
+        Some(get_child_nodes) => get_child_nodes(),
+        None if current_node.is_element() => current_node.get_children(),
+        None => Vec::new(),
+    };
+    // A whole element host in a node selection exports all of its subtree.
+    let child_selection =
+        if include && selection.is_some_and(SelectionRef::is_node) && current_node.is_element() {
+            None
+        } else {
+            selection
+        };
+    let mut last_included_child = None;
+    for child_node in &children {
+        let include_child = append_nodes_to_html(editor, child_node, &fragment, child_selection)?;
+        if include_child {
+            last_included_child = Some(child_node.clone());
+        }
+        if !include
+            && include_child
+            && extract_with_child(current_node, child_node, selection, "html")?
+        {
+            include = true;
+        }
+    }
+    if include && !exclude {
+        if element.is_element() || element.is_document_fragment() {
+            match export_props.append {
+                Some(append) => append(&fragment)?,
+                None => {
+                    element.append_child(&fragment);
+                }
+            }
+            append_terminating_line_break(&element, last_included_child.as_ref());
+        }
+        if element.is_document_fragment() {
+            if let Some(after) = export_props.after
+                && let Some(new_element) = after(&element)?
+            {
+                element.replace_children(&[new_element]);
+            }
+            parent.append_child(&element);
+        } else {
+            parent.append_child(&element);
+            if let Some(after) = export_props.after
+                && let Some(new_element) = after(&element)?
+            {
+                element.replace_with(&[new_element]);
+            }
+        }
+    } else {
+        parent.append_child(&fragment);
+    }
+    Ok(include)
+}
+
+/// The `forChild` conversions in effect, by the DOM node name that set
+/// them, in the order first set (a JS `Map`).
+#[derive(Clone, Default)]
+struct ForChildMap(Vec<(String, DomChildConversion)>);
+
+impl ForChildMap {
+    fn set(&mut self, key: String, conversion: DomChildConversion) {
+        match self.0.iter_mut().find(|(k, _)| *k == key) {
+            Some(entry) => entry.1 = conversion,
+            None => self.0.push((key, conversion)),
+        }
+    }
+}
+
+/// `$isBlockElementNode(node)`: an element that isn't inline.
+fn is_block_element_node(node: &NodeRef) -> bool {
+    node.is_element() && !node.is_inline()
+}
+
+/// `$createNodesFromDOM(node, editor, allArtificialNodes,
+/// hasBlockAncestorLexicalNode, forChildMap, parentLexicalNode)`.
+fn create_nodes_from_dom(
+    node: &DomNode,
+    editor: &Editor,
+    all_artificial_nodes: &mut Vec<NodeRef>,
+    has_block_ancestor_lexical_node: bool,
+    mut for_child_map: ForChildMap,
+    parent_lexical_node: Option<&NodeRef>,
+) -> Result<Vec<NodeRef>, LexicalError> {
+    let mut lexical_nodes = Vec::new();
+    let node_name = node.node_name();
+    if IGNORE_TAGS.contains(&node_name.as_str()) {
+        return Ok(lexical_nodes);
+    }
+    let mut current_lexical_node: Option<NodeRef> = None;
+    let transform_output = match get_conversion_function(node, editor) {
+        Some(conversion) => conversion(node)?,
+        None => None,
+    };
+    let mut post_transform = None;
+    if let Some(output) = transform_output {
+        post_transform = output.after;
+        let transform_nodes = output.node;
+        current_lexical_node = match &transform_nodes {
+            DomConversionNode::None => None,
+            DomConversionNode::One(n) => Some(n.clone()),
+            DomConversionNode::Many(nodes) => nodes.last().cloned(),
+        };
+        if current_lexical_node.is_some() {
+            for (_, for_child_function) in &for_child_map.0 {
+                let Some(current) = current_lexical_node.take() else {
+                    break;
+                };
+                current_lexical_node = for_child_function(&current, parent_lexical_node)?;
+                if current_lexical_node.is_none() {
+                    break;
+                }
+            }
+            if let Some(current) = &current_lexical_node {
+                match transform_nodes {
+                    DomConversionNode::Many(nodes) => lexical_nodes.extend(nodes),
+                    _ => lexical_nodes.push(current.clone()),
+                }
+            }
+        }
+        if let Some(for_child) = output.for_child {
+            for_child_map.set(node_name.clone(), for_child);
+        }
+    }
+
+    let has_block_ancestor_lexical_node_for_children = match &current_lexical_node {
+        Some(current) if crate::nodes::element::is_root_or_shadow_root(&*current.get_latest()) => {
+            false
+        }
+        Some(current) => is_block_element_node(current) || has_block_ancestor_lexical_node,
+        None => has_block_ancestor_lexical_node,
+    };
+
+    let mut child_lexical_nodes = Vec::new();
+    for child in node.child_nodes() {
+        child_lexical_nodes.extend(create_nodes_from_dom(
+            &child,
+            editor,
+            all_artificial_nodes,
+            has_block_ancestor_lexical_node_for_children,
+            for_child_map.clone(),
+            current_lexical_node.as_ref(),
+        )?);
+    }
+
+    if let Some(post_transform) = post_transform {
+        child_lexical_nodes = post_transform(child_lexical_nodes)?;
+    }
+
+    if is_block_dom_node(node) {
+        child_lexical_nodes = if !has_block_ancestor_lexical_node_for_children {
+            wrap_continuous_inlines(node, child_lexical_nodes, &mut create_paragraph_node)?
+        } else {
+            wrap_continuous_inlines(node, child_lexical_nodes, &mut || {
+                let artificial_node = create_artificial_node();
+                all_artificial_nodes.push(artificial_node.clone());
+                artificial_node
+            })?
+        };
+    }
+
+    match current_lexical_node {
+        None => {
+            if !child_lexical_nodes.is_empty() {
+                // A DOM node without a conversion hoists its children.
+                lexical_nodes.extend(child_lexical_nodes);
+            } else if is_block_dom_node(node) && is_dom_node_between_two_inline_nodes(node) {
+                // An empty block between inline nodes is a line break.
+                lexical_nodes.push(create_line_break_node());
+            }
+        }
+        Some(current) => {
+            if current.is_element() {
+                current.append(&child_lexical_nodes)?;
+            }
+        }
+    }
+    Ok(lexical_nodes)
+}
+
+/// `wrapContinuousInlines(domNode, nodes, createWrapperFn)`: each run of
+/// inline nodes in a wrapper, and the block's `text-align` on the blocks
+/// without an alignment.
+fn wrap_continuous_inlines(
+    dom_node: &DomNode,
+    nodes: Vec<NodeRef>,
+    create_wrapper_fn: &mut dyn FnMut() -> NodeRef,
+) -> Result<Vec<NodeRef>, LexicalError> {
+    let text_align = dom_node.style().get_property_value("text-align");
+    let mut out = Vec::new();
+    let mut continuous_inlines = Vec::new();
+    let len = nodes.len();
+    for (i, node) in nodes.iter().enumerate() {
+        if is_block_element_node(node) {
+            if !text_align.is_empty() && node.element_data().get_format() == 0 {
+                node.set_element_format(&text_align);
+            }
+            out.push(node.clone());
+        } else {
+            continuous_inlines.push(node.clone());
+            if i == len - 1 || is_block_element_node(&nodes[i + 1]) {
+                let wrapper = create_wrapper_fn();
+                // `setFormat` clears the alignment for a `text-align` that names none.
+                wrapper.set_element_format(&text_align);
+                wrapper.append(&continuous_inlines)?;
+                out.push(wrapper);
+                continuous_inlines.clear();
+            }
+        }
+    }
+    Ok(out)
+}
+
+/// `$unwrapArtificialNodes(allArtificialNodes)`: replaces each artificial
+/// node with its children, with a line break between adjacent ones.
+fn unwrap_artificial_nodes(all_artificial_nodes: &[NodeRef]) -> Result<(), LexicalError> {
+    for node in all_artificial_nodes {
+        if node.get_parent().is_some()
+            && node
+                .get_next_sibling()
+                .is_some_and(|n| is_artificial_node(&n))
+        {
+            node.insert_after(&create_line_break_node(), true)?;
+        }
+    }
+    for node in all_artificial_nodes {
+        if let Some(parent) = node.get_parent() {
+            let index = node
+                .get_index_within_parent()
+                .expect("a child has an index");
+            parent.splice(index, 1, &node.get_children())?;
+        }
+    }
+    Ok(())
+}
+
+/// `isDomNodeBetweenTwoInlineNodes(node)`.
+fn is_dom_node_between_two_inline_nodes(node: &DomNode) -> bool {
+    match (node.next_sibling(), node.previous_sibling()) {
+        (Some(next), Some(previous)) => is_inline_dom_node(&next) && is_inline_dom_node(&previous),
+        _ => false,
+    }
+}
diff --git a/rust/lexical-editor/src/lexical_dom.rs b/rust/lexical-editor/src/lexical_dom.rs
new file mode 100644
index 00000000000..79e7afea5c4
--- /dev/null
+++ b/rust/lexical-editor/src/lexical_dom.rs
@@ -0,0 +1,519 @@
+//! The DOM side of the core (the `html` feature): what `createDOM`,
+//! `exportDOM` and `importDOM` exchange (`DOMExportOutput`,
+//! `DOMConversionMap` and the rest, `LexicalNode.ts` and
+//! `LexicalEditor.ts`), the editor's default render config
+//! (`DEFAULT_EDITOR_DOM_CONFIG`), the import conversion cache
+//! (`initializeConversionCache`), and the DOM helpers of `LexicalUtils.ts`,
+//! `utils/classNames.ts` and `nodes/LexicalLineBreakNode.ts` that nodes and
+//! `@lexical/html` use. The DOM is [`crate::dom`].
+//!
+//! `DOMRenderExtension`'s overrides of the render config need the extension
+//! API, so an editor's render config is always the default one.
+
+use crate::dom::DomNode;
+use crate::editor::NodeClass;
+use crate::json::{Object, Value};
+use crate::lexical_selection::SelectionRef;
+use crate::node::{LexicalNode, NodeRef};
+use crate::selection_deletion::is_js_whitespace;
+use crate::{Editor, LexicalError};
+use std::collections::HashMap;
+use std::rc::Rc;
+
+pub use crate::dom::get_document;
+
+/// Runs once a node's DOM has its children; a node it returns replaces the
+/// DOM (`DOMExportOutput.after`).
+pub type DomExportAfter = Box<dyn FnOnce(&DomNode) -> Result<Option<DomNode>, LexicalError>>;
+
+/// Appends the exported children, as a fragment (`DOMExportOutput.append`).
+pub type DomExportAppend = Box<dyn FnOnce(&DomNode) -> Result<(), LexicalError>>;
+
+/// `DOMExportOutput`: the DOM a node exports (an element, a fragment, a
+/// text node or nothing), with optional hooks.
+#[derive(Default)]
+pub struct DomExportOutput {
+    pub element: Option<DomNode>,
+    /// `after`.
+    pub after: Option<DomExportAfter>,
+    /// `append`: appends the exported children (a fragment) somewhere other
+    /// than `element`.
+    pub append: Option<DomExportAppend>,
+    /// `$getChildNodes`: the children to export in place of the node's own.
+    pub get_child_nodes: Option<Box<dyn FnOnce() -> Vec<NodeRef>>>,
+}
+
+impl DomExportOutput {
+    /// `{element}`.
+    pub fn element(element: DomNode) -> Self {
+        Self {
+            element: Some(element),
+            ..Self::default()
+        }
+    }
+}
+
+/// `DOMChildConversion`: maps the Lexical node made from a descendant
+/// (given the one made from its parent) to the node to keep, or `None` to
+/// drop it.
+pub type DomChildConversion =
+    Rc<dyn Fn(&NodeRef, Option<&NodeRef>) -> Result<Option<NodeRef>, LexicalError>>;
+
+/// What `DOMConversionOutput.node` holds: nothing, one node, or an array
+/// (whose last node receives the children).
+#[derive(Clone, Debug, Default)]
+pub enum DomConversionNode {
+    #[default]
+    None,
+    One(NodeRef),
+    Many(Vec<NodeRef>),
+}
+
+/// Rewrites the Lexical nodes made from a DOM node's children
+/// (`DOMConversionOutput.after`).
+pub type DomConversionAfter = Box<dyn FnOnce(Vec<NodeRef>) -> Result<Vec<NodeRef>, LexicalError>>;
+
+/// `DOMConversionOutput`: what a conversion makes of a DOM node.
+#[derive(Default)]
+pub struct DomConversionOutput {
+    pub node: DomConversionNode,
+    /// `forChild`: applied to each Lexical node made from a descendant.
+    pub for_child: Option<DomChildConversion>,
+    /// `after`.
+    pub after: Option<DomConversionAfter>,
+}
+
+impl DomConversionOutput {
+    /// `{node}`, or `{node: null}`.
+    pub fn node(node: Option<NodeRef>) -> Self {
+        Self {
+            node: node.map_or(DomConversionNode::None, DomConversionNode::One),
+            ..Self::default()
+        }
+    }
+}
+
+/// `DOMConversionFn`.
+pub type DomConversionFn =
+    Rc<dyn Fn(&DomNode) -> Result<Option<DomConversionOutput>, LexicalError>>;
+
+/// `DOMConversion`: a conversion and its priority (0 to 4); the highest
+/// priority wins, and the last registered among equals.
+#[derive(Clone)]
+pub struct DomConversion {
+    pub conversion: DomConversionFn,
+    pub priority: u8,
+}
+
+/// What a `DOMConversionMap` holds for a node name: a function that offers
+/// a conversion for a DOM node, or `None` to decline it.
+pub type DomImporter = Rc<dyn Fn(&DomNode) -> Option<DomConversion>>;
+
+/// `DOMConversionMap`: lower-case node names (`p`, `#text`) to importers, in
+/// the order the map's keys are written.
+pub type DomConversionMap = Vec<(String, DomImporter)>;
+
+/// An importer that always offers `conversion` with `priority`, as most
+/// `importDOM` entries (`() => ({conversion, priority})`) do.
+pub fn importer(
+    priority: u8,
+    conversion: impl Fn(&DomNode) -> Result<Option<DomConversionOutput>, LexicalError> + 'static,
+) -> DomImporter {
+    let conversion: DomConversionFn = Rc::new(conversion);
+    Rc::new(move |_| {
+        Some(DomConversion {
+            conversion: conversion.clone(),
+            priority,
+        })
+    })
+}
+
+/// An `exportDOM` override of `html.export`, for a node value and its
+/// handle.
+pub type ExportOverride =
+    Rc<dyn Fn(&Editor, &dyn LexicalNode, &NodeRef) -> Result<DomExportOutput, LexicalError>>;
+
+/// `HTMLConfig`: `exportDOM` overrides by node type (`export`) and import
+/// conversions to add to those of the node classes (`import`).
+#[derive(Clone, Default)]
+pub struct HtmlConfig {
+    pub export: Vec<(&'static str, ExportOverride)>,
+    pub import: DomConversionMap,
+}
+
+/// `initializeConversionCache(nodes, additionalConversions)`: each class's
+/// own `importDOM`, then `html.import`, by node name, in that order.
+pub(crate) fn initialize_conversion_cache(
+    nodes: &[NodeClass],
+    additional: &DomConversionMap,
+) -> HashMap<String, Vec<DomImporter>> {
+    let mut cache: HashMap<String, Vec<DomImporter>> = HashMap::new();
+    let mut add = |map: &DomConversionMap| {
+        for (key, importer) in map {
+            cache.entry(key.clone()).or_default().push(importer.clone());
+        }
+    };
+    for class in nodes {
+        if let Some(map) = (class.import_dom)() {
+            add(&map);
+        }
+    }
+    add(additional);
+    cache
+}
+
+/// `getConversionFunction(domNode, editor)` (`@lexical/html`): the
+/// conversion with the highest priority among those offered for the node,
+/// the last registered among equals.
+pub(crate) fn get_conversion_function(
+    dom_node: &DomNode,
+    editor: &Editor,
+) -> Option<DomConversionFn> {
+    let name = dom_node.node_name().to_lowercase();
+    let mut current: Option<DomConversion> = None;
+    for importer in editor.0.html_conversions.get(&name)? {
+        if let Some(conversion) = importer(dom_node)
+            && current
+                .as_ref()
+                .is_none_or(|c| c.priority <= conversion.priority)
+        {
+            current = Some(conversion);
+        }
+    }
+    current.map(|c| c.conversion)
+}
+
+// `DEFAULT_EDITOR_DOM_CONFIG`.
+
+/// `$createDOM(node, editor)`: `node.createDOM(editor._config, editor)`.
+pub fn create_dom(
+    node: &dyn LexicalNode,
+    this: &NodeRef,
+    editor: &Editor,
+) -> Result<DomNode, LexicalError> {
+    node.create_dom(this, editor.config(), editor)
+}
+
+/// `$exportDOM(node, editor)`: the `html.export` override for the node's
+/// type, if there is one, or `node.exportDOM(editor)`.
+pub fn export_dom(
+    node: &dyn LexicalNode,
+    this: &NodeRef,
+    editor: &Editor,
+) -> Result<DomExportOutput, LexicalError> {
+    match editor.0.html_export.get(node.get_type()) {
+        Some(export) => export(editor, node, this),
+        None => node.export_dom(this, editor),
+    }
+}
+
+/// `$extractWithChild(node, childNode, selection, destination)`.
+pub fn extract_with_child(
+    node: &NodeRef,
+    child: &NodeRef,
+    selection: Option<&SelectionRef>,
+    destination: &str,
+) -> Result<bool, LexicalError> {
+    if !node.is_element() {
+        return Ok(false);
+    }
+    node.extract_with_child(child, selection, destination)
+}
+
+/// `$shouldExclude(node)`: an element that leaves itself out of HTML.
+pub fn should_exclude(node: &NodeRef) -> bool {
+    node.is_element() && node.exclude_from_copy("html")
+}
+
+/// `$shouldInclude(node, selection)`: whether the node is in the
+/// selection, or true without one.
+pub fn should_include(
+    node: &NodeRef,
+    selection: Option<&SelectionRef>,
+) -> Result<bool, LexicalError> {
+    match selection {
+        Some(selection) => node.is_selected(Some(selection)),
+        None => Ok(true),
+    }
+}
+
+/// `LexicalNode.exportDOM(editor)`: the element `$createDOM` makes. The
+/// `ElementNode` and `TextNode` overrides call it.
+pub fn export_dom_base(
+    node: &dyn LexicalNode,
+    this: &NodeRef,
+    editor: &Editor,
+) -> Result<DomExportOutput, LexicalError> {
+    Ok(DomExportOutput::element(create_dom(node, this, editor)?))
+}
+
+// DOM helpers.
+
+fn matches_tag(node: &DomNode, tags: &[&str]) -> bool {
+    let name = node.node_name().to_ascii_lowercase();
+    tags.contains(&name.as_str())
+}
+
+const INLINE_TAGS: &[&str] = &[
+    "a", "abbr", "acronym", "b", "cite", "code", "del", "em", "i", "ins", "kbd", "label", "mark",
+    "output", "q", "ruby", "s", "samp", "span", "strong", "sub", "sup", "time", "u", "tt", "var",
+    "#text",
+];
+
+const BLOCK_TAGS: &[&str] = &[
+    "address",
+    "article",
+    "aside",
+    "blockquote",
+    "canvas",
+    "dd",
+    "div",
+    "dl",
+    "dt",
+    "fieldset",
+    "figcaption",
+    "figure",
+    "footer",
+    "form",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "header",
+    "hr",
+    "li",
+    "main",
+    "nav",
+    "noscript",
+    "ol",
+    "p",
+    "pre",
+    "section",
+    "table",
+    "td",
+    "tfoot",
+    "ul",
+    "video",
+];
+
+fn is_displayed_inline(node: &DomNode) -> bool {
+    node.is_element()
+        && node
+            .style()
+            .get_property_value("display")
+            .starts_with("inline")
+}
+
+/// `isInlineDomNode(node)`: an element displayed inline, or a text node or
+/// an element with an inline tag.
+pub fn is_inline_dom_node(node: &DomNode) -> bool {
+    is_displayed_inline(node) || matches_tag(node, INLINE_TAGS)
+}
+
+/// `isBlockDomNode(node)`: an element with a block tag, not displayed
+/// inline.
+pub fn is_block_dom_node(node: &DomNode) -> bool {
+    !is_displayed_inline(node) && matches_tag(node, BLOCK_TAGS)
+}
+
+/// `normalizeClassNames(...classNames)`: the whitespace-separated tokens of
+/// the strings, in order.
+pub fn normalize_class_names(class_names: &[&str]) -> Vec<String> {
+    class_names
+        .iter()
+        .flat_map(|c| c.split(is_js_whitespace).filter(|s| !s.is_empty()))
+        .map(str::to_owned)
+        .collect()
+}
+
+/// `addClassNamesToElement(element, ...classNames)`.
+pub fn add_class_names_to_element(element: &DomNode, class_names: &[&str]) {
+    let tokens = normalize_class_names(class_names);
+    if !tokens.is_empty() {
+        element.class_list().add(&tokens);
+    }
+}
+
+/// `removeClassNamesFromElement(element, ...classNames)`.
+pub fn remove_class_names_from_element(element: &DomNode, class_names: &[&str]) {
+    let tokens = normalize_class_names(class_names);
+    if !tokens.is_empty() {
+        element.class_list().remove(&tokens);
+    }
+}
+
+/// `getCachedClassNameArray(theme, key)`: the class names a theme entry
+/// names, as a string of whitespace-separated names or an array of them.
+pub fn get_cached_class_name_array(theme: &Object, key: &str) -> Option<Vec<String>> {
+    match theme.get(key)? {
+        Value::String(names) => Some(normalize_class_names(&[names])),
+        Value::Array(names) => Some(
+            names
+                .iter()
+                .filter_map(|n| n.as_str().map(str::to_owned))
+                .collect(),
+        ),
+        _ => None,
+    }
+}
+
+/// A theme's `theme[key]` as a string, for `addClassNamesToElement`.
+pub fn theme_string<'a>(theme: &'a Object, key: &str) -> Option<&'a str> {
+    theme.get(key).and_then(Value::as_str)
+}
+
+/// `removeEmptyDOMAttribute(dom, attributeName)`.
+pub fn remove_empty_dom_attribute(dom: &DomNode, attribute_name: &str) {
+    if dom.get_attribute(attribute_name).as_deref() == Some("") {
+        dom.remove_attribute(attribute_name);
+    }
+}
+
+/// `parseInt(string, 10)`: the leading decimal integer after JS
+/// whitespace, or `None` for `NaN`.
+pub fn js_parse_int(string: &str) -> Option<f64> {
+    let s = string.trim_start_matches(is_js_whitespace);
+    let (negative, digits) = match s.as_bytes().first() {
+        Some(b'-') => (true, &s[1..]),
+        Some(b'+') => (false, &s[1..]),
+        _ => (false, s),
+    };
+    let end = digits
+        .bytes()
+        .position(|b| !b.is_ascii_digit())
+        .unwrap_or(digits.len());
+    if end == 0 {
+        return None;
+    }
+    let value: f64 = digits[..end].parse().ok()?;
+    Some(if negative { -value } else { value })
+}
+
+/// `Math.round(x)`.
+pub fn js_round(x: f64) -> f64 {
+    let r = (x + 0.5).floor();
+    if r == 0.0 && x < 0.0 { -0.0 } else { r }
+}
+
+/// `setNodeIndentFromDOM(elementDom, elementNode)`: the indent from
+/// `data-lexical-indent`, or from `padding-inline-start` in steps of 40px.
+pub fn set_node_indent_from_dom(
+    element_dom: &DomNode,
+    element_node: &NodeRef,
+) -> Result<(), LexicalError> {
+    if let Some(indent_attr) = element_dom.get_attribute("data-lexical-indent")
+        && let Some(parsed) = js_parse_int(&indent_attr).filter(|p| p.is_finite() && *p >= 0.0)
+    {
+        return element_node.set_indent(parsed);
+    }
+    let padding = element_dom
+        .style()
+        .get_property_value("padding-inline-start");
+    let indent_size = js_parse_int(&padding).filter(|n| *n != 0.0).unwrap_or(0.0);
+    element_node.set_indent(js_round(indent_size / 40.0) + 0.0)
+}
+
+/// `$setDirectionFromDOM(node, domNode)`: the `dir` attribute, when it is
+/// `ltr` or `rtl`.
+pub fn set_direction_from_dom(node: &NodeRef, dom_node: &DomNode) {
+    use crate::nodes::element::Direction;
+    match dom_node.get_attribute("dir").as_deref() {
+        Some("ltr") => node.set_direction(Some(Direction::Ltr)),
+        Some("rtl") => node.set_direction(Some(Direction::Rtl)),
+        _ => {}
+    }
+}
+
+/// Whether `ElementNode.setFormat` knows an alignment (`type in
+/// ELEMENT_TYPE_TO_FORMAT`).
+pub fn is_element_format_type(format_type: &str) -> bool {
+    !format_type.is_empty()
+        && crate::constants::lookup(crate::constants::ELEMENT_TYPE_TO_FORMAT, format_type).is_some()
+}
+
+/// `$setFormatFromDOM(node, domNode)`: the alignment of `text-align`, when
+/// it is one.
+pub fn set_format_from_dom(node: &NodeRef, dom_node: &DomNode) {
+    let alignment = dom_node.style().get_property_value("text-align");
+    if is_element_format_type(&alignment) {
+        node.set_element_format(&alignment);
+    }
+}
+
+/// `isWhitespaceDomTextNode(node)`: a text node of spaces, tabs and
+/// newlines.
+fn is_whitespace_dom_text_node(node: &DomNode) -> bool {
+    if !node.is_text() {
+        return false;
+    }
+    let text = node.text_content();
+    !text.is_empty() && is_whitespace_run(&text)
+}
+
+/// `/^( |\t|\r?\n)+$/` without its emptiness check.
+fn is_whitespace_run(text: &str) -> bool {
+    let bytes = text.as_bytes();
+    let mut i = 0;
+    while i < bytes.len() {
+        match bytes[i] {
+            b' ' | b'\t' | b'\n' => i += 1,
+            b'\r' if bytes.get(i + 1) == Some(&b'\n') => i += 2,
+            _ => return false,
+        }
+    }
+    true
+}
+
+/// `isOnlyChildInBlockNode(node)`: the one child of a block element, but
+/// for whitespace text on either side.
+pub fn is_only_child_in_block_node(node: &DomNode) -> bool {
+    let Some(parent) = node.parent_element().filter(is_block_dom_node) else {
+        return false;
+    };
+    let first = parent.first_child().expect("a parent has children");
+    let at_start = &first == node
+        || (first.next_sibling().as_ref() == Some(node) && is_whitespace_dom_text_node(&first));
+    if !at_start {
+        return false;
+    }
+    let last = parent.last_child().expect("a parent has children");
+    &last == node
+        || (last.previous_sibling().as_ref() == Some(node) && is_whitespace_dom_text_node(&last))
+}
+
+/// `isLastChildInBlockNode(node)`: the last child of a block element (but
+/// for whitespace text after it), other than its only one.
+pub fn is_last_child_in_block_node(node: &DomNode) -> bool {
+    let Some(parent) = node.parent_element().filter(is_block_dom_node) else {
+        return false;
+    };
+    let first = parent.first_child().expect("a parent has children");
+    if &first == node
+        || (first.next_sibling().as_ref() == Some(node) && is_whitespace_dom_text_node(&first))
+    {
+        return false;
+    }
+    let last = parent.last_child().expect("a parent has children");
+    &last == node
+        || (last.previous_sibling().as_ref() == Some(node) && is_whitespace_dom_text_node(&last))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_int_and_round_as_js() {
+        // parseInt(' 12px'), parseInt('-3.9'), parseInt('px'), parseInt('+7')
+        assert_eq!(js_parse_int(" 12px"), Some(12.0));
+        assert_eq!(js_parse_int("-3.9"), Some(-3.0));
+        assert_eq!(js_parse_int("px"), None);
+        assert_eq!(js_parse_int("+7"), Some(7.0));
+        // Math.round(2.5), Math.round(-2.5), Math.round(-0.4)
+        assert_eq!(js_round(2.5), 3.0);
+        assert_eq!(js_round(-2.5), -2.0);
+        assert!(js_round(-0.4) == 0.0 && js_round(-0.4).is_sign_negative());
+    }
+}
diff --git a/rust/lexical-editor/src/lib.rs b/rust/lexical-editor/src/lib.rs
index 34202c1f252..43570e1363a 100644
--- a/rust/lexical-editor/src/lib.rs
+++ b/rust/lexical-editor/src/lib.rs
@@ -64,7 +64,11 @@ mod generated_json;
 pub mod hashtag;
 #[cfg(feature = "history")]
 pub mod history;
+#[cfg(feature = "html")]
+pub mod html;
 pub mod json;
+#[cfg(feature = "html")]
+pub mod lexical_dom;
 mod lexical_selection;
 mod lexical_utils;
 #[cfg(feature = "link")]
@@ -127,9 +131,9 @@ pub use commands::{
 pub use editor::{
     COMMAND_PRIORITY_CRITICAL, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_HIGH,
     COMMAND_PRIORITY_LOW, COMMAND_PRIORITY_NORMAL, COMPOSITION_END_TAG, COMPOSITION_START_TAG,
-    CUT_TAG, CreateEditorArgs, Editor, HISTORIC_TAG, HISTORY_MERGE_TAG, HISTORY_PUSH_TAG,
-    LexicalCommand, NodeClass, PASTE_TAG, Transform, Unregister, UpdateListenerPayload,
-    UpdateOptions, create_command, create_editor,
+    CUT_TAG, CreateEditorArgs, Editor, EditorConfig, HISTORIC_TAG, HISTORY_MERGE_TAG,
+    HISTORY_PUSH_TAG, LexicalCommand, NodeClass, PASTE_TAG, Transform, Unregister,
+    UpdateListenerPayload, UpdateOptions, create_command, create_editor,
 };
 pub use editor_state::EditorState;
 pub use error::LexicalError;
diff --git a/rust/lexical-editor/src/node.rs b/rust/lexical-editor/src/node.rs
index bb427fa1b64..ec88b18091d 100644
--- a/rust/lexical-editor/src/node.rs
+++ b/rust/lexical-editor/src/node.rs
@@ -349,6 +349,49 @@ pub trait LexicalNode: NodeClone + fmt::Debug + 'static {
         element::should_serialize_text_styles(self.as_node())
     }
 
+    /// `createDOM(config, editor)` (the `html` feature): the element the
+    /// node renders as. `LexicalNode` throws, and `TextNode` renders its
+    /// text; every other node that renders overrides it.
+    #[cfg(feature = "html")]
+    fn create_dom(
+        &self,
+        this: &NodeRef,
+        config: &crate::EditorConfig,
+        editor: &crate::Editor,
+    ) -> Result<crate::dom::DomNode, LexicalError> {
+        let _ = (this, editor);
+        if self.text().is_some() {
+            return crate::nodes::text::create_dom(self.as_node(), config);
+        }
+        Err(LexicalError::new("createDOM: base method not extended"))
+    }
+
+    /// `exportDOM(editor)` (the `html` feature): the DOM the node exports
+    /// to HTML. `LexicalNode` exports the element `$createDOM` makes, which
+    /// `ElementNode` gives the indent and direction and `TextNode` its
+    /// formats.
+    #[cfg(feature = "html")]
+    fn export_dom(
+        &self,
+        this: &NodeRef,
+        editor: &crate::Editor,
+    ) -> Result<crate::lexical_dom::DomExportOutput, LexicalError> {
+        if self.element().is_some() {
+            element::export_dom(self.as_node(), this, editor)
+        } else if self.text().is_some() {
+            crate::nodes::text::export_dom(self.as_node(), this, editor)
+        } else {
+            crate::lexical_dom::export_dom_base(self.as_node(), this, editor)
+        }
+    }
+
+    /// The class's static `importDOM()` (the `html` feature): the
+    /// conversions it offers by DOM node name, or `None`.
+    #[cfg(feature = "html")]
+    fn import_dom(&self) -> Option<crate::lexical_dom::DomConversionMap> {
+        None
+    }
+
     /// `exportJSON(compact)`: the node's own properties, with an empty
     /// `children` array for an element (the export walk fills it).
     fn export_json(&self, compact: bool) -> Object;
@@ -659,6 +702,54 @@ impl NodeRef {
         selection.with_node(|n| n.has(&self.key)).unwrap_or(false)
     }
 
+    /// `isSelected(selection)`: whether the node is among the selection's
+    /// nodes (`selection`, or the current one), but for an inline decorator
+    /// a non-collapsed element selection only ends after.
+    pub fn is_selected(&self, selection: Option<&SelectionRef>) -> Result<bool, LexicalError> {
+        let current;
+        let target = match selection {
+            Some(selection) => selection,
+            None => match get_selection() {
+                Some(selection) => {
+                    current = selection;
+                    &current
+                }
+                None => return Ok(false),
+            },
+        };
+        let is_selected = target.get_nodes()?.iter().any(|n| n == self);
+        if !is_selected || self.is_text() {
+            return Ok(is_selected);
+        }
+        let Some(range) = target.range() else {
+            return Ok(is_selected);
+        };
+        if range.anchor.point_type == PointType::Element
+            && range.focus.point_type == PointType::Element
+        {
+            if range.is_collapsed() {
+                return Ok(false);
+            }
+            if let Some(parent) = self.get_parent()
+                && self.is_decorator()
+                && self.is_inline()
+            {
+                let first = if target.is_backward()? {
+                    &range.focus
+                } else {
+                    &range.anchor
+                };
+                if parent.get_key() == first.key
+                    && first.offset == parent.get_children_size()
+                    && parent.get_last_child().as_ref() == Some(self)
+                {
+                    return Ok(false);
+                }
+            }
+        }
+        Ok(is_selected)
+    }
+
     /// `markDirty()`: marks the node dirty, so transforms run on it.
     pub fn mark_dirty(&self) {
         get_writable(&self.key);
diff --git a/rust/lexical-editor/src/nodes/artificial.rs b/rust/lexical-editor/src/nodes/artificial.rs
new file mode 100644
index 00000000000..a594de09c5f
--- /dev/null
+++ b/rust/lexical-editor/src/nodes/artificial.rs
@@ -0,0 +1,69 @@
+//! `nodes/ArtificialNode.ts`: `ArtificialNode__DO_NOT_USE`, the element
+//! `@lexical/html`'s import wraps inline content in when it is already
+//! inside a block, then unwraps. Every editor registers it, as in JS.
+
+use crate::generated_json::{
+    export_compact_element_node, export_element_node, update_element_node,
+};
+use crate::json::Object;
+use crate::node::{LexicalNode, NodeBase, NodeRef};
+use crate::nodes::element::ElementData;
+
+/// `ArtificialNode__DO_NOT_USE`. Its JSON is `ElementNode`'s.
+#[derive(Clone, Debug, Default)]
+pub struct ArtificialNode {
+    base: NodeBase,
+    element: ElementData,
+}
+
+/// `new ArtificialNode__DO_NOT_USE()`.
+pub fn create_artificial_node() -> NodeRef {
+    crate::lexical_utils::set_node_key(Box::new(ArtificialNode::default()))
+}
+
+/// `node instanceof ArtificialNode__DO_NOT_USE`.
+pub fn is_artificial_node(node: &NodeRef) -> bool {
+    node.get_latest().is::<ArtificialNode>()
+}
+
+impl LexicalNode for ArtificialNode {
+    fn get_type(&self) -> &'static str {
+        "artificial"
+    }
+    fn base(&self) -> &NodeBase {
+        &self.base
+    }
+    fn base_mut(&mut self) -> &mut NodeBase {
+        &mut self.base
+    }
+    fn element(&self) -> Option<&ElementData> {
+        Some(&self.element)
+    }
+    fn element_mut(&mut self) -> Option<&mut ElementData> {
+        Some(&mut self.element)
+    }
+
+    /// `ArtificialNode__DO_NOT_USE.createDOM()`: a `<div>`, which nothing
+    /// uses.
+    #[cfg(feature = "html")]
+    fn create_dom(
+        &self,
+        _this: &NodeRef,
+        _config: &crate::EditorConfig,
+        _editor: &crate::Editor,
+    ) -> Result<crate::dom::DomNode, crate::LexicalError> {
+        Ok(crate::lexical_dom::get_document().create_element("div"))
+    }
+
+    fn export_json(&self, compact: bool) -> Object {
+        if compact {
+            export_compact_element_node(self)
+        } else {
+            export_element_node(self)
+        }
+    }
+
+    fn update_from_json(&mut self, json: &Object) {
+        update_element_node(&mut self.element, json);
+    }
+}
diff --git a/rust/lexical-editor/src/nodes/element.rs b/rust/lexical-editor/src/nodes/element.rs
index 169ba66c3a7..2f7a51bf302 100644
--- a/rust/lexical-editor/src/nodes/element.rs
+++ b/rust/lexical-editor/src/nodes/element.rs
@@ -435,3 +435,34 @@ pub fn splice(
     }
     Ok(())
 }
+
+/// `ElementNode.exportDOM(editor)`: `LexicalNode`'s export, with the
+/// indent (as `padding-inline-start` in steps of 40px and
+/// `data-lexical-indent`) and the direction on an element.
+#[cfg(feature = "html")]
+pub fn export_dom(
+    node: &dyn LexicalNode,
+    this: &NodeRef,
+    editor: &crate::Editor,
+) -> Result<crate::lexical_dom::DomExportOutput, LexicalError> {
+    let output = crate::lexical_dom::export_dom_base(node, this, editor)?;
+    if let Some(element) = output.element.as_ref().filter(|e| e.is_element()) {
+        let data = node.element().expect("an element");
+        let indent = data.get_indent();
+        if indent > 0.0 {
+            element.style().set_property(
+                "padding-inline-start",
+                &format!("{}px", crate::json::number_to_string(indent * 40.0)),
+                "",
+            );
+            element.set_attribute(
+                "data-lexical-indent",
+                &crate::json::number_to_string(indent),
+            );
+        }
+        if let Some(direction) = data.get_direction() {
+            element.set_attribute("dir", direction.as_str());
+        }
+    }
+    Ok(output)
+}
diff --git a/rust/lexical-editor/src/nodes/line_break.rs b/rust/lexical-editor/src/nodes/line_break.rs
index 4a9bf9a0291..9a7852d7c94 100644
--- a/rust/lexical-editor/src/nodes/line_break.rs
+++ b/rust/lexical-editor/src/nodes/line_break.rs
@@ -39,4 +39,43 @@ impl LexicalNode for LineBreakNode {
         }
     }
     fn update_from_json(&mut self, _json: &Object) {}
+
+    /// `LineBreakNode.createDOM()`: a `<br>`.
+    #[cfg(feature = "html")]
+    fn create_dom(
+        &self,
+        _this: &NodeRef,
+        _config: &crate::EditorConfig,
+        _editor: &crate::Editor,
+    ) -> Result<crate::dom::DomNode, crate::LexicalError> {
+        Ok(crate::lexical_dom::get_document().create_element("br"))
+    }
+
+    /// `LineBreakNode`'s `importDOM`: a `<br>`, but for the one that only
+    /// ends (or is all of) a block, which a browser doesn't render as a
+    /// line.
+    #[cfg(feature = "html")]
+    fn import_dom(&self) -> Option<crate::lexical_dom::DomConversionMap> {
+        use crate::lexical_dom::{
+            DomConversion, DomConversionOutput, is_last_child_in_block_node,
+            is_only_child_in_block_node,
+        };
+        let conversion: crate::lexical_dom::DomConversionFn = std::rc::Rc::new(|_| {
+            Ok(Some(DomConversionOutput::node(Some(
+                create_line_break_node(),
+            ))))
+        });
+        Some(vec![(
+            "br".to_owned(),
+            std::rc::Rc::new(move |node: &crate::dom::DomNode| {
+                if is_only_child_in_block_node(node) || is_last_child_in_block_node(node) {
+                    return None;
+                }
+                Some(DomConversion {
+                    conversion: conversion.clone(),
+                    priority: 0,
+                })
+            }),
+        )])
+    }
 }
diff --git a/rust/lexical-editor/src/nodes/mod.rs b/rust/lexical-editor/src/nodes/mod.rs
index 43c09f03404..010a44033ad 100644
--- a/rust/lexical-editor/src/nodes/mod.rs
+++ b/rust/lexical-editor/src/nodes/mod.rs
@@ -1,5 +1,6 @@
 //! `nodes/`: the core nodes every editor registers.
 
+pub mod artificial;
 pub mod element;
 pub mod line_break;
 pub mod paragraph;
diff --git a/rust/lexical-editor/src/nodes/paragraph.rs b/rust/lexical-editor/src/nodes/paragraph.rs
index 349ed3a34ce..08cfbec6f0d 100644
--- a/rust/lexical-editor/src/nodes/paragraph.rs
+++ b/rust/lexical-editor/src/nodes/paragraph.rs
@@ -117,4 +117,110 @@ impl LexicalNode for ParagraphNode {
         }
         Ok(false)
     }
+
+    /// `ParagraphNode.extractWithChild(child, selection, destination)`: a
+    /// paragraph with an alignment, an indent or a style travels as a block
+    /// when the selection covers all of its text, as those live nowhere
+    /// else.
+    fn extract_with_child(
+        &self,
+        this: &NodeRef,
+        _child: &NodeRef,
+        selection: Option<&SelectionRef>,
+        _destination: &str,
+    ) -> Result<bool, LexicalError> {
+        let Some(range) = selection.and_then(SelectionRef::range) else {
+            return Ok(false);
+        };
+        if self.element.get_format_type().is_empty()
+            && self.element.get_indent() == 0.0
+            && self.element.get_style().is_empty()
+        {
+            return Ok(false);
+        }
+        if crate::selection_deletion::is_block_fully_selected(this, &range)? {
+            let text_content = this.get_text_content();
+            return Ok(!text_content.is_empty()
+                && selection.expect("a range selection").get_text_content()? == text_content);
+        }
+        Ok(false)
+    }
+
+    /// `ParagraphNode.createDOM(config)`: a `<p>` with the theme's
+    /// `paragraph` class names.
+    #[cfg(feature = "html")]
+    fn create_dom(
+        &self,
+        _this: &NodeRef,
+        config: &crate::EditorConfig,
+        _editor: &crate::Editor,
+    ) -> Result<crate::dom::DomNode, LexicalError> {
+        let dom = crate::lexical_dom::get_document().create_element("p");
+        if let Some(class_names) =
+            crate::lexical_dom::get_cached_class_name_array(&config.theme, "paragraph")
+            && !class_names.is_empty()
+        {
+            dom.class_list().add(&class_names);
+        }
+        Ok(dom)
+    }
+
+    /// `ParagraphNode.exportDOM(editor)`: `ElementNode`'s, with a `<br>` in
+    /// an empty paragraph and the alignment as `text-align`.
+    #[cfg(feature = "html")]
+    fn export_dom(
+        &self,
+        this: &NodeRef,
+        editor: &crate::Editor,
+    ) -> Result<crate::lexical_dom::DomExportOutput, LexicalError> {
+        let output = crate::nodes::element::export_dom(self, this, editor)?;
+        if let Some(element) = output.element.as_ref().filter(|e| e.is_element()) {
+            if this.is_empty() {
+                element.append_child(&crate::lexical_dom::get_document().create_element("br"));
+            }
+            let format_type = self.element.get_format_type();
+            if !format_type.is_empty() {
+                element.style().set_property("text-align", format_type, "");
+            }
+        }
+        Ok(crate::lexical_dom::DomExportOutput {
+            element: output.element,
+            ..Default::default()
+        })
+    }
+
+    /// `ParagraphNode`'s `importDOM`: `<p>`.
+    #[cfg(feature = "html")]
+    fn import_dom(&self) -> Option<crate::lexical_dom::DomConversionMap> {
+        Some(vec![(
+            "p".to_owned(),
+            crate::lexical_dom::importer(0, convert_paragraph_element),
+        )])
+    }
+}
+
+/// `$convertParagraphElement(element)`: a paragraph with the element's
+/// alignment (from `text-align`, else the legacy `align` attribute),
+/// indent and direction.
+#[cfg(feature = "html")]
+fn convert_paragraph_element(
+    element: &crate::dom::DomNode,
+) -> Result<Option<crate::lexical_dom::DomConversionOutput>, LexicalError> {
+    use crate::lexical_dom::{
+        is_element_format_type, set_direction_from_dom, set_format_from_dom,
+        set_node_indent_from_dom,
+    };
+    let node = create_paragraph_node();
+    set_format_from_dom(&node, element);
+    set_node_indent_from_dom(element, &node)?;
+    if node.element_data().get_format_type().is_empty()
+        && let Some(align) = element.get_attribute("align")
+        && is_element_format_type(&align)
+    {
+        node.set_element_format(&align);
+    }
+    set_direction_from_dom(&node, element);
+    Ok(Some(crate::lexical_dom::DomConversionOutput::node(Some(
+        node,
+    ))))
 }
diff --git a/rust/lexical-editor/src/nodes/tab.rs b/rust/lexical-editor/src/nodes/tab.rs
index 380c03f7234..a17a83674f6 100644
--- a/rust/lexical-editor/src/nodes/tab.rs
+++ b/rust/lexical-editor/src/nodes/tab.rs
@@ -63,4 +63,23 @@ impl LexicalNode for TabNode {
     fn update_from_json(&mut self, json: &Object) {
         update_tab_node(&mut self.text, json);
     }
+
+    /// `TabNode.createDOM(config)`: `TextNode`'s, with the theme's `tab`
+    /// class names.
+    #[cfg(feature = "html")]
+    fn create_dom(
+        &self,
+        _this: &NodeRef,
+        config: &crate::EditorConfig,
+        _editor: &crate::Editor,
+    ) -> Result<crate::dom::DomNode, crate::LexicalError> {
+        let dom = crate::nodes::text::create_dom(self, config)?;
+        if let Some(class_names) =
+            crate::lexical_dom::get_cached_class_name_array(&config.theme, "tab")
+            && !class_names.is_empty()
+        {
+            dom.class_list().add(&class_names);
+        }
+        Ok(dom)
+    }
 }
diff --git a/rust/lexical-editor/src/nodes/text.rs b/rust/lexical-editor/src/nodes/text.rs
index f12fe810f84..4fbb350d152 100644
--- a/rust/lexical-editor/src/nodes/text.rs
+++ b/rust/lexical-editor/src/nodes/text.rs
@@ -102,6 +102,10 @@ impl LexicalNode for TextNode {
     fn update_from_json(&mut self, json: &Object) {
         update_text_node(&mut self.text, json);
     }
+    #[cfg(feature = "html")]
+    fn import_dom(&self) -> Option<crate::lexical_dom::DomConversionMap> {
+        Some(import_dom())
+    }
 }
 
 impl TextNode {
@@ -559,3 +563,506 @@ impl NodeRef {
         Ok(self.clone())
     }
 }
+
+// The DOM side of `TextNode` (the `html` feature).
+
+#[cfg(feature = "html")]
+pub(crate) use text_dom::{create_dom, export_dom, import_dom};
+
+#[cfg(feature = "html")]
+mod text_dom {
+    use super::{TEXT_TYPE_TO_FORMAT, create_text_node, to_int32, toggle_text_format_type};
+    use crate::constants::{
+        IS_BOLD, IS_CODE, IS_HIGHLIGHT, IS_ITALIC, IS_STRIKETHROUGH, IS_SUBSCRIPT, IS_SUPERSCRIPT,
+        IS_UNDERLINE,
+    };
+    use crate::dom::{CssStyle, DomNode};
+    use crate::json::Object;
+    use crate::lexical_dom::{
+        DomChildConversion, DomConversionMap, DomConversionOutput, DomExportOutput,
+        export_dom_base, get_cached_class_name_array, get_document, importer, is_inline_dom_node,
+        remove_empty_dom_attribute,
+    };
+    use crate::node::{LexicalNode, NodeRef};
+    use crate::selection_insert_nodes::generate_nodes_from_raw_text;
+    use crate::set_dom_style::set_dom_style_from_css;
+    use crate::{Editor, EditorConfig, LexicalError};
+    use std::rc::Rc;
+
+    /// `getElementOuterTag(node, format)`.
+    fn get_element_outer_tag(format: i32) -> Option<&'static str> {
+        if format & IS_CODE != 0 {
+            Some("code")
+        } else if format & IS_HIGHLIGHT != 0 {
+            Some("mark")
+        } else if format & IS_SUBSCRIPT != 0 {
+            Some("sub")
+        } else if format & IS_SUPERSCRIPT != 0 {
+            Some("sup")
+        } else {
+            None
+        }
+    }
+
+    /// `getElementInnerTag(node, format)`.
+    fn get_element_inner_tag(format: i32) -> &'static str {
+        if format & IS_BOLD != 0 {
+            "strong"
+        } else if format & IS_ITALIC != 0 {
+            "em"
+        } else {
+            "span"
+        }
+    }
+
+    fn add_classes(dom: &DomNode, class_names: &[String]) {
+        if !class_names.is_empty() {
+            dom.class_list().add(class_names);
+        }
+    }
+
+    fn remove_classes(dom: &DomNode, class_names: &[String]) {
+        if !class_names.is_empty() {
+            dom.class_list().remove(class_names);
+        }
+    }
+
+    /// `setTextThemeClassNames(tag, prevFormat, nextFormat, dom,
+    /// textClassNames)`.
+    fn set_text_theme_class_names(
+        prev_format: i32,
+        next_format: i32,
+        dom: &DomNode,
+        text_class_names: &Object,
+    ) {
+        if let Some(class_names) = get_cached_class_name_array(text_class_names, "base") {
+            add_classes(dom, &class_names);
+        }
+        let mut has_underline_strikethrough = false;
+        let both = IS_UNDERLINE | IS_STRIKETHROUGH;
+        let prev_underline_strikethrough = prev_format & both == both;
+        let next_underline_strikethrough = next_format & both == both;
+        if let Some(class_names) =
+            get_cached_class_name_array(text_class_names, "underlineStrikethrough")
+        {
+            if next_underline_strikethrough {
+                has_underline_strikethrough = true;
+                if !prev_underline_strikethrough {
+                    add_classes(dom, &class_names);
+                }
+            } else if prev_underline_strikethrough {
+                remove_classes(dom, &class_names);
+            }
+        }
+        for &(key, flag) in TEXT_TYPE_TO_FORMAT {
+            let Some(class_names) = get_cached_class_name_array(text_class_names, key) else {
+                continue;
+            };
+            if next_format & flag != 0 {
+                if has_underline_strikethrough && (key == "underline" || key == "strikethrough") {
+                    if prev_format & flag != 0 {
+                        remove_classes(dom, &class_names);
+                    }
+                    continue;
+                }
+                if prev_format & flag == 0
+                    || (prev_underline_strikethrough && key == "underline")
+                    || key == "strikethrough"
+                {
+                    add_classes(dom, &class_names);
+                }
+            } else if prev_format & flag != 0 {
+                remove_classes(dom, &class_names);
+            }
+        }
+        remove_empty_dom_attribute(dom, "class");
+    }
+
+    /// `$createTextInnerDOM(innerDOM, node, innerTag, format, text,
+    /// config)`. A node is never composing here, so `$setTextContent`
+    /// appends the text as it is.
+    fn create_text_inner_dom(inner_dom: &DomNode, format: i32, text: &str, config: &EditorConfig) {
+        inner_dom.append_child(&get_document().create_text_node(text));
+        if let Some(text_class_names) = config.theme.get("text").and_then(|t| t.as_object()) {
+            set_text_theme_class_names(0, format, inner_dom, text_class_names);
+        }
+    }
+
+    /// `TextNode.createDOM(config)`: the outer tag of the code, highlight,
+    /// subscript and superscript formats around the inner tag of bold and
+    /// italic, with the theme's class names and the node's style.
+    pub(crate) fn create_dom(
+        node: &dyn LexicalNode,
+        config: &EditorConfig,
+    ) -> Result<DomNode, LexicalError> {
+        let data = node.text().expect("a text node");
+        let format = to_int32(data.format);
+        let outer_tag = get_element_outer_tag(format);
+        let inner_tag = get_element_inner_tag(format);
+        let document = get_document();
+        let dom = document.create_element(outer_tag.unwrap_or(inner_tag));
+        let mut inner_dom = dom.clone();
+        if format & IS_CODE != 0 {
+            dom.set_attribute("spellcheck", "false");
+        }
+        if outer_tag.is_some() {
+            inner_dom = document.create_element(inner_tag);
+            dom.append_child(&inner_dom);
+        }
+        create_text_inner_dom(&inner_dom, format, &data.text, config);
+        if !data.style.is_empty() {
+            set_dom_style_from_css(&dom.style(), &data.style, "");
+        }
+        Ok(dom)
+    }
+
+    /// `$wrapElementWith(element, tag)`.
+    fn wrap_element_with(element: &DomNode, tag: &str) -> DomNode {
+        let el = get_document().create_element(tag);
+        el.append_child(element);
+        el
+    }
+
+    /// `TextNode.exportDOM(editor)`: the element `createDOM` makes, with
+    /// `white-space: pre-wrap` and the capitalization's `text-transform`,
+    /// inside `<b>`, `<i>`, `<s>` and `<u>` for those formats.
+    pub(crate) fn export_dom(
+        node: &dyn LexicalNode,
+        this: &NodeRef,
+        editor: &Editor,
+    ) -> Result<DomExportOutput, LexicalError> {
+        let output = export_dom_base(node, this, editor)?;
+        let mut element = match output.element {
+            Some(element) if element.is_element() => element,
+            _ => {
+                return Err(LexicalError::new(
+                    "Expected TextNode createDOM to always return a HTMLElement",
+                ));
+            }
+        };
+        let style = element.style();
+        style.set_property("white-space", "pre-wrap", "");
+        let format = to_int32(node.text().expect("a text node").format);
+        let has = |name: &str| {
+            format & crate::constants::lookup(TEXT_TYPE_TO_FORMAT, name).unwrap_or(0) != 0
+        };
+        if has("lowercase") {
+            style.set_property("text-transform", "lowercase", "");
+        } else if has("uppercase") {
+            style.set_property("text-transform", "uppercase", "");
+        } else if has("capitalize") {
+            style.set_property("text-transform", "capitalize", "");
+        }
+        for (name, tag) in [
+            ("bold", "b"),
+            ("italic", "i"),
+            ("strikethrough", "s"),
+            ("underline", "u"),
+        ] {
+            if has(name) {
+                element = wrap_element_with(&element, tag);
+            }
+        }
+        Ok(DomExportOutput::element(element))
+    }
+
+    /// `TextNode`'s `importDOM`: `#text`, and the inline formatting
+    /// elements, whose formats (and those their style implies) the text
+    /// inside them takes.
+    pub(crate) fn import_dom() -> DomConversionMap {
+        let mut map: DomConversionMap = vec![
+            ("#text".to_owned(), importer(0, convert_text_dom_node)),
+            (
+                "b".to_owned(),
+                importer(0, convert_bring_attention_to_element),
+            ),
+        ];
+        for name in ["code", "em", "i", "mark", "s"] {
+            map.push((name.to_owned(), importer(0, convert_text_format_element)));
+        }
+        map.push(("span".to_owned(), importer(0, convert_span_element)));
+        for name in ["strong", "sub", "sup", "u"] {
+            map.push((name.to_owned(), importer(0, convert_text_format_element)));
+        }
+        map
+    }
+
+    /// `convertSpanElement(domNode)`.
+    fn convert_span_element(
+        dom_node: &DomNode,
+    ) -> Result<Option<DomConversionOutput>, LexicalError> {
+        Ok(Some(DomConversionOutput {
+            for_child: Some(apply_text_format_from_style(&dom_node.style(), None)),
+            ..DomConversionOutput::default()
+        }))
+    }
+
+    /// `convertBringAttentionToElement(domNode)`: bold, unless the `<b>`
+    /// has `font-weight: normal` (as Google Docs wraps copied HTML).
+    fn convert_bring_attention_to_element(
+        dom_node: &DomNode,
+    ) -> Result<Option<DomConversionOutput>, LexicalError> {
+        let style = dom_node.style();
+        let has_normal_font_weight = style.get_property_value("font-weight") == "normal";
+        Ok(Some(DomConversionOutput {
+            for_child: Some(apply_text_format_from_style(
+                &style,
+                (!has_normal_font_weight).then_some("bold"),
+            )),
+            ..DomConversionOutput::default()
+        }))
+    }
+
+    /// `isNodePre(node)`.
+    fn is_node_pre(node: &DomNode) -> bool {
+        if !node.is_element() {
+            return false;
+        }
+        node.node_name() == "PRE"
+            || node
+                .style()
+                .get_property_value("white-space")
+                .starts_with("pre")
+    }
+
+    /// `findParentPreDOMNode(node)`: the nearest ancestor that keeps
+    /// whitespace (`<pre>` or `white-space: pre*`). JS caches the walk;
+    /// the import doesn't change the DOM, so the answer is the same.
+    pub(crate) fn find_parent_pre_dom_node(node: &DomNode) -> Option<DomNode> {
+        let mut parent = node.parent_node();
+        while let Some(p) = parent {
+            if is_node_pre(&p) {
+                return Some(p);
+            }
+            parent = p.parent_node();
+        }
+        None
+    }
+
+    /// `/[ \t\n]$/`.
+    fn ends_with_collapsible_space(text: &str) -> bool {
+        text.ends_with([' ', '\t', '\n'])
+    }
+
+    /// `text.replace(/^( |\t|\r?\n)+/, '')`.
+    fn trim_leading_whitespace_run(text: &str) -> &str {
+        let mut rest = text;
+        loop {
+            if let Some(r) = rest.strip_prefix([' ', '\t', '\n']) {
+                rest = r;
+            } else if let Some(r) = rest.strip_prefix("\r\n") {
+                rest = r;
+            } else {
+                return rest;
+            }
+        }
+    }
+
+    /// `$convertTextDOMNode(domNode)`: the text with whitespace collapsed as
+    /// a browser renders it, or raw text inside `pre`.
+    fn convert_text_dom_node(
+        dom_node: &DomNode,
+    ) -> Result<Option<DomConversionOutput>, LexicalError> {
+        crate::error::invariant!(
+            dom_node.parent_element().is_some(),
+            "Expected parentElement of Text not to be null"
+        );
+        let raw = dom_node.text_content();
+        if find_parent_pre_dom_node(dom_node).is_some() {
+            return Ok(Some(DomConversionOutput {
+                node: crate::lexical_dom::DomConversionNode::Many(generate_nodes_from_raw_text(
+                    &raw,
+                )),
+                ..DomConversionOutput::default()
+            }));
+        }
+        // .replace(/\r/g, '').replace(/[ \t\n]+/g, ' ')
+        let mut text_content = String::with_capacity(raw.len());
+        for c in raw.chars().filter(|&c| c != '\r') {
+            if matches!(c, ' ' | '\t' | '\n') {
+                if !text_content.ends_with(' ') || text_content.is_empty() {
+                    text_content.push(' ');
+                }
+            } else {
+                text_content.push(c);
+            }
+        }
+        if text_content.is_empty() {
+            return Ok(Some(DomConversionOutput::node(None)));
+        }
+        if text_content.starts_with(' ') {
+            let mut previous_text = Some(dom_node.clone());
+            let mut is_start_of_line = true;
+            while let Some(found) = previous_text
+                .as_ref()
+                .and_then(|t| find_text_in_line(t, false))
+            {
+                let previous_text_content = found.text_content();
+                if !previous_text_content.is_empty() {
+                    if ends_with_collapsible_space(&previous_text_content) {
+                        text_content.remove(0);
+                    }
+                    is_start_of_line = false;
+                    break;
+                }
+                previous_text = Some(found);
+            }
+            if is_start_of_line && !text_content.is_empty() {
+                text_content.remove(0);
+            }
+        }
+        if text_content.ends_with(' ') {
+            let mut next_text = Some(dom_node.clone());
+            let mut is_end_of_line = true;
+            while let Some(found) = next_text.as_ref().and_then(|t| find_text_in_line(t, true)) {
+                if !trim_leading_whitespace_run(&found.text_content()).is_empty() {
+                    is_end_of_line = false;
+                    break;
+                }
+                next_text = Some(found);
+            }
+            if is_end_of_line {
+                text_content.pop();
+            }
+        }
+        if text_content.is_empty() {
+            return Ok(Some(DomConversionOutput::node(None)));
+        }
+        Ok(Some(DomConversionOutput::node(Some(create_text_node(
+            &text_content,
+        )))))
+    }
+
+    /// `findTextInLine(text, forward)`: the next (or previous) text node on
+    /// the same line, stopping at a block element or a `<br>`.
+    fn find_text_in_line(text: &DomNode, forward: bool) -> Option<DomNode> {
+        let mut node = text.clone();
+        loop {
+            let sibling = loop {
+                let sibling = if forward {
+                    node.next_sibling()
+                } else {
+                    node.previous_sibling()
+                };
+                match sibling {
+                    Some(sibling) => break sibling,
+                    None => node = node.parent_element()?,
+                }
+            };
+            node = sibling;
+            if node.is_element() {
+                let display = node.style().get_property_value("display");
+                if (display.is_empty() && !is_inline_dom_node(&node))
+                    || (!display.is_empty() && !display.starts_with("inline"))
+                {
+                    return None;
+                }
+            }
+            while let Some(descendant) = if forward {
+                node.first_child()
+            } else {
+                node.last_child()
+            } {
+                node = descendant;
+            }
+            if node.is_text() {
+                return Some(node);
+            } else if node.node_name() == "BR" {
+                return None;
+            }
+        }
+    }
+
+    /// `nodeNameToTextFormat`.
+    fn node_name_to_text_format(name: &str) -> Option<&'static str> {
+        Some(match name {
+            "code" => "code",
+            "em" | "i" => "italic",
+            "mark" => "highlight",
+            "s" => "strikethrough",
+            "strong" => "bold",
+            "sub" => "subscript",
+            "sup" => "superscript",
+            "u" => "underline",
+            _ => return None,
+        })
+    }
+
+    /// `convertTextFormatElement(domNode)`.
+    fn convert_text_format_element(
+        dom_node: &DomNode,
+    ) -> Result<Option<DomConversionOutput>, LexicalError> {
+        let Some(format) = node_name_to_text_format(&dom_node.node_name().to_lowercase()) else {
+            return Ok(Some(DomConversionOutput::node(None)));
+        };
+        Ok(Some(DomConversionOutput {
+            for_child: Some(apply_text_format_from_style(
+                &dom_node.style(),
+                Some(format),
+            )),
+            ..DomConversionOutput::default()
+        }))
+    }
+
+    /// `applyTextFormatFromStyle(style, shouldApply)`: a child conversion
+    /// that gives a text node (or another inline formattable node) the
+    /// formats the style implies, and `shouldApply`.
+    pub(crate) fn apply_text_format_from_style(
+        style: &CssStyle,
+        should_apply: Option<&'static str>,
+    ) -> DomChildConversion {
+        let font_weight = style.get_property_value("font-weight");
+        let text_decoration = style.get_property_value("text-decoration");
+        let text_decoration: Vec<&str> = text_decoration.split(' ').collect();
+        let vertical_align = style.get_property_value("vertical-align");
+        let text_transform = style.get_property_value("text-transform");
+        let mut formats: Vec<&'static str> = Vec::new();
+        if font_weight == "700" || font_weight == "bold" {
+            formats.push("bold");
+        }
+        if text_decoration.contains(&"line-through") {
+            formats.push("strikethrough");
+        }
+        if style.get_property_value("font-style") == "italic" {
+            formats.push("italic");
+        }
+        if text_decoration.contains(&"underline") {
+            formats.push("underline");
+        }
+        if vertical_align == "sub" {
+            formats.push("subscript");
+        }
+        if vertical_align == "super" {
+            formats.push("superscript");
+        }
+        match text_transform.as_str() {
+            "lowercase" => formats.push("lowercase"),
+            "uppercase" => formats.push("uppercase"),
+            "capitalize" => formats.push("capitalize"),
+            _ => {}
+        }
+        formats.extend(should_apply);
+        Rc::new(move |lexical_node: &NodeRef, _parent: Option<&NodeRef>| {
+            let latest = lexical_node.get_latest();
+            if lexical_node.is_text() {
+                for format in &formats {
+                    if !lexical_node.has_format(format) {
+                        lexical_node.toggle_format(format);
+                    }
+                }
+            } else if latest.is_inline_formattable() {
+                for format in &formats {
+                    let current = to_int32(lexical_node.get_latest().get_inline_format());
+                    let flag = crate::constants::lookup(TEXT_TYPE_TO_FORMAT, format).unwrap_or(0);
+                    if current & flag == 0 {
+                        let next = toggle_text_format_type(current, format, None);
+                        lexical_node
+                            .get_latest()
+                            .set_inline_format(lexical_node, f64::from(next))?;
+                    }
+                }
+            }
+            Ok(Some(lexical_node.clone()))
+        })
+    }
+}
diff --git a/rust/lexical-editor/src/selection_deletion.rs b/rust/lexical-editor/src/selection_deletion.rs
index 3e0ed5a4d07..5db25c43693 100644
--- a/rust/lexical-editor/src/selection_deletion.rs
+++ b/rust/lexical-editor/src/selection_deletion.rs
@@ -1123,7 +1123,7 @@ fn internal_expand_selection_to_whole_document(
 /// `$isBlockFullySelected(blockNode, selection)`: whether the selection
 /// covers everything in the block. (Slot frames are not ported, so every
 /// node is in the same frame.)
-fn is_block_fully_selected(
+pub(crate) fn is_block_fully_selected(
     block: &NodeRef,
     selection: &RangeSelection,
 ) -> Result<bool, LexicalError> {