@byline/richtext-lexical 5.2.0 → 6.0.0

package/dist/config.d.ts

@@ -12,7 +12,7 @@
  * registration factory (which dynamic-imports the editor runtime on first
  * mount), the config types, the built-in extension **names**, and the
  * light toolbar-authoring primitives — but NOT `RichTextField` /
- * `EditorField` / `Nodes` or the heavy *content* extension classes
+ * `EditorField` / `READABLE_NODES` or the heavy *content* extension classes
  * (Table, InlineImage, Admonition, …), all of which statically pull React
  * plugins, nodes, and the Lexical core. Import from here at registration
  * sites (e.g. an admin/admin config that you want to evaluate eagerly)

package/dist/field/apply-value-plugin.js

@@ -1,16 +1,22 @@
 "use client";
-import { useEffect, useRef } from "react";
+import { useLayoutEffect, useRef } from "react";
 import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+import { registeredNodeTypes } from "./capabilities/registered-node-types.js";
 import { APPLY_VALUE_TAG } from "./constants.js";
+import { useNormalizationStatus } from "./normalize/normalization-status.js";
+import { normalizeValue } from "./normalize/normalize-value.js";
 import { hashSerializedState } from "./utils/hashSerializedState.js";
 function ApplyValuePlugin({ value, incomingHash, lastEmittedHashRef, normalizedIncomingHashRef, hasNormalizedBaselineRef }) {
     const [editor] = useLexicalComposerContext();
+    const { setStatus } = useNormalizationStatus();
     const lastAppliedHashRef = useRef(void 0);
+    const isRefusedRef = useRef(false);
     const cancelWaiterRef = useRef(void 0);
-    useEffect(()=>{
+    useLayoutEffect(()=>{
         if (null == value) return;
         const nextRawHash = incomingHash;
-        if (nextRawHash === lastEmittedHashRef.current) {
+        const refused = isRefusedRef.current;
+        if (!refused && nextRawHash === lastEmittedHashRef.current) {
             if (true !== hasNormalizedBaselineRef.current) {
                 hasNormalizedBaselineRef.current = true;
                 if (cancelWaiterRef.current) {
@@ -20,13 +26,31 @@ function ApplyValuePlugin({ value, incomingHash, lastEmittedHashRef, normalizedI
             }
             return;
         }
-        if (nextRawHash === lastAppliedHashRef.current) return;
+        if (!refused && nextRawHash === lastAppliedHashRef.current) return;
         if (cancelWaiterRef.current) {
             cancelWaiterRef.current();
             cancelWaiterRef.current = void 0;
         }
         hasNormalizedBaselineRef.current = false;
-        const nextState = editor.parseEditorState(value);
+        const normalized = normalizeValue(value, registeredNodeTypes(editor));
+        if ('refused' === normalized.status) {
+            setStatus({
+                kind: 'refused',
+                unsupportedTypes: normalized.unsupportedTypes
+            });
+            lastAppliedHashRef.current = void 0;
+            isRefusedRef.current = true;
+            hasNormalizedBaselineRef.current = false;
+            return;
+        }
+        isRefusedRef.current = false;
+        setStatus('adapted' === normalized.status ? {
+            kind: 'adapted',
+            convertedTypes: normalized.convertedTypes
+        } : {
+            kind: 'ok'
+        });
+        const nextState = editor.parseEditorState('adapted' === normalized.status ? JSON.stringify(normalized.value) : value);
         editor.setEditorState(nextState, {
             tag: APPLY_VALUE_TAG
         });
@@ -51,7 +75,8 @@ function ApplyValuePlugin({ value, incomingHash, lastEmittedHashRef, normalizedI
         incomingHash,
         lastEmittedHashRef,
         normalizedIncomingHashRef,
-        hasNormalizedBaselineRef
+        hasNormalizedBaselineRef,
+        setStatus
     ]);
     return null;
 }

package/dist/field/capabilities/filter-transformers.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 { Transformer } from '@lexical/markdown';
+import type { LexicalEditor } from 'lexical';
+/**
+ * The transformers that can safely be used with this editor.
+ *
+ * Markdown is a second route into node creation, and it fails harder
+ * than paste does. `registerMarkdownShortcuts` throws when a transformer
+ * names a node class the editor has not registered, and it throws for
+ * the whole pipeline rather than skipping that one transformer — so a
+ * field with the table extension removed would lose Markdown entirely,
+ * not just tables. The same applies to every `$convertFromMarkdownString`
+ * call, which creates nodes directly.
+ *
+ * The membership test is `editor.hasNode`, which is exactly what
+ * `registerMarkdownShortcuts` uses for its own guard, so this filter
+ * cannot disagree with the check it exists to satisfy.
+ *
+ * Takes the list as a parameter rather than importing it: the Markdown
+ * module imports this one, so reaching back for `BYLINE_TRANSFORMERS`
+ * here would be a cycle.
+ */
+export declare function transformersFor(editor: LexicalEditor, transformers: ReadonlyArray<Transformer>): Array<Transformer>;

package/dist/field/capabilities/filter-transformers.js

@@ -0,0 +1,8 @@
+function transformersFor(editor, transformers) {
+    return transformers.filter((transformer)=>{
+        const dependencies = 'dependencies' in transformer ? transformer.dependencies : void 0;
+        if (null == dependencies) return true;
+        return dependencies.every((klass)=>editor.hasNode(klass));
+    });
+}
+export { transformersFor };

package/dist/field/capabilities/registered-node-types.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 { LexicalEditor } from 'lexical';
+/**
+ * The set of node type strings this editor accepts.
+ *
+ * This is the ONLY place in Byline that reads `editor._nodes`. Lexical
+ * declares the property on the public `LexicalEditor` type but exposes
+ * no way to enumerate registered type strings — `hasNode` answers only
+ * for a class you already hold, while the normalizer works from
+ * serialized JSON where all it has is the type string. Keeping the
+ * access here gives a future Lexical change one site to fix.
+ */
+export declare function registeredNodeTypes(editor: LexicalEditor): ReadonlySet<string>;
+/**
+ * Whether this editor accepts `type`.
+ *
+ * Node registration is what decides whether a structure can exist in the
+ * field at all — it governs the legacy paste path, `parseEditorState`
+ * and every command that creates a node — so this is the honest answer
+ * to "does this field support X", not whether some extension appears in
+ * a configuration list.
+ */
+export declare function supportsNodeType(editor: LexicalEditor, type: string): boolean;

package/dist/field/capabilities/registered-node-types.js

@@ -0,0 +1,7 @@
+function registeredNodeTypes(editor) {
+    return new Set(editor._nodes.keys());
+}
+function supportsNodeType(editor, type) {
+    return editor._nodes.has(type);
+}
+export { registeredNodeTypes, supportsNodeType };

package/dist/field/config/built-in-extension-names.d.ts

@@ -31,6 +31,44 @@
  * against the live extension `name`s is exercised by the editor's
  * jsdom/integration coverage.
  */
+export declare const bylineExtensionNames: {
+    readonly Admonition: '@byline/richtext-lexical/Admonition';
+    readonly AutoEmbed: '@byline/richtext-lexical/AutoEmbed';
+    readonly AutoLink: '@byline/richtext-lexical/AutoLink';
+    readonly CodeHighlight: '@byline/richtext-lexical/CodeHighlight';
+    readonly FloatingTextFormat: '@byline/richtext-lexical/FloatingTextFormat';
+    readonly FloatingUI: '@byline/richtext-lexical/FloatingUI';
+    readonly Heading: '@byline/richtext-lexical/Heading';
+    readonly HorizontalRule: '@byline/richtext-lexical/HorizontalRule';
+    readonly InlineImage: '@byline/richtext-lexical/InlineImage';
+    readonly Layout: '@byline/richtext-lexical/Layout';
+    readonly Link: '@byline/richtext-lexical/Link';
+    readonly Quote: '@byline/richtext-lexical/Quote';
+    readonly Table: '@byline/richtext-lexical/Table';
+    readonly Toolbar: '@byline/richtext-lexical/Toolbar';
+    readonly Vimeo: '@byline/richtext-lexical/Vimeo';
+    readonly YouTube: '@byline/richtext-lexical/YouTube';
+};
+/**
+ * Names owned by upstream Lexical packages.
+ *
+ * These deliberately break the `@byline/richtext-lexical/<Key>`
+ * convention because Byline does not own the names — the extensions ship
+ * from `@lexical/list`. They are carried here so a site can remove lists
+ * without importing `@lexical/list` directly and taking a
+ * version-pinned dependency on `lexical` of its own.
+ */
+export declare const upstreamExtensionNames: {
+    readonly List: '@lexical/list/List';
+    readonly CheckList: '@lexical/list/CheckList';
+};
+/**
+ * Every extension a site may remove, replace or reorder.
+ *
+ * Note what is absent: `CoreNodesExtension` is injected by the editor
+ * root rather than configured here, because `MarkNode` and
+ * `OverflowNode` belong to no switchable feature.
+ */
 export declare const builtInExtensions: {
     readonly Admonition: '@byline/richtext-lexical/Admonition';
     readonly AutoEmbed: '@byline/richtext-lexical/AutoEmbed';
@@ -38,14 +76,18 @@ export declare const builtInExtensions: {
     readonly CodeHighlight: '@byline/richtext-lexical/CodeHighlight';
     readonly FloatingTextFormat: '@byline/richtext-lexical/FloatingTextFormat';
     readonly FloatingUI: '@byline/richtext-lexical/FloatingUI';
+    readonly Heading: '@byline/richtext-lexical/Heading';
     readonly HorizontalRule: '@byline/richtext-lexical/HorizontalRule';
     readonly InlineImage: '@byline/richtext-lexical/InlineImage';
     readonly Layout: '@byline/richtext-lexical/Layout';
     readonly Link: '@byline/richtext-lexical/Link';
+    readonly Quote: '@byline/richtext-lexical/Quote';
     readonly Table: '@byline/richtext-lexical/Table';
     readonly Toolbar: '@byline/richtext-lexical/Toolbar';
     readonly Vimeo: '@byline/richtext-lexical/Vimeo';
     readonly YouTube: '@byline/richtext-lexical/YouTube';
+    readonly List: '@lexical/list/List';
+    readonly CheckList: '@lexical/list/CheckList';
 };
 /** Union of the built-in extension `name` strings. */
 export type BuiltInExtensionName = (typeof builtInExtensions)[keyof typeof builtInExtensions];

package/dist/field/config/built-in-extension-names.js

@@ -1,17 +1,27 @@
-const builtInExtensions = {
+const bylineExtensionNames = {
     Admonition: '@byline/richtext-lexical/Admonition',
     AutoEmbed: '@byline/richtext-lexical/AutoEmbed',
     AutoLink: '@byline/richtext-lexical/AutoLink',
     CodeHighlight: '@byline/richtext-lexical/CodeHighlight',
     FloatingTextFormat: '@byline/richtext-lexical/FloatingTextFormat',
     FloatingUI: '@byline/richtext-lexical/FloatingUI',
+    Heading: '@byline/richtext-lexical/Heading',
     HorizontalRule: '@byline/richtext-lexical/HorizontalRule',
     InlineImage: '@byline/richtext-lexical/InlineImage',
     Layout: '@byline/richtext-lexical/Layout',
     Link: '@byline/richtext-lexical/Link',
+    Quote: '@byline/richtext-lexical/Quote',
     Table: '@byline/richtext-lexical/Table',
     Toolbar: '@byline/richtext-lexical/Toolbar',
     Vimeo: '@byline/richtext-lexical/Vimeo',
     YouTube: '@byline/richtext-lexical/YouTube'
 };
-export { builtInExtensions };
+const upstreamExtensionNames = {
+    List: '@lexical/list/List',
+    CheckList: '@lexical/list/CheckList'
+};
+const builtInExtensions = {
+    ...bylineExtensionNames,
+    ...upstreamExtensionNames
+};
+export { builtInExtensions, bylineExtensionNames, upstreamExtensionNames };

package/dist/field/config/default-extensions.js

@@ -6,10 +6,12 @@ import { BylineFloatingUIExtension } from "../extensions/byline-floating-ui/byli
 import { BylineToolbarExtension } from "../extensions/byline-toolbar/byline-toolbar-extension.js";
 import { CodeHighlightExtension } from "../extensions/code-highlight/code-highlight-extension.js";
 import { FloatingTextFormatExtension } from "../extensions/floating-text-format/floating-text-format-extension.js";
+import { HeadingExtension } from "../extensions/heading/heading-extension.js";
 import { HorizontalRuleExtension } from "../extensions/horizontal-rule/horizontal-rule-extension.js";
 import { InlineImageExtension } from "../extensions/inline-image/inline-image-extension.js";
 import { LayoutExtension } from "../extensions/layout/layout-extension.js";
 import { LinkExtension } from "../extensions/link/link-extension.js";
+import { QuoteExtension } from "../extensions/quote/quote-extension.js";
 import { TableExtension } from "../extensions/table/table-extension.js";
 import { VimeoExtension } from "../extensions/vimeo/vimeo-extension.js";
 import { YouTubeExtension } from "../extensions/youtube/youtube-extension.js";
@@ -21,6 +23,8 @@ function defaultExtensionsArray() {
         TabIndentationExtension,
         BylineToolbarExtension,
         BylineFloatingUIExtension,
+        HeadingExtension,
+        QuoteExtension,
         ListExtension,
         CheckListExtension,
         HorizontalRuleExtension,

package/dist/field/config/default.js

@@ -4,17 +4,17 @@ const defaultEditorLexicalConfig = {
     theme: theme
 };
 const DEFAULT_EDITOR_SETTINGS = {
-    options: {
-        richText: true,
-        showTreeView: false,
+    mode: 'richText',
+    markdownShortcuts: false,
+    controls: {
+        blockFormat: true,
+        inlineCode: true,
+        undoRedo: true,
         textAlignment: true,
-        markdownShortcutPlugin: false,
         markdownToggle: false,
-        undoRedo: true,
-        textStyle: true,
-        inlineCode: true,
-        debug: false
+        treeView: false
     },
+    debug: false,
     inlineImageUploadCollection: 'media',
     placeholderText: 'Enter some rich text...'
 };

package/dist/field/config/editor-config-context.d.ts

@@ -1,7 +1,7 @@
 import type * as React from 'react';
-import type { EditorSettings, OptionName } from './types.js';
+import type { EditorControls, EditorSettings } from './types.js';
 interface ContextType {
-    setOption: (name: OptionName, value: boolean) => void;
+    setControl: (name: keyof EditorControls, value: boolean) => void;
     config: EditorSettings;
     uuid: string;
 }

package/dist/field/config/editor-config-context.js

@@ -6,31 +6,28 @@ function generateQuickGuid() {
     return Math.random().toString(36).substring(2, 12) + Math.random().toString(36).substring(2, 12);
 }
 const Context = /*#__PURE__*/ createContext({
-    setOption: (_name, _value)=>{},
+    setControl: (_name, _value)=>{},
     config: DEFAULT_EDITOR_SETTINGS,
     uuid: generateQuickGuid()
 });
 const EditorConfigContext = ({ children, config: configFromProps })=>{
     const [config, setConfig] = useState(configFromProps ?? DEFAULT_EDITOR_SETTINGS);
     const [uuid] = useState(()=>generateQuickGuid());
-    const setOption = useCallback((option, value)=>{
-        setConfig((config)=>{
-            const options = {
-                ...config.options,
-                [option]: value
-            };
-            return {
+    const setControl = useCallback((control, value)=>{
+        setConfig((config)=>({
                 ...config,
-                options
-            };
-        });
+                controls: {
+                    ...config.controls,
+                    [control]: value
+                }
+            }));
     }, []);
     const editorContext = useMemo(()=>({
-            setOption,
+            setControl,
             config,
             uuid
         }), [
-        setOption,
+        setControl,
         config,
         uuid
     ]);

package/dist/field/config/resolve-editor-config.js

@@ -4,9 +4,9 @@ function resolveEditorConfig(fieldConfig, registeredConfig) {
         settings: {
             ...registeredConfig.settings,
             ...fieldConfig.settings,
-            options: {
-                ...registeredConfig.settings.options,
-                ...fieldConfig.settings?.options
+            controls: {
+                ...registeredConfig.settings.controls,
+                ...fieldConfig.settings?.controls
             }
         },
         lexical: fieldConfig.lexical ?? registeredConfig.lexical,

package/dist/field/config/root-dependencies.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 { AnyLexicalExtensionArgument } from 'lexical';
+import type { ExtensionsList } from './extensions-list.js';
+/**
+ * The complete dependency list for an editor root.
+ *
+ * `editorConfig.extensions` carries the OPTIONAL features a site
+ * configures. What an editor actually registers is that list plus
+ * mandatory infrastructure, and `CoreNodesExtension` is injected here
+ * rather than living in the configurable list because `MarkNode` and
+ * `OverflowNode` belong to no switchable feature — `ExtensionsList.remove()`
+ * matches by name and accepts the extension object, so an entry in the
+ * list could be removed by site code.
+ *
+ * Everything that builds an editor goes through this: the live editor,
+ * the test builders, and the capability manifest. A manifest that
+ * disagreed with the runtime about which nodes exist would be worse than
+ * no manifest, and this is the seam that keeps them identical.
+ */
+export declare function rootDependencies(extensions: ExtensionsList): AnyLexicalExtensionArgument[];

package/dist/field/config/root-dependencies.js

@@ -0,0 +1,8 @@
+import { CoreNodesExtension } from "../extensions/core-nodes/core-nodes-extension.js";
+function rootDependencies(extensions) {
+    return [
+        CoreNodesExtension,
+        ...extensions.toArray()
+    ];
+}
+export { rootDependencies };

package/dist/field/config/types.d.ts

@@ -1,15 +1,65 @@
 import type { EditorConfig as LexicalEditorConfig } from 'lexical';
 import type { ExtensionsList } from './extensions-list.js';
 /**
- * Settings that aren't expressible as "is extension X present in the
- * extensions list?" — toolbar / UI mode toggles, debug switches, the
- * inline-image upload target, etc. Everything else now lives on
- * {@link EditorConfig.extensions} and is manipulated via the chainable
- * `lexicalEditor((c) => c.extensions.add(...).remove(...))` API.
+ * Interface preferences — which controls the editing surface shows.
+ *
+ * Every flag here hides an affordance and NOTHING else. None of them
+ * restricts what the field accepts: content still arrives by paste, by
+ * Markdown, and from storage regardless. What a field supports is
+ * decided by its resolved editor — the extensions it is configured with,
+ * everything those pull in transitively, and mandatory core nodes.
+ *
+ * If you want to stop a structure existing in a field, remove the
+ * extension that owns it:
+ * `lexicalEditor((c) => c.extensions.remove(builtInExtensions.Heading))`.
  */
-export type OptionName = 'richText' | 'showTreeView' | 'textAlignment' | 'markdownShortcutPlugin' | 'markdownToggle' | 'undoRedo' | 'textStyle' | 'inlineCode' | 'debug';
+export interface EditorControls {
+    /**
+     * Show the block-format dropdown. Its entries are further limited to
+     * the formats the editor can actually produce, so this hides a control
+     * that is already capability-aware.
+     */
+    blockFormat: boolean;
+    /**
+     * Show the inline-code button.
+     *
+     * This does NOT prevent inline code. Inline code is a `TextNode`
+     * format rather than a node type, so it has no node to unregister and
+     * still arrives by paste. Node-level configuration cannot constrain
+     * it, and neither can this flag.
+     */
+    inlineCode: boolean;
+    /** Show the undo and redo buttons. Keyboard undo keeps working either way. */
+    undoRedo: boolean;
+    /** Show the text-alignment controls. */
+    textAlignment: boolean;
+    /** Show the Markdown source-mode toggle. */
+    markdownToggle: boolean;
+    /** Show the Lexical tree view beneath the editor. */
+    treeView: boolean;
+}
 export interface EditorSettings {
-    options: Record<OptionName, boolean>;
+    /**
+     * Which editing surface to mount: `RichTextPlugin` or
+     * `PlainTextPlugin`. Plain-text mode also hides the toolbar.
+     *
+     * This selects the plugin and its input handling — it does NOT change
+     * what the field accepts. Switching to `plainText` unregisters no node
+     * class, so structural content already in a stored value still loads,
+     * and a paste is still governed by the editor's registered nodes. To
+     * stop a structure existing in the field, remove the extension that
+     * owns it.
+     */
+    mode: 'richText' | 'plainText';
+    /**
+     * Enable Markdown input shortcuts (`# `, `- `, `> ` as you type). The
+     * active transformer set follows the editor's registered nodes, so a
+     * shortcut for a structure the field does not support never fires.
+     */
+    markdownShortcuts: boolean;
+    controls: EditorControls;
+    /** Render debug output and the tree view. */
+    debug: boolean;
     /**
      * Upload collection passed to the inline-image picker. Forwarded to
      * `InlineImageExtension`'s config when the extensions list is built;
@@ -20,7 +70,10 @@ export interface EditorSettings {
     placeholderText: string;
 }
 export interface EditorSettingsOverride {
-    options?: Partial<Record<OptionName, boolean>>;
+    mode?: EditorSettings['mode'];
+    markdownShortcuts?: boolean;
+    controls?: Partial<EditorControls>;
+    debug?: boolean;
     inlineImageUploadCollection?: string;
     placeholderText?: string;
 }

package/dist/field/editor-context.js

@@ -1,16 +1,18 @@
 "use client";
-import { jsx, jsxs } from "react/jsx-runtime";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { useMemo } from "react";
 import { LexicalExtensionComposer } from "@lexical/react/LexicalExtensionComposer";
 import { defineExtension } from "lexical";
 import { defaultExtensionsList } from "./config/default-extensions.js";
 import { EditorConfigContext } from "./config/editor-config-context.js";
+import { rootDependencies } from "./config/root-dependencies.js";
 import { MarkdownModeProvider } from "./context/markdown-mode-context.js";
 import { SharedHistoryContext } from "./context/shared-history-context.js";
 import { SharedOnChangeContext } from "./context/shared-on-change-context.js";
 import { Editor } from "./editor.js";
 import { InlineImageExtension } from "./extensions/inline-image/inline-image-extension.js";
-import { Nodes } from "./nodes/index.js";
+import { AdaptedNotice, UnsupportedContentNotice } from "./normalize/adapted-notice.js";
+import { NormalizationStatusProvider, useNormalizationStatus } from "./normalize/normalization-status.js";
 function EditorContext(props) {
     const { composerKey, editorConfig, onChange, readOnly, value, beforeEditor, afterEditor, children } = props;
     const editable = true !== readOnly;
@@ -20,16 +22,12 @@ function EditorContext(props) {
         if (configured.has(InlineImageExtension)) configured.configure(InlineImageExtension, {
             collection: editorConfig.settings.inlineImageUploadCollection
         });
-        const dependencies = configured.toArray();
+        const dependencies = rootDependencies(configured);
         return defineExtension({
             name: '[root]',
             namespace: editorConfig.lexical.namespace,
-            nodes: [
-                ...Nodes
-            ],
             theme: editorConfig.lexical.theme,
             editable,
-            $initialEditorState: null != value ? JSON.stringify(value) : void 0,
             onError: (error)=>{
                 throw error;
             },
@@ -38,29 +36,48 @@ function EditorContext(props) {
     }, []);
     return /*#__PURE__*/ jsx(EditorConfigContext, {
         config: editorConfig.settings,
-        children: /*#__PURE__*/ jsx(SharedOnChangeContext, {
-            onChange: onChange,
-            children: /*#__PURE__*/ jsx(SharedHistoryContext, {
-                children: /*#__PURE__*/ jsx(MarkdownModeProvider, {
-                    children: /*#__PURE__*/ jsx(LexicalExtensionComposer, {
-                        extension: rootExtension,
-                        contentEditable: null,
-                        children: /*#__PURE__*/ jsxs("div", {
-                            className: "editor-shell",
-                            children: [
-                                beforeEditor,
-                                /*#__PURE__*/ jsx(Editor, {
-                                    minHeight: props.minHeight,
-                                    maxHeight: props.maxHeight
-                                }),
-                                afterEditor,
-                                children
-                            ]
-                        })
-                    }, composerKey + editable)
+        children: /*#__PURE__*/ jsx(NormalizationStatusProvider, {
+            children: /*#__PURE__*/ jsx(SharedOnChangeContext, {
+                onChange: onChange,
+                children: /*#__PURE__*/ jsx(SharedHistoryContext, {
+                    children: /*#__PURE__*/ jsx(MarkdownModeProvider, {
+                        children: /*#__PURE__*/ jsx(LexicalExtensionComposer, {
+                            extension: rootExtension,
+                            contentEditable: null,
+                            children: /*#__PURE__*/ jsx(EditorShell, {
+                                beforeEditor: beforeEditor,
+                                afterEditor: afterEditor,
+                                minHeight: props.minHeight,
+                                maxHeight: props.maxHeight,
+                                children: children
+                            })
+                        }, composerKey + editable)
+                    })
                 })
             })
         })
     });
 }
+function EditorShell({ beforeEditor, afterEditor, minHeight, maxHeight, children }) {
+    const { status } = useNormalizationStatus();
+    return /*#__PURE__*/ jsxs("div", {
+        className: "editor-shell",
+        children: [
+            'refused' === status.kind ? /*#__PURE__*/ jsx(UnsupportedContentNotice, {
+                unsupportedTypes: status.unsupportedTypes
+            }) : /*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    'adapted' === status.kind && /*#__PURE__*/ jsx(AdaptedNotice, {}),
+                    beforeEditor,
+                    /*#__PURE__*/ jsx(Editor, {
+                        minHeight: minHeight,
+                        maxHeight: maxHeight
+                    }),
+                    afterEditor
+                ]
+            }),
+            children
+        ]
+    });
+}
 export { EditorContext };