@ckeditor/ckeditor5-core 48.1.0 → 48.2.0-alpha.0

package/dist/editor/editor.d.ts

@@ -173,7 +173,7 @@ export declare abstract class Editor extends /* #__PURE__ */ Editor_base {
      *
      * // The default options can be overridden by the configuration passed to create().
      * ClassicEditor
-     * 	.create( sourceElement, { bar: 3 } )
+     * 	.create( { bar: 3 } )
      * 	.then( editor => {
      * 		editor.config.get( 'foo' ); // -> 1
      * 		editor.config.get( 'bar' ); // -> 3
@@ -206,7 +206,7 @@ export declare abstract class Editor extends /* #__PURE__ */ Editor_base {
      * 	} );
      *
      * ClassicEditor
-     * 	.create( sourceElement, {
+     * 	.create( {
      * 		// Do not initialize these plugins (note: it is defined by a string):
      * 		removePlugins: [ 'Foo' ]
      * 	} )
@@ -216,7 +216,7 @@ export declare abstract class Editor extends /* #__PURE__ */ Editor_base {
      * 	} );
      *
      * ClassicEditor
-     * 	.create( sourceElement, {
+     * 	.create( {
      * 		// Load only this plugin. It can also be defined by a string if
      * 		// this plugin was built into the editor class.
      * 		plugins: [ FooPlugin ]
@@ -441,12 +441,18 @@ export declare abstract class Editor extends /* #__PURE__ */ Editor_base {
      * Registers a given string as a root attribute key. Registered root attributes are added to
      * the {@link module:engine/model/schema~ModelSchema schema}.
      *
-     * Note: Attributes passed in the configuration for multi-root editors
+     * **Note:** Attributes passed in the configuration for multi-root editors
      * ({@link module:core/editor/editorconfig~EditorConfig#roots `config.roots.<rootName>.modelAttributes`}) or
      * single-root editors ({@link module:core/editor/editorconfig~EditorConfig#root `config.root.modelAttributes`})
      * are automatically registered when the editor is initialized. However, registering the same attribute twice
      * does not have any negative impact, so it is recommended to use this method in any feature that uses
      * root attributes.
+     *
+     * **Note:** Registered attributes are attached only to the generic `$root` schema element. A custom root
+     * {@link module:core/editor/editorconfig~RootConfig#modelElement `modelElement`} must opt into the `$root`
+     * attribute chain via `allowAttributesOf: '$root'` to inherit these attributes.
+     * See the {@glink framework/deep-dive/schema#custom-root-elements Custom root elements} section of the
+     * {@glink framework/deep-dive/schema Schema deep-dive} guide for more details.
      */
     registerRootAttribute(key: string): void;
     /**

package/dist/editor/editorconfig.d.ts

@@ -79,8 +79,11 @@ export interface EditorConfig extends EngineConfig {
      *
      * ```ts
      * ClassicEditor
-     * 	.create( document.querySelector( '#editor' ), {
-     * 		initialData: '<h2>Initial data</h2><p>Foo bar.</p>'
+     * 	.create( {
+     * 		attachTo: document.querySelector( '#editor' ),
+     * 		root: {
+     * 			initialData: '<h2>Initial data</h2><p>Foo bar.</p>'
+     * 		}
      * 	} )
      * 	.then( ... )
      * 	.catch( ... );
@@ -94,24 +97,26 @@ export interface EditorConfig extends EngineConfig {
      * roots names and values equal to the data that should be set in each root:
      *
      * ```ts
-     * MultiRootEditor.create(
-     * 	// Roots for the editor:
-     * 	{
-     * 		header: document.querySelector( '#header' ),
-     * 		content: document.querySelector( '#content' ),
-     * 		leftSide: document.querySelector( '#left-side' ),
-     * 		rightSide: document.querySelector( '#right-side' )
-     * 	},
-     * 	// Config:
-     * 	{
-     * 		initialData: {
-     * 			header: '<p>Content for header part.</p>',
-     * 			content: '<p>Content for main part.</p>',
-     * 			leftSide: '<p>Content for left-side box.</p>',
-     * 			rightSide: '<p>Content for right-side box.</p>'
+     * MultiRootEditor.create( {
+     * 	roots: {
+     * 		header: {
+     * 			element: document.querySelector( '#header' ),
+     * 			initialData: '<p>Content for header part.</p>'
+     * 		},
+     * 		content: {
+     * 			element: document.querySelector( '#content' ),
+     * 			initialData: '<p>Content for main part.</p>'
+     * 		},
+     * 		leftSide: {
+     * 			element: document.querySelector( '#left-side' ),
+     * 			initialData: '<p>Content for left-side box.</p>'
+     * 		},
+     * 		rightSide: {
+     * 			element: document.querySelector( '#right-side' ),
+     * 			initialData: '<p>Content for right-side box.</p>'
      * 		}
      * 	}
-     * )
+     * } )
      * .then( ... )
      * .catch( ... );
      * ```
@@ -521,8 +526,11 @@ export interface EditorConfig extends EngineConfig {
      *
      * ```ts
      * ClassicEditor
-     * 	.create( document.querySelector( '#editor' ), {
-     * 		placeholder: 'Type some text...'
+     * 	.create( {
+     * 		attachTo: document.querySelector( '#editor' ),
+     * 		root: {
+     * 			placeholder: 'Type some text...'
+     * 		}
      * 	} )
      * 	.then( ... )
      * 	.catch( ... );
@@ -532,24 +540,26 @@ export interface EditorConfig extends EngineConfig {
      * roots names and values equal to the placeholder that should be set in each root:
      *
      * ```ts
-     * MultiRootEditor.create(
-     * 	// Roots for the editor:
-     * 	{
-     * 		header: document.querySelector( '#header' ),
-     * 		content: document.querySelector( '#content' ),
-     * 		leftSide: document.querySelector( '#left-side' ),
-     * 		rightSide: document.querySelector( '#right-side' )
-     * 	},
-     * 	// Config:
-     * 	{
-     * 		placeholder: {
-     * 			header: 'Type header...',
-     * 			content: 'Type content...',
-     * 			leftSide: 'Type left-side...',
-     * 			rightSide: 'Type right-side...'
+     * MultiRootEditor.create( {
+     * 	roots: {
+     * 		header: {
+     * 			element: document.querySelector( '#header' ),
+     * 			placeholder: 'Type header...'
+     * 		},
+     * 		content: {
+     * 			element: document.querySelector( '#content' ),
+     * 			placeholder: 'Type content...'
+     * 		},
+     * 		leftSide: {
+     * 			element: document.querySelector( '#left-side' ),
+     * 			placeholder: 'Type left-side...'
+     * 		},
+     * 		rightSide: {
+     * 			element: document.querySelector( '#right-side' ),
+     * 			placeholder: 'Type right-side...'
      * 		}
      * 	}
-     * )
+     * } )
      * .then( ... )
      * .catch( ... );
      * ```
@@ -866,8 +876,11 @@ export interface EditorConfig extends EngineConfig {
      *
      * ```ts
      * ClassicEditor
-     * 	.create( document.querySelector( '#editor' ), {
-     * 		label: 'Article main content'
+     * 	.create( {
+     * 		attachTo: document.querySelector( '#editor' ),
+     * 		root: {
+     * 			label: 'Article main content'
+     * 		}
      * 	} )
      * 	.then( ... )
      * 	.catch( ... );
@@ -877,24 +890,26 @@ export interface EditorConfig extends EngineConfig {
      * roots names and values equal to the label that should be used for each root:
      *
      * ```ts
-     * MultiRootEditor.create(
-     * 	// Roots for the editor:
-     * 	{
-     * 		header: document.querySelector( '#header' ),
-     * 		content: document.querySelector( '#content' ),
-     * 		sideQuote: document.querySelector( '#side-quote' ),
-     * 		relatedLinks: document.querySelector( '#related-links' )
-     * 	},
-     * 	// Config:
-     * 	{
-     * 		label: {
-     * 			header: 'Article header',
-     * 			content: 'Article main content',
-     * 			sideQuote: 'Side-quote',
-     * 			relatedLinks: 'Related links'
+     * MultiRootEditor.create( {
+     * 	roots: {
+     * 		header: {
+     * 			element: document.querySelector( '#header' ),
+     * 			label: 'Article header'
+     * 		},
+     * 		content: {
+     * 			element: document.querySelector( '#content' ),
+     * 			label: 'Article main content'
+     * 		},
+     * 		sideQuote: {
+     * 			element: document.querySelector( '#side-quote' ),
+     * 			label: 'Side-quote'
+     * 		},
+     * 		relatedLinks: {
+     * 			element: document.querySelector( '#related-links' ),
+     * 			label: 'Related links'
      * 		}
      * 	}
-     * )
+     * } )
      * .then( ... )
      * .catch( ... );
      * ```
@@ -1089,18 +1104,52 @@ export interface EditorConfig extends EngineConfig {
  */
 export interface RootConfig {
     /**
-     * The DOM element that will be the source for the created editor root (on which the editor root will be initialized).
+     * The DOM element to use as the editor's editable root, or a description of one to create.
+     *
+     * Accepted forms:
+     *
+     * * An existing DOM element.
+     *
+     *   Its content is automatically loaded to the editor upon initialization (but only when
+     *   {@link #initialData `initialData`} is not set).
      *
-     * If a DOM element is passed, its content will be automatically loaded to the editor upon initialization (but only when
-     * {@link #initialData `initialData`} is not set).
+     *   The editor data will be set back to the original element once the editor is destroyed only if the
+     *   {@link module:core/editor/editorconfig~EditorConfig#updateSourceElementOnDestroy `updateSourceElementOnDestroy`}
+     *   option is set to `true`.
      *
-     * The editor data will be set back to the original element once the editor is destroyed only if the
-     * {@link module:core/editor/editorconfig~EditorConfig#updateSourceElementOnDestroy updateSourceElementOnDestroy}
-     * option is set to `true`.
+     *   Not accepted by {@link module:editor-classic/classiceditor~ClassicEditor} - use
+     *   {@link module:core/editor/editorconfig~EditorConfig#attachTo `config.attachTo`} instead.
      *
-     * If this config property is not set, a detached editor will be created. In this case you need to insert it into the DOM manually.
+     * * A tag name string, e.g. `'h1'`. The editor creates a fresh element with that tag and uses it as the editable.
+     *
+     * * A {@link ~ViewRootElementDefinition} object. The editor creates a fresh element matching the definition and
+     * uses it as the editable.
+     *
+     * ```ts
+     * // Tag name string.
+     * BalloonEditor.create( {
+     * 	root: {
+     * 		element: 'h1'
+     * 	}
+     * } );
+     *
+     * // Element definition.
+     * BalloonEditor.create( {
+     * 	root: {
+     * 		element: {
+     * 			name: 'h1',
+     * 			classes: [ 'article-title' ],
+     * 			styles: { 'font-weight': 'bold' },
+     * 			attributes: { 'data-id': '123' }
+     * 		}
+     * 	}
+     * } );
+     * ```
+     *
+     * Unless an existing DOM element is provided, a detached editor will be created. In this case you need to insert
+     * it into the DOM manually.
      */
-    element?: HTMLElement;
+    element?: HTMLElement | string | ViewRootElementDefinition;
     /**
      * The initial editor data to be used instead of the HTML content of the
      * {@link module:core/editor/editorconfig~RootConfig#element source element}.
@@ -1434,6 +1483,47 @@ export interface RootConfig {
      */
     modelAttributes?: EditorRootAttributes;
 }
+/**
+ * A description of the DOM element used as an editor's editable root, accepted by
+ * {@link module:core/editor/editorconfig~RootConfig#element `config.root.element`}.
+ *
+ * ```ts
+ * const element: ViewRootElementDefinition = {
+ * 	name: 'h1',
+ * 	classes: [ 'article-title' ],
+ * 	styles: { 'font-weight': 'bold' },
+ * 	attributes: { 'data-id': '123' }
+ * };
+ * ```
+ *
+ * `class` and `style` may also be passed as strings inside `attributes` as a shorthand:
+ *
+ * ```ts
+ * const element: ViewRootElementDefinition = {
+ * 	name: 'h1',
+ * 	attributes: { class: 'article-title', style: 'font-weight: bold' }
+ * };
+ * ```
+ */
+export interface ViewRootElementDefinition {
+    /**
+     * The DOM tag name to use. Defaults to `'div'` when not provided, so integrators can keep the default element and
+     * still specify {@link #classes}, {@link #styles}, or {@link #attributes}.
+     */
+    name?: string;
+    /**
+     * Class name or array of class names to apply to the editable element. Each name can be provided as a string.
+     */
+    classes?: string | Array<string>;
+    /**
+     * Inline styles to apply to the editable element as a record of style properties.
+     */
+    styles?: Record<string, string>;
+    /**
+     * Additional DOM attributes to apply to the editable element.
+     */
+    attributes?: Record<string, string>;
+}
 /**
  * The configuration of the editor language.
  *

package/dist/editor/utils/normalizerootsconfig.d.ts

@@ -5,7 +5,7 @@
 /**
  * @module core/editor/utils/normalizerootsconfig
  */
-import type { EditorConfig } from '../editorconfig.js';
+import type { EditorConfig, ViewRootElementDefinition } from '../editorconfig.js';
 import { type Config } from '@ckeditor/ckeditor5-utils';
 /**
  * Normalizes the editor roots configuration. It ensures that all root configurations are defined in `config.roots`
@@ -48,3 +48,30 @@ export declare function normalizeMultiRootEditorConstructorParams(sourceElementO
     sourceElementsOrData: Record<string, string> | Record<string, HTMLElement>;
     editorConfig: EditorConfig;
 };
+/**
+ * Normalizes the value passed in {@link module:core/editor/editorconfig~RootConfig#element `config.root.element`} into a
+ * canonical form (`HTMLElement` or {@link module:core/editor/editorconfig~ViewRootElementDefinition}) that the UI layer
+ * can consume directly.
+ *
+ * Accepts:
+ *
+ * * an existing `HTMLElement` - returned as is, so the editor wraps it in place,
+ * * a tag name string (e.g. `'h1'`) - turned into `{ name: 'h1' }`,
+ * * a {@link module:core/editor/editorconfig~ViewRootElementDefinition} object - reshaped so `classes` becomes an
+ * array and `attributes.class` is lifted into it.
+ *
+ * The `class` attribute may be passed either as the dedicated `classes` field (string or array of strings) or as a
+ * `class` key inside `attributes`. They are concatenated. The `style` attribute may be passed either as the `styles`
+ * object or as a `style` string inside `attributes`. When both are provided, the object form takes precedence and a
+ * warning is logged.
+ *
+ * The `<textarea>` tag name is rejected as it cannot host a rich-text editable.
+ *
+ * Already used internally by {@link ~normalizeRootsConfig `normalizeRootsConfig()`} for `config.root.element` /
+ * `config.roots.*.element`. Exported for callers that bypass the regular config-normalization pass, e.g.
+ * {@link module:editor-multi-root/multirooteditor~MultiRootEditor#addRoot `MultiRootEditor.addRoot()`}
+ * and {@link module:editor-multi-root/multirooteditor~MultiRootEditor#createEditable `MultiRootEditor.createEditable()`}.
+ *
+ * @internal
+ */
+export declare function normalizeViewRootElementDefinition(spec: HTMLElement | string | ViewRootElementDefinition | undefined): HTMLElement | ViewRootElementDefinition | undefined;

package/dist/editor/utils/rootacceptsblocks.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+ */
+/**
+ * @module core/editor/utils/rootacceptsblocks
+ */
+import type { Editor } from '../editor.js';
+/**
+ * Returns whether the model root with the given name accepts `$block` children according to the editor's schema.
+ *
+ * Call this once the plugin initialization phase is finished — typically during UI init or right after creating
+ * a new editable — so the schema reflects any plugin-registered root types or additional content rules.
+ *
+ * @internal
+ */
+export declare function rootAcceptsBlocks(editor: Editor, rootName: string): boolean;

package/dist/index.d.ts

@@ -15,13 +15,14 @@ export { ContextPlugin, type ContextInterface, type ContextPluginDependencies }
 export { EditingKeystrokeHandler, type EditingKeystrokeCallback } from './editingkeystrokehandler.js';
 export type { PartialBy, NonEmptyArray, HexColor } from './typings.js';
 export { Editor, type EditorRootAttributes, type EditorCollectUsageDataEvent, type EditorReadyEvent, type EditorDestroyEvent, type LicenseErrorReason as _LicenseErrorReason } from './editor/editor.js';
-export type { EditorConfig, RootConfig, LanguageConfig, ToolbarConfig, ToolbarConfigItem, UiConfig, ViewportOffsetConfig, PoweredByConfig } from './editor/editorconfig.js';
+export type { EditorConfig, RootConfig, ViewRootElementDefinition, LanguageConfig, ToolbarConfig, ToolbarConfigItem, UiConfig, ViewportOffsetConfig, PoweredByConfig } from './editor/editorconfig.js';
 export { attachToForm } from './editor/utils/attachtoform.js';
 export { ElementApiMixin, type ElementApi } from './editor/utils/elementapimixin.js';
 export { secureSourceElement } from './editor/utils/securesourceelement.js';
 export { registerAndInitializeRootConfigAttributes } from './editor/utils/registerandinitializerootconfigattributes.js';
-export { normalizeRootsConfig, normalizeSingleRootEditorConstructorParams, normalizeMultiRootEditorConstructorParams } from './editor/utils/normalizerootsconfig.js';
+export { normalizeRootsConfig, normalizeSingleRootEditorConstructorParams, normalizeMultiRootEditorConstructorParams, normalizeViewRootElementDefinition } from './editor/utils/normalizerootsconfig.js';
 export { verifyRootElements } from './editor/utils/verifyrootelements.js';
+export { rootAcceptsBlocks } from './editor/utils/rootacceptsblocks.js';
 export { PendingActions, type PendingAction, type PendingActionsAddEvent, type PendingActionsRemoveEvent } from './pendingactions.js';
 export { Accessibility, DEFAULT_GROUP_ID as _DEFAULT_ACCESSIBILITY_GROUP_ID, type AddKeystrokeInfoCategoryData, type AddKeystrokeInfoGroupData, type AddKeystrokeInfosData, type KeystrokeInfoDefinition, type KeystrokeInfoDefinitions, type KeystrokeInfoGroupDefinition, type KeystrokeInfoCategoryDefinition } from './accessibility.js';
 export { getEditorUsageData as _getEditorUsageData, type EditorUsageData as _EditorUsageData } from './editor/utils/editorusagedata.js';

package/dist/index.js

@@ -1944,7 +1944,7 @@ function getPageSessionID() {
 	 *
 	 * // The default options can be overridden by the configuration passed to create().
 	 * ClassicEditor
-	 * 	.create( sourceElement, { bar: 3 } )
+	 * 	.create( { bar: 3 } )
 	 * 	.then( editor => {
 	 * 		editor.config.get( 'foo' ); // -> 1
 	 * 		editor.config.get( 'bar' ); // -> 3
@@ -1976,7 +1976,7 @@ function getPageSessionID() {
 	 * 	} );
 	 *
 	 * ClassicEditor
-	 * 	.create( sourceElement, {
+	 * 	.create( {
 	 * 		// Do not initialize these plugins (note: it is defined by a string):
 	 * 		removePlugins: [ 'Foo' ]
 	 * 	} )
@@ -1986,7 +1986,7 @@ function getPageSessionID() {
 	 * 	} );
 	 *
 	 * ClassicEditor
-	 * 	.create( sourceElement, {
+	 * 	.create( {
 	 * 		// Load only this plugin. It can also be defined by a string if
 	 * 		// this plugin was built into the editor class.
 	 * 		plugins: [ FooPlugin ]
@@ -2547,12 +2547,18 @@ function getPageSessionID() {
 	 * Registers a given string as a root attribute key. Registered root attributes are added to
 	 * the {@link module:engine/model/schema~ModelSchema schema}.
 	 *
-	 * Note: Attributes passed in the configuration for multi-root editors
+	 * **Note:** Attributes passed in the configuration for multi-root editors
 	 * ({@link module:core/editor/editorconfig~EditorConfig#roots `config.roots.<rootName>.modelAttributes`}) or
 	 * single-root editors ({@link module:core/editor/editorconfig~EditorConfig#root `config.root.modelAttributes`})
 	 * are automatically registered when the editor is initialized. However, registering the same attribute twice
 	 * does not have any negative impact, so it is recommended to use this method in any feature that uses
 	 * root attributes.
+	 *
+	 * **Note:** Registered attributes are attached only to the generic `$root` schema element. A custom root
+	 * {@link module:core/editor/editorconfig~RootConfig#modelElement `modelElement`} must opt into the `$root`
+	 * attribute chain via `allowAttributesOf: '$root'` to inherit these attributes.
+	 * See the {@glink framework/deep-dive/schema#custom-root-elements Custom root elements} section of the
+	 * {@glink framework/deep-dive/schema Schema deep-dive} guide for more details.
 	 */ registerRootAttribute(key) {
         if (this._registeredRootsAttributesKeys.has(key)) {
             return;
@@ -3064,22 +3070,32 @@ function isTextArea(sourceElement) {
         }
         if (separateAttachTo && isElement(rootConfig.element)) {
             /**
-			 * The {@link module:editor-classic/classiceditor~ClassicEditor} ignores
-			 * {@link module:core/editor/editorconfig~RootConfig#element `config.root.element`} because
-			 * the classic editor replaces the DOM element with its own UI rather than editing inline within it.
-			 * Use {@link module:core/editor/editorconfig~EditorConfig#attachTo `config.attachTo`}
-			 * to specify the DOM element the editor should replace.
+			 * The {@link module:editor-classic/classiceditor~ClassicEditor} cannot use an existing DOM element as
+			 * {@link module:core/editor/editorconfig~RootConfig#element `config.root.element`} because the classic
+			 * editor replaces the source element with its own UI rather than editing inline within it. The passed
+			 * element is ignored along with its content, so any markup inside it will not be used as the editor's
+			 * initial data. Use {@link module:core/editor/editorconfig~EditorConfig#attachTo `config.attachTo`}
+			 * to specify the DOM element the editor should replace, or pass the initial data via
+			 * {@link module:core/editor/editorconfig~RootConfig#initialData `config.root.initialData`}.
+			 *
+			 * A tag name string (e.g. `'h1'`) or a
+			 * {@link module:engine/view/elementdefinition~ViewElementDefinition view element definition} are still
+			 * accepted - they describe the editable root element the classic editor creates inside its UI box.
 			 *
 			 * @error editor-create-root-element-not-supported
 			 */ logWarning('editor-create-root-element-not-supported');
+            // Drop the unsupported DOM element so downstream code can read a normalized value without re-checking.
+            rootConfig.element = undefined;
         }
         // No dedicated initial data for the root.
         if (rootConfig.initialData === undefined) {
             // No legacy initial data for the root, either.
             if (legacyInitialData[rootName] === undefined) {
                 // Use source element data or data itself as a string.
-                // Fall back to legacy sourceElement, `rootConfig.element` or `config.attachTo` (for ClassicEditor) for data extraction.
-                rootConfig.initialData = getInitialData(sourceElementOrDataForRoot || rootConfig.element || separateAttachTo && config.get('attachTo') || '');
+                // Fall back to legacy sourceElement, `rootConfig.element` (only when it is an HTMLElement)
+                // or `config.attachTo` (for ClassicEditor) for data extraction.
+                const rootConfigElement = isElement(rootConfig.element) ? rootConfig.element : undefined;
+                rootConfig.initialData = getInitialData(sourceElementOrDataForRoot || rootConfigElement || separateAttachTo && config.get('attachTo') || '');
             } else if (sourceElementOrDataForRoot && !isElement(sourceElementOrDataForRoot)) {
                 /**
 				 * The initial data is specified both as the first argument of the editor `create()` method
@@ -3129,6 +3145,9 @@ function isTextArea(sourceElement) {
         rootConfig.label ??= getLegacyPlainConfigValue(config, 'label', rootName);
         // Default model element to `$root` so all callers can rely on `rootConfig.modelElement` being a string.
         rootConfig.modelElement ||= '$root';
+        // Reshape `rootConfig.element` into a canonical form (`HTMLElement` or `ViewRootElementDefinition`)
+        // so downstream code can read it directly without re-running the string / flat-notation normalization.
+        rootConfig.element = normalizeViewRootElementDefinition(rootConfig.element);
         rootsConfig[rootName] = rootConfig;
     }
     // The ClassicEditor has a special separate config option `attachTo`.
@@ -3235,6 +3254,123 @@ function isTextArea(sourceElement) {
         return typeof legacyValue == 'string' ? legacyValue : legacyValue[rootName];
     }
 }
+/**
+ * Normalizes the value passed in {@link module:core/editor/editorconfig~RootConfig#element `config.root.element`} into a
+ * canonical form (`HTMLElement` or {@link module:core/editor/editorconfig~ViewRootElementDefinition}) that the UI layer
+ * can consume directly.
+ *
+ * Accepts:
+ *
+ * * an existing `HTMLElement` - returned as is, so the editor wraps it in place,
+ * * a tag name string (e.g. `'h1'`) - turned into `{ name: 'h1' }`,
+ * * a {@link module:core/editor/editorconfig~ViewRootElementDefinition} object - reshaped so `classes` becomes an
+ * array and `attributes.class` is lifted into it.
+ *
+ * The `class` attribute may be passed either as the dedicated `classes` field (string or array of strings) or as a
+ * `class` key inside `attributes`. They are concatenated. The `style` attribute may be passed either as the `styles`
+ * object or as a `style` string inside `attributes`. When both are provided, the object form takes precedence and a
+ * warning is logged.
+ *
+ * The `<textarea>` tag name is rejected as it cannot host a rich-text editable.
+ *
+ * Already used internally by {@link ~normalizeRootsConfig `normalizeRootsConfig()`} for `config.root.element` /
+ * `config.roots.*.element`. Exported for callers that bypass the regular config-normalization pass, e.g.
+ * {@link module:editor-multi-root/multirooteditor~MultiRootEditor#addRoot `MultiRootEditor.addRoot()`}
+ * and {@link module:editor-multi-root/multirooteditor~MultiRootEditor#createEditable `MultiRootEditor.createEditable()`}.
+ *
+ * @internal
+ */ function normalizeViewRootElementDefinition(spec) {
+    if (spec == null) {
+        return undefined;
+    }
+    if (isElement(spec)) {
+        assertAllowedTagName(spec.tagName);
+        return spec;
+    }
+    if (typeof spec === 'string') {
+        assertAllowedTagName(spec);
+        return {
+            name: spec
+        };
+    }
+    const { name, classes, styles, attributes } = spec;
+    if (name !== undefined) {
+        assertAllowedTagName(name);
+    }
+    const { class: attrClass, style: attrStyle, ...restAttributes } = attributes || {};
+    const hadAttrClass = !!attributes && 'class' in attributes;
+    const hasStyles = !!styles && Object.keys(styles).length > 0;
+    const stylesOverrode = hasStyles && !!attrStyle;
+    if (stylesOverrode) {
+        /**
+		 * Both the {@link module:engine/view/elementdefinition~ViewElementObjectDefinition#styles `styles`} object
+		 * and the {@link module:engine/view/elementdefinition~ViewElementObjectDefinition#attributes `attributes.style`}
+		 * string were provided in {@link module:core/editor/editorconfig~RootConfig#element `config.root.element`}.
+		 * Provide one or the other - the object form takes precedence.
+		 *
+		 * @error editor-root-element-styles-overspecified
+		 */ logWarning('editor-root-element-styles-overspecified');
+    }
+    // Split whitespace-separated tokens (e.g. `'foo bar'` or `[ 'a b', 'c' ]`) into individual class names so the
+    // canonical `classes` array is "one class per entry". This matches how a caller would expect the array form to
+    // behave if it were ever passed directly to per-class APIs.
+    const normalizedClasses = [
+        ...tokenizeClasses(classes),
+        ...tokenizeClasses(attrClass)
+    ];
+    // `class` and `style` are kept as empty strings (rather than stripped) when their value was lifted into `classes`
+    // or overridden by `styles`. This way the deep-merge in `Config.set()` overwrites any stale value left from the
+    // user-provided input, instead of preserving it.
+    const normalizedAttributes = {
+        ...restAttributes
+    };
+    if (hadAttrClass) {
+        normalizedAttributes.class = '';
+    }
+    if (stylesOverrode) {
+        normalizedAttributes.style = '';
+    } else if (attrStyle) {
+        normalizedAttributes.style = attrStyle;
+    }
+    return {
+        ...name !== undefined && {
+            name
+        },
+        ...normalizedClasses.length && {
+            classes: normalizedClasses
+        },
+        ...hasStyles && {
+            styles
+        },
+        ...Object.keys(normalizedAttributes).length && {
+            attributes: normalizedAttributes
+        }
+    };
+}
+/**
+ * Splits a class value (string, array of strings, or `undefined`) into individual class tokens.
+ * Whitespace-separated tokens within a single string are split into separate array entries and empty entries are dropped.
+ */ function tokenizeClasses(value) {
+    if (!value) {
+        return [];
+    }
+    return toArray(value).flatMap((token)=>token.split(/\s+/)).filter(Boolean);
+}
+/**
+ * Throws when the given tag name cannot be used as an editable root.
+ */ function assertAllowedTagName(name) {
+    if ([
+        'textarea',
+        'input'
+    ].includes(name.toLowerCase())) {
+        /**
+		 * The DOM tag name specified in {@link module:core/editor/editorconfig~RootConfig#element `config.root.element`}
+		 * cannot be used as an editor's editable root.
+		 *
+		 * @error editor-wrong-element
+		 */ throw new CKEditorError('editor-wrong-element', null);
+    }
+}
 /**
  * An alias for `isElement` from `es-toolkit/compat` with additional type guard.
  */ function isElement(value) {
@@ -3274,6 +3410,23 @@ function isTextArea(sourceElement) {
     }
 }
 
+/**
+ * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+ */ /**
+ * @module core/editor/utils/rootacceptsblocks
+ */ /**
+ * Returns whether the model root with the given name accepts `$block` children according to the editor's schema.
+ *
+ * Call this once the plugin initialization phase is finished — typically during UI init or right after creating
+ * a new editable — so the schema reflects any plugin-registered root types or additional content rules.
+ *
+ * @internal
+ */ function rootAcceptsBlocks(editor, rootName) {
+    const root = editor.model.document.getRoot(rootName);
+    return editor.model.schema.checkChild(root, '$block');
+}
+
 /**
  * The list of pending editor actions.
  *
@@ -3385,5 +3538,5 @@ function isTextArea(sourceElement) {
     }
 }
 
-export { Accessibility, Command, CommandCollection, Context, ContextPlugin, EditingKeystrokeHandler, Editor, ElementApiMixin, MultiCommand, PendingActions, Plugin, PluginCollection, DEFAULT_GROUP_ID as _DEFAULT_ACCESSIBILITY_GROUP_ID, getEditorUsageData as _getEditorUsageData, attachToForm, normalizeMultiRootEditorConstructorParams, normalizeRootsConfig, normalizeSingleRootEditorConstructorParams, registerAndInitializeRootConfigAttributes, secureSourceElement, verifyRootElements };
+export { Accessibility, Command, CommandCollection, Context, ContextPlugin, EditingKeystrokeHandler, Editor, ElementApiMixin, MultiCommand, PendingActions, Plugin, PluginCollection, DEFAULT_GROUP_ID as _DEFAULT_ACCESSIBILITY_GROUP_ID, getEditorUsageData as _getEditorUsageData, attachToForm, normalizeMultiRootEditorConstructorParams, normalizeRootsConfig, normalizeSingleRootEditorConstructorParams, normalizeViewRootElementDefinition, registerAndInitializeRootConfigAttributes, rootAcceptsBlocks, secureSourceElement, verifyRootElements };
 //# sourceMappingURL=index.js.map