@ckeditor/ckeditor5-utils 41.4.1 → 42.0.0-alpha.0

package/dist/index.js

@@ -7,9 +7,47 @@ import { isObject, isString, isPlainObject, cloneDeepWith, isElement, isFunction
 /**
  * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
  * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */ /* globals navigator:false */ /**
- * @module utils/env
+ */ /* globals window, document */ /**
+ * @module utils/dom/global
+ */ // This interface exists to make our API pages more readable.
+/**
+ * A helper (module) giving an access to the global DOM objects such as `window` and `document`.
  */ /**
+ * A helper (module) giving an access to the global DOM objects such as `window` and
+ * `document`. Accessing these objects using this helper allows easy and bulletproof
+ * testing, i.e. stubbing native properties:
+ *
+ * ```ts
+ * import { global } from 'ckeditor5/utils';
+ *
+ * // This stub will work for any code using global module.
+ * testUtils.sinon.stub( global, 'window', {
+ * 	innerWidth: 10000
+ * } );
+ *
+ * console.log( global.window.innerWidth );
+ * ```
+ */ let globalVar; // named globalVar instead of global: https://github.com/ckeditor/ckeditor5/issues/12971
+// In some environments window and document API might not be available.
+try {
+    globalVar = {
+        window,
+        document
+    };
+} catch (e) {
+    // It's not possible to mock a window object to simulate lack of a window object without writing extremely convoluted code.
+    /* istanbul ignore next -- @preserve */ // Let's cast it to not change module's API.
+    // We only handle this so loading editor in environments without window and document doesn't fail.
+    // For better DX we shouldn't introduce mixed types and require developers to check the type manually.
+    // This module should not be used on purpose in any environment outside browser.
+    globalVar = {
+        window: {},
+        document: {}
+    };
+}
+var global = globalVar;
+
+/**
  * Safely returns `userAgent` from browser's navigator API in a lower case.
  * If navigator API is not available it will return an empty string.
  */ function getUserAgent() {
@@ -20,23 +58,25 @@ import { isObject, isString, isPlainObject, cloneDeepWith, isElement, isFunction
         return '';
     }
 }
-const userAgent = getUserAgent();
+const userAgent = /* #__PURE__ */ getUserAgent();
 /**
  * A namespace containing environment and browser information.
  */ const env = {
-    isMac: isMac(userAgent),
-    isWindows: isWindows(userAgent),
-    isGecko: isGecko(userAgent),
-    isSafari: isSafari(userAgent),
-    isiOS: isiOS(userAgent),
-    isAndroid: isAndroid(userAgent),
-    isBlink: isBlink(userAgent),
-    isMediaForcedColors: isMediaForcedColors(),
+    isMac: /* #__PURE__ */ isMac(userAgent),
+    isWindows: /* #__PURE__ */ isWindows(userAgent),
+    isGecko: /* #__PURE__ */ isGecko(userAgent),
+    isSafari: /* #__PURE__ */ isSafari(userAgent),
+    isiOS: /* #__PURE__ */ isiOS(userAgent),
+    isAndroid: /* #__PURE__ */ isAndroid(userAgent),
+    isBlink: /* #__PURE__ */ isBlink(userAgent),
+    get isMediaForcedColors () {
+        return isMediaForcedColors();
+    },
     get isMotionReduced () {
         return isMotionReduced();
     },
     features: {
-        isRegExpUnicodePropertySupported: isRegExpUnicodePropertySupported()
+        isRegExpUnicodePropertySupported: /* #__PURE__ */ isRegExpUnicodePropertySupported()
     }
 };
 /**
@@ -116,13 +156,17 @@ const userAgent = getUserAgent();
 }
 /**
  * Checks if the user agent has enabled a forced colors mode (e.g. Windows High Contrast mode).
+ *
+ * Returns `false` in environments where `window` global object is not available.
  */ function isMediaForcedColors() {
-    return window.matchMedia('(forced-colors: active)').matches;
+    return global.window.matchMedia ? global.window.matchMedia('(forced-colors: active)').matches : false;
 }
 /**
- * Checks if user enabled "prefers reduced motion" setting in browser.
+ * Checks if the user enabled "prefers reduced motion" setting in browser.
+ *
+ * Returns `false` in environments where `window` global object is not available.
  */ function isMotionReduced() {
-    return window.matchMedia('(prefers-reduced-motion)').matches;
+    return global.window.matchMedia ? global.window.matchMedia('(prefers-reduced-motion)').matches : false;
 }
 
 /**
@@ -620,11 +664,45 @@ diff.fastDiff = fastDiff;
     };
 }
 
-class EventInfo {
+/**
+ * The event object passed to event callbacks. It is used to provide information about the event as well as a tool to
+ * manipulate it.
+ */ class EventInfo {
+    /**
+	 * The object that fired the event.
+	 */ source;
     /**
-     * @param source The emitter.
-     * @param name The event name.
-     */ constructor(source, name){
+	 * The event name.
+	 */ name;
+    /**
+	 * Path this event has followed. See {@link module:utils/emittermixin~Emitter#delegate}.
+	 */ path;
+    /**
+	 * Stops the event emitter to call further callbacks for this event interaction.
+	 */ stop;
+    /**
+	 * Removes the current callback from future interactions of this event.
+	 */ off;
+    /**
+	 * The value which will be returned by {@link module:utils/emittermixin~Emitter#fire}.
+	 *
+	 * It's `undefined` by default and can be changed by an event listener:
+	 *
+	 * ```ts
+	 * dataController.fire( 'getSelectedContent', ( evt ) => {
+	 * 	// This listener will make `dataController.fire( 'getSelectedContent' )`
+	 * 	// always return an empty DocumentFragment.
+	 * 	evt.return = new DocumentFragment();
+	 *
+	 * 	// Make sure no other listeners are executed.
+	 * 	evt.stop();
+	 * } );
+	 * ```
+	 */ return;
+    /**
+	 * @param source The emitter.
+	 * @param name The event name.
+	 */ constructor(source, name){
         this.source = source;
         this.name = name;
         this.path = [];
@@ -675,6 +753,10 @@ class EventInfo {
  * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
  * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
  */ /**
+ * @module utils/priorities
+ */ /**
+ * String representing a priority value.
+ */ /**
  * Provides group of constants to use instead of hardcoding numeric priority values.
  */ const priorities = {
     get (priority = 'normal') {
@@ -715,57 +797,90 @@ class EventInfo {
  */ /* globals console */ /**
  * URL to the documentation with error codes.
  */ const DOCUMENTATION_URL = 'https://ckeditor.com/docs/ckeditor5/latest/support/error-codes.html';
-class CKEditorError extends Error {
+/**
+ * The CKEditor error class.
+ *
+ * You should throw `CKEditorError` when:
+ *
+ * * An unexpected situation occurred and the editor (most probably) will not work properly. Such exception will be handled
+ * by the {@link module:watchdog/watchdog~Watchdog watchdog} (if it is integrated),
+ * * If the editor is incorrectly integrated or the editor API is used in the wrong way. This way you will give
+ * feedback to the developer as soon as possible. Keep in mind that for common integration issues which should not
+ * stop editor initialization (like missing upload adapter, wrong name of a toolbar component) we use
+ * {@link module:utils/ckeditorerror~logWarning `logWarning()`} and
+ * {@link module:utils/ckeditorerror~logError `logError()`}
+ * to improve developers experience and let them see the a working editor as soon as possible.
+ *
+ * ```ts
+ * /**
+ *  * Error thrown when a plugin cannot be loaded due to JavaScript errors, lack of plugins with a given name, etc.
+ *  *
+ *  * @error plugin-load
+ *  * @param pluginName The name of the plugin that could not be loaded.
+ *  * @param moduleName The name of the module which tried to load this plugin.
+ *  *\/
+ * throw new CKEditorError( 'plugin-load', {
+ * 	pluginName: 'foo',
+ * 	moduleName: 'bar'
+ * } );
+ * ```
+ */ class CKEditorError extends Error {
+    /**
+	 * A context of the error by which the Watchdog is able to determine which editor crashed.
+	 */ context;
+    /**
+	 * The additional error data passed to the constructor. Undefined if none was passed.
+	 */ data;
+    /**
+	 * Creates an instance of the CKEditorError class.
+	 *
+	 * @param errorName The error id in an `error-name` format. A link to this error documentation page will be added
+	 * to the thrown error's `message`.
+	 * @param context A context of the error by which the {@link module:watchdog/watchdog~Watchdog watchdog}
+	 * is able to determine which editor crashed. It should be an editor instance or a property connected to it. It can be also
+	 * a `null` value if the editor should not be restarted in case of the error (e.g. during the editor initialization).
+	 * The error context should be checked using the `areConnectedThroughProperties( editor, context )` utility
+	 * to check if the object works as the context.
+	 * @param data Additional data describing the error. A stringified version of this object
+	 * will be appended to the error message, so the data are quickly visible in the console. The original
+	 * data object will also be later available under the {@link #data} property.
+	 */ constructor(errorName, context, data){
+        super(getErrorMessage(errorName, data));
+        this.name = 'CKEditorError';
+        this.context = context;
+        this.data = data;
+    }
     /**
-     * Checks if the error is of the `CKEditorError` type.
-     */ is(type) {
+	 * Checks if the error is of the `CKEditorError` type.
+	 */ is(type) {
         return type === 'CKEditorError';
     }
     /**
-     * A utility that ensures that the thrown error is a {@link module:utils/ckeditorerror~CKEditorError} one.
-     * It is useful when combined with the {@link module:watchdog/watchdog~Watchdog} feature, which can restart the editor in case
-     * of a {@link module:utils/ckeditorerror~CKEditorError} error.
-     *
-     * @param err The error to rethrow.
-     * @param context An object connected through properties with the editor instance. This context will be used
-     * by the watchdog to verify which editor should be restarted.
-     */ static rethrowUnexpectedError(err, context) {
+	 * A utility that ensures that the thrown error is a {@link module:utils/ckeditorerror~CKEditorError} one.
+	 * It is useful when combined with the {@link module:watchdog/watchdog~Watchdog} feature, which can restart the editor in case
+	 * of a {@link module:utils/ckeditorerror~CKEditorError} error.
+	 *
+	 * @param err The error to rethrow.
+	 * @param context An object connected through properties with the editor instance. This context will be used
+	 * by the watchdog to verify which editor should be restarted.
+	 */ static rethrowUnexpectedError(err, context) {
         if (err.is && err.is('CKEditorError')) {
             throw err;
         }
         /**
-         * An unexpected error occurred inside the CKEditor 5 codebase. This error will look like the original one
-         * to make the debugging easier.
-         *
-         * This error is only useful when the editor is initialized using the {@link module:watchdog/watchdog~Watchdog} feature.
-         * In case of such error (or any {@link module:utils/ckeditorerror~CKEditorError} error) the watchdog should restart the editor.
-         *
-         * @error unexpected-error
-         */ const error = new CKEditorError(err.message, context);
+		 * An unexpected error occurred inside the CKEditor 5 codebase. This error will look like the original one
+		 * to make the debugging easier.
+		 *
+		 * This error is only useful when the editor is initialized using the {@link module:watchdog/watchdog~Watchdog} feature.
+		 * In case of such error (or any {@link module:utils/ckeditorerror~CKEditorError} error) the watchdog should restart the editor.
+		 *
+		 * @error unexpected-error
+		 */ const error = new CKEditorError(err.message, context);
         // Restore the original stack trace to make the error look like the original one.
         // See https://github.com/ckeditor/ckeditor5/issues/5595 for more details.
         error.stack = err.stack;
         throw error;
     }
-    /**
-     * Creates an instance of the CKEditorError class.
-     *
-     * @param errorName The error id in an `error-name` format. A link to this error documentation page will be added
-     * to the thrown error's `message`.
-     * @param context A context of the error by which the {@link module:watchdog/watchdog~Watchdog watchdog}
-     * is able to determine which editor crashed. It should be an editor instance or a property connected to it. It can be also
-     * a `null` value if the editor should not be restarted in case of the error (e.g. during the editor initialization).
-     * The error context should be checked using the `areConnectedThroughProperties( editor, context )` utility
-     * to check if the object works as the context.
-     * @param data Additional data describing the error. A stringified version of this object
-     * will be appended to the error message, so the data are quickly visible in the console. The original
-     * data object will also be later available under the {@link #data} property.
-     */ constructor(errorName, context, data){
-        super(getErrorMessage(errorName, data));
-        this.name = 'CKEditorError';
-        this.context = context;
-        this.data = data;
-    }
 }
 /**
  * Logs a warning to the console with a properly formatted message and adds a link to the documentation.
@@ -850,144 +965,146 @@ class CKEditorError extends Error {
     ];
 }
 
-const version = '41.4.1';
+const version = '42.0.0-alpha.0';
 // The second argument is not a month. It is `monthIndex` and starts from `0`.
-const releaseDate = new Date(2024, 4, 16);
+const releaseDate = new Date(2024, 5, 5);
 /* istanbul ignore next -- @preserve */ if (globalThis.CKEDITOR_VERSION) {
     /**
-     * This error is thrown when due to a mistake in how CKEditor 5 was installed or initialized, some
-     * of its modules were duplicated (evaluated and executed twice). Module duplication leads to inevitable runtime
-     * errors.
-     *
-     * There are many situations in which some modules can be loaded twice. In the worst case scenario,
-     * you may need to check your project for each of these issues and fix them all.
-     *
-     * # Trying to add a plugin to an existing build
-     *
-     * If you import an existing CKEditor 5 build and a plugin like this:
-     *
-     * ```ts
-     * import ClassicEditor from '@ckeditor/ckeditor5-build-classic';
-     * import Highlight from '@ckeditor/ckeditor5-highlight/src/highlight';
-     * ```
-     *
-     * Then your project loads some CKEditor 5 packages twice. How does it happen?
-     *
-     * The build package contains a file which is already compiled with webpack. This means
-     * that it contains all the necessary code from e.g. `@ckeditor/ckeditor5-engine` and `@ckeditor/ckeditor5-utils`.
-     *
-     * However, the `Highlight` plugin imports some of the modules from these packages, too. If you ask webpack to
-     * build such a project, you will end up with the modules being included (and run) twice – first, because they are
-     * included inside the build package, and second, because they are required by the `Highlight` plugin.
-     *
-     * Therefore, **you must never add plugins to an existing build** unless your plugin has no dependencies.
-     *
-     * Adding plugins to a build is done by taking the source version of this build (so, before it was built with webpack)
-     * and adding plugins there. In this situation, webpack will know that it only needs to load each plugin once.
-     *
-     * Read more in the {@glink installation/plugins/installing-plugins Installing plugins} guide.
-     *
-     * # Confused an editor build with an editor implementation
-     *
-     * This scenario is very similar to the previous one, but has a different origin.
-     *
-     * Let's assume that you wanted to use CKEditor 5 from source, as explained in the
-     * {@glink installation/advanced/alternative-setups/integrating-from-source-webpack "Building from source"} section
-     * or in the {@glink framework/quick-start "Quick start"} guide of CKEditor 5 Framework.
-     *
-     * The correct way to do so is to import an editor and plugins and run them together like this:
-     *
-     * ```ts
-     * import ClassicEditor from '@ckeditor/ckeditor5-editor-classic/src/classiceditor';
-     * import Essentials from '@ckeditor/ckeditor5-essentials/src/essentials';
-     * import Paragraph from '@ckeditor/ckeditor5-paragraph/src/paragraph';
-     * import Bold from '@ckeditor/ckeditor5-basic-styles/src/bold';
-     * import Italic from '@ckeditor/ckeditor5-basic-styles/src/italic';
-     *
-     * ClassicEditor
-     * 	.create( document.querySelector( '#editor' ), {
-     * 		plugins: [ Essentials, Paragraph, Bold, Italic ],
-     * 		toolbar: [ 'bold', 'italic' ]
-     * 	} )
-     * 	.then( editor => {
-     * 		console.log( 'Editor was initialized', editor );
-     * 	} )
-     * 	.catch( error => {
-     * 		console.error( error.stack );
-     * 	} );
-     * ```
-     *
-     * However, you might have mistakenly imported a build instead of the source `ClassicEditor`. In this case
-     * your imports will look like this:
-     *
-     * ```ts
-     * import ClassicEditor from '@ckeditor/ckeditor5-build-classic';
-     * import Essentials from '@ckeditor/ckeditor5-essentials/src/essentials';
-     * import Paragraph from '@ckeditor/ckeditor5-paragraph/src/paragraph';
-     * import Bold from '@ckeditor/ckeditor5-basic-styles/src/bold';
-     * import Italic from '@ckeditor/ckeditor5-basic-styles/src/italic';
-     * ```
-     *
-     * This creates the same situation as in the previous section because you use a build together with source plugins.
-     *
-     * Remember: `@ckeditor/ckeditor5-build-*` packages contain editor builds and `@ckeditor/ckeditor5-editor-*` contain source editors.
-     *
-     * # Loading two or more builds on one page
-     *
-     * If you use CKEditor 5 builds, you might have loaded two (or more) `ckeditor.js` files on one web page.
-     * Check your web page for duplicated `<script>` elements or make sure your page builder/bundler includes CKEditor only once.
-     *
-     * If you want to use two different types of editors at once, see the
-     * {@glink installation/advanced/using-two-editors "Using two different editors"}
-     * section.
-     *
-     * # Using outdated packages
-     *
-     * Building CKEditor 5 from source requires using multiple npm packages. These packages have their dependencies
-     * to other packages. If you use the latest version of, for example, `@ckeditor/ckeditor5-editor-classic` with
-     * an outdated version of `@ckeditor/ckeditor5-image`, npm or yarn will need to install two different versions of
-     * `@ckeditor/ckeditor5-core` because `@ckeditor/ckeditor5-editor-classic` and `@ckeditor/ckeditor5-image` may require
-     * different versions of the core package.
-     *
-     * The solution to this issue is to update all packages to their latest version. We recommend
-     * using tools like [`npm-check-updates`](https://www.npmjs.com/package/npm-check-updates) which simplify this process.
-     *
-     * # Conflicting version of dependencies
-     *
-     * This is a special case of the previous scenario. If you use CKEditor 5 with some third-party plugins,
-     * it may happen that even if you use the latest versions of the official packages and the latest version of
-     * these third-party packages, there will be a conflict between some of their dependencies.
-     *
-     * Such a problem can be resolved by either downgrading CKEditor 5 packages (which we do not recommend) or
-     * asking the author of the third-party package to upgrade its depdendencies (or forking their project and doing this yourself).
-     *
-     * **Note:** All official CKEditor 5 packages (excluding integrations and `ckeditor5-dev-*` packages) are released in the
-     * same major version. This means that in the `x.y.z` version, the `x` is the same for all packages. This is the simplest way to check
-     * whether you use packages coming from the same CKEditor 5 version. You can read more about versioning in the
-     * {@glink updating/versioning-policy Versioning policy} guide.
-     *
-     * # Packages were duplicated in `node_modules`
-     *
-     * In some situations, especially when calling `npm install` multiple times, it may happen
-     * that npm will not correctly "deduplicate" packages.
-     *
-     * Normally, npm deduplicates all packages so, for example, `@ckeditor/ckeditor5-core` is installed only once in `node_modules/`.
-     * However, it is known to fail to do so from time to time.
-     *
-     * We recommend checking if any of the steps listed below help:
-     *
-     * * `rm -rf node_modules && npm install` to make sure you have a clean `node_modules/` directory. This step
-     * is known to help in most cases.
-     * * If you use `yarn.lock` or `package-lock.json`, remove it before `npm install`.
-     * * Check whether all CKEditor 5 packages are up to date and reinstall them
-     * if you changed anything (`rm -rf node_modules && npm install`).
-     *
-     * If all packages are correct and compatible with each other, the steps above are known to help. If not, you may
-     * try to check with `npm ls` how many times packages like `@ckeditor/ckeditor5-core`, `@ckeditor/ckeditor5-engine` and
-     *`@ckeditor/ckeditor5-utils` are installed. If more than once, verify which package causes that.
-     *
-     * @error ckeditor-duplicated-modules
-     */ throw new CKEditorError('ckeditor-duplicated-modules', null);
+	 * The best solution to avoid this error is migrating your CKEditor&nbsp;5 instance to
+	 * {@glink updating/new-installation-methods new installation methods}.
+	 *
+	 * Mentioned below are predefined builds, which are a deprecated installation method. The solutions
+	 * provided are kept here for legacy support only.
+	 *
+	 * This error is thrown when due to a mistake in how CKEditor 5 was installed or initialized, some
+	 * of its modules were duplicated (evaluated and executed twice). Module duplication leads to inevitable runtime
+	 * errors.
+	 *
+	 * There are many situations in which some modules can be loaded twice. In the worst case scenario,
+	 * you may need to check your project for each of these issues and fix them all.
+	 *
+	 * # Trying to add a plugin to an existing build
+	 *
+	 * If you import an existing CKEditor 5 build and a plugin like this:
+	 *
+	 * ```ts
+	 * import ClassicEditor from '@ckeditor/ckeditor5-build-classic';
+	 * import Highlight from '@ckeditor/ckeditor5-highlight/src/highlight';
+	 * ```
+	 *
+	 * Then your project loads some CKEditor 5 packages twice. How does it happen?
+	 *
+	 * The build package contains a file which is already compiled with webpack. This means
+	 * that it contains all the necessary code from e.g. `@ckeditor/ckeditor5-engine` and `@ckeditor/ckeditor5-utils`.
+	 *
+	 * However, the `Highlight` plugin imports some of the modules from these packages, too. If you ask webpack to
+	 * build such a project, you will end up with the modules being included (and run) twice &ndash; first, because they are
+	 * included inside the build package, and second, because they are required by the `Highlight` plugin.
+	 *
+	 * Therefore, **you must never add plugins to an existing build** unless your plugin has no dependencies.
+	 *
+	 * Adding plugins to a build is done by taking the source version of this build (so, before it was built with webpack)
+	 * and adding plugins there. In this situation, webpack will know that it only needs to load each plugin once.
+	 *
+	 * # Confused an editor build with an editor implementation
+	 *
+	 * This scenario is very similar to the previous one, but has a different origin.
+	 *
+	 * Let's assume that you wanted to use CKEditor 5 from source.
+	 *
+	 * The correct way to do so is to import an editor and plugins and run them together like this:
+	 *
+	 * ```ts
+	 * import ClassicEditor from '@ckeditor/ckeditor5-editor-classic/src/classiceditor';
+	 * import Essentials from '@ckeditor/ckeditor5-essentials/src/essentials';
+	 * import Paragraph from '@ckeditor/ckeditor5-paragraph/src/paragraph';
+	 * import Bold from '@ckeditor/ckeditor5-basic-styles/src/bold';
+	 * import Italic from '@ckeditor/ckeditor5-basic-styles/src/italic';
+	 *
+	 * ClassicEditor
+	 * 	.create( document.querySelector( '#editor' ), {
+	 * 		plugins: [ Essentials, Paragraph, Bold, Italic ],
+	 * 		toolbar: [ 'bold', 'italic' ]
+	 * 	} )
+	 * 	.then( editor => {
+	 * 		console.log( 'Editor was initialized', editor );
+	 * 	} )
+	 * 	.catch( error => {
+	 * 		console.error( error.stack );
+	 * 	} );
+	 * ```
+	 *
+	 * However, you might have mistakenly imported a build instead of the source `ClassicEditor`. In this case
+	 * your imports will look like this:
+	 *
+	 * ```ts
+	 * import ClassicEditor from '@ckeditor/ckeditor5-build-classic';
+	 * import Essentials from '@ckeditor/ckeditor5-essentials/src/essentials';
+	 * import Paragraph from '@ckeditor/ckeditor5-paragraph/src/paragraph';
+	 * import Bold from '@ckeditor/ckeditor5-basic-styles/src/bold';
+	 * import Italic from '@ckeditor/ckeditor5-basic-styles/src/italic';
+	 * ```
+	 *
+	 * This creates the same situation as in the previous section because you use a build together with source plugins.
+	 *
+	 * Remember: `@ckeditor/ckeditor5-build-*` packages contain editor builds and `@ckeditor/ckeditor5-editor-*` contain source editors.
+	 *
+	 * # Loading two or more builds on one page
+	 *
+	 * If you use CKEditor 5 builds, you might have loaded two (or more) `ckeditor.js` files on one web page.
+	 * Check your web page for duplicated `<script>` elements or make sure your page builder/bundler includes CKEditor only once.
+	 *
+	 * If you want to use two different types of editors at once, see the
+	 * {@glink getting-started/legacy/advanced/using-two-editors "Using two different editors"}
+	 * section.
+	 *
+	 * # Using outdated packages
+	 *
+	 * Building CKEditor 5 from source requires using multiple npm packages. These packages have their dependencies
+	 * to other packages. If you use the latest version of, for example, `@ckeditor/ckeditor5-editor-classic` with
+	 * an outdated version of `@ckeditor/ckeditor5-image`, npm or yarn will need to install two different versions of
+	 * `@ckeditor/ckeditor5-core` because `@ckeditor/ckeditor5-editor-classic` and `@ckeditor/ckeditor5-image` may require
+	 * different versions of the core package.
+	 *
+	 * The solution to this issue is to update all packages to their latest version. We recommend
+	 * using tools like [`npm-check-updates`](https://www.npmjs.com/package/npm-check-updates) which simplify this process.
+	 *
+	 * # Conflicting version of dependencies
+	 *
+	 * This is a special case of the previous scenario. If you use CKEditor 5 with some third-party plugins,
+	 * it may happen that even if you use the latest versions of the official packages and the latest version of
+	 * these third-party packages, there will be a conflict between some of their dependencies.
+	 *
+	 * Such a problem can be resolved by either downgrading CKEditor 5 packages (which we do not recommend) or
+	 * asking the author of the third-party package to upgrade its depdendencies (or forking their project and doing this yourself).
+	 *
+	 * **Note:** All official CKEditor 5 packages (excluding integrations and `ckeditor5-dev-*` packages) are released in the
+	 * same major version. This means that in the `x.y.z` version, the `x` is the same for all packages. This is the simplest way to check
+	 * whether you use packages coming from the same CKEditor 5 version. You can read more about versioning in the
+	 * {@glink updating/versioning-policy Versioning policy} guide.
+	 *
+	 * # Packages were duplicated in `node_modules`
+	 *
+	 * In some situations, especially when calling `npm install` multiple times, it may happen
+	 * that npm will not correctly "deduplicate" packages.
+	 *
+	 * Normally, npm deduplicates all packages so, for example, `@ckeditor/ckeditor5-core` is installed only once in `node_modules/`.
+	 * However, it is known to fail to do so from time to time.
+	 *
+	 * We recommend checking if any of the steps listed below help:
+	 *
+	 * * `rm -rf node_modules && npm install` to make sure you have a clean `node_modules/` directory. This step
+	 * is known to help in most cases.
+	 * * If you use `yarn.lock` or `package-lock.json`, remove it before `npm install`.
+	 * * Check whether all CKEditor 5 packages are up to date and reinstall them
+	 * if you changed anything (`rm -rf node_modules && npm install`).
+	 *
+	 * If all packages are correct and compatible with each other, the steps above are known to help. If not, you may
+	 * try to check with `npm ls` how many times packages like `@ckeditor/ckeditor5-core`, `@ckeditor/ckeditor5-engine` and
+	 *`@ckeditor/ckeditor5-utils` are installed. If more than once, verify which package causes that.
+	 *
+	 * @error ckeditor-duplicated-modules
+	 */ throw new CKEditorError('ckeditor-duplicated-modules', null);
 } else {
     globalThis.CKEDITOR_VERSION = version;
 }
@@ -995,7 +1112,7 @@ const releaseDate = new Date(2024, 4, 16);
 const _listeningTo = Symbol('listeningTo');
 const _emitterId = Symbol('emitterId');
 const _delegations = Symbol('delegations');
-const defaultEmitterClass$1 = EmitterMixin(Object);
+const defaultEmitterClass$1 = /* #__PURE__ */ EmitterMixin(Object);
 function EmitterMixin(base) {
     if (!base) {
         return defaultEmitterClass$1;
@@ -1426,7 +1543,7 @@ const boundObservablesSymbol = Symbol('boundObservables');
 const boundPropertiesSymbol = Symbol('boundProperties');
 const decoratedMethods = Symbol('decoratedMethods');
 const decoratedOriginal = Symbol('decoratedOriginal');
-const defaultObservableClass = ObservableMixin(EmitterMixin());
+const defaultObservableClass = /* #__PURE__ */ ObservableMixin(/* #__PURE__ */ EmitterMixin());
 function ObservableMixin(base) {
     if (!base) {
         return defaultObservableClass;
@@ -1444,22 +1561,22 @@ function ObservableMixin(base) {
             const properties = this[observablePropertiesSymbol];
             if (name in this && !properties.has(name)) {
                 /**
-                 * Cannot override an existing property.
-                 *
-                 * This error is thrown when trying to {@link module:utils/observablemixin~Observable#set set} a property with
-                 * a name of an already existing property. For example:
-                 *
-                 * ```ts
-                 * let observable = new Model();
-                 * observable.property = 1;
-                 * observable.set( 'property', 2 );			// throws
-                 *
-                 * observable.set( 'property', 1 );
-                 * observable.set( 'property', 2 );			// ok, because this is an existing property.
-                 * ```
-                 *
-                 * @error observable-set-cannot-override
-                 */ throw new CKEditorError('observable-set-cannot-override', this);
+				 * Cannot override an existing property.
+				 *
+				 * This error is thrown when trying to {@link module:utils/observablemixin~Observable#set set} a property with
+				 * a name of an already existing property. For example:
+				 *
+				 * ```ts
+				 * let observable = new Model();
+				 * observable.property = 1;
+				 * observable.set( 'property', 2 );			// throws
+				 *
+				 * observable.set( 'property', 1 );
+				 * observable.set( 'property', 2 );			// ok, because this is an existing property.
+				 * ```
+				 *
+				 * @error observable-set-cannot-override
+				 */ throw new CKEditorError('observable-set-cannot-override', this);
             }
             Object.defineProperty(this, name, {
                 enumerable: true,
@@ -1489,27 +1606,27 @@ function ObservableMixin(base) {
         bind(...bindProperties) {
             if (!bindProperties.length || !isStringArray(bindProperties)) {
                 /**
-                 * All properties must be strings.
-                 *
-                 * @error observable-bind-wrong-properties
-                 */ throw new CKEditorError('observable-bind-wrong-properties', this);
+				 * All properties must be strings.
+				 *
+				 * @error observable-bind-wrong-properties
+				 */ throw new CKEditorError('observable-bind-wrong-properties', this);
             }
             if (new Set(bindProperties).size !== bindProperties.length) {
                 /**
-                 * Properties must be unique.
-                 *
-                 * @error observable-bind-duplicate-properties
-                 */ throw new CKEditorError('observable-bind-duplicate-properties', this);
+				 * Properties must be unique.
+				 *
+				 * @error observable-bind-duplicate-properties
+				 */ throw new CKEditorError('observable-bind-duplicate-properties', this);
             }
             initObservable(this);
             const boundProperties = this[boundPropertiesSymbol];
             bindProperties.forEach((propertyName)=>{
                 if (boundProperties.has(propertyName)) {
                     /**
-                     * Cannot bind the same property more than once.
-                     *
-                     * @error observable-bind-rebind
-                     */ throw new CKEditorError('observable-bind-rebind', this);
+					 * Cannot bind the same property more than once.
+					 *
+					 * @error observable-bind-rebind
+					 */ throw new CKEditorError('observable-bind-rebind', this);
                 }
             });
             const bindings = new Map();
@@ -1540,10 +1657,10 @@ function ObservableMixin(base) {
             if (unbindProperties.length) {
                 if (!isStringArray(unbindProperties)) {
                     /**
-                     * Properties must be strings.
-                     *
-                     * @error observable-unbind-wrong-properties
-                     */ throw new CKEditorError('observable-unbind-wrong-properties', this);
+					 * Properties must be strings.
+					 *
+					 * @error observable-unbind-wrong-properties
+					 */ throw new CKEditorError('observable-unbind-wrong-properties', this);
                 }
                 unbindProperties.forEach((propertyName)=>{
                     const binding = boundProperties.get(propertyName);
@@ -1578,12 +1695,12 @@ function ObservableMixin(base) {
             const originalMethod = this[methodName];
             if (!originalMethod) {
                 /**
-                 * Cannot decorate an undefined method.
-                 *
-                 * @error observablemixin-cannot-decorate-undefined
-                 * @param {Object} object The object which method should be decorated.
-                 * @param {String} methodName Name of the method which does not exist.
-                 */ throw new CKEditorError('observablemixin-cannot-decorate-undefined', this, {
+				 * Cannot decorate an undefined method.
+				 *
+				 * @error observablemixin-cannot-decorate-undefined
+				 * @param {Object} object The object which method should be decorated.
+				 * @param {String} methodName Name of the method which does not exist.
+				 */ throw new CKEditorError('observablemixin-cannot-decorate-undefined', this, {
                     object: this,
                     methodName
                 });
@@ -1615,6 +1732,10 @@ function ObservableMixin(base) {
             }
             super.stopListening(emitter, event, callback);
         }
+        [observablePropertiesSymbol];
+        [decoratedMethods];
+        [boundPropertiesSymbol];
+        [boundObservablesSymbol];
     }
     return Mixin;
 }
@@ -1734,27 +1855,27 @@ function initObservable(observable) {
     // Eliminate A.bind( 'x' ).to( B, C )
     if (!parsedArgs.callback && parsedArgs.to.length > 1) {
         /**
-         * Binding multiple observables only possible with callback.
-         *
-         * @error observable-bind-to-no-callback
-         */ throw new CKEditorError('observable-bind-to-no-callback', this);
+		 * Binding multiple observables only possible with callback.
+		 *
+		 * @error observable-bind-to-no-callback
+		 */ throw new CKEditorError('observable-bind-to-no-callback', this);
     }
     // Eliminate A.bind( 'x', 'y' ).to( B, callback )
     if (numberOfBindings > 1 && parsedArgs.callback) {
         /**
-         * Cannot bind multiple properties and use a callback in one binding.
-         *
-         * @error observable-bind-to-extra-callback
-         */ throw new CKEditorError('observable-bind-to-extra-callback', this);
+		 * Cannot bind multiple properties and use a callback in one binding.
+		 *
+		 * @error observable-bind-to-extra-callback
+		 */ throw new CKEditorError('observable-bind-to-extra-callback', this);
     }
     parsedArgs.to.forEach((to)=>{
         // Eliminate A.bind( 'x', 'y' ).to( B, 'a' )
         if (to.properties.length && to.properties.length !== numberOfBindings) {
             /**
-             * The number of properties must match.
-             *
-             * @error observable-bind-to-properties-length
-             */ throw new CKEditorError('observable-bind-to-properties-length', this);
+			 * The number of properties must match.
+			 *
+			 * @error observable-bind-to-properties-length
+			 */ throw new CKEditorError('observable-bind-to-properties-length', this);
         }
         // When no to.properties specified, observing source properties instead i.e.
         // A.bind( 'x', 'y' ).to( B ) -> Observe B.x and B.y
@@ -1780,10 +1901,10 @@ function initObservable(observable) {
  */ function bindToMany(observables, attribute, callback) {
     if (this._bindings.size > 1) {
         /**
-         * Binding one attribute to many observables only possible with one attribute.
-         *
-         * @error observable-bind-to-many-not-one-binding
-         */ throw new CKEditorError('observable-bind-to-many-not-one-binding', this);
+		 * Binding one attribute to many observables only possible with one attribute.
+		 *
+		 * @error observable-bind-to-many-not-one-binding
+		 */ throw new CKEditorError('observable-bind-to-many-not-one-binding', this);
     }
     this.to(// Bind to #attribute of each observable...
     ...getBindingTargets(observables, attribute), // ...using given callback to parse attribute values.
@@ -1829,10 +1950,10 @@ function initObservable(observable) {
     // Eliminate A.bind( 'x' ).to()
     if (!args.length) {
         /**
-         * Invalid argument syntax in `to()`.
-         *
-         * @error observable-bind-to-parse-error
-         */ throw new CKEditorError('observable-bind-to-parse-error', null);
+		 * Invalid argument syntax in `to()`.
+		 *
+		 * @error observable-bind-to-parse-error
+		 */ throw new CKEditorError('observable-bind-to-parse-error', null);
     }
     const parsed = {
         to: []
@@ -2001,13 +2122,19 @@ function initObservable(observable) {
  * the original elements from the DOM.
  */ class ElementReplacer {
     /**
-     * Hides the `element` and, if specified, inserts the the given element next to it.
-     *
-     * The effect of this method can be reverted by {@link #restore}.
-     *
-     * @param element The element to replace.
-     * @param newElement The replacement element. If not passed, then the `element` will just be hidden.
-     */ replace(element, newElement) {
+	 * The elements replaced by {@link #replace} and their replacements.
+	 */ _replacedElements;
+    constructor(){
+        this._replacedElements = [];
+    }
+    /**
+	 * Hides the `element` and, if specified, inserts the the given element next to it.
+	 *
+	 * The effect of this method can be reverted by {@link #restore}.
+	 *
+	 * @param element The element to replace.
+	 * @param newElement The replacement element. If not passed, then the `element` will just be hidden.
+	 */ replace(element, newElement) {
         this._replacedElements.push({
             element,
             newElement
@@ -2018,8 +2145,8 @@ function initObservable(observable) {
         }
     }
     /**
-     * Restores what {@link #replace} did.
-     */ restore() {
+	 * Restores what {@link #replace} did.
+	 */ restore() {
         this._replacedElements.forEach(({ element, newElement })=>{
             element.style.display = '';
             if (newElement) {
@@ -2028,9 +2155,6 @@ function initObservable(observable) {
         });
         this._replacedElements = [];
     }
-    constructor(){
-        this._replacedElements = [];
-    }
 }
 
 /**
@@ -2165,7 +2289,32 @@ function initObservable(observable) {
     return element;
 }
 
-class Config {
+/**
+ * Handles a configuration dictionary.
+ *
+ * @typeParam Cfg A type of the configuration dictionary.
+ */ class Config {
+    /**
+	 * Store for the whole configuration.
+	 */ _config;
+    /**
+	 * Creates an instance of the {@link ~Config} class.
+	 *
+	 * @param configurations The initial configurations to be set. Usually, provided by the user.
+	 * @param defaultConfigurations The default configurations. Usually, provided by the system.
+	 */ constructor(configurations, defaultConfigurations){
+        this._config = {};
+        // Set default configuration.
+        if (defaultConfigurations) {
+            // Clone the configuration to make sure that the properties will not be shared
+            // between editors and make the watchdog feature work correctly.
+            this.define(cloneConfig(defaultConfigurations));
+        }
+        // Set initial configuration.
+        if (configurations) {
+            this._setObjectToTarget(this._config, configurations);
+        }
+    }
     set(name, value) {
         this._setToTarget(this._config, name, value);
     }
@@ -2174,39 +2323,39 @@ class Config {
         this._setToTarget(this._config, name, value, isDefine);
     }
     /**
-     * Gets the value for a configuration entry.
-     *
-     * ```ts
-     * config.get( 'name' );
-     * ```
-     *
-     * Deep configurations can be retrieved by separating each part with a dot.
-     *
-     * ```ts
-     * config.get( 'toolbar.collapsed' );
-     * ```
-     *
-     * @param name The configuration name. Configuration names are case-sensitive.
-     * @returns The configuration value or `undefined` if the configuration entry was not found.
-     */ get(name) {
+	 * Gets the value for a configuration entry.
+	 *
+	 * ```ts
+	 * config.get( 'name' );
+	 * ```
+	 *
+	 * Deep configurations can be retrieved by separating each part with a dot.
+	 *
+	 * ```ts
+	 * config.get( 'toolbar.collapsed' );
+	 * ```
+	 *
+	 * @param name The configuration name. Configuration names are case-sensitive.
+	 * @returns The configuration value or `undefined` if the configuration entry was not found.
+	 */ get(name) {
         return this._getFromSource(this._config, name);
     }
     /**
-     * Iterates over all top level configuration names.
-     */ *names() {
+	 * Iterates over all top level configuration names.
+	 */ *names() {
         for (const name of Object.keys(this._config)){
             yield name;
         }
     }
     /**
-     * Saves passed configuration to the specified target (nested object).
-     *
-     * @param target Nested config object.
-     * @param name The configuration name or an object from which take properties as
-     * configuration entries. Configuration names are case-sensitive.
-     * @param value The configuration value. Used if a name is passed.
-     * @param isDefine Define if passed configuration should overwrite existing one.
-     */ _setToTarget(target, name, value, isDefine = false) {
+	 * Saves passed configuration to the specified target (nested object).
+	 *
+	 * @param target Nested config object.
+	 * @param name The configuration name or an object from which take properties as
+	 * configuration entries. Configuration names are case-sensitive.
+	 * @param value The configuration value. Used if a name is passed.
+	 * @param isDefine Define if passed configuration should overwrite existing one.
+	 */ _setToTarget(target, name, value, isDefine = false) {
         // In case of an object, iterate through it and call `_setToTarget` again for each property.
         if (isPlainObject(name)) {
             this._setObjectToTarget(target, name, isDefine);
@@ -2243,12 +2392,12 @@ class Config {
         target[name] = value;
     }
     /**
-     * Get specified configuration from specified source (nested object).
-     *
-     * @param source level of nested object.
-     * @param name The configuration name. Configuration names are case-sensitive.
-     * @returns The configuration value or `undefined` if the configuration entry was not found.
-     */ _getFromSource(source, name) {
+	 * Get specified configuration from specified source (nested object).
+	 *
+	 * @param source level of nested object.
+	 * @param name The configuration name. Configuration names are case-sensitive.
+	 * @returns The configuration value or `undefined` if the configuration entry was not found.
+	 */ _getFromSource(source, name) {
         // The configuration name should be split into parts if it has dots. E.g. `resize.width` -> [`resize`, `width`].
         const parts = name.split('.');
         // Take the name of the configuration out of the parts. E.g. `resize.width` -> `width`.
@@ -2266,34 +2415,16 @@ class Config {
         return source ? cloneConfig(source[name]) : undefined;
     }
     /**
-     * Iterates through passed object and calls {@link #_setToTarget} method with object key and value for each property.
-     *
-     * @param target Nested config object.
-     * @param configuration Configuration data set
-     * @param isDefine Defines if passed configuration is default configuration or not.
-     */ _setObjectToTarget(target, configuration, isDefine) {
+	 * Iterates through passed object and calls {@link #_setToTarget} method with object key and value for each property.
+	 *
+	 * @param target Nested config object.
+	 * @param configuration Configuration data set
+	 * @param isDefine Defines if passed configuration is default configuration or not.
+	 */ _setObjectToTarget(target, configuration, isDefine) {
         Object.keys(configuration).forEach((key)=>{
             this._setToTarget(target, key, configuration[key], isDefine);
         });
     }
-    /**
-     * Creates an instance of the {@link ~Config} class.
-     *
-     * @param configurations The initial configurations to be set. Usually, provided by the user.
-     * @param defaultConfigurations The default configurations. Usually, provided by the system.
-     */ constructor(configurations, defaultConfigurations){
-        this._config = {};
-        // Set default configuration.
-        if (defaultConfigurations) {
-            // Clone the configuration to make sure that the properties will not be shared
-            // between editors and make the watchdog feature work correctly.
-            this.define(cloneConfig(defaultConfigurations));
-        }
-        // Set initial configuration.
-        if (configurations) {
-            this._setObjectToTarget(this._config, configurations);
-        }
-    }
 }
 /**
  * Clones configuration object or value.
@@ -2346,7 +2477,7 @@ class Config {
     return false;
 }
 
-const defaultEmitterClass = DomEmitterMixin(EmitterMixin());
+const defaultEmitterClass = /* #__PURE__ */ DomEmitterMixin(/* #__PURE__ */ EmitterMixin());
 function DomEmitterMixin(base) {
     if (!base) {
         return defaultEmitterClass;
@@ -2379,23 +2510,23 @@ function DomEmitterMixin(base) {
             }
         }
         /**
-         * Retrieves ProxyEmitter instance for given DOM Node residing in this Host and given options.
-         *
-         * @param node DOM Node of the ProxyEmitter.
-         * @param options Additional options.
-         * @param options.useCapture Indicates that events of this type will be dispatched to the registered
-         * listener before being dispatched to any EventTarget beneath it in the DOM tree.
-         * @param options.usePassive Indicates that the function specified by listener will never call preventDefault()
-         * and prevents blocking browser's main thread by this event handler.
-         * @returns ProxyEmitter instance bound to the DOM Node.
-         */ _getProxyEmitter(node, options) {
+		 * Retrieves ProxyEmitter instance for given DOM Node residing in this Host and given options.
+		 *
+		 * @param node DOM Node of the ProxyEmitter.
+		 * @param options Additional options.
+		 * @param options.useCapture Indicates that events of this type will be dispatched to the registered
+		 * listener before being dispatched to any EventTarget beneath it in the DOM tree.
+		 * @param options.usePassive Indicates that the function specified by listener will never call preventDefault()
+		 * and prevents blocking browser's main thread by this event handler.
+		 * @returns ProxyEmitter instance bound to the DOM Node.
+		 */ _getProxyEmitter(node, options) {
             return _getEmitterListenedTo(this, getProxyEmitterId(node, options));
         }
         /**
-         * Retrieves all the ProxyEmitter instances for given DOM Node residing in this Host.
-         *
-         * @param node DOM Node of the ProxyEmitter.
-         */ _getAllProxyEmitters(node) {
+		 * Retrieves all the ProxyEmitter instances for given DOM Node residing in this Host.
+		 *
+		 * @param node DOM Node of the ProxyEmitter.
+		 */ _getAllProxyEmitters(node) {
             return [
                 {
                     capture: false,
@@ -2462,18 +2593,39 @@ function DomEmitterMixin(base) {
  *                    |                                         |                  click (DOM Event)
  *                    +-----------------------------------------+
  *                                fire( click, DOM Event )
- */ class ProxyEmitter extends EmitterMixin() {
+ */ class ProxyEmitter extends /* #__PURE__ */ EmitterMixin() {
+    _domNode;
+    _options;
     /**
-     * Registers a callback function to be executed when an event is fired.
-     *
-     * It attaches a native DOM listener to the DOM Node. When fired,
-     * a corresponding Emitter event will also fire with DOM Event object as an argument.
-     *
-     * **Note**: This is automatically called by the
-     * {@link module:utils/emittermixin~Emitter#listenTo `Emitter#listenTo()`}.
-     *
-     * @param event The name of the event.
-     */ attach(event) {
+	 * @param node DOM Node that fires events.
+	 * @param options Additional options.
+	 * @param options.useCapture Indicates that events of this type will be dispatched to the registered
+	 * listener before being dispatched to any EventTarget beneath it in the DOM tree.
+	 * @param options.usePassive Indicates that the function specified by listener will never call preventDefault()
+	 * and prevents blocking browser's main thread by this event handler.
+	 */ constructor(node, options){
+        super();
+        // Set emitter ID to match DOM Node "expando" property.
+        _setEmitterId(this, getProxyEmitterId(node, options));
+        // Remember the DOM Node this ProxyEmitter is bound to.
+        this._domNode = node;
+        // And given options.
+        this._options = options;
+    }
+    /**
+	 * Collection of native DOM listeners.
+	 */ _domListeners;
+    /**
+	 * Registers a callback function to be executed when an event is fired.
+	 *
+	 * It attaches a native DOM listener to the DOM Node. When fired,
+	 * a corresponding Emitter event will also fire with DOM Event object as an argument.
+	 *
+	 * **Note**: This is automatically called by the
+	 * {@link module:utils/emittermixin~Emitter#listenTo `Emitter#listenTo()`}.
+	 *
+	 * @param event The name of the event.
+	 */ attach(event) {
         // If the DOM Listener for given event already exist it is pointless
         // to attach another one.
         if (this._domListeners && this._domListeners[event]) {
@@ -2490,13 +2642,13 @@ function DomEmitterMixin(base) {
         this._domListeners[event] = domListener;
     }
     /**
-     * Stops executing the callback on the given event.
-     *
-     * **Note**: This is automatically called by the
-     * {@link module:utils/emittermixin~Emitter#stopListening `Emitter#stopListening()`}.
-     *
-     * @param event The name of the event.
-     */ detach(event) {
+	 * Stops executing the callback on the given event.
+	 *
+	 * **Note**: This is automatically called by the
+	 * {@link module:utils/emittermixin~Emitter#stopListening `Emitter#stopListening()`}.
+	 *
+	 * @param event The name of the event.
+	 */ detach(event) {
         let events;
         // Remove native DOM listeners which are orphans. If no callbacks
         // are awaiting given event, detach native DOM listener from DOM Node.
@@ -2506,34 +2658,34 @@ function DomEmitterMixin(base) {
         }
     }
     /**
-     * Adds callback to emitter for given event.
-     *
-     * @internal
-     * @param event The name of the event.
-     * @param callback The function to be called on event.
-     * @param options Additional options.
-     */ _addEventListener(event, callback, options) {
+	 * Adds callback to emitter for given event.
+	 *
+	 * @internal
+	 * @param event The name of the event.
+	 * @param callback The function to be called on event.
+	 * @param options Additional options.
+	 */ _addEventListener(event, callback, options) {
         this.attach(event);
         EmitterMixin().prototype._addEventListener.call(this, event, callback, options);
     }
     /**
-     * Removes callback from emitter for given event.
-     *
-     * @internal
-     * @param event The name of the event.
-     * @param callback The function to stop being called.
-     */ _removeEventListener(event, callback) {
+	 * Removes callback from emitter for given event.
+	 *
+	 * @internal
+	 * @param event The name of the event.
+	 * @param callback The function to stop being called.
+	 */ _removeEventListener(event, callback) {
         EmitterMixin().prototype._removeEventListener.call(this, event, callback);
         this.detach(event);
     }
     /**
-     * Creates a native DOM listener callback. When the native DOM event
-     * is fired it will fire corresponding event on this ProxyEmitter.
-     * Note: A native DOM Event is passed as an argument.
-     *
-     * @param event The name of the event.
-     * @returns The DOM listener callback.
-     */ _createDomListener(event) {
+	 * Creates a native DOM listener callback. When the native DOM event
+	 * is fired it will fire corresponding event on this ProxyEmitter.
+	 * Note: A native DOM Event is passed as an argument.
+	 *
+	 * @param event The name of the event.
+	 * @returns The DOM listener callback.
+	 */ _createDomListener(event) {
         const domListener = (domEvt)=>{
             this.fire(event, domEvt);
         };
@@ -2546,22 +2698,6 @@ function DomEmitterMixin(base) {
         };
         return domListener;
     }
-    /**
-     * @param node DOM Node that fires events.
-     * @param options Additional options.
-     * @param options.useCapture Indicates that events of this type will be dispatched to the registered
-     * listener before being dispatched to any EventTarget beneath it in the DOM tree.
-     * @param options.usePassive Indicates that the function specified by listener will never call preventDefault()
-     * and prevents blocking browser's main thread by this event handler.
-     */ constructor(node, options){
-        super();
-        // Set emitter ID to match DOM Node "expando" property.
-        _setEmitterId(this, getProxyEmitterId(node, options));
-        // Remember the DOM Node this ProxyEmitter is bound to.
-        this._domNode = node;
-        // And given options.
-        this._options = options;
-    }
 }
 /**
  * Gets an unique DOM Node identifier. The identifier will be set if not defined.
@@ -2582,44 +2718,6 @@ function DomEmitterMixin(base) {
     return id;
 }
 
-/**
- * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */ /**
- * A helper (module) giving an access to the global DOM objects such as `window` and
- * `document`. Accessing these objects using this helper allows easy and bulletproof
- * testing, i.e. stubbing native properties:
- *
- * ```ts
- * import { global } from 'ckeditor5/utils';
- *
- * // This stub will work for any code using global module.
- * testUtils.sinon.stub( global, 'window', {
- * 	innerWidth: 10000
- * } );
- *
- * console.log( global.window.innerWidth );
- * ```
- */ let globalVar; // named globalVar instead of global: https://github.com/ckeditor/ckeditor5/issues/12971
-// In some environments window and document API might not be available.
-try {
-    globalVar = {
-        window,
-        document
-    };
-} catch (e) {
-    // It's not possible to mock a window object to simulate lack of a window object without writing extremely convoluted code.
-    /* istanbul ignore next -- @preserve */ // Let's cast it to not change module's API.
-    // We only handle this so loading editor in environments without window and document doesn't fail.
-    // For better DX we shouldn't introduce mixed types and require developers to check the type manually.
-    // This module should not be used on purpose in any environment outside browser.
-    globalVar = {
-        window: {},
-        document: {}
-    };
-}
-var global = globalVar;
-
 /**
  * Returns the closest scrollable ancestor of a DOM element.
  *
@@ -2750,21 +2848,127 @@ const rectProperties = [
     'width',
     'height'
 ];
-class Rect {
+/**
+ * A helper class representing a `ClientRect` object, e.g. value returned by
+ * the native `object.getBoundingClientRect()` method. Provides a set of methods
+ * to manipulate the rect and compare it against other rect instances.
+ */ class Rect {
+    /**
+	 * The "top" value of the rect.
+	 *
+	 * @readonly
+	 */ top;
+    /**
+	 * The "right" value of the rect.
+	 *
+	 * @readonly
+	 */ right;
+    /**
+	 * The "bottom" value of the rect.
+	 *
+	 * @readonly
+	 */ bottom;
+    /**
+	 * The "left" value of the rect.
+	 *
+	 * @readonly
+	 */ left;
+    /**
+	 * The "width" value of the rect.
+	 *
+	 * @readonly
+	 */ width;
+    /**
+	 * The "height" value of the rect.
+	 *
+	 * @readonly
+	 */ height;
+    /**
+	 * The object this rect is for.
+	 *
+	 * @readonly
+	 */ _source;
+    /**
+	 * Creates an instance of rect.
+	 *
+	 * ```ts
+	 * // Rect of an HTMLElement.
+	 * const rectA = new Rect( document.body );
+	 *
+	 * // Rect of a DOM Range.
+	 * const rectB = new Rect( document.getSelection().getRangeAt( 0 ) );
+	 *
+	 * // Rect of a window (web browser viewport).
+	 * const rectC = new Rect( window );
+	 *
+	 * // Rect out of an object.
+	 * const rectD = new Rect( { top: 0, right: 10, bottom: 10, left: 0, width: 10, height: 10 } );
+	 *
+	 * // Rect out of another Rect instance.
+	 * const rectE = new Rect( rectD );
+	 *
+	 * // Rect out of a ClientRect.
+	 * const rectF = new Rect( document.body.getClientRects().item( 0 ) );
+	 * ```
+	 *
+	 * **Note**: By default a rect of an HTML element includes its CSS borders and scrollbars (if any)
+	 * ant the rect of a `window` includes scrollbars too. Use {@link #excludeScrollbarsAndBorders}
+	 * to get the inner part of the rect.
+	 *
+	 * @param source A source object to create the rect.
+	 */ constructor(source){
+        const isSourceRange = isRange(source);
+        Object.defineProperty(this, '_source', {
+            // If the source is a Rect instance, copy it's #_source.
+            value: source._source || source,
+            writable: true,
+            enumerable: false
+        });
+        if (isDomElement(source) || isSourceRange) {
+            // The `Rect` class depends on `getBoundingClientRect` and `getClientRects` DOM methods. If the source
+            // of a rect in an HTML element or a DOM range but it does not belong to any rendered DOM tree, these methods
+            // will fail to obtain the geometry and the rect instance makes little sense to the features using it.
+            // To get rid of this warning make sure the source passed to the constructor is a descendant of `window.document.body`.
+            // @if CK_DEBUG // const sourceNode = isSourceRange ? source.startContainer : source;
+            // @if CK_DEBUG // if ( !sourceNode.ownerDocument || !sourceNode.ownerDocument.body.contains( sourceNode ) ) {
+            // @if CK_DEBUG // 	console.warn(
+            // @if CK_DEBUG // 		'rect-source-not-in-dom: The source of this rect does not belong to any rendered DOM tree.',
+            // @if CK_DEBUG // 		{ source } );
+            // @if CK_DEBUG // }
+            if (isSourceRange) {
+                const rangeRects = Rect.getDomRangeRects(source);
+                copyRectProperties(this, Rect.getBoundingRect(rangeRects));
+            } else {
+                copyRectProperties(this, source.getBoundingClientRect());
+            }
+        } else if (isWindow(source)) {
+            const { innerWidth, innerHeight } = source;
+            copyRectProperties(this, {
+                top: 0,
+                right: innerWidth,
+                bottom: innerHeight,
+                left: 0,
+                width: innerWidth,
+                height: innerHeight
+            });
+        } else {
+            copyRectProperties(this, source);
+        }
+    }
     /**
-     * Returns a clone of the rect.
-     *
-     * @returns A cloned rect.
-     */ clone() {
+	 * Returns a clone of the rect.
+	 *
+	 * @returns A cloned rect.
+	 */ clone() {
         return new Rect(this);
     }
     /**
-     * Moves the rect so that its upper–left corner lands in desired `[ x, y ]` location.
-     *
-     * @param x Desired horizontal location.
-     * @param y Desired vertical location.
-     * @returns A rect which has been moved.
-     */ moveTo(x, y) {
+	 * Moves the rect so that its upper–left corner lands in desired `[ x, y ]` location.
+	 *
+	 * @param x Desired horizontal location.
+	 * @param y Desired vertical location.
+	 * @returns A rect which has been moved.
+	 */ moveTo(x, y) {
         this.top = y;
         this.right = x + this.width;
         this.bottom = y + this.height;
@@ -2772,12 +2976,12 @@ class Rect {
         return this;
     }
     /**
-     * Moves the rect in–place by a dedicated offset.
-     *
-     * @param x A horizontal offset.
-     * @param y A vertical offset
-     * @returns A rect which has been moved.
-     */ moveBy(x, y) {
+	 * Moves the rect in–place by a dedicated offset.
+	 *
+	 * @param x A horizontal offset.
+	 * @param y A vertical offset
+	 * @returns A rect which has been moved.
+	 */ moveBy(x, y) {
         this.top += y;
         this.right += x;
         this.left += x;
@@ -2785,8 +2989,8 @@ class Rect {
         return this;
     }
     /**
-     * Returns a new rect a a result of intersection with another rect.
-     */ getIntersection(anotherRect) {
+	 * Returns a new rect a a result of intersection with another rect.
+	 */ getIntersection(anotherRect) {
         const rect = {
             top: Math.max(this.top, anotherRect.top),
             right: Math.min(this.right, anotherRect.right),
@@ -2806,10 +3010,10 @@ class Rect {
         }
     }
     /**
-     * Returns the area of intersection with another rect.
-     *
-     * @returns Area of intersection.
-     */ getIntersectionArea(anotherRect) {
+	 * Returns the area of intersection with another rect.
+	 *
+	 * @returns Area of intersection.
+	 */ getIntersectionArea(anotherRect) {
         const rect = this.getIntersection(anotherRect);
         if (rect) {
             return rect.getArea();
@@ -2818,27 +3022,27 @@ class Rect {
         }
     }
     /**
-     * Returns the area of the rect.
-     */ getArea() {
+	 * Returns the area of the rect.
+	 */ getArea() {
         return this.width * this.height;
     }
     /**
-     * Returns a new rect, a part of the original rect, which is actually visible to the user and is relative to the,`body`,
-     * e.g. an original rect cropped by parent element rects which have `overflow` set in CSS
-     * other than `"visible"`.
-     *
-     * If there's no such visible rect, which is when the rect is limited by one or many of
-     * the ancestors, `null` is returned.
-     *
-     * **Note**: This method does not consider the boundaries of the viewport (window).
-     * To get a rect cropped by all ancestors and the viewport, use an intersection such as:
-     *
-     * ```ts
-     * const visibleInViewportRect = new Rect( window ).getIntersection( new Rect( source ).getVisible() );
-     * ```
-     *
-     * @returns A visible rect instance or `null`, if there's none.
-     */ getVisible() {
+	 * Returns a new rect, a part of the original rect, which is actually visible to the user and is relative to the,`body`,
+	 * e.g. an original rect cropped by parent element rects which have `overflow` set in CSS
+	 * other than `"visible"`.
+	 *
+	 * If there's no such visible rect, which is when the rect is limited by one or many of
+	 * the ancestors, `null` is returned.
+	 *
+	 * **Note**: This method does not consider the boundaries of the viewport (window).
+	 * To get a rect cropped by all ancestors and the viewport, use an intersection such as:
+	 *
+	 * ```ts
+	 * const visibleInViewportRect = new Rect( window ).getIntersection( new Rect( source ).getVisible() );
+	 * ```
+	 *
+	 * @returns A visible rect instance or `null`, if there's none.
+	 */ getVisible() {
         const source = this._source;
         let visibleRect = this.clone();
         // There's no ancestor to crop <body> with the overflow.
@@ -2910,13 +3114,13 @@ class Rect {
         return visibleRect;
     }
     /**
-     * Checks if all property values ({@link #top}, {@link #left}, {@link #right},
-     * {@link #bottom}, {@link #width} and {@link #height}) are the equal in both rect
-     * instances.
-     *
-     * @param anotherRect A rect instance to compare with.
-     * @returns `true` when Rects are equal. `false` otherwise.
-     */ isEqual(anotherRect) {
+	 * Checks if all property values ({@link #top}, {@link #left}, {@link #right},
+	 * {@link #bottom}, {@link #width} and {@link #height}) are the equal in both rect
+	 * instances.
+	 *
+	 * @param anotherRect A rect instance to compare with.
+	 * @returns `true` when Rects are equal. `false` otherwise.
+	 */ isEqual(anotherRect) {
         for (const prop of rectProperties){
             if (this[prop] !== anotherRect[prop]) {
                 return false;
@@ -2925,17 +3129,17 @@ class Rect {
         return true;
     }
     /**
-     * Checks whether a rect fully contains another rect instance.
-     *
-     * @param anotherRect
-     * @returns `true` if contains, `false` otherwise.
-     */ contains(anotherRect) {
+	 * Checks whether a rect fully contains another rect instance.
+	 *
+	 * @param anotherRect
+	 * @returns `true` if contains, `false` otherwise.
+	 */ contains(anotherRect) {
         const intersectRect = this.getIntersection(anotherRect);
         return !!(intersectRect && intersectRect.isEqual(anotherRect));
     }
     /**
-     * Recalculates screen coordinates to coordinates relative to the positioned ancestor offset.
-     */ toAbsoluteRect() {
+	 * Recalculates screen coordinates to coordinates relative to the positioned ancestor offset.
+	 */ toAbsoluteRect() {
         const { scrollX, scrollY } = global.window;
         const absoluteRect = this.clone().moveBy(scrollX, scrollY);
         if (isDomElement(absoluteRect._source)) {
@@ -2947,13 +3151,13 @@ class Rect {
         return absoluteRect;
     }
     /**
-     * Excludes scrollbars and CSS borders from the rect.
-     *
-     * * Borders are removed when {@link #_source} is an HTML element.
-     * * Scrollbars are excluded from HTML elements and the `window`.
-     *
-     * @returns A rect which has been updated.
-     */ excludeScrollbarsAndBorders() {
+	 * Excludes scrollbars and CSS borders from the rect.
+	 *
+	 * * Borders are removed when {@link #_source} is an HTML element.
+	 * * Scrollbars are excluded from HTML elements and the `window`.
+	 *
+	 * @returns A rect which has been updated.
+	 */ excludeScrollbarsAndBorders() {
         const source = this._source;
         let scrollBarWidth, scrollBarHeight, direction;
         if (isWindow(source)) {
@@ -2983,11 +3187,11 @@ class Rect {
         return this;
     }
     /**
-     * Returns an array of rects of the given native DOM Range.
-     *
-     * @param range A native DOM range.
-     * @returns DOM Range rects.
-     */ static getDomRangeRects(range) {
+	 * Returns an array of rects of the given native DOM Range.
+	 *
+	 * @param range A native DOM range.
+	 * @returns DOM Range rects.
+	 */ static getDomRangeRects(range) {
         const rects = [];
         // Safari does not iterate over ClientRectList using for...of loop.
         const clientRects = Array.from(range.getClientRects());
@@ -3008,11 +3212,11 @@ class Rect {
         return rects;
     }
     /**
-     * Returns a bounding rectangle that contains all the given `rects`.
-     *
-     * @param rects A list of rectangles that should be contained in the result rectangle.
-     * @returns Bounding rectangle or `null` if no `rects` were given.
-     */ static getBoundingRect(rects) {
+	 * Returns a bounding rectangle that contains all the given `rects`.
+	 *
+	 * @param rects A list of rectangles that should be contained in the result rectangle.
+	 * @returns Bounding rectangle or `null` if no `rects` were given.
+	 */ static getBoundingRect(rects) {
         const boundingRectData = {
             left: Number.POSITIVE_INFINITY,
             top: Number.POSITIVE_INFINITY,
@@ -3036,73 +3240,6 @@ class Rect {
         boundingRectData.height = boundingRectData.bottom - boundingRectData.top;
         return new Rect(boundingRectData);
     }
-    /**
-     * Creates an instance of rect.
-     *
-     * ```ts
-     * // Rect of an HTMLElement.
-     * const rectA = new Rect( document.body );
-     *
-     * // Rect of a DOM Range.
-     * const rectB = new Rect( document.getSelection().getRangeAt( 0 ) );
-     *
-     * // Rect of a window (web browser viewport).
-     * const rectC = new Rect( window );
-     *
-     * // Rect out of an object.
-     * const rectD = new Rect( { top: 0, right: 10, bottom: 10, left: 0, width: 10, height: 10 } );
-     *
-     * // Rect out of another Rect instance.
-     * const rectE = new Rect( rectD );
-     *
-     * // Rect out of a ClientRect.
-     * const rectF = new Rect( document.body.getClientRects().item( 0 ) );
-     * ```
-     *
-     * **Note**: By default a rect of an HTML element includes its CSS borders and scrollbars (if any)
-     * ant the rect of a `window` includes scrollbars too. Use {@link #excludeScrollbarsAndBorders}
-     * to get the inner part of the rect.
-     *
-     * @param source A source object to create the rect.
-     */ constructor(source){
-        const isSourceRange = isRange(source);
-        Object.defineProperty(this, '_source', {
-            // If the source is a Rect instance, copy it's #_source.
-            value: source._source || source,
-            writable: true,
-            enumerable: false
-        });
-        if (isDomElement(source) || isSourceRange) {
-            // The `Rect` class depends on `getBoundingClientRect` and `getClientRects` DOM methods. If the source
-            // of a rect in an HTML element or a DOM range but it does not belong to any rendered DOM tree, these methods
-            // will fail to obtain the geometry and the rect instance makes little sense to the features using it.
-            // To get rid of this warning make sure the source passed to the constructor is a descendant of `window.document.body`.
-            // @if CK_DEBUG // const sourceNode = isSourceRange ? source.startContainer : source;
-            // @if CK_DEBUG // if ( !sourceNode.ownerDocument || !sourceNode.ownerDocument.body.contains( sourceNode ) ) {
-            // @if CK_DEBUG // 	console.warn(
-            // @if CK_DEBUG // 		'rect-source-not-in-dom: The source of this rect does not belong to any rendered DOM tree.',
-            // @if CK_DEBUG // 		{ source } );
-            // @if CK_DEBUG // }
-            if (isSourceRange) {
-                const rangeRects = Rect.getDomRangeRects(source);
-                copyRectProperties(this, Rect.getBoundingRect(rangeRects));
-            } else {
-                copyRectProperties(this, source.getBoundingClientRect());
-            }
-        } else if (isWindow(source)) {
-            const { innerWidth, innerHeight } = source;
-            copyRectProperties(this, {
-                top: 0,
-                right: innerWidth,
-                bottom: innerHeight,
-                left: 0,
-                width: innerWidth,
-                height: innerHeight
-            });
-        } else {
-            copyRectProperties(this, source);
-        }
-    }
 }
 /**
  * Acquires all the rect properties from the passed source.
@@ -3188,18 +3325,50 @@ class Rect {
  * under the hood.
  */ class ResizeObserver {
     /**
-     * The element observed by this observer.
-     */ get element() {
+	 * The element observed by this observer.
+	 */ _element;
+    /**
+	 * The callback executed each time {@link #_element} is resized.
+	 */ _callback;
+    /**
+	 * The single native observer instance shared across all {@link module:utils/dom/resizeobserver~ResizeObserver} instances.
+	 */ static _observerInstance = null;
+    /**
+	 * A mapping of native DOM elements and their callbacks shared across all
+	 * {@link module:utils/dom/resizeobserver~ResizeObserver} instances.
+	 */ static _elementCallbacks = null;
+    /**
+	 * Creates an instance of the `ResizeObserver` class.
+	 *
+	 * @param element A DOM element that is to be observed for resizing. Note that
+	 * the element must be visible (i.e. not detached from DOM) for the observer to work.
+	 * @param callback A function called when the observed element was resized. It passes
+	 * the [`ResizeObserverEntry`](https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserverEntry)
+	 * object with information about the resize event.
+	 */ constructor(element, callback){
+        // **Note**: For the maximum performance, this class ensures only a single instance of the native
+        // observer is used no matter how many instances of this class were created.
+        if (!ResizeObserver._observerInstance) {
+            ResizeObserver._createObserver();
+        }
+        this._element = element;
+        this._callback = callback;
+        ResizeObserver._addElementCallback(element, callback);
+        ResizeObserver._observerInstance.observe(element);
+    }
+    /**
+	 * The element observed by this observer.
+	 */ get element() {
         return this._element;
     }
     /**
-     * Destroys the observer which disables the `callback` passed to the {@link #constructor}.
-     */ destroy() {
+	 * Destroys the observer which disables the `callback` passed to the {@link #constructor}.
+	 */ destroy() {
         ResizeObserver._deleteElementCallback(this._element, this._callback);
     }
     /**
-     * Registers a new resize callback for the DOM element.
-     */ static _addElementCallback(element, callback) {
+	 * Registers a new resize callback for the DOM element.
+	 */ static _addElementCallback(element, callback) {
         if (!ResizeObserver._elementCallbacks) {
             ResizeObserver._elementCallbacks = new Map();
         }
@@ -3211,9 +3380,9 @@ class Rect {
         callbacks.add(callback);
     }
     /**
-     * Removes a resize callback from the DOM element. If no callbacks are left
-     * for the element, it removes the element from the native observer.
-     */ static _deleteElementCallback(element, callback) {
+	 * Removes a resize callback from the DOM element. If no callbacks are left
+	 * for the element, it removes the element from the native observer.
+	 */ static _deleteElementCallback(element, callback) {
         const callbacks = ResizeObserver._getElementCallbacks(element);
         // Remove the element callback. Check if exist first in case someone
         // called destroy() twice.
@@ -3231,16 +3400,16 @@ class Rect {
         }
     }
     /**
-     * Returns are registered resize callbacks for the DOM element.
-     */ static _getElementCallbacks(element) {
+	 * Returns are registered resize callbacks for the DOM element.
+	 */ static _getElementCallbacks(element) {
         if (!ResizeObserver._elementCallbacks) {
             return null;
         }
         return ResizeObserver._elementCallbacks.get(element);
     }
     /**
-     * Creates the single native observer shared across all `ResizeObserver` instances.
-     */ static _createObserver() {
+	 * Creates the single native observer shared across all `ResizeObserver` instances.
+	 */ static _createObserver() {
         ResizeObserver._observerInstance = new global.window.ResizeObserver((entries)=>{
             for (const entry of entries){
                 const callbacks = ResizeObserver._getElementCallbacks(entry.target);
@@ -3252,33 +3421,7 @@ class Rect {
             }
         });
     }
-    /**
-     * Creates an instance of the `ResizeObserver` class.
-     *
-     * @param element A DOM element that is to be observed for resizing. Note that
-     * the element must be visible (i.e. not detached from DOM) for the observer to work.
-     * @param callback A function called when the observed element was resized. It passes
-     * the [`ResizeObserverEntry`](https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserverEntry)
-     * object with information about the resize event.
-     */ constructor(element, callback){
-        // **Note**: For the maximum performance, this class ensures only a single instance of the native
-        // observer is used no matter how many instances of this class were created.
-        if (!ResizeObserver._observerInstance) {
-            ResizeObserver._createObserver();
-        }
-        this._element = element;
-        this._callback = callback;
-        ResizeObserver._addElementCallback(element, callback);
-        ResizeObserver._observerInstance.observe(element);
-    }
 }
-/**
- * The single native observer instance shared across all {@link module:utils/dom/resizeobserver~ResizeObserver} instances.
- */ ResizeObserver._observerInstance = null;
-/**
- * A mapping of native DOM elements and their callbacks shared across all
- * {@link module:utils/dom/resizeobserver~ResizeObserver} instances.
- */ ResizeObserver._elementCallbacks = null;
 
 /**
  * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
@@ -3609,21 +3752,53 @@ class Rect {
  * translate directly to the `top` and `left` properties in CSS "`position: absolute` coordinate system". If set on the positioned element
  * in DOM, they will make it display it in the right place in the viewport.
  */ class PositionObject {
+    name;
+    config;
+    _positioningFunctionCoordinates;
+    _options;
+    _cachedRect;
+    _cachedAbsoluteRect;
     /**
-     * The left value in pixels in the CSS `position: absolute` coordinate system.
-     * Set it on the positioned element in DOM to move it to the position.
-     */ get left() {
+	 * Creates an instance of the {@link module:utils/dom/position~PositionObject} class.
+	 *
+	 * @param positioningFunction function The function that defines the expected
+	 * coordinates the positioned element should move to.
+	 * @param options options object.
+	 * @param options.elementRect The positioned element rect.
+	 * @param options.targetRect The target element rect.
+	 * @param options.viewportRect The viewport rect.
+	 * @param options.limiterRect The limiter rect.
+	 * @param options.positionedElementAncestor Nearest element ancestor element which CSS position is not "static".
+	 */ constructor(positioningFunction, options){
+        const positioningFunctionOutput = positioningFunction(options.targetRect, options.elementRect, options.viewportRect, options.limiterRect);
+        // Nameless position for a function that didn't participate.
+        if (!positioningFunctionOutput) {
+            return;
+        }
+        const { left, top, name, config } = positioningFunctionOutput;
+        this.name = name;
+        this.config = config;
+        this._positioningFunctionCoordinates = {
+            left,
+            top
+        };
+        this._options = options;
+    }
+    /**
+	 * The left value in pixels in the CSS `position: absolute` coordinate system.
+	 * Set it on the positioned element in DOM to move it to the position.
+	 */ get left() {
         return this._absoluteRect.left;
     }
     /**
-     * The top value in pixels in the CSS `position: absolute` coordinate system.
-     * Set it on the positioned element in DOM to move it to the position.
-     */ get top() {
+	 * The top value in pixels in the CSS `position: absolute` coordinate system.
+	 * Set it on the positioned element in DOM to move it to the position.
+	 */ get top() {
         return this._absoluteRect.top;
     }
     /**
-     * An intersection area between positioned element and limiter within viewport constraints.
-     */ get limiterIntersectionArea() {
+	 * An intersection area between positioned element and limiter within viewport constraints.
+	 */ get limiterIntersectionArea() {
         const limiterRect = this._options.limiterRect;
         if (limiterRect) {
             return limiterRect.getIntersectionArea(this._rect);
@@ -3631,15 +3806,15 @@ class Rect {
         return 0;
     }
     /**
-     * An intersection area between positioned element and viewport.
-     */ get viewportIntersectionArea() {
+	 * An intersection area between positioned element and viewport.
+	 */ get viewportIntersectionArea() {
         const viewportRect = this._options.viewportRect;
         return viewportRect.getIntersectionArea(this._rect);
     }
     /**
-     * An already positioned element rect. A clone of the element rect passed to the constructor
-     * but placed in the viewport according to the positioning function.
-     */ get _rect() {
+	 * An already positioned element rect. A clone of the element rect passed to the constructor
+	 * but placed in the viewport according to the positioning function.
+	 */ get _rect() {
         if (this._cachedRect) {
             return this._cachedRect;
         }
@@ -3647,40 +3822,14 @@ class Rect {
         return this._cachedRect;
     }
     /**
-     * An already absolutely positioned element rect. See ({@link #_rect}).
-     */ get _absoluteRect() {
+	 * An already absolutely positioned element rect. See ({@link #_rect}).
+	 */ get _absoluteRect() {
         if (this._cachedAbsoluteRect) {
             return this._cachedAbsoluteRect;
         }
         this._cachedAbsoluteRect = this._rect.toAbsoluteRect();
         return this._cachedAbsoluteRect;
     }
-    /**
-     * Creates an instance of the {@link module:utils/dom/position~PositionObject} class.
-     *
-     * @param positioningFunction function The function that defines the expected
-     * coordinates the positioned element should move to.
-     * @param options options object.
-     * @param options.elementRect The positioned element rect.
-     * @param options.targetRect The target element rect.
-     * @param options.viewportRect The viewport rect.
-     * @param options.limiterRect The limiter rect.
-     * @param options.positionedElementAncestor Nearest element ancestor element which CSS position is not "static".
-     */ constructor(positioningFunction, options){
-        const positioningFunctionOutput = positioningFunction(options.targetRect, options.elementRect, options.viewportRect, options.limiterRect);
-        // Nameless position for a function that didn't participate.
-        if (!positioningFunctionOutput) {
-            return;
-        }
-        const { left, top, name, config } = positioningFunctionOutput;
-        this.name = name;
-        this.config = config;
-        this._positioningFunctionCoordinates = {
-            left,
-            top
-        };
-        this._options = options;
-    }
 }
 
 /**
@@ -4083,8 +4232,8 @@ const keyCodesToGlyphs = {
  * * `arrow(left|up|right|bottom)`,
  * * `backspace`, `delete`, `enter`, `esc`, `tab`,
  * * `ctrl`, `cmd`, `shift`, `alt`.
- */ const keyCodes = generateKnownKeyCodes();
-const keyCodeNames = Object.fromEntries(Object.entries(keyCodes).map(([name, code])=>{
+ */ const keyCodes = /* #__PURE__ */ generateKnownKeyCodes();
+const keyCodeNames = /* #__PURE__ */ Object.fromEntries(/* #__PURE__ */ Object.entries(keyCodes).map(([name, code])=>{
     let prettyKeyName;
     if (code in keyCodesToGlyphs) {
         prettyKeyName = keyCodesToGlyphs[code];
@@ -4109,11 +4258,11 @@ const keyCodeNames = Object.fromEntries(Object.entries(keyCodes).map(([name, cod
         keyCode = keyCodes[key.toLowerCase()];
         if (!keyCode) {
             /**
-             * Unknown key name. Only key names included in the {@link module:utils/keyboard#keyCodes} can be used.
-             *
-             * @error keyboard-unknown-key
-             * @param {String} key
-             */ throw new CKEditorError('keyboard-unknown-key', null, {
+			 * Unknown key name. Only key names included in the {@link module:utils/keyboard#keyCodes} can be used.
+			 *
+			 * @error keyboard-unknown-key
+			 * @param {String} key
+			 */ throw new CKEditorError('keyboard-unknown-key', null, {
                 key
             });
         }
@@ -4285,6 +4434,10 @@ function splitKeystrokeText(keystroke) {
 /**
  * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
  * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */ /**
+ * @module utils/language
+ */ /**
+ * String representing a language direction.
  */ const RTL_LANGUAGE_CODES = [
     'ar',
     'ara',
@@ -4311,6 +4464,14 @@ function splitKeystrokeText(keystroke) {
 /**
  * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
  * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */ /**
+ * @module utils/toarray
+ */ /**
+ * Transforms any value to an array. If the provided value is already an array, it is returned unchanged.
+ *
+ * @label MUTABLE
+ * @param data The value to transform to an array.
+ * @returns An array created from data.
  */ function toArray(data) {
     return Array.isArray(data) ? data : [
         data
@@ -4360,12 +4521,12 @@ function splitKeystrokeText(keystroke) {
  */ function _translate(language, message, quantity = 1, translations) {
     if (typeof quantity !== 'number') {
         /**
-         * An incorrect value was passed to the translation function. This was probably caused
-         * by an incorrect message interpolation of a plural form. Note that for messages supporting plural forms
-         * the second argument of the `t()` function should always be a number or an array with a number as the first element.
-         *
-         * @error translation-service-quantity-not-a-number
-         */ throw new CKEditorError('translation-service-quantity-not-a-number', null, {
+		 * An incorrect value was passed to the translation function. This was probably caused
+		 * by an incorrect message interpolation of a plural form. Note that for messages supporting plural forms
+		 * the second argument of the `t()` function should always be a number or an array with a number as the first element.
+		 *
+		 * @error translation-service-quantity-not-a-number
+		 */ throw new CKEditorError('translation-service-quantity-not-a-number', null, {
             quantity
         });
     }
@@ -4411,27 +4572,121 @@ function getNumberOfLanguages(translations) {
     return Object.keys(translations).length;
 }
 
-class Locale {
+/**
+ * Represents the localization services.
+ */ class Locale {
+    /**
+	 * The editor UI language code in the [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1) format.
+	 *
+	 * If the {@link #contentLanguage content language} was not specified in the `Locale` constructor,
+	 * it also defines the language of the content.
+	 */ uiLanguage;
+    /**
+	 * Text direction of the {@link #uiLanguage editor UI language}. Either `'ltr'` or `'rtl'`.
+	 */ uiLanguageDirection;
+    /**
+	 * The editor content language code in the [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1) format.
+	 *
+	 * Usually the same as the {@link #uiLanguage editor language}, it can be customized by passing an optional
+	 * argument to the `Locale` constructor.
+	 */ contentLanguage;
     /**
-     * The editor UI language code in the [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1) format.
-     *
-     * **Note**: This property was deprecated. Please use {@link #uiLanguage} and {@link #contentLanguage}
-     * properties instead.
-     *
-     * @deprecated
-     */ get language() {
+	 * Text direction of the {@link #contentLanguage editor content language}.
+	 *
+	 * If the content language was passed directly to the `Locale` constructor, this property represents the
+	 * direction of that language.
+	 *
+	 * If the {@link #contentLanguage editor content language} was derived from the {@link #uiLanguage editor language},
+	 * the content language direction is the same as the {@link #uiLanguageDirection UI language direction}.
+	 *
+	 * The value is either `'ltr'` or `'rtl'`.
+	 */ contentLanguageDirection;
+    /**
+	 * Translates the given message to the {@link #uiLanguage}. This method is also available in
+	 * {@link module:core/editor/editor~Editor#t `Editor`} and {@link module:ui/view~View#t `View`}.
+	 *
+	 * This method's context is statically bound to the `Locale` instance and **should always be called as a function**:
+	 *
+	 * ```ts
+	 * const t = locale.t;
+	 * t( 'Label' );
+	 * ```
+	 *
+	 * The message can be either a string or an object implementing the {@link module:utils/translation-service~Message} interface.
+	 *
+	 * The message may contain placeholders (`%<index>`) for value(s) that are passed as a `values` parameter.
+	 * For an array of values, the `%<index>` will be changed to an element of that array at the given index.
+	 * For a single value passed as the second argument, only the `%0` placeholders will be changed to the provided value.
+	 *
+	 * ```ts
+	 * t( 'Created file "%0" in %1ms.', [ fileName, timeTaken ] );
+	 * t( 'Created file "%0", fileName );
+	 * ```
+	 *
+	 * The message supports plural forms. To specify the plural form, use the `plural` property. Singular or plural form
+	 * will be chosen depending on the first value from the passed `values`. The value of the `plural` property is used
+	 * as a default plural translation when the translation for the target language is missing.
+	 *
+	 * ```ts
+	 * t( { string: 'Add a space', plural: 'Add %0 spaces' }, 1 ); // 'Add a space' for the English language.
+	 * t( { string: 'Add a space', plural: 'Add %0 spaces' }, 5 ); // 'Add 5 spaces' for the English language.
+	 * t( { string: '%1 a space', plural: '%1 %0 spaces' }, [ 2, 'Add' ] ); // 'Add 2 spaces' for the English language.
+	 *
+	 * t( { string: 'Add a space', plural: 'Add %0 spaces' }, 1 ); // 'Dodaj spację' for the Polish language.
+	 * t( { string: 'Add a space', plural: 'Add %0 spaces' }, 5 ); // 'Dodaj 5 spacji' for the Polish language.
+	 * t( { string: '%1 a space', plural: '%1 %0 spaces' }, [ 2, 'Add' ] ); // 'Dodaj 2 spacje' for the Polish language.
+	 * ```
+	 *
+	 *  * The message should provide an ID using the `id` property when the message strings are not unique and their
+	 * translations should be different.
+	 *
+	 * ```ts
+	 * translate( 'en', { string: 'image', id: 'ADD_IMAGE' } );
+	 * translate( 'en', { string: 'image', id: 'AN_IMAGE' } );
+	 * ```
+	 */ t;
+    /**
+	 * Object that contains translations.
+	 */ translations;
+    /**
+	 * Creates a new instance of the locale class. Learn more about
+	 * {@glink getting-started/setup/ui-language configuring the language of the editor}.
+	 *
+	 * @param options Locale configuration.
+	 * @param options.uiLanguage The editor UI language code in the
+	 * [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1) format. See {@link #uiLanguage}.
+	 * @param options.contentLanguage The editor content language code in the
+	 * [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1) format. If not specified, the same as `options.language`.
+	 * See {@link #contentLanguage}.
+	 * @param translations Translations passed as a editor config parameter.
+	 */ constructor({ uiLanguage = 'en', contentLanguage, translations } = {}){
+        this.uiLanguage = uiLanguage;
+        this.contentLanguage = contentLanguage || this.uiLanguage;
+        this.uiLanguageDirection = getLanguageDirection(this.uiLanguage);
+        this.contentLanguageDirection = getLanguageDirection(this.contentLanguage);
+        this.translations = _unifyTranslations(translations);
+        this.t = (message, values)=>this._t(message, values);
+    }
+    /**
+	 * The editor UI language code in the [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1) format.
+	 *
+	 * **Note**: This property was deprecated. Please use {@link #uiLanguage} and {@link #contentLanguage}
+	 * properties instead.
+	 *
+	 * @deprecated
+	 */ get language() {
         /**
-         * The {@link module:utils/locale~Locale#language `Locale#language`} property was deprecated and will
-         * be removed in the near future. Please use the {@link module:utils/locale~Locale#uiLanguage `Locale#uiLanguage`} and
-         * {@link module:utils/locale~Locale#contentLanguage `Locale#contentLanguage`} properties instead.
-         *
-         * @error locale-deprecated-language-property
-         */ console.warn('locale-deprecated-language-property: ' + 'The Locale#language property has been deprecated and will be removed in the near future. ' + 'Please use #uiLanguage and #contentLanguage properties instead.');
+		 * The {@link module:utils/locale~Locale#language `Locale#language`} property was deprecated and will
+		 * be removed in the near future. Please use the {@link module:utils/locale~Locale#uiLanguage `Locale#uiLanguage`} and
+		 * {@link module:utils/locale~Locale#contentLanguage `Locale#contentLanguage`} properties instead.
+		 *
+		 * @error locale-deprecated-language-property
+		 */ console.warn('locale-deprecated-language-property: ' + 'The Locale#language property has been deprecated and will be removed in the near future. ' + 'Please use #uiLanguage and #contentLanguage properties instead.');
         return this.uiLanguage;
     }
     /**
-     * An unbound version of the {@link #t} method.
-     */ _t(message, values = []) {
+	 * An unbound version of the {@link #t} method.
+	 */ _t(message, values = []) {
         values = toArray(values);
         if (typeof message === 'string') {
             message = {
@@ -4443,25 +4698,6 @@ class Locale {
         const translatedString = _translate(this.uiLanguage, message, quantity, this.translations);
         return interpolateString(translatedString, values);
     }
-    /**
-     * Creates a new instance of the locale class. Learn more about
-     * {@glink features/ui-language configuring the language of the editor}.
-     *
-     * @param options Locale configuration.
-     * @param options.uiLanguage The editor UI language code in the
-     * [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1) format. See {@link #uiLanguage}.
-     * @param options.contentLanguage The editor content language code in the
-     * [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1) format. If not specified, the same as `options.language`.
-     * See {@link #contentLanguage}.
-     * @param translations Translations passed as a editor config parameter.
-     */ constructor({ uiLanguage = 'en', contentLanguage, translations } = {}){
-        this.uiLanguage = uiLanguage;
-        this.contentLanguage = contentLanguage || this.uiLanguage;
-        this.uiLanguageDirection = getLanguageDirection(this.uiLanguage);
-        this.contentLanguageDirection = getLanguageDirection(this.contentLanguage);
-        this.translations = _unifyTranslations(translations);
-        this.t = (message, values)=>this._t(message, values);
-    }
 }
 /**
  * Fills the `%0, %1, ...` string placeholders with values.
@@ -4471,56 +4707,117 @@ class Locale {
     });
 }
 
-class Collection extends EmitterMixin() {
+/**
+ * Collections are ordered sets of objects. Items in the collection can be retrieved by their indexes
+ * in the collection (like in an array) or by their ids.
+ *
+ * If an object without an `id` property is being added to the collection, the `id` property will be generated
+ * automatically. Note that the automatically generated id is unique only within this single collection instance.
+ *
+ * By default an item in the collection is identified by its `id` property. The name of the identifier can be
+ * configured through the constructor of the collection.
+ *
+ * @typeParam T The type of the collection element.
+ */ class Collection extends /* #__PURE__ */ EmitterMixin() {
+    /**
+	 * The internal list of items in the collection.
+	 */ _items;
+    /**
+	 * The internal map of items in the collection.
+	 */ _itemMap;
+    /**
+	 * The name of the property which is considered to identify an item.
+	 */ _idProperty;
+    /**
+	 * A collection instance this collection is bound to as a result
+	 * of calling {@link #bindTo} method.
+	 */ _bindToCollection;
+    /**
+	 * A helper mapping external items of a bound collection ({@link #bindTo})
+	 * and actual items of this collection. It provides information
+	 * necessary to properly remove items bound to another collection.
+	 *
+	 * See {@link #_bindToInternalToExternalMap}.
+	 */ _bindToExternalToInternalMap;
+    /**
+	 * A helper mapping items of this collection to external items of a bound collection
+	 * ({@link #bindTo}). It provides information necessary to manage the bindings, e.g.
+	 * to avoid loops in two–way bindings.
+	 *
+	 * See {@link #_bindToExternalToInternalMap}.
+	 */ _bindToInternalToExternalMap;
+    /**
+	 * Stores indexes of skipped items from bound external collection.
+	 */ _skippedIndexesFromExternal;
+    constructor(initialItemsOrOptions = {}, options = {}){
+        super();
+        const hasInitialItems = isIterable(initialItemsOrOptions);
+        if (!hasInitialItems) {
+            options = initialItemsOrOptions;
+        }
+        this._items = [];
+        this._itemMap = new Map();
+        this._idProperty = options.idProperty || 'id';
+        this._bindToExternalToInternalMap = new WeakMap();
+        this._bindToInternalToExternalMap = new WeakMap();
+        this._skippedIndexesFromExternal = [];
+        // Set the initial content of the collection (if provided in the constructor).
+        if (hasInitialItems) {
+            for (const item of initialItemsOrOptions){
+                this._items.push(item);
+                this._itemMap.set(this._getItemIdBeforeAdding(item), item);
+            }
+        }
+    }
     /**
-     * The number of items available in the collection.
-     */ get length() {
+	 * The number of items available in the collection.
+	 */ get length() {
         return this._items.length;
     }
     /**
-     * Returns the first item from the collection or null when collection is empty.
-     */ get first() {
+	 * Returns the first item from the collection or null when collection is empty.
+	 */ get first() {
         return this._items[0] || null;
     }
     /**
-     * Returns the last item from the collection or null when collection is empty.
-     */ get last() {
+	 * Returns the last item from the collection or null when collection is empty.
+	 */ get last() {
         return this._items[this.length - 1] || null;
     }
     /**
-     * Adds an item into the collection.
-     *
-     * If the item does not have an id, then it will be automatically generated and set on the item.
-     *
-     * @param item
-     * @param index The position of the item in the collection. The item
-     * is pushed to the collection when `index` not specified.
-     * @fires add
-     * @fires change
-     */ add(item, index) {
+	 * Adds an item into the collection.
+	 *
+	 * If the item does not have an id, then it will be automatically generated and set on the item.
+	 *
+	 * @param item
+	 * @param index The position of the item in the collection. The item
+	 * is pushed to the collection when `index` not specified.
+	 * @fires add
+	 * @fires change
+	 */ add(item, index) {
         return this.addMany([
             item
         ], index);
     }
     /**
-     * Adds multiple items into the collection.
-     *
-     * Any item not containing an id will get an automatically generated one.
-     *
-     * @param items
-     * @param index The position of the insertion. Items will be appended if no `index` is specified.
-     * @fires add
-     * @fires change
-     */ addMany(items, index) {
+	 * Adds multiple items into the collection.
+	 *
+	 * Any item not containing an id will get an automatically generated one.
+	 *
+	 * @param items
+	 * @param index The position of the insertion. Items will be appended if no `index` is specified.
+	 * @fires add
+	 * @fires change
+	 */ addMany(items, index) {
         if (index === undefined) {
             index = this._items.length;
         } else if (index > this._items.length || index < 0) {
             /**
-             * The `index` passed to {@link module:utils/collection~Collection#addMany `Collection#addMany()`}
-             * is invalid. It must be a number between 0 and the collection's length.
-             *
-             * @error collection-add-item-invalid-index
-             */ throw new CKEditorError('collection-add-item-invalid-index', this);
+			 * The `index` passed to {@link module:utils/collection~Collection#addMany `Collection#addMany()`}
+			 * is invalid. It must be a number between 0 and the collection's length.
+			 *
+			 * @error collection-add-item-invalid-index
+			 */ throw new CKEditorError('collection-add-item-invalid-index', this);
         }
         let offset = 0;
         for (const item of items){
@@ -4539,11 +4836,11 @@ class Collection extends EmitterMixin() {
         return this;
     }
     /**
-     * Gets an item by its ID or index.
-     *
-     * @param idOrIndex The item ID or index in the collection.
-     * @returns The requested item or `null` if such item does not exist.
-     */ get(idOrIndex) {
+	 * Gets an item by its ID or index.
+	 *
+	 * @param idOrIndex The item ID or index in the collection.
+	 * @returns The requested item or `null` if such item does not exist.
+	 */ get(idOrIndex) {
         let item;
         if (typeof idOrIndex == 'string') {
             item = this._itemMap.get(idOrIndex);
@@ -4551,19 +4848,19 @@ class Collection extends EmitterMixin() {
             item = this._items[idOrIndex];
         } else {
             /**
-             * An index or ID must be given.
-             *
-             * @error collection-get-invalid-arg
-             */ throw new CKEditorError('collection-get-invalid-arg', this);
+			 * An index or ID must be given.
+			 *
+			 * @error collection-get-invalid-arg
+			 */ throw new CKEditorError('collection-get-invalid-arg', this);
         }
         return item || null;
     }
     /**
-     * Returns a Boolean indicating whether the collection contains an item.
-     *
-     * @param itemOrId The item or its ID in the collection.
-     * @returns `true` if the collection contains the item, `false` otherwise.
-     */ has(itemOrId) {
+	 * Returns a Boolean indicating whether the collection contains an item.
+	 *
+	 * @param itemOrId The item or its ID in the collection.
+	 * @returns `true` if the collection contains the item, `false` otherwise.
+	 */ has(itemOrId) {
         if (typeof itemOrId == 'string') {
             return this._itemMap.has(itemOrId);
         } else {
@@ -4573,12 +4870,12 @@ class Collection extends EmitterMixin() {
         }
     }
     /**
-     * Gets an index of an item in the collection.
-     * When an item is not defined in the collection, the index will equal -1.
-     *
-     * @param itemOrId The item or its ID in the collection.
-     * @returns The index of a given item.
-     */ getIndex(itemOrId) {
+	 * Gets an index of an item in the collection.
+	 * When an item is not defined in the collection, the index will equal -1.
+	 *
+	 * @param itemOrId The item or its ID in the collection.
+	 * @returns The index of a given item.
+	 */ getIndex(itemOrId) {
         let item;
         if (typeof itemOrId == 'string') {
             item = this._itemMap.get(itemOrId);
@@ -4588,13 +4885,13 @@ class Collection extends EmitterMixin() {
         return item ? this._items.indexOf(item) : -1;
     }
     /**
-     * Removes an item from the collection.
-     *
-     * @param subject The item to remove, its ID or index in the collection.
-     * @returns The removed item.
-     * @fires remove
-     * @fires change
-     */ remove(subject) {
+	 * Removes an item from the collection.
+	 *
+	 * @param subject The item to remove, its ID or index in the collection.
+	 * @returns The removed item.
+	 * @fires remove
+	 * @fires change
+	 */ remove(subject) {
         const [item, index] = this._remove(subject);
         this.fire('change', {
             added: [],
@@ -4606,47 +4903,47 @@ class Collection extends EmitterMixin() {
         return item;
     }
     /**
-     * Executes the callback for each item in the collection and composes an array or values returned by this callback.
-     *
-     * @typeParam U The result type of the callback.
-     * @param callback
-     * @param ctx Context in which the `callback` will be called.
-     * @returns The result of mapping.
-     */ map(callback, ctx) {
+	 * Executes the callback for each item in the collection and composes an array or values returned by this callback.
+	 *
+	 * @typeParam U The result type of the callback.
+	 * @param callback
+	 * @param ctx Context in which the `callback` will be called.
+	 * @returns The result of mapping.
+	 */ map(callback, ctx) {
         return this._items.map(callback, ctx);
     }
     /**
-     * Performs the specified action for each item in the collection.
-     *
-     * @param ctx Context in which the `callback` will be called.
-     */ forEach(callback, ctx) {
+	 * Performs the specified action for each item in the collection.
+	 *
+	 * @param ctx Context in which the `callback` will be called.
+	 */ forEach(callback, ctx) {
         this._items.forEach(callback, ctx);
     }
     /**
-     * Finds the first item in the collection for which the `callback` returns a true value.
-     *
-     * @param callback
-     * @param ctx Context in which the `callback` will be called.
-     * @returns The item for which `callback` returned a true value.
-     */ find(callback, ctx) {
+	 * Finds the first item in the collection for which the `callback` returns a true value.
+	 *
+	 * @param callback
+	 * @param ctx Context in which the `callback` will be called.
+	 * @returns The item for which `callback` returned a true value.
+	 */ find(callback, ctx) {
         return this._items.find(callback, ctx);
     }
     /**
-     * Returns an array with items for which the `callback` returned a true value.
-     *
-     * @param callback
-     * @param ctx Context in which the `callback` will be called.
-     * @returns The array with matching items.
-     */ filter(callback, ctx) {
+	 * Returns an array with items for which the `callback` returned a true value.
+	 *
+	 * @param callback
+	 * @param ctx Context in which the `callback` will be called.
+	 * @returns The array with matching items.
+	 */ filter(callback, ctx) {
         return this._items.filter(callback, ctx);
     }
     /**
-     * Removes all items from the collection and destroys the binding created using
-     * {@link #bindTo}.
-     *
-     * @fires remove
-     * @fires change
-     */ clear() {
+	 * Removes all items from the collection and destroys the binding created using
+	 * {@link #bindTo}.
+	 *
+	 * @fires remove
+	 * @fires change
+	 */ clear() {
         if (this._bindToCollection) {
             this.stopListening(this._bindToCollection);
             this._bindToCollection = null;
@@ -4662,122 +4959,122 @@ class Collection extends EmitterMixin() {
         });
     }
     /**
-     * Binds and synchronizes the collection with another one.
-     *
-     * The binding can be a simple factory:
-     *
-     * ```ts
-     * class FactoryClass {
-     * 	public label: string;
-     *
-     * 	constructor( data: { label: string } ) {
-     * 		this.label = data.label;
-     * 	}
-     * }
-     *
-     * const source = new Collection<{ label: string }>( { idProperty: 'label' } );
-     * const target = new Collection<FactoryClass>();
-     *
-     * target.bindTo( source ).as( FactoryClass );
-     *
-     * source.add( { label: 'foo' } );
-     * source.add( { label: 'bar' } );
-     *
-     * console.log( target.length ); // 2
-     * console.log( target.get( 1 ).label ); // 'bar'
-     *
-     * source.remove( 0 );
-     * console.log( target.length ); // 1
-     * console.log( target.get( 0 ).label ); // 'bar'
-     * ```
-     *
-     * or the factory driven by a custom callback:
-     *
-     * ```ts
-     * class FooClass {
-     * 	public label: string;
-     *
-     * 	constructor( data: { label: string } ) {
-     * 		this.label = data.label;
-     * 	}
-     * }
-     *
-     * class BarClass {
-     * 	public label: string;
-     *
-     * 	constructor( data: { label: string } ) {
-     * 		this.label = data.label;
-     * 	}
-     * }
-     *
-     * const source = new Collection<{ label: string }>( { idProperty: 'label' } );
-     * const target = new Collection<FooClass | BarClass>();
-     *
-     * target.bindTo( source ).using( ( item ) => {
-     * 	if ( item.label == 'foo' ) {
-     * 		return new FooClass( item );
-     * 	} else {
-     * 		return new BarClass( item );
-     * 	}
-     * } );
-     *
-     * source.add( { label: 'foo' } );
-     * source.add( { label: 'bar' } );
-     *
-     * console.log( target.length ); // 2
-     * console.log( target.get( 0 ) instanceof FooClass ); // true
-     * console.log( target.get( 1 ) instanceof BarClass ); // true
-     * ```
-     *
-     * or the factory out of property name:
-     *
-     * ```ts
-     * const source = new Collection<{ nested: { value: string } }>();
-     * const target = new Collection<{ value: string }>();
-     *
-     * target.bindTo( source ).using( 'nested' );
-     *
-     * source.add( { nested: { value: 'foo' } } );
-     * source.add( { nested: { value: 'bar' } } );
-     *
-     * console.log( target.length ); // 2
-     * console.log( target.get( 0 ).value ); // 'foo'
-     * console.log( target.get( 1 ).value ); // 'bar'
-     * ```
-     *
-     * It's possible to skip specified items by returning null value:
-     *
-     * ```ts
-     * const source = new Collection<{ hidden: boolean }>();
-     * const target = new Collection<{ hidden: boolean }>();
-     *
-     * target.bindTo( source ).using( item => {
-     * 	if ( item.hidden ) {
-     * 		return null;
-     * 	}
-     *
-     * 	return item;
-     * } );
-     *
-     * source.add( { hidden: true } );
-     * source.add( { hidden: false } );
-     *
-     * console.log( source.length ); // 2
-     * console.log( target.length ); // 1
-     * ```
-     *
-     * **Note**: {@link #clear} can be used to break the binding.
-     *
-     * @typeParam S The type of `externalCollection` element.
-     * @param externalCollection A collection to be bound.
-     * @returns The binding chain object.
-     */ bindTo(externalCollection) {
+	 * Binds and synchronizes the collection with another one.
+	 *
+	 * The binding can be a simple factory:
+	 *
+	 * ```ts
+	 * class FactoryClass {
+	 * 	public label: string;
+	 *
+	 * 	constructor( data: { label: string } ) {
+	 * 		this.label = data.label;
+	 * 	}
+	 * }
+	 *
+	 * const source = new Collection<{ label: string }>( { idProperty: 'label' } );
+	 * const target = new Collection<FactoryClass>();
+	 *
+	 * target.bindTo( source ).as( FactoryClass );
+	 *
+	 * source.add( { label: 'foo' } );
+	 * source.add( { label: 'bar' } );
+	 *
+	 * console.log( target.length ); // 2
+	 * console.log( target.get( 1 ).label ); // 'bar'
+	 *
+	 * source.remove( 0 );
+	 * console.log( target.length ); // 1
+	 * console.log( target.get( 0 ).label ); // 'bar'
+	 * ```
+	 *
+	 * or the factory driven by a custom callback:
+	 *
+	 * ```ts
+	 * class FooClass {
+	 * 	public label: string;
+	 *
+	 * 	constructor( data: { label: string } ) {
+	 * 		this.label = data.label;
+	 * 	}
+	 * }
+	 *
+	 * class BarClass {
+	 * 	public label: string;
+	 *
+	 * 	constructor( data: { label: string } ) {
+	 * 		this.label = data.label;
+	 * 	}
+	 * }
+	 *
+	 * const source = new Collection<{ label: string }>( { idProperty: 'label' } );
+	 * const target = new Collection<FooClass | BarClass>();
+	 *
+	 * target.bindTo( source ).using( ( item ) => {
+	 * 	if ( item.label == 'foo' ) {
+	 * 		return new FooClass( item );
+	 * 	} else {
+	 * 		return new BarClass( item );
+	 * 	}
+	 * } );
+	 *
+	 * source.add( { label: 'foo' } );
+	 * source.add( { label: 'bar' } );
+	 *
+	 * console.log( target.length ); // 2
+	 * console.log( target.get( 0 ) instanceof FooClass ); // true
+	 * console.log( target.get( 1 ) instanceof BarClass ); // true
+	 * ```
+	 *
+	 * or the factory out of property name:
+	 *
+	 * ```ts
+	 * const source = new Collection<{ nested: { value: string } }>();
+	 * const target = new Collection<{ value: string }>();
+	 *
+	 * target.bindTo( source ).using( 'nested' );
+	 *
+	 * source.add( { nested: { value: 'foo' } } );
+	 * source.add( { nested: { value: 'bar' } } );
+	 *
+	 * console.log( target.length ); // 2
+	 * console.log( target.get( 0 ).value ); // 'foo'
+	 * console.log( target.get( 1 ).value ); // 'bar'
+	 * ```
+	 *
+	 * It's possible to skip specified items by returning null value:
+	 *
+	 * ```ts
+	 * const source = new Collection<{ hidden: boolean }>();
+	 * const target = new Collection<{ hidden: boolean }>();
+	 *
+	 * target.bindTo( source ).using( item => {
+	 * 	if ( item.hidden ) {
+	 * 		return null;
+	 * 	}
+	 *
+	 * 	return item;
+	 * } );
+	 *
+	 * source.add( { hidden: true } );
+	 * source.add( { hidden: false } );
+	 *
+	 * console.log( source.length ); // 2
+	 * console.log( target.length ); // 1
+	 * ```
+	 *
+	 * **Note**: {@link #clear} can be used to break the binding.
+	 *
+	 * @typeParam S The type of `externalCollection` element.
+	 * @param externalCollection A collection to be bound.
+	 * @returns The binding chain object.
+	 */ bindTo(externalCollection) {
         if (this._bindToCollection) {
             /**
-             * The collection cannot be bound more than once.
-             *
-             * @error collection-bind-to-rebind
-             */ throw new CKEditorError('collection-bind-to-rebind', this);
+			 * The collection cannot be bound more than once.
+			 *
+			 * @error collection-bind-to-rebind
+			 */ throw new CKEditorError('collection-bind-to-rebind', this);
         }
         this._bindToCollection = externalCollection;
         return {
@@ -4794,10 +5091,10 @@ class Collection extends EmitterMixin() {
         };
     }
     /**
-     * Finalizes and activates a binding initiated by {@link #bindTo}.
-     *
-     * @param factory A function which produces collection items.
-     */ _setUpBindToBinding(factory) {
+	 * Finalizes and activates a binding initiated by {@link #bindTo}.
+	 *
+	 * @param factory A function which produces collection items.
+	 */ _setUpBindToBinding(factory) {
         const externalCollection = this._bindToCollection;
         // Adds the item to the collection once a change has been done to the external collection.
         const addItem = (evt, externalItem, index)=>{
@@ -4898,29 +5195,29 @@ class Collection extends EmitterMixin() {
         });
     }
     /**
-     * Returns an unique id property for a given `item`.
-     *
-     * The method will generate new id and assign it to the `item` if it doesn't have any.
-     *
-     * @param item Item to be added.
-     */ _getItemIdBeforeAdding(item) {
+	 * Returns an unique id property for a given `item`.
+	 *
+	 * The method will generate new id and assign it to the `item` if it doesn't have any.
+	 *
+	 * @param item Item to be added.
+	 */ _getItemIdBeforeAdding(item) {
         const idProperty = this._idProperty;
         let itemId;
         if (idProperty in item) {
             itemId = item[idProperty];
             if (typeof itemId != 'string') {
                 /**
-                 * This item's ID should be a string.
-                 *
-                 * @error collection-add-invalid-id
-                 */ throw new CKEditorError('collection-add-invalid-id', this);
+				 * This item's ID should be a string.
+				 *
+				 * @error collection-add-invalid-id
+				 */ throw new CKEditorError('collection-add-invalid-id', this);
             }
             if (this.get(itemId)) {
                 /**
-                 * This item already exists in the collection.
-                 *
-                 * @error collection-add-item-already-exists
-                 */ throw new CKEditorError('collection-add-item-already-exists', this);
+				 * This item already exists in the collection.
+				 *
+				 * @error collection-add-item-already-exists
+				 */ throw new CKEditorError('collection-add-item-already-exists', this);
             }
         } else {
             item[idProperty] = itemId = uid();
@@ -4928,14 +5225,14 @@ class Collection extends EmitterMixin() {
         return itemId;
     }
     /**
-     * Core {@link #remove} method implementation shared in other functions.
-     *
-     * In contrast this method **does not** fire the {@link #event:change} event.
-     *
-     * @param subject The item to remove, its id or index in the collection.
-     * @returns Returns an array with the removed item and its index.
-     * @fires remove
-     */ _remove(subject) {
+	 * Core {@link #remove} method implementation shared in other functions.
+	 *
+	 * In contrast this method **does not** fire the {@link #event:change} event.
+	 *
+	 * @param subject The item to remove, its id or index in the collection.
+	 * @returns Returns an array with the removed item and its index.
+	 * @fires remove
+	 */ _remove(subject) {
         let index, id, item;
         let itemDoesNotExist = false;
         const idProperty = this._idProperty;
@@ -4961,10 +5258,10 @@ class Collection extends EmitterMixin() {
         }
         if (itemDoesNotExist) {
             /**
-             * Item not found.
-             *
-             * @error collection-remove-404
-             */ throw new CKEditorError('collection-remove-404', this);
+			 * Item not found.
+			 *
+			 * @error collection-remove-404
+			 */ throw new CKEditorError('collection-remove-404', this);
         }
         this._items.splice(index, 1);
         this._itemMap.delete(id);
@@ -4978,30 +5275,10 @@ class Collection extends EmitterMixin() {
         ];
     }
     /**
-     * Iterable interface.
-     */ [Symbol.iterator]() {
+	 * Iterable interface.
+	 */ [Symbol.iterator]() {
         return this._items[Symbol.iterator]();
     }
-    constructor(initialItemsOrOptions = {}, options = {}){
-        super();
-        const hasInitialItems = isIterable(initialItemsOrOptions);
-        if (!hasInitialItems) {
-            options = initialItemsOrOptions;
-        }
-        this._items = [];
-        this._itemMap = new Map();
-        this._idProperty = options.idProperty || 'id';
-        this._bindToExternalToInternalMap = new WeakMap();
-        this._bindToInternalToExternalMap = new WeakMap();
-        this._skippedIndexesFromExternal = [];
-        // Set the initial content of the collection (if provided in the constructor).
-        if (hasInitialItems) {
-            for (const item of initialItemsOrOptions){
-                this._items.push(item);
-                this._itemMap.set(this._getItemIdBeforeAdding(item), item);
-            }
-        }
-    }
 }
 
 /**
@@ -5019,16 +5296,40 @@ class Collection extends EmitterMixin() {
     return iteratorItem.value;
 }
 
-class FocusTracker extends DomEmitterMixin(ObservableMixin()) {
+/**
+ * Allows observing a group of `Element`s whether at least one of them is focused.
+ *
+ * Used by the {@link module:core/editor/editor~Editor} in order to track whether the focus is still within the application,
+ * or were used outside of its UI.
+ *
+ * **Note** `focus` and `blur` listeners use event capturing, so it is only needed to register wrapper `Element`
+ * which contain other `focusable` elements. But note that this wrapper element has to be focusable too
+ * (have e.g. `tabindex="-1"`).
+ *
+ * Check out the {@glink framework/deep-dive/ui/focus-tracking "Deep dive into focus tracking"} guide to learn more.
+ */ class FocusTracker extends /* #__PURE__ */ DomEmitterMixin(/* #__PURE__ */ ObservableMixin()) {
     /**
-     * Starts tracking the specified element.
-     */ add(element) {
+	 * List of registered elements.
+	 *
+	 * @internal
+	 */ _elements = new Set();
+    /**
+	 * Event loop timeout.
+	 */ _nextEventLoopTimeout = null;
+    constructor(){
+        super();
+        this.set('isFocused', false);
+        this.set('focusedElement', null);
+    }
+    /**
+	 * Starts tracking the specified element.
+	 */ add(element) {
         if (this._elements.has(element)) {
             /**
-             * This element is already tracked by {@link module:utils/focustracker~FocusTracker}.
-             *
-             * @error focustracker-add-element-already-exist
-             */ throw new CKEditorError('focustracker-add-element-already-exist', this);
+			 * This element is already tracked by {@link module:utils/focustracker~FocusTracker}.
+			 *
+			 * @error focustracker-add-element-already-exist
+			 */ throw new CKEditorError('focustracker-add-element-already-exist', this);
         }
         this.listenTo(element, 'focus', ()=>this._focus(element), {
             useCapture: true
@@ -5039,8 +5340,8 @@ class FocusTracker extends DomEmitterMixin(ObservableMixin()) {
         this._elements.add(element);
     }
     /**
-     * Stops tracking the specified element and stops listening on this element.
-     */ remove(element) {
+	 * Stops tracking the specified element and stops listening on this element.
+	 */ remove(element) {
         if (element === this.focusedElement) {
             this._blur();
         }
@@ -5050,48 +5351,77 @@ class FocusTracker extends DomEmitterMixin(ObservableMixin()) {
         }
     }
     /**
-     * Destroys the focus tracker by:
-     * - Disabling all event listeners attached to tracked elements.
-     * - Removing all tracked elements that were previously added.
-     */ destroy() {
+	 * Destroys the focus tracker by:
+	 * - Disabling all event listeners attached to tracked elements.
+	 * - Removing all tracked elements that were previously added.
+	 */ destroy() {
         this.stopListening();
     }
     /**
-     * Stores currently focused element and set {@link #isFocused} as `true`.
-     */ _focus(element) {
+	 * Stores currently focused element and set {@link #isFocused} as `true`.
+	 */ _focus(element) {
         clearTimeout(this._nextEventLoopTimeout);
         this.focusedElement = element;
         this.isFocused = true;
     }
     /**
-     * Clears currently focused element and set {@link #isFocused} as `false`.
-     * This method uses `setTimeout` to change order of fires `blur` and `focus` events.
-     */ _blur() {
+	 * Clears currently focused element and set {@link #isFocused} as `false`.
+	 * This method uses `setTimeout` to change order of fires `blur` and `focus` events.
+	 */ _blur() {
         clearTimeout(this._nextEventLoopTimeout);
         this._nextEventLoopTimeout = setTimeout(()=>{
             this.focusedElement = null;
             this.isFocused = false;
         }, 0);
     }
-    constructor(){
-        super();
-        /**
-         * List of registered elements.
-         *
-         * @internal
-         */ this._elements = new Set();
-        /**
-         * Event loop timeout.
-         */ this._nextEventLoopTimeout = null;
-        this.set('isFocused', false);
-        this.set('focusedElement', null);
-    }
 }
 
-class KeystrokeHandler {
+/**
+ * Keystroke handler allows registering callbacks for given keystrokes.
+ *
+ * The most frequent use of this class is through the {@link module:core/editor/editor~Editor#keystrokes `editor.keystrokes`}
+ * property. It allows listening to keystrokes executed in the editing view:
+ *
+ * ```ts
+ * editor.keystrokes.set( 'Ctrl+A', ( keyEvtData, cancel ) => {
+ * 	console.log( 'Ctrl+A has been pressed' );
+ * 	cancel();
+ * } );
+ * ```
+ *
+ * However, this utility class can be used in various part of the UI. For instance, a certain {@link module:ui/view~View}
+ * can use it like this:
+ *
+ * ```ts
+ * class MyView extends View {
+ * 	constructor() {
+ * 		this.keystrokes = new KeystrokeHandler();
+ *
+ * 		this.keystrokes.set( 'tab', handleTabKey );
+ * 	}
+ *
+ * 	render() {
+ * 		super.render();
+ *
+ * 		this.keystrokes.listenTo( this.element );
+ * 	}
+ * }
+ * ```
+ *
+ * That keystroke handler will listen to `keydown` events fired in this view's main element.
+ *
+ */ class KeystrokeHandler {
+    /**
+	 * Listener used to listen to events for easier keystroke handler destruction.
+	 */ _listener;
     /**
-     * Starts listening for `keydown` events from a given emitter.
-     */ listenTo(emitter) {
+	 * Creates an instance of the keystroke handler.
+	 */ constructor(){
+        this._listener = new (DomEmitterMixin())();
+    }
+    /**
+	 * Starts listening for `keydown` events from a given emitter.
+	 */ listenTo(emitter) {
         // The #_listener works here as a kind of dispatcher. It groups the events coming from the same
         // keystroke so the listeners can be attached to them with different priorities.
         //
@@ -5106,18 +5436,18 @@ class KeystrokeHandler {
         });
     }
     /**
-     * Registers a handler for the specified keystroke.
-     *
-     * @param keystroke Keystroke defined in a format accepted by
-     * the {@link module:utils/keyboard~parseKeystroke} function.
-     * @param callback A function called with the
-     * {@link module:engine/view/observer/keyobserver~KeyEventData key event data} object and
-     * a helper function to call both `preventDefault()` and `stopPropagation()` on the underlying event.
-     * @param options Additional options.
-     * @param options.priority The priority of the keystroke
-     * callback. The higher the priority value the sooner the callback will be executed. Keystrokes having the same priority
-     * are called in the order they were added.
-     */ set(keystroke, callback, options = {}) {
+	 * Registers a handler for the specified keystroke.
+	 *
+	 * @param keystroke Keystroke defined in a format accepted by
+	 * the {@link module:utils/keyboard~parseKeystroke} function.
+	 * @param callback A function called with the
+	 * {@link module:engine/view/observer/keyobserver~KeyEventData key event data} object and
+	 * a helper function to call both `preventDefault()` and `stopPropagation()` on the underlying event.
+	 * @param options Additional options.
+	 * @param options.priority The priority of the keystroke
+	 * callback. The higher the priority value the sooner the callback will be executed. Keystrokes having the same priority
+	 * are called in the order they were added.
+	 */ set(keystroke, callback, options = {}) {
         const keyCode = parseKeystroke(keystroke);
         const priority = options.priority;
         // Execute the passed callback on KeystrokeHandler#_keydown.
@@ -5139,28 +5469,23 @@ class KeystrokeHandler {
         });
     }
     /**
-     * Triggers a keystroke handler for a specified key combination, if such a keystroke was {@link #set defined}.
-     *
-     * @param keyEvtData Key event data.
-     * @returns Whether the keystroke was handled.
-     */ press(keyEvtData) {
+	 * Triggers a keystroke handler for a specified key combination, if such a keystroke was {@link #set defined}.
+	 *
+	 * @param keyEvtData Key event data.
+	 * @returns Whether the keystroke was handled.
+	 */ press(keyEvtData) {
         return !!this._listener.fire('_keydown:' + getCode(keyEvtData), keyEvtData);
     }
     /**
-     * Stops listening to `keydown` events from the given emitter.
-     */ stopListening(emitter) {
+	 * Stops listening to `keydown` events from the given emitter.
+	 */ stopListening(emitter) {
         this._listener.stopListening(emitter);
     }
     /**
-     * Destroys the keystroke handler.
-     */ destroy() {
+	 * Destroys the keystroke handler.
+	 */ destroy() {
         this.stopListening();
     }
-    /**
-     * Creates an instance of the keystroke handler.
-     */ constructor(){
-        this._listener = new (DomEmitterMixin())();
-    }
 }
 
 /**
@@ -5460,7 +5785,7 @@ class KeystrokeHandler {
  */ function isInsideCombinedSymbol(string, offset) {
     return isCombiningMark(string.charAt(offset));
 }
-const EMOJI_PATTERN = buildEmojiRegexp();
+const EMOJI_PATTERN = /* #__PURE__ */ buildEmojiRegexp();
 /**
  * Checks whether given offset in a string is inside multi-character emoji sequence.
  *
@@ -5473,15 +5798,15 @@ const EMOJI_PATTERN = buildEmojiRegexp();
 function buildEmojiRegexp() {
     const parts = [
         // Emoji Tag Sequence (ETS)
-        RegExp("\\p{Emoji}[\\u{E0020}-\\u{E007E}]+\\u{E007F}", "u"),
+        /\p{Emoji}[\u{E0020}-\u{E007E}]+\u{E007F}/u,
         // Emoji Keycap Sequence
-        RegExp("\\p{Emoji}\\u{FE0F}?\\u{20E3}", "u"),
+        /\p{Emoji}\u{FE0F}?\u{20E3}/u,
         // Emoji Presentation Sequence
-        RegExp("\\p{Emoji}\\u{FE0F}", "u"),
+        /\p{Emoji}\u{FE0F}/u,
         // Single-Character Emoji / Emoji Modifier Sequence
-        RegExp("(?=\\p{General_Category=Other_Symbol})\\p{Emoji}\\p{Emoji_Modifier}*", "u")
+        /(?=\p{General_Category=Other_Symbol})\p{Emoji}\p{Emoji_Modifier}*/u
     ];
-    const flagSequence = RegExp("\\p{Regional_Indicator}{2}", "u").source;
+    const flagSequence = /\p{Regional_Indicator}{2}/u.source;
     const emoji = '(?:' + parts.map((part)=>part.source).join('|') + ')';
     const sequence = `${flagSequence}|${emoji}(?:\u{200D}${emoji})*`;
     return new RegExp(sequence, 'ug');