@ckeditor/ckeditor5-utils 0.0.0-internal-20241017.0

package/dist/spy.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @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
+ */
+/**
+ * @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/spy
+ */
+/**
+ * Creates a spy function (ala Sinon.js) that can be used to inspect call to it.
+ *
+ * The following are the present features:
+ *
+ * * spy.called: property set to `true` if the function has been called at least once.
+ *
+ * @returns The spy function.
+ */
+declare function spy(): {
+    (): void;
+    called?: boolean;
+};
+export default spy;

package/dist/toarray.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @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
+ */
+/**
+ * @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.
+ */
+export default function toArray<T>(data: ArrayOrItem<T>): Array<T>;
+/**
+ * Transforms any value to an array. If the provided value is already an array, it is returned unchanged.
+ *
+ * @label IMMUTABLE
+ * @param data The value to transform to an array.
+ * @returns An array created from data.
+ */
+export default function toArray<T>(data: ReadonlyArrayOrItem<T>): ReadonlyArray<T>;
+export type ArrayOrItem<T> = T | Array<T>;
+export type ReadonlyArrayOrItem<T> = T | ReadonlyArray<T>;

package/dist/tomap.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @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
+ */
+/**
+ * @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
+ */
+/**
+ * Transforms object or iterable to map. Iterable needs to be in the format acceptable by the `Map` constructor.
+ *
+ * ```ts
+ * map = toMap( { 'foo': 1, 'bar': 2 } );
+ * map = toMap( [ [ 'foo', 1 ], [ 'bar', 2 ] ] );
+ * map = toMap( anotherMap );
+ * ```
+ *
+ * @param data Object or iterable to transform.
+ * @returns Map created from data.
+ */
+export default function toMap<T>(data: {
+    readonly [key: string]: T;
+} | Iterable<readonly [string, T]> | null | undefined): Map<string, T>;

package/dist/translation-service.d.ts

@@ -0,0 +1,178 @@
+/**
+ * @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
+ */
+/**
+ * @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/translation-service
+ */
+import type { Translations } from './locale.js';
+import { type ArrayOrItem } from './toarray.js';
+declare global {
+    var CKEDITOR_TRANSLATIONS: Translations;
+}
+/**
+ * Adds translations to existing ones or overrides the existing translations. These translations will later
+ * be available for the {@link module:utils/locale~Locale#t `t()`} function.
+ *
+ * The `translations` is an object which consists of `messageId: translation` pairs. Note that the message ID can be
+ * either constructed from the message string or from the message ID if it was passed
+ * (this happens rarely and mostly for short messages or messages with placeholders).
+ * Since the editor displays only the message string, the message ID can be found either in the source code or in the
+ * built translations for another language.
+ *
+ * ```ts
+ * add( 'pl', {
+ * 	'Cancel': 'Anuluj',
+ * 	'IMAGE': 'obraz', // Note that the `IMAGE` comes from the message ID, while the string can be `image`.
+ * } );
+ * ```
+ *
+ * If the message is supposed to support various plural forms, make sure to provide an array with the singular form and all plural forms:
+ *
+ * ```ts
+ * add( 'pl', {
+ * 	'Add space': [ 'Dodaj spację', 'Dodaj %0 spacje', 'Dodaj %0 spacji' ]
+ * } );
+ * ```
+ *
+ * You should also specify the third argument (the `getPluralForm()` function) that will be used to determine the plural form if no
+ * language file was loaded for that language. All language files coming from CKEditor 5 sources will have this option set, so
+ * these plural form rules will be reused by other translations added to the registered languages. The `getPluralForm()` function
+ * can return either a Boolean or a number.
+ *
+ * ```ts
+ * add( 'en', {
+ * 	// ... Translations.
+ * }, n => n !== 1 );
+ * add( 'pl', {
+ * 	// ... Translations.
+ * }, n => n == 1 ? 0 : n % 10 >= 2 && n % 10 <= 4 && ( n % 100 < 10 || n % 100 >= 20 ) ? 1 : 2 );
+ * ```
+ *
+ * All translations extend the global `window.CKEDITOR_TRANSLATIONS` object. An example of this object can be found below:
+ *
+ * ```ts
+ * {
+ * 	pl: {
+ * 		dictionary: {
+ * 			'Cancel': 'Anuluj',
+ * 			'Add space': [ 'Dodaj spację', 'Dodaj %0 spacje', 'Dodaj %0 spacji' ]
+ * 		},
+ * 		// A function that returns the plural form index.
+ * 		getPluralForm: n => n == 1 ? 0 : n % 10 >= 2 && n % 10 <= 4 && ( n % 100 < 10 || n % 100 >= 20 ) ? 1 : 2 );
+ * 	}
+ * 	// Other languages.
+ * 	}
+ * ```
+ *
+ * If you cannot import this function from this module (e.g. because you use a CKEditor 5 build), you can
+ * still add translations by extending the global `window.CKEDITOR_TRANSLATIONS` object by using a function like
+ * the one below:
+ *
+ * ```ts
+ * function addTranslations( language, translations, getPluralForm ) {
+ * 	if ( !global.window.CKEDITOR_TRANSLATIONS ) {
+ * 		global.window.CKEDITOR_TRANSLATIONS = {};
+ * 	}
+
+ * 	if ( !global.window.CKEDITOR_TRANSLATIONS[ language ] ) {
+ * 		global.window.CKEDITOR_TRANSLATIONS[ language ] = {};
+ * 	}
+ *
+ * 	const languageTranslations = global.window.CKEDITOR_TRANSLATIONS[ language ];
+ *
+ * 	languageTranslations.dictionary = languageTranslations.dictionary || {};
+ * 	languageTranslations.getPluralForm = getPluralForm || languageTranslations.getPluralForm;
+ *
+ * 	// Extend the dictionary for the given language.
+ * 	Object.assign( languageTranslations.dictionary, translations );
+ * }
+ * ```
+ *
+ * @param language Target language.
+ * @param translations An object with translations which will be added to the dictionary.
+ * For each message ID the value should be either a translation or an array of translations if the message
+ * should support plural forms.
+ * @param getPluralForm A function that returns the plural form index (a number).
+ */
+export declare function add(language: string, translations: {
+    readonly [messageId: string]: string | ReadonlyArray<string>;
+}, getPluralForm?: (n: number) => number): void;
+/**
+ * **Note:** This method is internal, use {@link module:utils/locale~Locale#t the `t()` function} instead to translate
+ * the editor UI parts.
+ *
+ * This function is responsible for translating messages to the specified language. It uses translations added perviously
+ * by {@link module:utils/translation-service~add} (a translations dictionary and the `getPluralForm()` function
+ * to provide accurate translations of plural forms).
+ *
+ * When no translation is defined in the dictionary or the dictionary does not exist, this function returns
+ * the original message string or the message plural depending on the number of elements.
+ *
+ * ```ts
+ * translate( 'pl', { string: 'Cancel' } ); // 'Cancel'
+ * ```
+ *
+ * The third optional argument is the number of elements, based on which the single form or one of the plural forms
+ * should be picked when the message is supposed to support various plural forms.
+ *
+ * ```ts
+ * translate( 'en', { string: 'Add a space', plural: 'Add %0 spaces' }, 1 ); // 'Add a space'
+ * translate( 'en', { string: 'Add a space', plural: 'Add %0 spaces' }, 3 ); // 'Add %0 spaces'
+ * ```
+ *
+ * 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' } );
+ * ```
+ *
+ * @internal
+ * @param language Target language.
+ * @param message A message that will be translated.
+ * @param quantity The number of elements for which a plural form should be picked from the target language dictionary.
+ * @param translations Translations passed in editor config, if not provided use the global `window.CKEDITOR_TRANSLATIONS`.
+ * @returns Translated sentence.
+ */
+export declare function _translate(language: string, message: Message, quantity?: number, translations?: Translations): string;
+/**
+ * Clears dictionaries for test purposes.
+ *
+ * @internal
+ */
+export declare function _clear(): void;
+/**
+ * If array then merge objects which are inside otherwise return given object.
+ *
+ * @internal
+ * @param translations Translations passed in editor config.
+ */
+export declare function _unifyTranslations(translations?: ArrayOrItem<Translations>): Translations | undefined;
+/**
+ * The internationalization message interface. A message that implements this interface can be passed to the `t()` function
+ * to be translated to the target UI language.
+ */
+export interface Message {
+    /**
+     * The message string to translate. Acts as a default translation if the translation for a given language
+     * is not defined. When the message is supposed to support plural forms, the string should be the English singular form of the message.
+     */
+    readonly string: string;
+    /**
+     * The message ID. If passed, the message ID is taken from this property instead of the `message.string`.
+     * This property is useful when various messages share the same message string, for example, the `editor` string in `in the editor`
+     * and `my editor` sentences.
+     */
+    readonly id?: string;
+    /**
+     * The plural form of the message. This property should be skipped when a message is not supposed
+     * to support plural forms. Otherwise it should always be set to a string with the English plural form of the message.
+     */
+    readonly plural?: string;
+}

package/dist/uid.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @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
+ */
+/**
+ * @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
+ */
+/**
+ * Returns a unique id. The id starts with an "e" character and a randomly generated string of
+ * 32 alphanumeric characters.
+ *
+ * **Note**: The characters the unique id is built from correspond to the hex number notation
+ * (from "0" to "9", from "a" to "f"). In other words, each id corresponds to an "e" followed
+ * by 16 8-bit numbers next to each other.
+ *
+ * @returns An unique id string.
+ */
+export default function uid(): string;

package/dist/unicode.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @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
+ */
+/**
+ * @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
+ */
+/**
+ * Set of utils to handle unicode characters.
+ *
+ * @module utils/unicode
+ */
+/**
+ * Checks whether given `character` is a combining mark.
+ *
+ * @param character Character to check.
+ */
+export declare function isCombiningMark(character: string): boolean;
+/**
+ * Checks whether given `character` is a high half of surrogate pair.
+ *
+ * Using UTF-16 terminology, a surrogate pair denotes UTF-16 character using two UTF-8 characters. The surrogate pair
+ * consist of high surrogate pair character followed by low surrogate pair character.
+ *
+ * @param character Character to check.
+ */
+export declare function isHighSurrogateHalf(character: string): boolean;
+/**
+ * Checks whether given `character` is a low half of surrogate pair.
+ *
+ * Using UTF-16 terminology, a surrogate pair denotes UTF-16 character using two UTF-8 characters. The surrogate pair
+ * consist of high surrogate pair character followed by low surrogate pair character.
+ *
+ * @param character Character to check.
+ */
+export declare function isLowSurrogateHalf(character: string): boolean;
+/**
+ * Checks whether given offset in a string is inside a surrogate pair (between two surrogate halves).
+ *
+ * @param string String to check.
+ * @param offset Offset to check.
+ */
+export declare function isInsideSurrogatePair(string: string, offset: number): boolean;
+/**
+ * Checks whether given offset in a string is between base character and combining mark or between two combining marks.
+ *
+ * @param string String to check.
+ * @param offset Offset to check.
+ */
+export declare function isInsideCombinedSymbol(string: string, offset: number): boolean;
+/**
+ * Checks whether given offset in a string is inside multi-character emoji sequence.
+ *
+ * @param string String to check.
+ * @param offset Offset to check.
+ */
+export declare function isInsideEmojiSequence(string: string, offset: number): boolean;

package/dist/version.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @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
+ */
+/**
+ * @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
+ */
+declare const version = "0.0.0-internal-20241017.0";
+export default version;
+export declare const releaseDate: Date;
+declare global {
+    var CKEDITOR_VERSION: string;
+}

package/dist/wait.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @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
+ */
+/**
+ * @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/wait
+ */
+/**
+ * Returns a promise that is resolved after the specified time.
+ *
+ * @param timeout The time in milliseconds to wait.
+ * @param options.signal A signal to abort the waiting.
+ */
+export default function wait(timeout: number, options?: {
+    signal?: AbortSignal;
+}): Promise<void>;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@ckeditor/ckeditor5-utils",
+  "version": "0.0.0-internal-20241017.0",
+  "description": "Miscellaneous utilities used by CKEditor 5.",
+  "keywords": [
+    "ckeditor",
+    "ckeditor5",
+    "ckeditor 5",
+    "ckeditor5-lib",
+    "ckeditor5-dll"
+  ],
+  "type": "module",
+  "main": "src/index.js",
+  "dependencies": {
+    "lodash-es": "4.17.21"
+  },
+  "author": "CKSource (http://cksource.com/)",
+  "license": "GPL-2.0-or-later",
+  "homepage": "https://ckeditor.com/ckeditor-5",
+  "bugs": "https://github.com/ckeditor/ckeditor5/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ckeditor/ckeditor5.git",
+    "directory": "packages/ckeditor5-utils"
+  },
+  "files": [
+    "dist",
+    "lang",
+    "src/**/*.js",
+    "src/**/*.d.ts",
+    "theme",
+    "ckeditor5-metadata.json",
+    "CHANGELOG.md"
+  ],
+  "types": "src/index.d.ts"
+}

package/src/abortabledebounce.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @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/abortabledebounce
+ */
+/**
+ * Returns a function wrapper that will execute the provided function and abort any previous call that is still in progress.
+ *
+ * @param func The function to be called. It will be provided with `AbortSignal` as the first parameter.
+ */
+export default function abortableDebounce<Args extends Array<any>, Ret>(func: (signal: AbortSignal, ...args: Args) => Ret): AbortableFunc<Args, Ret>;
+export interface AbortableFunc<Args extends Array<any>, Ret> {
+    (...args: Args): Ret;
+    abort(): void;
+}

package/src/abortabledebounce.js

@@ -0,0 +1,22 @@
+/**
+ * @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/abortabledebounce
+ */
+/**
+ * Returns a function wrapper that will execute the provided function and abort any previous call that is still in progress.
+ *
+ * @param func The function to be called. It will be provided with `AbortSignal` as the first parameter.
+ */
+export default function abortableDebounce(func) {
+    let controller = new AbortController();
+    function abortable(...args) {
+        controller.abort();
+        controller = new AbortController();
+        return func(controller.signal, ...args);
+    }
+    abortable.abort = () => controller.abort();
+    return abortable;
+}

package/src/areconnectedthroughproperties.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @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/areconnectedthroughproperties
+ */
+/**
+ * Traverses both structures to find out whether there is a reference that is shared between both structures.
+ */
+export default function areConnectedThroughProperties(obj1: object, obj2: object): boolean;

package/src/areconnectedthroughproperties.js

@@ -0,0 +1,73 @@
+/**
+ * @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/areconnectedthroughproperties
+ */
+/* globals EventTarget, Event */
+/**
+ * Traverses both structures to find out whether there is a reference that is shared between both structures.
+ */
+export default function areConnectedThroughProperties(obj1, obj2) {
+    if (obj1 === obj2 && isObject(obj1)) {
+        return true;
+    }
+    const subNodes1 = getSubNodes(obj1);
+    const subNodes2 = getSubNodes(obj2);
+    for (const node of subNodes1) {
+        if (subNodes2.has(node)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Traverses JS structure and stores all sub-nodes, including the head node.
+ * It walks into each iterable structures with the `try catch` block to omit errors that might be thrown during
+ * tree walking. All primitives, functions and built-ins are skipped.
+ */
+function getSubNodes(head) {
+    const nodes = [head];
+    // Nodes are stored to prevent infinite looping.
+    const subNodes = new Set();
+    while (nodes.length > 0) {
+        const node = nodes.shift();
+        if (subNodes.has(node) || shouldNodeBeSkipped(node)) {
+            continue;
+        }
+        subNodes.add(node);
+        // Handle arrays, maps, sets, custom collections that implements `[ Symbol.iterator ]()`, etc.
+        if (node[Symbol.iterator]) {
+            // The custom editor iterators might cause some problems if the editor is crashed.
+            try {
+                nodes.push(...node);
+            }
+            catch (err) {
+                // eslint-disable-line no-empty
+            }
+        }
+        else {
+            nodes.push(...Object.values(node));
+        }
+    }
+    return subNodes;
+}
+function shouldNodeBeSkipped(node) {
+    const type = Object.prototype.toString.call(node);
+    return (type === '[object Number]' ||
+        type === '[object Boolean]' ||
+        type === '[object String]' ||
+        type === '[object Symbol]' ||
+        type === '[object Function]' ||
+        type === '[object Date]' ||
+        type === '[object RegExp]' ||
+        node === undefined ||
+        node === null ||
+        // Skip native DOM objects, e.g. Window, nodes, events, etc.
+        node instanceof EventTarget ||
+        node instanceof Event);
+}
+function isObject(structure) {
+    return typeof structure === 'object' && structure !== null;
+}

package/src/ckeditorerror.d.ts

@@ -0,0 +1,123 @@
+/**
+ * @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/ckeditorerror
+ */
+/**
+ * URL to the documentation with error codes.
+ */
+export declare const DOCUMENTATION_URL = "https://ckeditor.com/docs/ckeditor5/latest/support/error-codes.html";
+/**
+ * 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'
+ * } );
+ * ```
+ */
+export default class CKEditorError extends Error {
+    /**
+     * A context of the error by which the Watchdog is able to determine which editor crashed.
+     */
+    readonly context: object | null | undefined;
+    /**
+     * The additional error data passed to the constructor. Undefined if none was passed.
+     */
+    readonly data?: object;
+    /**
+     * 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: string, context?: object | null, data?: object);
+    /**
+     * Checks if the error is of the `CKEditorError` type.
+     */
+    is(type: string): boolean;
+    /**
+     * 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: Error, context: object): never;
+}
+/**
+ * Logs a warning to the console with a properly formatted message and adds a link to the documentation.
+ * Use whenever you want to log a warning to the console.
+ *
+ * ```ts
+ * /**
+ *  * There was a problem processing the configuration of the toolbar. The item with the given
+ *  * name does not exist, so it was omitted when rendering the toolbar.
+ *  *
+ *  * @error toolbarview-item-unavailable
+ *  * @param {String} name The name of the component.
+ *  *\/
+ * logWarning( 'toolbarview-item-unavailable', { name } );
+ * ```
+ *
+ * See also {@link module:utils/ckeditorerror~CKEditorError} for an explanation when to throw an error and when to log
+ * a warning or an error to the console.
+ *
+ * @param errorName The error name to be logged.
+ * @param data Additional data to be logged.
+ */
+export declare function logWarning(errorName: string, data?: object): void;
+/**
+ * Logs an error to the console with a properly formatted message and adds a link to the documentation.
+ * Use whenever you want to log an error to the console.
+ *
+ * ```ts
+ * /**
+ *  * There was a problem processing the configuration of the toolbar. The item with the given
+ *  * name does not exist, so it was omitted when rendering the toolbar.
+ *  *
+ *  * @error toolbarview-item-unavailable
+ *  * @param {String} name The name of the component.
+ *  *\/
+ *  logError( 'toolbarview-item-unavailable', { name } );
+ * ```
+ *
+ * **Note**: In most cases logging a warning using {@link module:utils/ckeditorerror~logWarning} is enough.
+ *
+ * See also {@link module:utils/ckeditorerror~CKEditorError} for an explanation when to use each method.
+ *
+ * @param errorName The error name to be logged.
+ * @param data Additional data to be logged.
+ */
+export declare function logError(errorName: string, data?: object): void;