@ckeditor/ckeditor5-core 48.0.1-alpha.1 → 48.1.0-alpha.0

package/dist/editor/editor.d.ts

@@ -243,6 +243,12 @@ export declare abstract class Editor extends /* #__PURE__ */ Editor_base {
      * A set of lock IDs for the {@link #isReadOnly} getter.
      */
     protected readonly _readOnlyLocks: Set<symbol | string>;
+    /**
+     * Holds attributes keys that were passed in
+     * {@link module:core/editor/editorconfig~EditorConfig#roots `config.roots.<rootName>.modelAttributes`}
+     *  or {@link module:core/editor/editorconfig~EditorConfig#root `config.root.modelAttributes`}.
+     */
+    protected readonly _registeredRootsAttributesKeys: Set<string>;
     /**
      * `Editor` class is commonly put in `config.plugins` array.
      *
@@ -431,6 +437,26 @@ export declare abstract class Editor extends /* #__PURE__ */ Editor_base {
      * of the {@glink framework/deep-dive/ui/focus-tracking Deep dive into focus tracking} guide to learn more.
      */
     focus(): void;
+    /**
+     * 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
+     * ({@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.
+     */
+    registerRootAttribute(key: string): void;
+    /**
+     * Returns attributes for the specified root.
+     * If no root name is provided, it returns attributes for the 'main' root by default.
+     *
+     * Note: all and only {@link ~Editor#registerRootAttribute registered} roots attributes will be returned.
+     * If a registered root attribute is not set for a given root, `null` will be returned.
+     */
+    getRootAttributes(rootName?: string): EditorRootAttributes;
     /**
      * Creates and initializes a new editor instance.
      *
@@ -522,6 +548,10 @@ export type EditorDestroyEvent = {
     name: 'destroy';
     args: [];
 };
+/**
+ * Attributes set on a model root element.
+ */
+export type EditorRootAttributes = Record<string, unknown>;
 export {};
 /**
  * This error is thrown when trying to pass a `<textarea>` element to a `create()` function of an editor class.
@@ -549,8 +579,10 @@ export {};
  * In case you intended to use the [LTS Edition](https://ckeditor.com/ckeditor-5-lts/),
  * but have not yet made a purchase, please [contact our sales team](https://ckeditor.com/contact-sales/)
  *
- * If you did not intend to use LTS, please switch to non-LTS edition, for example,
- * the [latest](https://ckeditor.com/docs/ckeditor5/latest/updating/guides/changelog.html) build.
+ * If you did not intend to use LTS, please note that all releases in the v47.7 line are
+ * for LTS subscribers only. To use a non-LTS edition, either upgrade to v48 or newer,
+ * which is our standard [latest](https://ckeditor.com/docs/ckeditor5/latest/updating/guides/changelog.html)
+ * release line, or stay on a version 47.6.2 or earlier.
  *
  * @error license-key-lts-not-allowed
  */

package/dist/editor/editorconfig.d.ts

@@ -8,7 +8,7 @@
 import type { ArrayOrItem, Translations } from '@ckeditor/ckeditor5-utils';
 import { type Context } from '../context.js';
 import type { PluginConstructor } from '../plugin.js';
-import { type Editor } from './editor.js';
+import type { EditorRootAttributes, Editor } from './editor.js';
 import type { MenuBarConfig } from '@ckeditor/ckeditor5-ui';
 import type { EngineConfig } from '@ckeditor/ckeditor5-engine';
 /**
@@ -1215,6 +1215,50 @@ export interface RootConfig {
      * See the {@glink features/editor-placeholder "Editor placeholder"} guide for more information and live examples.
      */
     placeholder?: string;
+    /**
+     * The name of the model root element to use for this editor root.
+     *
+     * By default, the editor creates model roots using the generic `$root` element, which allows all standard block
+     * content (paragraphs, headings, lists, tables, etc.). You can set this option to a custom element name if you
+     * need a root with different schema rules — for example, a root that restricts or extends what content is allowed
+     * at the top level.
+     *
+     * The element name must be registered in the {@link module:engine/model/schema~ModelSchema schema} before or during
+     * editor initialization. See the {@glink framework/deep-dive/schema "Schema"} guide for more information about
+     * generic items like `$root` and `$inlineRoot`.
+     *
+     * ```ts
+     * ClassicEditor
+     * 	.create( {
+     * 		root: {
+     * 			modelElement: '$inlineRoot'
+     * 		}
+     * 	} )
+     * 	.then( ... )
+     * 	.catch( ... );
+     * ```
+     *
+     * If your editor implementation uses multiple roots, you can set a different model element for each root:
+     *
+     * ```ts
+     * MultiRootEditor.create( {
+     * 	roots: {
+     * 		header: {
+     * 			modelElement: '$inlineRoot',
+     * 			initialData: 'My document title'
+     * 		},
+     * 		content: {
+     * 			initialData: '<p>Main content goes here.</p>'
+     * 		}
+     * 	}
+     * } )
+     * .then( ... )
+     * .catch( ... );
+     * ```
+     *
+     * @default '$root'
+     */
+    modelElement?: string;
     /**
      * Label which briefly describes this editing area.
      *
@@ -1222,7 +1266,7 @@ export interface RootConfig {
      * to tell apart multiple editor instances (editing areas) on the page. If not set, a default
      * "Rich Text Editor. Editing area [name of the area]" is used instead.
      *
-     * It can also be used by other features when referring to this editing area (e.g. AI features).
+     * It can also be used by other features when referring to this editing area.
      *
      * ```ts
      * ClassicEditor
@@ -1264,6 +1308,131 @@ export interface RootConfig {
      * ```
      */
     label?: string;
+    /**
+     * An optional, longer description of this editing area. It is intended as a stable, human-readable identifier
+     * so features can match a root across sessions, for instance AI features interacting with multiple editor instances
+     * and multi-root editors.
+     *
+     * ```ts
+     * ClassicEditor
+     * 	.create( {
+     * 		attachTo: document.querySelector( '#editor' ),
+     * 		root: {
+     * 			description: '...'
+     * 		}
+     * 	} )
+     * 	.then( ... )
+     * 	.catch( ... );
+     * ```
+     *
+     * If your editor implementation uses multiple roots, you should provide config for roots individually:
+     *
+     * ```ts
+     * MultiRootEditor.create( {
+     * 	roots: {
+     * 		chapter1: {
+     * 			element: document.querySelector( '#chapter1' ),
+     * 			description: 'Editing root for the first chapter.'
+     * 		},
+     * 		chapter2: {
+     * 			element: document.querySelector( '#chapter2' ),
+     * 			description: 'Editing root for the second chapter.'
+     * 		},
+     * 		chapter3: {
+     * 			element: document.querySelector( '#chapter3' ),
+     * 			description: 'Editing root for the third chapter.'
+     * 		}
+     * 	}
+     * } )
+     * .then( ... )
+     * .catch( ... );
+     * ```
+     */
+    description?: string;
+    /**
+     * Initial root attributes for a root.
+     *
+     * **Note: You must provide full set of attributes for each root. If an attribute is not set on a root, set the value to `null`.
+     * Only provided attribute keys will be returned by {@link module:core/editor/editor~Editor#getRootAttributes} or
+     *  {@link module:editor-multi-root/multirooteditor~MultiRootEditor#getRootsAttributes}.**
+     *
+     * Roots attributes hold additional data related to the document roots, in addition to the regular document data (which usually is
+     * HTML). In roots attributes, for each root, you can store arbitrary key-value pairs with attributes connected with that root.
+     * Use it to store any custom data that is specific to your integration or custom features.
+     *
+     * Currently, any official plugins do not use root attributes. This is a mechanism that is prepared for custom features
+     * and non-standard integrations. If you do not provide any custom feature that would use root attributes, you do not need to
+     * handle (save and load) this property.
+     *
+     * ```ts
+     * ClassicEditor.create( {
+     * 	root: {
+     * 		modelAttributes: { customAttribute: true }
+     * 	}
+     * } )
+     * .then( ... )
+     * .catch( ... );
+     * ```
+     *
+     * If your editor implementation uses multiple roots, you should provide attributes for roots individually:
+     *
+     * ```ts
+     * MultiRootEditor.create(
+     * 	{
+     * 		roots: {
+     * 			uid1: {
+     * 				// ... other root config
+     * 				modelAttributes: { order: 20, isLocked: false } // Third, unlocked.
+     * 			},
+     * 			uid2: {
+     * 				// ... other root config
+     * 				modelAttributes: { order: 10, isLocked: true } // Second, locked.
+     * 			},
+     * 			uid3: {
+     * 				// ... other root config
+     * 				modelAttributes: { order: 30, isLocked: true } // Fourth, locked.
+     * 			},
+     * 			uid4: {
+     * 				// ... other root config
+     * 				modelAttributes: { order: 0, isLocked: false } // First, unlocked.
+     * 			}
+     * 		}
+     * 	}
+     * )
+     * .then( ... )
+     * .catch( ... );
+     * ```
+     *
+     * Note, that the above code snippet is only an example. You need to implement your own features that will use these attributes.
+     *
+     * Roots attributes can be changed the same way as attributes set on other model nodes:
+     *
+     * ```ts
+     * editor.model.change( writer => {
+     * 	const root = editor.model.getRoot( 'uid3' );
+     *
+     * 	writer.setAttribute( 'order', 40, root );
+     * } );
+     * ```
+     *
+     * You can react to root attributes changes by listening to
+     * {@link module:engine/model/document~ModelDocument#event:change:data document `change:data` event}:
+     *
+     * ```ts
+     * editor.model.document.on( 'change:data', () => {
+     * 	const changedRoots = editor.model.document.differ.getChangedRoots();
+     *
+     * 	for ( const change of changedRoots ) {
+     * 		if ( change.attributes ) {
+     * 			const root = editor.model.getRoot( change.name );
+     *
+     * 			// ...
+     * 		}
+     * 	}
+     * } );
+     * ```
+     */
+    modelAttributes?: EditorRootAttributes;
 }
 /**
  * The configuration of the editor language.

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

@@ -0,0 +1,16 @@
+/**
+ * @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/registerandinitializerootconfigattributes
+ */
+import type { Editor } from '../editor.js';
+/**
+ * Registers and initializes root attributes from
+ * {@link module:core/editor/editorconfig~EditorConfig#roots `config.roots.<rootName>.modelAttributes`}
+ *  and {@link module:core/editor/editorconfig~EditorConfig#roots `config.root.modelAttributes`}.
+ *
+ * @internal
+ */
+export declare function registerAndInitializeRootConfigAttributes(editor: Editor): void;

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

@@ -0,0 +1,11 @@
+/**
+ * @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
+ */
+import type { Editor } from '../editor.js';
+/**
+ * Verifies that all model root elements are registered in the schema as limit elements.
+ *
+ * @internal
+ */
+export declare function verifyRootElements(editor: Editor): void;

package/dist/index.d.ts

@@ -9,17 +9,19 @@ export { Plugin, type PluginDependencies, type PluginConstructor, type PluginInt
 export { Command, type CommandExecuteEvent } from './command.js';
 export { MultiCommand } from './multicommand.js';
 export { CommandCollection, type CommandsMap } from './commandcollection.js';
-export type { PluginsMap, PluginCollection, PluginEntry } from './plugincollection.js';
+export { type PluginsMap, PluginCollection, type PluginEntry } from './plugincollection.js';
 export { Context, type ContextConfig } from './context.js';
 export { ContextPlugin, type ContextInterface, type ContextPluginDependencies } from './contextplugin.js';
 export { EditingKeystrokeHandler, type EditingKeystrokeCallback } from './editingkeystrokehandler.js';
 export type { PartialBy, NonEmptyArray, HexColor } from './typings.js';
-export { Editor, type EditorCollectUsageDataEvent, type EditorReadyEvent, type EditorDestroyEvent, type LicenseErrorReason as _LicenseErrorReason } from './editor/editor.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 { 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 { verifyRootElements } from './editor/utils/verifyrootelements.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

@@ -2006,6 +2006,11 @@ function getPageSessionID() {
     /**
 	 * A set of lock IDs for the {@link #isReadOnly} getter.
 	 */ _readOnlyLocks;
+    /**
+	 * Holds attributes keys that were passed in
+	 * {@link module:core/editor/editorconfig~EditorConfig#roots `config.roots.<rootName>.modelAttributes`}
+	 *  or {@link module:core/editor/editorconfig~EditorConfig#root `config.root.modelAttributes`}.
+	 */ _registeredRootsAttributesKeys = new Set();
     /**
 	 * `Editor` class is commonly put in `config.plugins` array.
 	 *
@@ -2445,16 +2450,15 @@ function getPageSessionID() {
 	 * Loads and initializes plugins specified in the configuration.
 	 *
 	 * @returns A promise which resolves once the initialization is completed, providing an array of loaded plugins.
-	 */ initPlugins() {
+	 */ async initPlugins() {
         const config = this.config;
         const plugins = config.get('plugins');
         const removePlugins = config.get('removePlugins') || [];
         const extraPlugins = config.get('extraPlugins') || [];
         const substitutePlugins = config.get('substitutePlugins') || [];
-        return this.plugins.init(plugins.concat(extraPlugins), removePlugins, substitutePlugins).then((plugins)=>{
-            checkPluginsAllowedByLicenseKey(this);
-            return plugins;
-        });
+        const loadedPlugins = await this.plugins.init(plugins.concat(extraPlugins), removePlugins, substitutePlugins);
+        checkPluginsAllowedByLicenseKey(this);
+        return loadedPlugins;
         function checkPluginsAllowedByLicenseKey(editor) {
             const licenseKey = editor.config.get('licenseKey');
             if (licenseKey === 'GPL') {
@@ -2489,23 +2493,24 @@ function getPageSessionID() {
 	 *
 	 * @fires destroy
 	 * @returns A promise that resolves once the editor instance is fully destroyed.
-	 */ destroy() {
-        let readyPromise = Promise.resolve();
+	 */ async destroy() {
         if (this.state == 'initializing') {
-            readyPromise = new Promise((resolve)=>this.once('ready', resolve));
-        }
-        return readyPromise.then(()=>{
-            this.fire('destroy');
-            this.stopListening();
-            this.commands.destroy();
-        }).then(()=>this.plugins.destroy()).then(()=>{
-            this.model.destroy();
-            this.data.destroy();
-            this.editing.destroy();
-            this.keystrokes.destroy();
-        })// Remove the editor from the context.
+            await new Promise((resolve)=>this.once('ready', resolve));
+        }
+        this.fire('destroy');
+        this.stopListening();
+        this.commands.destroy();
+        await this.plugins.destroy();
+        this.model.destroy();
+        this.data.destroy();
+        this.editing.destroy();
+        this.keystrokes.destroy();
+        // Remove the editor from the context.
         // When the context was created by this editor, the context will be destroyed.
-        .then(()=>this._context._removeEditor(this));
+        await this._context._removeEditor(this);
+        // To satisfy the return type and to keep it backward compatible.
+        // eslint-disable-next-line no-useless-return
+        return;
     }
     /**
 	 * Executes the specified command with given parameters.
@@ -2538,6 +2543,49 @@ function getPageSessionID() {
 	 */ focus() {
         this.editing.view.focus();
     }
+    /**
+	 * 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
+	 * ({@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.
+	 */ registerRootAttribute(key) {
+        if (this._registeredRootsAttributesKeys.has(key)) {
+            return;
+        }
+        this._registeredRootsAttributesKeys.add(key);
+        this.editing.model.schema.extend('$root', {
+            allowAttributes: key
+        });
+    }
+    /**
+	 * Returns attributes for the specified root.
+	 * If no root name is provided, it returns attributes for the 'main' root by default.
+	 *
+	 * Note: all and only {@link ~Editor#registerRootAttribute registered} roots attributes will be returned.
+	 * If a registered root attribute is not set for a given root, `null` will be returned.
+	 */ getRootAttributes(rootName = 'main') {
+        const root = this.model.document.getRoot(rootName);
+        if (!root) {
+            /**
+			 * The requested root does not exist. Please ensure that the provided root name
+			 * is correct and that the root has been properly initialized in the document.
+			 *
+			 * @error get-root-attributes-missing-root
+			 */ throw new CKEditorError('get-root-attributes-missing-root', this, {
+                rootName
+            });
+        }
+        const rootAttributes = {};
+        for (const key of this._registeredRootsAttributesKeys){
+            rootAttributes[key] = root.hasAttribute(key) ? root.getAttribute(key) : null;
+        }
+        return rootAttributes;
+    }
     /* istanbul ignore next -- @preserve */ /**
 	 * Creates and initializes a new editor instance.
 	 *
@@ -2769,8 +2817,10 @@ function collectUsageData(editor) {
  * In case you intended to use the [LTS Edition](https://ckeditor.com/ckeditor-5-lts/),
  * but have not yet made a purchase, please [contact our sales team](https://ckeditor.com/contact-sales/)
  *
- * If you did not intend to use LTS, please switch to non-LTS edition, for example,
- * the [latest](https://ckeditor.com/docs/ckeditor5/latest/updating/guides/changelog.html) build.
+ * If you did not intend to use LTS, please note that all releases in the v47.7 line are
+ * for LTS subscribers only. To use a non-LTS edition, either upgrade to v48 or newer,
+ * which is our standard [latest](https://ckeditor.com/docs/ckeditor5/latest/updating/guides/changelog.html)
+ * release line, or stay on a version 47.6.2 or earlier.
  *
  * @error license-key-lts-not-allowed
  */
@@ -2881,6 +2931,48 @@ 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/registerandinitializerootconfigattributes
+ */ /**
+ * Registers and initializes root attributes from
+ * {@link module:core/editor/editorconfig~EditorConfig#roots `config.roots.<rootName>.modelAttributes`}
+ *  and {@link module:core/editor/editorconfig~EditorConfig#roots `config.root.modelAttributes`}.
+ *
+ * @internal
+ */ function registerAndInitializeRootConfigAttributes(editor) {
+    const rootsConfig = editor.config.get('roots');
+    let hasRootAttributes = false;
+    for (const rootConfig of Object.values(rootsConfig)){
+        for (const key of Object.keys(rootConfig.modelAttributes || {})){
+            editor.registerRootAttribute(key);
+            hasRootAttributes = true;
+        }
+    }
+    if (!hasRootAttributes) {
+        return;
+    }
+    editor.data.once('init', ()=>{
+        editor.model.enqueueChange({
+            isUndoable: false
+        }, (writer)=>{
+            for (const [rootName, rootConfig] of Object.entries(rootsConfig)){
+                const root = editor.model.document.getRoot(rootName);
+                if (!root) {
+                    continue;
+                }
+                for (const [key, value] of Object.entries(rootConfig.modelAttributes || {})){
+                    if (value !== null) {
+                        writer.setAttribute(key, value, root);
+                    }
+                }
+            }
+        });
+    });
+}
+
 /**
  * Normalizes the editor roots configuration. It ensures that all root configurations are defined in `config.roots`
  * and that they have `initialData` defined.
@@ -3035,6 +3127,8 @@ function isTextArea(sourceElement) {
         // Handle legacy `config.placeholder` and `config.label` for the root.
         rootConfig.placeholder ??= getLegacyPlainConfigValue(config, 'placeholder', rootName);
         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';
         rootsConfig[rootName] = rootConfig;
     }
     // The ClassicEditor has a special separate config option `attachTo`.
@@ -3147,6 +3241,39 @@ function isTextArea(sourceElement) {
     return isElement$1(value);
 }
 
+/**
+ * Verifies that all model root elements are registered in the schema as limit elements.
+ *
+ * @internal
+ */ function verifyRootElements(editor) {
+    const schema = editor.model.schema;
+    const document = editor.model.document;
+    // Iterate `document.roots` directly instead of `document.getRootNames()` because the latter filters out roots
+    // that are not loaded yet (e.g. lazy roots in the multi-root editor), which still need to be verified.
+    // Detached roots are skipped – a detached root is equivalent to being removed, so there is no point in validating it.
+    for (const root of document.roots){
+        if (root === document.graveyard || !root.isAttached()) {
+            continue;
+        }
+        if (!schema.isLimit(root)) {
+            /**
+			 * The model root element must be a {@link module:engine/model/schema~ModelSchemaItemDefinition#isLimit limit element}.
+			 * The element name specified in
+			 * {@link module:core/editor/editorconfig~RootConfig#modelElement `config.root.modelElement`}
+			 * (or `config.roots.<rootName>.modelElement`) must be registered in the schema
+			 * with `isLimit` set to `true`.
+			 *
+			 * @error editor-root-element-is-not-limit
+			 * @param rootName The name of the root that uses a non-limit element.
+			 * @param elementName The name of the model element used for the root.
+			 */ throw new CKEditorError('editor-root-element-is-not-limit', null, {
+                rootName: root.rootName,
+                elementName: root.name
+            });
+        }
+    }
+}
+
 /**
  * The list of pending editor actions.
  *
@@ -3258,5 +3385,5 @@ function isTextArea(sourceElement) {
     }
 }
 
-export { Accessibility, Command, CommandCollection, Context, ContextPlugin, EditingKeystrokeHandler, Editor, ElementApiMixin, MultiCommand, PendingActions, Plugin, DEFAULT_GROUP_ID as _DEFAULT_ACCESSIBILITY_GROUP_ID, getEditorUsageData as _getEditorUsageData, attachToForm, normalizeMultiRootEditorConstructorParams, normalizeRootsConfig, normalizeSingleRootEditorConstructorParams, secureSourceElement };
+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 };
 //# sourceMappingURL=index.js.map