@byline/richtext-lexical 5.2.0 → 6.0.1

package/dist/field/editor.js

@@ -1,13 +1,16 @@
 "use client";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { memo, useCallback, useEffect, useMemo, useState } from "react";
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
 import { LexicalErrorBoundary } from "@lexical/react/LexicalErrorBoundary";
 import { HistoryPlugin } from "@lexical/react/LexicalHistoryPlugin";
 import { MarkdownShortcutPlugin } from "@lexical/react/LexicalMarkdownShortcutPlugin";
 import { OnChangePlugin } from "@lexical/react/LexicalOnChangePlugin";
 import { PlainTextPlugin } from "@lexical/react/LexicalPlainTextPlugin";
 import { RichTextPlugin } from "@lexical/react/LexicalRichTextPlugin";
-import { useExtensionDependency, useOptionalExtensionDependency } from "@lexical/react/useExtensionComponent";
+import { useExtensionDependency } from "@lexical/react/useExtensionComponent";
+import { transformersFor } from "./capabilities/filter-transformers.js";
+import { supportsNodeType } from "./capabilities/registered-node-types.js";
 import { useEditorConfig } from "./config/editor-config-context.js";
 import { ContentEditable } from "./content-editable.js";
 import { useMarkdownMode } from "./context/markdown-mode-context.js";
@@ -15,7 +18,6 @@ import { useSharedHistoryContext } from "./context/shared-history-context.js";
 import { useSharedOnChange } from "./context/shared-on-change-context.js";
 import { Debug } from "./debug.js";
 import { BylineFloatingUIExtension, selectFloatingUIItems } from "./extensions/byline-floating-ui/byline-floating-ui-extension.js";
-import { TableExtension } from "./extensions/table/table-extension.js";
 import { BYLINE_TRANSFORMERS } from "./markdown/transformers.js";
 import { TablePlugin } from "./plugins/table-plugin/index.js";
 import { ToolbarPlugin } from "./plugins/toolbar-plugin/index.js";
@@ -33,8 +35,13 @@ const editor_Editor = /*#__PURE__*/ memo(function({ minHeight, maxHeight }) {
     const { onChange } = useSharedOnChange();
     const { historyState } = useSharedHistoryContext();
     const { markdownModeRef } = useMarkdownMode();
-    const { config: { options: { debug, richText, showTreeView, markdownShortcutPlugin }, placeholderText } } = useEditorConfig();
-    const hasTableExtension = void 0 !== useOptionalExtensionDependency(TableExtension);
+    const { config: { mode, markdownShortcuts, controls: { treeView }, debug, placeholderText } } = useEditorConfig();
+    const richText = 'richText' === mode;
+    const [editor] = useLexicalComposerContext();
+    const hasTableNode = supportsNodeType(editor, 'table');
+    const activeTransformers = useMemo(()=>transformersFor(editor, BYLINE_TRANSFORMERS), [
+        editor
+    ]);
     const floatingUIItems = selectFloatingUIItems(useExtensionDependency(BylineFloatingUIExtension).config.items);
     const onRef = useCallback((_floatingAnchorElem)=>{
         if (null != _floatingAnchorElem) setFloatingAnchorElem(_floatingAnchorElem);
@@ -84,10 +91,10 @@ const editor_Editor = /*#__PURE__*/ memo(function({ minHeight, maxHeight }) {
     ]);
     const content = /*#__PURE__*/ jsxs(Fragment, {
         children: [
-            hasTableExtension && /*#__PURE__*/ jsx(TablePlugin, {}),
+            hasTableNode && /*#__PURE__*/ jsx(TablePlugin, {}),
             richText && /*#__PURE__*/ jsx(ToolbarPlugin, {}),
             /*#__PURE__*/ jsxs("div", {
-                className: `editor-container ${showTreeView ? 'tree-view' : ''} ${!richText ? 'plain-text' : ''}`,
+                className: `editor-container ${treeView ? 'tree-view' : ''} ${!richText ? 'plain-text' : ''}`,
                 children: [
                     /*#__PURE__*/ jsx(OnChangePlugin, {
                         ignoreSelectionChange: true,
@@ -111,8 +118,8 @@ const editor_Editor = /*#__PURE__*/ memo(function({ minHeight, maxHeight }) {
                             /*#__PURE__*/ jsx(HistoryPlugin, {
                                 externalHistoryState: historyState
                             }),
-                            markdownShortcutPlugin && /*#__PURE__*/ jsx(MarkdownShortcutPlugin, {
-                                transformers: BYLINE_TRANSFORMERS
+                            markdownShortcuts && /*#__PURE__*/ jsx(MarkdownShortcutPlugin, {
+                                transformers: activeTransformers
                             }),
                             null != floatingAnchorElem && !isSmallWidthViewport && floatingUIItems.map(({ id, Component })=>/*#__PURE__*/ jsx(Component, {
                                     anchorElem: floatingAnchorElem

package/dist/field/extensions/core-nodes/core-nodes-extension.d.ts

@@ -0,0 +1,24 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+/**
+ * Owns the node classes that belong to no switchable feature.
+ *
+ * `MarkNode` and `OverflowNode` ship without an upstream extension, and
+ * neither corresponds to something a field can turn off. Without an
+ * owner both would lose their only registration once the editor root
+ * stopped registering a blanket node list.
+ *
+ * `EditorContext` injects this extension directly into the root's
+ * dependencies, outside `editorConfig.extensions`. Leaving it out of
+ * `builtInExtensions` would NOT have made it non-removable: this module
+ * is publicly exported and `ExtensionsList.remove()` accepts an
+ * extension object as readily as a name string, so site code could have
+ * removed it from the configurable list. Injection at the root is what
+ * enforces its presence.
+ */
+export declare const CoreNodesExtension: import("lexical").LexicalExtension<import("lexical").ExtensionConfigBase, "@byline/richtext-lexical/CoreNodes", unknown, unknown>;

package/dist/field/extensions/core-nodes/core-nodes-extension.js

@@ -0,0 +1,11 @@
+import { MarkNode } from "@lexical/mark";
+import { OverflowNode } from "@lexical/overflow";
+import { defineExtension } from "lexical";
+const CoreNodesExtension = defineExtension({
+    name: '@byline/richtext-lexical/CoreNodes',
+    nodes: ()=>[
+            MarkNode,
+            OverflowNode
+        ]
+});
+export { CoreNodesExtension };

package/dist/field/extensions/heading/heading-extension.d.ts

@@ -0,0 +1,20 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+/**
+ * Owns `HeadingNode`.
+ *
+ * Byline deliberately does not adopt `@lexical/rich-text`'s
+ * `RichTextExtension` for this. That extension binds heading and quote
+ * registration to general rich-text behaviour, so adopting it would
+ * register headings in every rich-text field — and a field configured
+ * without headings would still accept one from a paste, which is the
+ * defect this package had. Owning the node here keeps headings
+ * removable on their own, independently of quotes and of rich-text
+ * behaviour itself.
+ */
+export declare const HeadingExtension: import("lexical").LexicalExtension<import("lexical").ExtensionConfigBase, "@byline/richtext-lexical/Heading", unknown, unknown>;

package/dist/field/extensions/heading/heading-extension.js

@@ -0,0 +1,9 @@
+import { HeadingNode } from "@lexical/rich-text";
+import { defineExtension } from "lexical";
+const HeadingExtension = defineExtension({
+    name: '@byline/richtext-lexical/Heading',
+    nodes: ()=>[
+            HeadingNode
+        ]
+});
+export { HeadingExtension };

package/dist/field/extensions/quote/quote-extension.d.ts

@@ -0,0 +1,16 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+/**
+ * Owns `QuoteNode`.
+ *
+ * Separate from {@link HeadingExtension} on purpose: a field may want
+ * headings without block quotes, or neither. See the heading extension
+ * for why Byline owns these nodes rather than adopting
+ * `RichTextExtension`.
+ */
+export declare const QuoteExtension: import("lexical").LexicalExtension<import("lexical").ExtensionConfigBase, "@byline/richtext-lexical/Quote", unknown, unknown>;

package/dist/field/extensions/quote/quote-extension.js

@@ -0,0 +1,9 @@
+import { QuoteNode } from "@lexical/rich-text";
+import { defineExtension } from "lexical";
+const QuoteExtension = defineExtension({
+    name: '@byline/richtext-lexical/Quote',
+    nodes: ()=>[
+            QuoteNode
+        ]
+});
+export { QuoteExtension };

package/dist/field/hooks/use-markdown-toggle.d.ts

@@ -1,3 +1,4 @@
+import { type LexicalEditor } from 'lexical';
 /**
  * Document-level "view as markdown source" toggle for a single editor.
  *
@@ -13,6 +14,20 @@
  *  - Edits made in markdown produce a single conversion back to rich
  *    nodes on exit, emitting one field value change → **one patch**.
  */
+/**
+ * Whether this editor can offer Markdown source mode.
+ *
+ * Source mode holds the Markdown text in a `CodeNode`, so it needs that
+ * class registered — `$createCodeNode()` throws
+ * "Attempted to create node CodeNode that was not configured to be used
+ * on the editor" otherwise. A field with the code-highlight extension
+ * removed therefore cannot offer the toggle.
+ *
+ * The fix is to withhold the control, NOT to register `CodeNode` for the
+ * toggle's benefit: registering it would let code blocks back in through
+ * paste and storage, which is the acceptance hole this work closed.
+ */
+export declare function canUseMarkdownSourceMode(editor: LexicalEditor): boolean;
 export declare function useMarkdownToggle(): {
     isMarkdown: boolean;
     toggleMarkdown: () => void;

package/dist/field/hooks/use-markdown-toggle.js

@@ -1,9 +1,10 @@
 "use client";
 import { useCallback, useEffect, useRef } from "react";
-import { $createCodeNode, $isCodeNode } from "@lexical/code";
+import { $createCodeNode, $isCodeNode, CodeNode } from "@lexical/code";
 import { $convertFromMarkdownString, $convertToMarkdownString } from "@lexical/markdown";
 import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
 import { $getRoot, RootNode } from "lexical";
+import { transformersFor } from "../capabilities/filter-transformers.js";
 import { APPLY_VALUE_TAG } from "../constants.js";
 import { useMarkdownMode } from "../context/markdown-mode-context.js";
 import { BYLINE_TRANSFORMERS } from "../markdown/transformers.js";
@@ -11,6 +12,11 @@ const MARKDOWN_LANGUAGE = 'markdown';
 function normalize(markdown) {
     return markdown.replace(/\n+$/, '');
 }
+function canUseMarkdownSourceMode(editor) {
+    return editor.hasNodes([
+        CodeNode
+    ]);
+}
 function useMarkdownToggle() {
     const [editor] = useLexicalComposerContext();
     const { isMarkdown, setIsMarkdown, markdownModeRef } = useMarkdownMode();
@@ -18,6 +24,7 @@ function useMarkdownToggle() {
     const originalMarkdownRef = useRef('');
     const unregisterTransformRef = useRef(null);
     const registerRootGuard = useCallback(()=>{
+        if (!canUseMarkdownSourceMode(editor)) return;
         unregisterTransformRef.current?.();
         unregisterTransformRef.current = editor.registerNodeTransform(RootNode, (rootNode)=>{
             let codeNode = rootNode.getChildren().find($isCodeNode);
@@ -38,10 +45,11 @@ function useMarkdownToggle() {
         unregisterTransformRef.current = null;
     }, []);
     const enterMarkdown = useCallback(()=>{
+        if (!canUseMarkdownSourceMode(editor)) return;
         originalEditorStateRef.current = editor.getEditorState();
         markdownModeRef.current = true;
         editor.update(()=>{
-            const markdown = $convertToMarkdownString(BYLINE_TRANSFORMERS, void 0, true);
+            const markdown = $convertToMarkdownString(transformersFor(editor, BYLINE_TRANSFORMERS), void 0, true);
             originalMarkdownRef.current = markdown;
             const codeNode = $createCodeNode(MARKDOWN_LANGUAGE);
             $getRoot().clear().append(codeNode);
@@ -66,7 +74,7 @@ function useMarkdownToggle() {
         if (edited || null == originalEditorStateRef.current) {
             markdownModeRef.current = false;
             editor.update(()=>{
-                $convertFromMarkdownString(currentMarkdown, BYLINE_TRANSFORMERS, void 0, true);
+                $convertFromMarkdownString(currentMarkdown, transformersFor(editor, BYLINE_TRANSFORMERS), void 0, true);
             });
         } else {
             editor.setEditorState(originalEditorStateRef.current, {
@@ -99,4 +107,4 @@ function useMarkdownToggle() {
         toggleMarkdown
     };
 }
-export { useMarkdownToggle };
+export { canUseMarkdownSourceMode, useMarkdownToggle };

package/dist/field/hooks/use-platform-modifier.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Whether to label keyboard shortcuts the Apple way.
+ *
+ * `IS_APPLE` is resolved at module scope from `navigator.platform`, which
+ * is false on the server and true on a Mac client. Reading it directly
+ * during render therefore produced markup the server and client
+ * disagreed about — React reported a hydration mismatch on the toolbar's
+ * `title` and `aria-label` attributes and, as it warns, did not patch
+ * them up: a Mac user could be shown `Ctrl+B`, and a screen reader could
+ * announce it.
+ *
+ * `useSyncExternalStore` uses its server snapshot for the initial client
+ * render as well as for SSR, so the first client render matches the
+ * server exactly and the real platform is adopted immediately after.
+ */
+export declare function useIsApplePlatform(): boolean;

package/dist/field/hooks/use-platform-modifier.js

@@ -0,0 +1,8 @@
+"use client";
+import { useSyncExternalStore } from "react";
+import { IS_APPLE } from "../shared/environment.js";
+const subscribe = ()=>()=>{};
+function useIsApplePlatform() {
+    return useSyncExternalStore(subscribe, ()=>IS_APPLE, ()=>false);
+}
+export { useIsApplePlatform };

package/dist/field/markdown/transformers.d.ts

@@ -20,6 +20,7 @@
  */
 import { type ElementTransformer, type MultilineElementTransformer, type Transformer } from '@lexical/markdown';
 export declare const TABLE: ElementTransformer;
+export declare const ADMONITION_BODY_TRANSFORMERS: Array<Transformer>;
 export declare const ADMONITION: MultilineElementTransformer;
 /**
  * Stock transformers plus Byline's custom-node handlers. Self-referenced by

package/dist/field/markdown/transformers.js

@@ -1,6 +1,7 @@
 import { $convertFromMarkdownString, $convertToMarkdownString, LINK, TEXT_FORMAT_TRANSFORMERS, TRANSFORMERS } from "@lexical/markdown";
 import { $createTableCellNode, $createTableNode, $createTableRowNode, $isTableCellNode, $isTableNode, $isTableRowNode, TableCellHeaderStates, TableCellNode, TableNode, TableRowNode } from "@lexical/table";
-import { $createParagraphNode, $isParagraphNode, $isTextNode } from "lexical";
+import { $createParagraphNode, $getEditor, $isParagraphNode, $isTextNode } from "lexical";
+import { transformersFor } from "../capabilities/filter-transformers.js";
 import { $createAdmonitionNode, $isAdmonitionNode, AdmonitionNode } from "../extensions/admonition/admonition-node.js";
 const TABLE_ROW_REG_EXP = /^(?:\|)(.+)(?:\|)\s?$/;
 const TABLE_ROW_DIVIDER_REG_EXP = /^(\| ?:?-+:? ?)+\|?\s?$/;
@@ -86,7 +87,7 @@ function getTableColumnsSize(table) {
 const $createTableCell = (textContent)=>{
     const content = textContent.replace(/\\n/g, '\n');
     const cell = $createTableCellNode(TableCellHeaderStates.NO_STATUS);
-    $convertFromMarkdownString(content, BYLINE_TRANSFORMERS, cell);
+    $convertFromMarkdownString(content, transformersFor($getEditor(), BYLINE_TRANSFORMERS), cell);
     return cell;
 };
 const mapToTableCells = (textContent)=>{
@@ -135,7 +136,7 @@ const ADMONITION = {
         if (null != children) node.append(...children);
         else if (null != linesInBetween) {
             const body = linesInBetween.join('\n').trim();
-            if (body) $convertFromMarkdownString(body, ADMONITION_BODY_TRANSFORMERS, node);
+            if (body) $convertFromMarkdownString(body, transformersFor($getEditor(), ADMONITION_BODY_TRANSFORMERS), node);
         }
         if (0 === node.getChildrenSize()) node.append($createParagraphNode());
         rootNode.append(node);
@@ -148,4 +149,4 @@ const BYLINE_TRANSFORMERS = [
     ADMONITION,
     ...TRANSFORMERS
 ];
-export { ADMONITION, BYLINE_TRANSFORMERS, TABLE };
+export { ADMONITION, ADMONITION_BODY_TRANSFORMERS, BYLINE_TRANSFORMERS, TABLE };

package/dist/field/nodes/index.d.ts

@@ -6,4 +6,14 @@
  * Copyright (c) Infonomic Company Limited
  */
 import type { Klass, LexicalNode } from 'lexical';
-export declare const Nodes: Array<Klass<LexicalNode>>;
+/**
+ * Every node class Byline knows how to READ.
+ *
+ * This is not a registration list — registration belongs to the
+ * extension that owns each node, so that removing an extension removes
+ * what the field accepts as well as what it offers. This array is the
+ * vocabulary the normalizer and the capability manifest work from, so a
+ * stored document can still be inspected by a field that supports far
+ * less than the document contains.
+ */
+export declare const READABLE_NODES: Array<Klass<LexicalNode>>;

package/dist/field/nodes/index.js

@@ -12,7 +12,7 @@ import { LayoutItemNode } from "../extensions/layout/layout-item-node.js";
 import { AutoLinkNode, LinkNode } from "../extensions/link/index.js";
 import { VimeoNode } from "../extensions/vimeo/vimeo-node.js";
 import { YouTubeNode } from "../extensions/youtube/youtube-node.js";
-const Nodes = [
+const READABLE_NODES = [
     HeadingNode,
     ListNode,
     ListItemNode,
@@ -34,4 +34,4 @@ const Nodes = [
     LayoutContainerNode,
     LayoutItemNode
 ];
-export { Nodes };
+export { READABLE_NODES };

package/dist/field/normalize/adapted-notice.css

@@ -0,0 +1,34 @@
+@layer base, byline-base, theme, byline-theme, byline-functional, byline-typography, components;
+
+@layer byline-components {
+  .byline-richtext-notice {
+    border-radius: var(--border-radius-sm, 4px);
+    font-size: var(--font-size-sm, .8125rem);
+    margin-bottom: 8px;
+    padding: 8px 10px;
+    line-height: 1.4;
+  }
+
+  .byline-richtext-notice p {
+    margin: 0;
+  }
+
+  .byline-richtext-notice p + p {
+    margin-top: 4px;
+  }
+
+  .byline-richtext-notice--adapted {
+    background-color: var(--fill-warning-weak);
+    border: 1px solid var(--stroke-warning);
+    color: var(--text-on-warning-weak);
+  }
+
+  .byline-richtext-notice--refused {
+    background-color: var(--fill-danger-weak);
+    border: 1px solid var(--stroke-danger);
+    color: var(--text-on-danger-weak);
+  }
+}
+
+@layer utilities, byline-utilities;
+

package/dist/field/normalize/adapted-notice.d.ts

@@ -0,0 +1,29 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import type * as React from 'react';
+import './adapted-notice.css';
+/**
+ * Shown when stored content held a structure this field no longer
+ * supports and it was adapted for editing.
+ *
+ * Inline and non-blocking: the content is editable, and the adaptation
+ * only reaches storage if the reader actually saves an edit.
+ */
+export declare function AdaptedNotice(): React.JSX.Element;
+/**
+ * Shown when stored content holds something with no safe conversion —
+ * an image, an embed, or a node type this build does not know.
+ *
+ * Those carry information no structural rewrite can preserve: an inline
+ * image has a media relation and a caption held in a nested editor.
+ * Discarding them silently would be worse than declining to edit, so the
+ * field opens read-only rather than adapting.
+ */
+export declare function UnsupportedContentNotice({ unsupportedTypes, }: {
+    unsupportedTypes: string[];
+}): React.JSX.Element;

package/dist/field/normalize/adapted-notice.js

@@ -0,0 +1,35 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { contentLabelKey, joinLabels } from "./content-labels.js";
+import { useNoticeText } from "./use-notice-text.js";
+import "./adapted-notice.css";
+function AdaptedNotice() {
+    const { t } = useNoticeText();
+    return /*#__PURE__*/ jsx("div", {
+        className: "byline-richtext-notice byline-richtext-notice--adapted",
+        role: "status",
+        children: t('richtext.adapted.notice')
+    });
+}
+function UnsupportedContentNotice({ unsupportedTypes }) {
+    const { t, locale } = useNoticeText();
+    const labels = unsupportedTypes.map((type)=>{
+        const key = contentLabelKey(type);
+        return null != key ? t(key) : type;
+    });
+    return /*#__PURE__*/ jsxs("div", {
+        className: "byline-richtext-notice byline-richtext-notice--refused",
+        role: "alert",
+        children: [
+            /*#__PURE__*/ jsx("p", {
+                children: t('richtext.unsupported.notice', {
+                    items: joinLabels(labels, locale)
+                })
+            }),
+            /*#__PURE__*/ jsx("p", {
+                children: t('richtext.unsupported.action')
+            })
+        ]
+    });
+}
+export { AdaptedNotice, UnsupportedContentNotice };

package/dist/field/normalize/content-labels.d.ts

@@ -0,0 +1,15 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+export declare function contentLabelKey(type: string): string | undefined;
+/**
+ * Join labels the way the active locale writes a list.
+ *
+ * `Intl.ListFormat` is not available in every runtime this may render
+ * in, so fall back to a comma join rather than throwing over a notice.
+ */
+export declare function joinLabels(labels: string[], locale: string): string;

package/dist/field/normalize/content-labels.js

@@ -0,0 +1,19 @@
+const CONTENT_LABEL_KEYS = {
+    'inline-image': 'richtext.content.image',
+    youtube: 'richtext.content.youtube',
+    vimeo: 'richtext.content.vimeo'
+};
+function contentLabelKey(type) {
+    return CONTENT_LABEL_KEYS[type];
+}
+function joinLabels(labels, locale) {
+    try {
+        return new Intl.ListFormat(locale, {
+            style: 'long',
+            type: 'conjunction'
+        }).format(labels);
+    } catch  {
+        return labels.join(', ');
+    }
+}
+export { contentLabelKey, joinLabels };

package/dist/field/normalize/declared-conversions.d.ts

@@ -0,0 +1,131 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+/** A serialized Lexical node, as stored. */
+export interface SerializedNode {
+    type: string;
+    children?: SerializedNode[];
+    [key: string]: unknown;
+}
+/**
+ * What a convertible structure CONTAINS, which is what decides a
+ * structurally valid replacement for it.
+ *
+ * - `to-paragraph` — a block holding inline content. Becomes exactly one
+ *   paragraph, so two adjacent headings stay two paragraphs and an empty
+ *   heading stays an empty paragraph instead of vanishing.
+ * - `lift-blocks` — a block holding blocks. Its children are lifted in
+ *   place, already block-level and already valid where the parent sat.
+ * - `unwrap-inline` — inline content. Its children are lifted inline and
+ *   stay inside the paragraph that held them.
+ * - `to-text` — a text-carrying leaf whose class is unsupported, such as
+ *   a syntax-highlighted code token. Becomes a plain text node with its
+ *   text and inline formats intact.
+ * - `drop` — removed entirely; neighbours are untouched.
+ */
+export type ConversionKind = 'to-paragraph' | 'lift-blocks' | 'unwrap-inline' | 'to-text' | 'drop';
+/**
+ * Serialized types Byline knows to be block-level.
+ *
+ * Needed because a converted node's children are not always inline: a
+ * `listitem` may hold a nested `list`, so turning every item straight
+ * into a paragraph would nest a block inside a paragraph.
+ */
+export declare const BLOCK_TYPES: ReadonlySet<string>;
+export declare function isBlockType(type: string): boolean;
+/**
+ * Serialized types Byline knows to be inline.
+ *
+ * The counterpart to {@link BLOCK_TYPES}, and the reason both lists
+ * exist rather than one: a node's structural role cannot be recovered
+ * from its serialized shape. An inline `link` and a block `quote` are
+ * both elements with `children`, `direction`, `format` and `indent`, so
+ * there is no reliable metadata to infer the role from.
+ *
+ * A SUPPORTED node can reach this test — it arrives as the child of an
+ * unsupported parent being converted — so "not a known block" cannot be
+ * read as "inline". A custom block from a downstream site would be
+ * wrapped into a paragraph and produce a tree Lexical rejects. When a
+ * type appears in neither list its role is unknown, and normalization
+ * refuses the document rather than guessing at it.
+ */
+export declare const INLINE_TYPES: ReadonlySet<string>;
+export declare function isInlineType(type: string): boolean;
+export interface DeclaredConversion {
+    kind: ConversionKind;
+    /**
+     * Information carried on the node's own properties rather than in its
+     * children, which would otherwise be lost silently. Emitted as a
+     * leading paragraph for `lift-blocks` (an admonition title becomes the
+     * first line) and appended to the text for `unwrap-inline` (a link URL
+     * follows its text).
+     */
+    preserveText?: (node: SerializedNode) => string | undefined;
+}
+declare const urlText: (node: SerializedNode) => string | undefined;
+/**
+ * How each convertible structure degrades when a field does not support
+ * it. Type strings are the node classes' own `getType()` values.
+ *
+ * A type absent from this table has NO conversion and is never guessed
+ * at — normalization refuses the document instead. That covers custom
+ * nodes from downstream sites as well as inline images and embeds, whose
+ * media relations and nested-editor captions cannot survive any
+ * structural rewrite.
+ */
+export declare const DECLARED_CONVERSIONS: {
+    readonly heading: {
+        readonly kind: 'to-paragraph';
+    };
+    readonly quote: {
+        readonly kind: 'to-paragraph';
+    };
+    readonly code: {
+        readonly kind: 'to-paragraph';
+    };
+    readonly listitem: {
+        readonly kind: 'to-paragraph';
+    };
+    readonly table: {
+        readonly kind: 'lift-blocks';
+    };
+    readonly tablerow: {
+        readonly kind: 'lift-blocks';
+    };
+    readonly tablecell: {
+        readonly kind: 'lift-blocks';
+    };
+    readonly list: {
+        readonly kind: 'lift-blocks';
+    };
+    readonly 'layout-container': {
+        readonly kind: 'lift-blocks';
+    };
+    readonly 'layout-item': {
+        readonly kind: 'lift-blocks';
+    };
+    readonly admonition: {
+        readonly kind: 'lift-blocks';
+        readonly preserveText: (node: SerializedNode) => string | undefined;
+    };
+    readonly 'code-highlight': {
+        readonly kind: 'to-text';
+    };
+    readonly link: {
+        readonly kind: 'unwrap-inline';
+        readonly preserveText: typeof urlText;
+    };
+    readonly autolink: {
+        readonly kind: 'unwrap-inline';
+        readonly preserveText: typeof urlText;
+    };
+    readonly horizontalrule: {
+        readonly kind: 'drop';
+    };
+};
+export declare function conversionFor(type: string): DeclaredConversion | undefined;
+export {};