@mx-space/cli 0.13.0 → 0.13.2

package/dist/{LexicalHtml.dev-prBAwszN.mjs → LexicalHtml.dev-3rdckXIU.mjs}

@@ -1,8 +1,8 @@
-import { d as getPeerDependencyFromEditor, i as HorizontalRuleExtension, n as $getExtensionOutput, t as $createHorizontalRuleNode, u as getKnownTypesAndNodes } from "./LexicalExtension.node-BVlcrgOx.mjs";
-import { $ as $isElementNode, At as ArtificialNode__DO_NOT_USE, Cn as IS_STRIKETHROUGH, En as IS_UNDERLINE, F as $getEditor, Fr as shallowMergeConfig, Gn as RootNode, Gt as DEFAULT_EDITOR_DOM_CONFIG, H as $getRoot, I as $getEditorDOMRenderConfig, Pr as setNodeIndentFromDOM, Sr as isHTMLElement, St as $setFormatFromDOM, Tn as IS_SUPERSCRIPT, Y as $isBlockElementNode, Z as $isDecoratorNode, _ as $createTextNode, _n as IS_CODE, _r as isDOMDocumentNode, b as $fullReconcile, br as isDocumentFragment, cr as defineExtension, f as $createParagraphNode, fr as getStaticNodeConfig, ft as $isTextNode, hn as IS_BOLD, hr as isBlockDomNode, lt as $isRootOrShadowRoot, or as createState, rr as configExtension, rt as $isLexicalNode, u as $createLineBreakNode, wn as IS_SUBSCRIPT, wr as isInlineDomNode, x as $generateNodesFromRawText, xn as IS_ITALIC, xt as $setDirectionFromDOM, yn as IS_HIGHLIGHT, yr as isDOMTextNode } from "./Lexical.node-fXM8Jp7p.mjs";
-import { i as $sliceSelectedTextNodeContent } from "./LexicalSelection.node-BU5L4193.mjs";
-import { g as objectKlassEquals } from "./LexicalUtils.node-j3Llm7Y3.mjs";
-//#region ../../node_modules/.pnpm/@lexical+html@0.45.0/node_modules/@lexical/html/dist/LexicalHtml.dev.mjs
+import { a as HorizontalRuleNode, d as getPeerDependencyFromEditor, i as HorizontalRuleExtension, n as $getExtensionOutput, t as $createHorizontalRuleNode, u as getKnownTypesAndNodes } from "./LexicalExtension.node-CMsupJZs.mjs";
+import { At as $setFormatFromDOM, Br as isDOMDocumentNode, Dn as IS_BOLD, Fn as IS_STRIKETHROUGH, I as $getEditor, In as IS_SUBSCRIPT, L as $getEditorDOMRenderConfig, Ln as IS_SUPERSCRIPT, Nn as IS_ITALIC, Nr as getRegisteredSubtypeMap, Qr as isOnlyChildInBlockNode, Rn as IS_UNDERLINE, Rr as isBlockDomNode, Rt as ArtificialNode__DO_NOT_USE, S as $generateNodesFromRawText, U as $getRoot, Ur as isDOMTextNode, Wr as isDocumentFragment, Xr as isLastChildInBlockNode, Yr as isInlineDomNode, at as $isElementNode, br as defineExtension, bt as $isTextNode, ci as setNodeIndentFromDOM, d as $createLineBreakNode, dt as $isNodeSelection, ei as iterStaticNodeConfigChain, hr as configExtension, ht as $isRootOrShadowRoot, jn as IS_HIGHLIGHT, kn as IS_CODE, kt as $setDirectionFromDOM, li as shallowMergeConfig, lt as $isLexicalNode, p as $createParagraphNode, pt as $isRangeSelection, q as $getSlotFrame, qr as isHTMLElement, r as $assumeActiveEditor, rn as DEFAULT_EDITOR_DOM_CONFIG, rr as RootNode, rt as $isDecoratorNode, tt as $isBlockElementNode, ut as $isLineBreakNode, v as $createTextNode, vr as createState, x as $fullReconcile } from "./Lexical.node-DnR_u_Ke.mjs";
+import { a as $sliceSelectedTextNodeContent } from "./LexicalSelection.node-pyZyrANz.mjs";
+import { h as objectKlassEquals } from "./LexicalUtils.node-Ck74ludK.mjs";
+//#region ../../node_modules/.pnpm/@lexical+html@0.46.0_typescript@6.0.3/node_modules/@lexical/html/dist/LexicalHtml.dev.mjs
 /**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
@@ -256,12 +256,12 @@ function createRenderState(name, getDefaultValue, isEqual) {
 * Render context state that is true if the export was initiated from the root of the document.
 * @experimental
 */
-const RenderContextRoot = createRenderState("root", Boolean);
+const RenderContextRoot = /* @__PURE__ */ createRenderState("root", Boolean);
 /**
 * Render context state that is true if this is an export operation ($generateHtmlFromNodes).
 * @experimental
 */
-const RenderContextExport = createRenderState("isExport", Boolean);
+const RenderContextExport = /* @__PURE__ */ createRenderState("isExport", Boolean);
 function getDefaultRenderContext(editor) {
 	const dep = getPeerDependencyFromEditor(editor, DOMRenderExtensionName);
 	return dep ? dep.output.defaults : void 0;
@@ -348,39 +348,19 @@ function domOverride(nodes, config, options) {
 		nodes
 	};
 }
-function buildTypeTree(editorConfig) {
-	const t = {};
-	const { nodes } = getKnownTypesAndNodes(editorConfig);
-	for (const klass of nodes) {
-		const type = klass.getType();
-		t[type] = {
-			klass,
-			types: {}
-		};
-	}
-	for (const baseRec of Object.values(t)) if (baseRec) {
-		const baseType = baseRec.klass.getType();
-		for (let { klass } = baseRec; $isLexicalNode(klass.prototype); klass = Object.getPrototypeOf(klass)) {
-			const { ownNodeType } = getStaticNodeConfig(klass);
-			const superRec = ownNodeType && t[ownNodeType];
-			if (superRec) superRec.types[baseType] = true;
-		}
-	}
-	return t;
-}
 function buildNodePredicate(klass) {
 	return (node) => node instanceof klass;
 }
-function getPredicate(typeTree, { nodes }) {
+function getPredicate(subtypeMap, { nodes }) {
 	if (nodes === "*") return ALWAYS_TRUE;
 	let types = {};
 	const predicates = [];
 	for (const klassOrPredicate of nodes) if ("getType" in klassOrPredicate) {
 		const type = klassOrPredicate.getType();
 		if (types) {
-			const tree = typeTree[type];
-			if (!(tree !== void 0)) formatDevErrorMessage(`Node class ${klassOrPredicate.name} with type ${type} not registered in editor`);
-			types = Object.assign(types, tree.types);
+			const subtypes = subtypeMap.get(type);
+			if (!(subtypes !== void 0)) formatDevErrorMessage(`Node class ${klassOrPredicate.name} with type ${type} not registered in editor`);
+			for (const subtype of subtypes) types[subtype] = true;
 		}
 		predicates.push(buildNodePredicate(klassOrPredicate));
 	} else {
@@ -401,6 +381,7 @@ function makePrerender() {
 		$exportDOM: [],
 		$extractWithChild: [],
 		$getDOMSlot: [],
+		$getSlotTargetElement: [],
 		$shouldExclude: [],
 		$shouldInclude: [],
 		$updateDOM: []
@@ -513,8 +494,8 @@ function sortedOverrides(overrides) {
 	const depthOf = (klass) => {
 		let depth = depths.get(klass);
 		if (depth === void 0) {
-			depth = 0;
-			for (let k = klass; $isLexicalNode(k.prototype); k = Object.getPrototypeOf(k)) depth++;
+			depth = -1;
+			for (const _ of iterStaticNodeConfigChain(klass)) depth++;
 			depths.set(klass, depth);
 		}
 		return depth;
@@ -527,10 +508,10 @@ function sortedOverrides(overrides) {
 	];
 }
 function precompileDOMRenderConfigOverrides(editorConfig, overrides) {
-	const typeTree = buildTypeTree(editorConfig);
+	const subtypeMap = getRegisteredSubtypeMap(getKnownTypesAndNodes(editorConfig).nodes);
 	const prerender = makePrerender();
 	for (const override of sortedOverrides(overrides)) {
-		const predicateOrTypes = getPredicate(typeTree, override);
+		const predicateOrTypes = getPredicate(subtypeMap, override);
 		for (const k_ in prerender) {
 			const k = k_;
 			addOverride(prerender, k, predicateOrTypes, override[k]);
@@ -553,6 +534,7 @@ function compileDOMRenderConfigOverrides(editorConfig, { overrides }) {
 	compilePrerenderKey(prerender, "$getDOMSlot", dom, merge3GetDOMSlot, ignoreNext3GetDOMSlot);
 	compilePrerenderKey(prerender, "$shouldExclude", dom, merge3, ignoreNext3);
 	compilePrerenderKey(prerender, "$shouldInclude", dom, merge3, ignoreNext3);
+	compilePrerenderKey(prerender, "$getSlotTargetElement", dom, merge4, ignoreNext4);
 	compilePrerenderKey(prerender, "$updateDOM", dom, merge4, ignoreNext4);
 	compilePrerenderKey(prerender, "$decorateDOM", dom, sequence4, identity);
 	return dom;
@@ -712,7 +694,7 @@ var DOMRenderRuntimeImpl = class {
 * editor. This is highly experimental and subject to change from one version
 * to the next.
 **/
-const DOMRenderExtension = defineExtension({
+const DOMRenderExtension = /* @__PURE__ */ defineExtension({
 	build(editor, config, state) {
 		const { initialEditorConfig } = state.getInitResult();
 		const editorContext = createEditorContextRecord(config.contextDefaults);
@@ -1119,7 +1101,7 @@ function createImportState(name, getDefaultValue, isEqual) {
 *
 * @experimental
 */
-const ImportSource = createImportState("importSource", () => "unknown");
+const ImportSource = /* @__PURE__ */ createImportState("importSource", () => "unknown");
 /**
 * Built-in import-context state holding the {@link DataTransfer} the
 * import was sourced from, if any. `null` outside paste/drop flows.
@@ -1143,7 +1125,7 @@ const ImportSource = createImportState("importSource", () => "unknown");
 *
 * @experimental
 */
-const ImportSourceDataTransfer = createImportState("importSourceDataTransfer", () => null);
+const ImportSourceDataTransfer = /* @__PURE__ */ createImportState("importSourceDataTransfer", () => null);
 /**
 * Built-in import-context state holding the bit-packed
 * {@link TextFormatType} formats that should apply to {@link TextNode}s
@@ -1153,7 +1135,7 @@ const ImportSourceDataTransfer = createImportState("importSourceDataTransfer", (
 *
 * @experimental
 */
-const ImportTextFormat = createImportState("textFormat", () => 0);
+const ImportTextFormat = /* @__PURE__ */ createImportState("textFormat", () => 0);
 /**
 * Built-in import-context state holding a parsed CSS-style record
 * (the {@link getStyleObjectFromCSS} shape) that should apply to
@@ -1170,7 +1152,7 @@ const ImportTextFormat = createImportState("textFormat", () => 0);
 *
 * @experimental
 */
-const ImportTextStyle = createImportState("textStyle", () => ({}));
+const ImportTextStyle = /* @__PURE__ */ createImportState("textStyle", () => ({}));
 /**
 * Determines whether a given DOM element should be treated as preserving
 * whitespace (i.e. text content under it is not collapsed and is split on
@@ -1234,7 +1216,7 @@ function defaultIsInline(node) {
 *
 * @experimental
 */
-const ImportWhitespaceConfig = createImportState("whitespaceConfig", () => ({
+const ImportWhitespaceConfig = /* @__PURE__ */ createImportState("whitespaceConfig", () => ({
 	isInline: defaultIsInline,
 	preservesWhitespace: defaultPreservesWhitespace
 }));
@@ -1256,7 +1238,7 @@ const ImportWhitespaceConfig = createImportState("whitespaceConfig", () => ({
 *
 * @experimental
 */
-const ImportOverlays = createImportState("importOverlays", () => []);
+const ImportOverlays = /* @__PURE__ */ createImportState("importOverlays", () => []);
 /**
 * The session IS the root-layer {@link ContextRecord} of the walk. Reads
 * fall through the prototype chain to the editor's `contextDefaults`,
@@ -1311,6 +1293,197 @@ const $withImportContext = $withContext(DOMImportContextSymbol, getDefaultImport
 * LICENSE file in the root directory of this source tree.
 *
 */
+/**
+* True if the node fills a block slot at the root or inside another
+* block — covers both ElementNode-style blocks (paragraph, heading,
+* quote) and block-level DecoratorNodes (HorizontalRuleNode,
+* ImageNode-as-block, etc.). Used by {@link BlockSchema},
+* {@link RootSchema}, and {@link NestedBlockSchema}.
+*
+* @experimental
+*/
+function $isBlockLevel(node) {
+	return $isBlockElementNode(node) || $isDecoratorNode(node) && !node.isInline();
+}
+/**
+* Distribute an inline wrapper (`LinkNode`, `MarkNode`, …) across a
+* heterogeneous run of children produced by `$importChildren`, lifting
+* any block children to the top level while keeping the wrapper around
+* the leaf inline content.
+*
+* Use from a rule whose DOM source is an inline element that the
+* browser permitted to enclose block elements — the canonical case is
+* `<a href="…"><h1>title</h1><div>body</div></a>`, which a link rule
+* wants to surface as two block siblings (heading + paragraph), each
+* with its own link wrapping the original inline content. Schemas
+* can't express this because they reason about a parent's children
+* only — they cannot lift the parent out of itself.
+*
+* For each top-level child:
+* - **Inline children** are collected into runs; each run is wrapped
+*   in a single fresh wrapper (from `$makeWrapper()`).
+* - **Block children** are descended into: their own children are
+*   recursively distributed with `$makeWrapper`, then re-attached so
+*   the block keeps its position at the top level.
+*
+* The returned list will contain a mix of blocks and wrapped inline
+* runs. The enclosing schema (typically {@link BlockSchema}) will
+* then package those inline wrappers into paragraphs as usual.
+*
+* @experimental
+*/
+function $distributeInlineWrapper(children, $makeWrapper) {
+	const out = [];
+	let inlineRun = [];
+	const flushInline = () => {
+		if (inlineRun.length === 0) return;
+		out.push($makeWrapper().splice(0, 0, inlineRun));
+		inlineRun = [];
+	};
+	for (const child of children) if ($isBlockLevel(child)) {
+		flushInline();
+		if ($isElementNode(child)) {
+			const wrapped = $distributeInlineWrapper(child.getChildren(), $makeWrapper);
+			child.splice(0, child.getChildrenSize(), wrapped);
+		}
+		out.push(child);
+	} else inlineRun.push(child);
+	flushInline();
+	return out;
+}
+/**
+* Apply a {@link ChildSchema} to a flat list of children produced by
+* `$importChildren`. Walks the list once, partitions into accepted vs.
+* rejected runs, packages or drops rejected runs, then runs `$finalize`.
+*
+* @internal
+*/
+function $applySchema(schema, children, parent, domParent) {
+	const out = [];
+	let run = null;
+	const flushRun = () => {
+		if (run === null) return;
+		const rejected = run;
+		run = null;
+		if (schema.$packageRun) {
+			const packaged = schema.$packageRun(rejected, parent, domParent);
+			if (packaged.length > 0) {
+				for (const n of packaged) out.push(n);
+				return;
+			}
+		}
+		if (schema.onReject === "hoist") for (const n of rejected) out.push(n);
+	};
+	for (const child of children) if (schema.$accepts(child, parent)) {
+		flushRun();
+		out.push(child);
+	} else {
+		if (run === null) run = [];
+		run.push(child);
+	}
+	flushRun();
+	return schema.$finalize ? schema.$finalize(out, parent) : out;
+}
+/**
+* Apply a parent DOM element's `text-align` (when set to one of the
+* supported {@link ElementFormatType} values) to each block-level child
+* Lexical node that does not yet have its own format.
+*
+* Mirrors the part of the legacy `wrapContinuousInlines` that wrote
+* `node.setFormat(textAlign)` onto pre-existing block children when the
+* DOM parent carried `style.textAlign`. Pair with
+* {@link $paragraphPackageRun} (which carries the same propagation onto
+* paragraphs synthesized around inline runs) to fully replicate the
+* legacy behavior on a run of mixed children.
+*
+* @experimental
+*/
+function $propagateTextAlignToBlockChildren(children, domParent) {
+	if (!isHTMLElement(domParent)) return children;
+	const textAlign = domParent.style.textAlign;
+	if (!isAlignmentValue(textAlign)) return children;
+	for (const child of children) if ($isBlockElementNode(child) && child.getFormatType() === "") child.setFormat(textAlign);
+	return children;
+}
+/**
+* Wrap a run of inline lexical nodes in a fresh paragraph, propagating the
+* `text-align` of `domParent` as the paragraph's format type (matching the
+* legacy `wrapContinuousInlines` behavior).
+*/
+function $paragraphPackageRun(run, _parent, domParent) {
+	if (run.length === 1 && $isLineBreakNode(run[0])) run = [];
+	const paragraph = $createParagraphNode();
+	if (isHTMLElement(domParent)) {
+		const textAlign = domParent.style.textAlign;
+		if (isAlignmentValue(textAlign)) paragraph.setFormat(textAlign);
+	}
+	return [paragraph.splice(0, 0, run)];
+}
+/**
+* Default schema for block-level positions (root of the document, the body
+* of a block element node). Accepts block lexical nodes; packages runs of
+* inline children into fresh paragraph nodes.
+*
+* @experimental
+*/
+const BlockSchema = {
+	$accepts: $isBlockLevel,
+	$packageRun: $paragraphPackageRun,
+	name: "BlockSchema"
+};
+/**
+* Schema for inline-only positions (the body of an inline lexical node such
+* as a link). Accepts non-block lexical nodes; runs of block children are
+* dropped (`onReject: 'drop'` is the default).
+*
+* @experimental
+*/
+const InlineSchema = {
+	$accepts: (child) => !$isBlockLevel(child),
+	name: "InlineSchema"
+};
+/**
+* Schema for nested block positions — the equivalent of the legacy
+* `ArtificialNode__DO_NOT_USE` flow used when a block DOM element appears
+* inside another block lexical ancestor. Accepts block nodes; runs of inline
+* children are emitted with a line break between consecutive runs (instead
+* of being wrapped in a paragraph, which would introduce an extra level of
+* nesting).
+*
+* @experimental
+*/
+const NestedBlockSchema = {
+	$accepts: $isBlockLevel,
+	/**
+	* Pass an inline run through unchanged. Because the schema iterator only
+	* groups *maximal* rejected runs (each separated from the next by an
+	* accepted block child), the legacy "linebreak between adjacent inline
+	* groups" case never arises — adjacent inline siblings are already
+	* coalesced into one run.
+	*/
+	$packageRun: (run) => run,
+	name: "NestedBlockSchema"
+};
+/**
+* Schema for the topmost level of `$generateNodesFromDOM`. Identical to
+* {@link BlockSchema}; aliased for clarity at the entry point and so it can
+* be overridden separately in the future (e.g. to synthesize a `ListNode`
+* around runs of orphan `ListItemNode`s).
+*
+* @experimental
+*/
+const RootSchema = {
+	$accepts: $isBlockLevel,
+	$packageRun: $paragraphPackageRun,
+	name: "RootSchema"
+};
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*
+*/
 const sel$1 = selBase;
 const ALIGNMENT_VALUES = new Set([
 	"center",
@@ -1448,7 +1621,7 @@ function applyFormatOverride(format, ov) {
 * - `<span style="text-decoration: none">` strip inherited underline /
 *   line-through.
 */
-const InlineFormatRule = defineImportRule({
+const InlineFormatRule = /* @__PURE__ */ defineImportRule({
 	$import: (ctx, el) => {
 		const inherited = ctx.get(ImportTextFormat);
 		const tagDefault = TAG_DEFAULT_STYLE[el.nodeName];
@@ -1549,7 +1722,7 @@ function $applyTextStyle(node, style) {
 * collapse whitespace using the same neighbor-aware rules as the legacy
 * `$convertTextDOMNode`.
 */
-const TextRule = defineImportRule({
+const TextRule = /* @__PURE__ */ defineImportRule({
 	$import: (ctx, el) => {
 		const format = ctx.get(ImportTextFormat);
 		const style = ctx.get(ImportTextStyle);
@@ -1578,41 +1751,77 @@ const TextRule = defineImportRule({
 * a higher-priority `<style>` rule to capture stylesheet text into the
 * import session for later use.
 */
-const IgnoreScriptStyleRule = defineImportRule({
+const IgnoreScriptStyleRule = /* @__PURE__ */ defineImportRule({
 	$import: () => [],
 	match: sel$1.tag("script", "style"),
 	name: "@lexical/html/script-style-ignore"
 });
-const LineBreakRule = defineImportRule({
-	$import: () => [$createLineBreakNode()],
+const LineBreakRule = /* @__PURE__ */ defineImportRule({
+	$import: (_ctx, el) => isOnlyChildInBlockNode(el) || isLastChildInBlockNode(el) ? [] : [$createLineBreakNode()],
 	match: sel$1.tag("br"),
 	name: "@lexical/html/br"
 });
 /**
+* `<p>` rule. Re-applies format, indent, direction, and the legacy
+* `align` attribute fallback.
+*/
+const ParagraphRule = /* @__PURE__ */ defineImportRule({
+	$import: (ctx, el) => {
+		const p = $createParagraphNode();
+		$setFormatFromDOM(p, el);
+		setNodeIndentFromDOM(el, p);
+		if (p.getFormatType() === "") {
+			const align = el.getAttribute("align");
+			if (align && isAlignmentValue(align)) p.setFormat(align);
+		}
+		$setDirectionFromDOM(p, el);
+		return [p.splice(0, 0, ctx.$importChildren(el))];
+	},
+	match: sel$1.tag("p"),
+	name: "@lexical/html/p"
+});
+/**
+* `<hr>` rule, gated on {@link HorizontalRuleNode} registration so it
+* mirrors the legacy `importDOM` contract (a node's conversions are only
+* active when the node itself is registered). It lives here rather than
+* next to `HorizontalRuleExtension` because `@lexical/extension`
+* is upstream of `@lexical/html` in the package graph and cannot define
+* import rules — this is the one node-providing extension whose import
+* support cannot be implied by depending on it.
+*
+* Registered ahead of {@link TransparentBlockRule}: `<hr>` matches
+* `isBlockDomNode`, so the wildcard block rule would otherwise consume
+* it. When `HorizontalRuleNode` is not registered, `$next()` restores
+* the old behavior (the childless element vanishes).
+*
+* @internal
+*/
+const HorizontalRuleRule = /* @__PURE__ */ defineImportRule({
+	$import: (_ctx, _el, $next) => $getEditor().hasNode(HorizontalRuleNode) ? [$createHorizontalRuleNode()] : $next(),
+	match: sel$1.tag("hr"),
+	name: "@lexical/html/hr"
+});
+/**
 * Rules covering the {@link ParagraphNode}, {@link TextNode},
 * {@link LineBreakNode}, and {@link TabNode} cases that the legacy
-* `importDOM` machinery in `@lexical/lexical` handled. Intended to be
-* registered as a dependency of every editor that uses
-* {@link DOMImportExtension}.
+* `importDOM` machinery in `@lexical/lexical` handled, plus the
+* registration-gated `<hr>` rule for {@link HorizontalRuleNode} (see
+* {@link HorizontalRuleRule}). Intended to be registered as a dependency
+* of every editor that uses {@link DOMImportExtension}.
 *
 * @experimental
 */
 const CoreImportRules = [
 	IgnoreScriptStyleRule,
-	defineImportRule({
-		$import: (ctx, el) => {
-			const p = $createParagraphNode();
-			$setFormatFromDOM(p, el);
-			setNodeIndentFromDOM(el, p);
-			if (p.getFormatType() === "") {
-				const align = el.getAttribute("align");
-				if (align && isAlignmentValue(align)) p.setFormat(align);
-			}
-			$setDirectionFromDOM(p, el);
-			return [p.splice(0, 0, ctx.$importChildren(el))];
+	ParagraphRule,
+	HorizontalRuleRule,
+	/* @__PURE__ */ defineImportRule({
+		$import: (ctx, el, $next) => {
+			if (!isBlockDomNode(el)) return $next();
+			return $propagateTextAlignToBlockChildren(ctx.$importChildren(el, { schema: BlockSchema }), el);
 		},
-		match: sel$1.tag("p"),
-		name: "@lexical/html/p"
+		match: sel$1.any(),
+		name: "@lexical/html/transparent-block"
 	}),
 	TextRule,
 	LineBreakRule,
@@ -1780,175 +1989,6 @@ function defineOverlayRules(entries) {
 * LICENSE file in the root directory of this source tree.
 *
 */
-/**
-* True if the node fills a block slot at the root or inside another
-* block — covers both ElementNode-style blocks (paragraph, heading,
-* quote) and block-level DecoratorNodes (HorizontalRuleNode,
-* ImageNode-as-block, etc.). Used by {@link BlockSchema},
-* {@link RootSchema}, and {@link NestedBlockSchema}.
-*
-* @experimental
-*/
-function $isBlockLevel(node) {
-	return $isBlockElementNode(node) || $isDecoratorNode(node) && !node.isInline();
-}
-/**
-* Distribute an inline wrapper (`LinkNode`, `MarkNode`, …) across a
-* heterogeneous run of children produced by `$importChildren`, lifting
-* any block children to the top level while keeping the wrapper around
-* the leaf inline content.
-*
-* Use from a rule whose DOM source is an inline element that the
-* browser permitted to enclose block elements — the canonical case is
-* `<a href="…"><h1>title</h1><div>body</div></a>`, which a link rule
-* wants to surface as two block siblings (heading + paragraph), each
-* with its own link wrapping the original inline content. Schemas
-* can't express this because they reason about a parent's children
-* only — they cannot lift the parent out of itself.
-*
-* For each top-level child:
-* - **Inline children** are collected into runs; each run is wrapped
-*   in a single fresh wrapper (from `$makeWrapper()`).
-* - **Block children** are descended into: their own children are
-*   recursively distributed with `$makeWrapper`, then re-attached so
-*   the block keeps its position at the top level.
-*
-* The returned list will contain a mix of blocks and wrapped inline
-* runs. The enclosing schema (typically {@link BlockSchema}) will
-* then package those inline wrappers into paragraphs as usual.
-*
-* @experimental
-*/
-function $distributeInlineWrapper(children, $makeWrapper) {
-	const out = [];
-	let inlineRun = [];
-	const flushInline = () => {
-		if (inlineRun.length === 0) return;
-		out.push($makeWrapper().splice(0, 0, inlineRun));
-		inlineRun = [];
-	};
-	for (const child of children) if ($isBlockLevel(child)) {
-		flushInline();
-		if ($isElementNode(child)) {
-			const wrapped = $distributeInlineWrapper(child.getChildren(), $makeWrapper);
-			child.splice(0, child.getChildrenSize(), wrapped);
-		}
-		out.push(child);
-	} else inlineRun.push(child);
-	flushInline();
-	return out;
-}
-/**
-* Apply a {@link ChildSchema} to a flat list of children produced by
-* `$importChildren`. Walks the list once, partitions into accepted vs.
-* rejected runs, packages or drops rejected runs, then runs `$finalize`.
-*
-* @internal
-*/
-function $applySchema(schema, children, parent, domParent) {
-	const out = [];
-	let run = null;
-	const flushRun = () => {
-		if (run === null) return;
-		const rejected = run;
-		run = null;
-		if (schema.$packageRun) {
-			const packaged = schema.$packageRun(rejected, parent, domParent);
-			if (packaged.length > 0) {
-				for (const n of packaged) out.push(n);
-				return;
-			}
-		}
-		if (schema.onReject === "hoist") for (const n of rejected) out.push(n);
-	};
-	for (const child of children) if (schema.$accepts(child, parent)) {
-		flushRun();
-		out.push(child);
-	} else {
-		if (run === null) run = [];
-		run.push(child);
-	}
-	flushRun();
-	return schema.$finalize ? schema.$finalize(out, parent) : out;
-}
-/**
-* Wrap a run of inline lexical nodes in a fresh paragraph, propagating the
-* `text-align` of `domParent` as the paragraph's format type (matching the
-* legacy `wrapContinuousInlines` behavior).
-*/
-function $paragraphPackageRun(run, _parent, domParent) {
-	const paragraph = $createParagraphNode();
-	if (isHTMLElement(domParent)) {
-		const textAlign = domParent.style.textAlign;
-		if (isAlignmentValue(textAlign)) paragraph.setFormat(textAlign);
-	}
-	return [paragraph.splice(0, 0, run)];
-}
-/**
-* Default schema for block-level positions (root of the document, the body
-* of a block element node). Accepts block lexical nodes; packages runs of
-* inline children into fresh paragraph nodes.
-*
-* @experimental
-*/
-const BlockSchema = {
-	$accepts: $isBlockLevel,
-	$packageRun: $paragraphPackageRun,
-	name: "BlockSchema"
-};
-/**
-* Schema for inline-only positions (the body of an inline lexical node such
-* as a link). Accepts non-block lexical nodes; runs of block children are
-* dropped (`onReject: 'drop'` is the default).
-*
-* @experimental
-*/
-const InlineSchema = {
-	$accepts: (child) => !$isBlockLevel(child),
-	name: "InlineSchema"
-};
-/**
-* Schema for nested block positions — the equivalent of the legacy
-* `ArtificialNode__DO_NOT_USE` flow used when a block DOM element appears
-* inside another block lexical ancestor. Accepts block nodes; runs of inline
-* children are emitted with a line break between consecutive runs (instead
-* of being wrapped in a paragraph, which would introduce an extra level of
-* nesting).
-*
-* @experimental
-*/
-const NestedBlockSchema = {
-	$accepts: $isBlockLevel,
-	/**
-	* Pass an inline run through unchanged. Because the schema iterator only
-	* groups *maximal* rejected runs (each separated from the next by an
-	* accepted block child), the legacy "linebreak between adjacent inline
-	* groups" case never arises — adjacent inline siblings are already
-	* coalesced into one run.
-	*/
-	$packageRun: (run) => run,
-	name: "NestedBlockSchema"
-};
-/**
-* Schema for the topmost level of `$generateNodesFromDOM`. Identical to
-* {@link BlockSchema}; aliased for clarity at the entry point and so it can
-* be overridden separately in the future (e.g. to synthesize a `ListNode`
-* around runs of orphan `ListItemNode`s).
-*
-* @experimental
-*/
-const RootSchema = {
-	$accepts: $isBlockLevel,
-	$packageRun: $paragraphPackageRun,
-	name: "RootSchema"
-};
-/**
-* Copyright (c) Meta Platforms, Inc. and affiliates.
-*
-* This source code is licensed under the MIT license found in the
-* LICENSE file in the root directory of this source tree.
-*
-*/
 const NO_CAPTURES = Object.freeze({});
 function makeContext(runtime, captures) {
 	return {
@@ -2113,7 +2153,7 @@ function $runPreprocessStack(stack, dom, ctx) {
 *
 * @experimental
 */
-const DefaultHoistRule = defineImportRule({
+const DefaultHoistRule = /* @__PURE__ */ defineImportRule({
 	$import: (ctx, el) => ctx.$importChildren(el),
 	match: selBase.any(),
 	name: "@lexical/html/default-hoist"
@@ -2130,7 +2170,7 @@ const DefaultHoistRule = defineImportRule({
 * The legacy `$generateNodesFromDOM` continues to work in parallel; the
 * intent is to migrate node packages over to this extension incrementally.
 */
-const DOMImportExtension = defineExtension({
+const DOMImportExtension = /* @__PURE__ */ defineExtension({
 	build(editor, config) {
 		const dispatch = compileImportRules(flattenRuleEntries(config.rules));
 		const defaults = contextFromPairs(config.contextDefaults, void 0);
@@ -2186,47 +2226,49 @@ function $generateNodesFromDOMViaExtension(dom, options) {
 */
 /**
 * Bundles {@link CoreImportRules} into a {@link DOMImportExtension}-aware
-* extension. Depend on this from your editor (directly or via richer
-* extensions like `RichTextImportExtension`) to get the equivalent of the
-* legacy core `importDOM` behavior for `<p>`, `<span>`, `<b>`,
-* `<strong>`, `<em>`, `<i>`, `<code>`, `<mark>`, `<s>`, `<sub>`, `<sup>`,
-* `<u>`, `<br>`, and `#text`.
+* extension. Node-providing extensions that contribute import rules
+* (`RichTextExtension`, `ListExtension`, `LinkExtension`,
+* `TableExtension`, `CodeExtension`, …) depend on this themselves, so
+* most editors get it implicitly; depend on it directly to get the
+* equivalent of the legacy core `importDOM` behavior for `<p>`,
+* `<span>`, `<b>`, `<strong>`, `<em>`, `<i>`, `<code>`, `<mark>`,
+* `<s>`, `<sub>`, `<sup>`, `<u>`, `<br>`, and `#text` (plus `<hr>`
+* when `HorizontalRuleNode` is registered).
 *
 * @experimental
 */
-const CoreImportExtension = defineExtension({
-	dependencies: [configExtension(DOMImportExtension, { rules: CoreImportRules })],
+const CoreImportExtension = /* @__PURE__ */ defineExtension({
+	dependencies: [/* @__PURE__ */ configExtension(DOMImportExtension, { rules: CoreImportRules })],
 	name: "@lexical/html/CoreImport"
 });
 /**
-* Import rules for {@link HorizontalRuleNode}.
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
 *
-* @experimental
 */
-const HorizontalRuleImportRules = [defineImportRule({
-	$import: () => [$createHorizontalRuleNode()],
-	match: selBase.tag("hr"),
-	name: "@lexical/html/hr"
-})];
 /**
-* Bundles {@link HorizontalRuleImportRules} (plus
-* {@link CoreImportExtension}) into a single dependency. The legacy
-* {@link HorizontalRuleExtension.importDOM} continues to work in parallel;
-* depend on this extension to opt into the new pipeline.
+* Import rules for {@link HorizontalRuleNode}. The `<hr>` rule is part of
+* {@link CoreImportRules} (gated on `HorizontalRuleNode` registration), so
+* this array exists only for backwards compatibility and introspection.
 *
-* Lives in `@lexical/html` (not `@lexical/extension`) because
-* {@link DOMImportExtension} itself is in `@lexical/html`, and
-* `@lexical/extension` is upstream of `@lexical/html` in the dependency
-* graph — same arrangement as {@link CoreImportExtension}.
+* @experimental
+*/
+const HorizontalRuleImportRules = [HorizontalRuleRule];
+/**
+* Bundles the runtime {@link HorizontalRuleExtension} together with
+* {@link CoreImportExtension}, whose {@link CoreImportRules} include the
+* registration-gated `<hr>` rule.
 *
 * @experimental
+* @deprecated The `<hr>` import rule now ships with
+* {@link CoreImportRules} and activates whenever `HorizontalRuleNode` is
+* registered — depend on `HorizontalRuleExtension` (plus any extension
+* that brings in `CoreImportExtension`) directly instead.
 */
-const HorizontalRuleImportExtension = defineExtension({
-	dependencies: [
-		CoreImportExtension,
-		HorizontalRuleExtension,
-		configExtension(DOMImportExtension, { rules: HorizontalRuleImportRules })
-	],
+const HorizontalRuleImportExtension = /* @__PURE__ */ defineExtension({
+	dependencies: [HorizontalRuleExtension, CoreImportExtension],
 	name: "@lexical/html/HorizontalRuleImport"
 });
 /**
@@ -2281,8 +2323,9 @@ function $generateDOMFromNodes(container, selection = null, editor = $getEditor(
 	return $withRenderContext([contextValue(RenderContextExport, true)], editor)(() => {
 		const root = $getRoot();
 		const domConfig = $getSessionDOMRenderConfig(editor);
+		const slotFrame = $isRangeSelection(selection) ? $getSlotFrame(selection.anchor.getNode()) : null;
 		const parentElementAppend = container.append.bind(container);
-		for (const topLevelNode of root.getChildren()) $appendNodesToHTML(editor, topLevelNode, parentElementAppend, selection, domConfig);
+		for (const topLevelNode of ($isElementNode(slotFrame) ? slotFrame : root).getChildren()) $appendNodesToHTML(editor, topLevelNode, parentElementAppend, selection, domConfig);
 		return container;
 	});
 }
@@ -2312,6 +2355,7 @@ function $generateDOMFromRoot(container, root = $getRoot()) {
 */
 function $generateHtmlFromNodes(editor, selection = null) {
 	if (typeof document === "undefined" || typeof window === "undefined" && typeof global.window === "undefined") formatDevErrorMessage(`To use $generateHtmlFromNodes in headless mode please initialize a headless browser implementation such as JSDom or use withDOM from @lexical/headless/dom before calling this function.`);
+	$assumeActiveEditor(editor);
 	return $generateDOMFromNodes(document.createElement("div"), selection, editor).innerHTML;
 }
 function $appendNodesToHTML(editor, currentNode, parentElementAppend, selection = null, domConfig = $getEditorDOMRenderConfig(editor)) {
@@ -2323,9 +2367,10 @@ function $appendNodesToHTML(editor, currentNode, parentElementAppend, selection
 	if (!element) return false;
 	const fragment = document.createDocumentFragment();
 	const children = $getChildNodes ? $getChildNodes() : $isElementNode(target) ? target.getChildren() : [];
+	const childSelection = shouldInclude && $isNodeSelection(selection) && $isElementNode(currentNode) ? null : selection;
 	const fragmentAppend = fragment.append.bind(fragment);
 	for (const childNode of children) {
-		const shouldIncludeChild = $appendNodesToHTML(editor, childNode, fragmentAppend, selection, domConfig);
+		const shouldIncludeChild = $appendNodesToHTML(editor, childNode, fragmentAppend, childSelection, domConfig);
 		if (!shouldInclude && shouldIncludeChild && domConfig.$extractWithChild(currentNode, childNode, selection, "html", editor)) shouldInclude = true;
 	}
 	if (shouldInclude && !shouldExclude) {
@@ -2340,6 +2385,19 @@ function $appendNodesToHTML(editor, currentNode, parentElementAppend, selection
 	} else parentElementAppend(fragment);
 	return shouldInclude;
 }
+/**
+* Serialize a single node (and its subtree) into `parentElement`, the same way
+* the top-level HTML exporter serializes the nodes it walks. Slots are not part
+* of any node's child list and — like {@link LexicalNode.exportJSON} vs
+* `exportDOM` for NodeState — are intentionally NOT auto-serialized to HTML;
+* a host node opts in by calling this from its own `exportDOM`, e.g. to render
+* each slot value into a `data-lexical-slot` wrapper.
+*
+* @experimental
+*/
+function $appendNodeToHTML(editor, node, parentElement, selection = null) {
+	return $appendNodesToHTML(editor, node, parentElement.append.bind(parentElement), selection, $getSessionDOMRenderConfig(editor));
+}
 function getConversionFunction(domNode, editor) {
 	const { nodeName } = domNode;
 	const cachedConversions = editor._htmlConversions.get(nodeName.toLowerCase());
@@ -2421,4 +2479,4 @@ function isDomNodeBetweenTwoInlineNodes(node) {
 	return isInlineDomNode(node.nextSibling) && isInlineDomNode(node.previousSibling);
 }
 //#endregion
-export { $distributeInlineWrapper, $generateDOMFromNodes, $generateDOMFromRoot, $generateHtmlFromNodes, $generateNodesFromDOM, $generateNodesFromDOMViaExtension, $getImportContextValue, $getRenderContextValue, $getSessionDOMRenderConfig, $inlineStylesFromStyleSheets, $isBlockLevel, $setRenderContextValue, $updateRenderContextValue, $withImportContext, $withRenderContext, BlockSchema, CoreImportExtension, CoreImportRules, DOMImportExtension, DOMRenderExtension, HorizontalRuleImportExtension, HorizontalRuleImportRules, ImportOverlays, ImportSource, ImportSourceDataTransfer, ImportTextFormat, ImportTextStyle, ImportWhitespaceConfig, InlineSchema, NestedBlockSchema, RenderContextExport, RenderContextRoot, RootSchema, contextUpdater, contextValue, createImportState, createRenderState, defaultIsInline, defaultPreservesWhitespace, defineImportRule, defineOverlayRules, domOverride, isElementOfTag, parseSelector, sel };
+export { $appendNodeToHTML, $distributeInlineWrapper, $generateDOMFromNodes, $generateDOMFromRoot, $generateHtmlFromNodes, $generateNodesFromDOM, $generateNodesFromDOMViaExtension, $getImportContextValue, $getRenderContextValue, $getSessionDOMRenderConfig, $inlineStylesFromStyleSheets, $isBlockLevel, $propagateTextAlignToBlockChildren, $setRenderContextValue, $updateRenderContextValue, $withImportContext, $withRenderContext, BlockSchema, CoreImportExtension, CoreImportRules, DOMImportExtension, DOMRenderExtension, HorizontalRuleImportExtension, HorizontalRuleImportRules, ImportOverlays, ImportSource, ImportSourceDataTransfer, ImportTextFormat, ImportTextStyle, ImportWhitespaceConfig, InlineSchema, NestedBlockSchema, RenderContextExport, RenderContextRoot, RootSchema, contextUpdater, contextValue, createImportState, createRenderState, defaultIsInline, defaultPreservesWhitespace, defineImportRule, defineOverlayRules, domOverride, isElementOfTag, parseSelector, sel };