@ckeditor/ckeditor5-utils 0.0.0-internal-20241017.0

package/dist/inserttopriorityarray.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @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
+ */
+import { type PriorityString } from './priorities.js';
+/**
+ * @module utils/inserttopriorityarray
+ */
+/**
+ * The priority object descriptor.
+ *
+ * ```ts
+ * const objectWithPriority = {
+ * 	priority: 'high'
+ * }
+ * ```
+ */
+export interface ObjectWithPriority {
+    /**
+     * Priority of the object.
+     */
+    priority: PriorityString;
+}
+/**
+ * Inserts any object with priority at correct index by priority so registered objects are always sorted from highest to lowest priority.
+ *
+ * @param objects Array of objects with priority to insert object to.
+ * @param objectToInsert Object with `priority` property.
+ */
+export default function insertToPriorityArray<T extends ObjectWithPriority>(objects: Array<T>, objectToInsert: T): void;

package/dist/isiterable.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @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/isiterable
+ */
+/**
+ * Checks if value implements iterator interface.
+ *
+ * @param value The value to check.
+ * @returns True if value implements iterator interface.
+ */
+export default function isIterable(value: any): value is Iterable<any>;

package/dist/keyboard.d.ts

@@ -0,0 +1,130 @@
+/**
+ * @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
+ */
+/**
+ * A set of utilities related to keyboard support.
+ *
+ * @module utils/keyboard
+ */
+import type { LanguageDirection } from './language.js';
+/**
+ * An object with `keyName => keyCode` pairs for a set of known keys.
+ *
+ * Contains:
+ *
+ * * `a-z`,
+ * * `0-9`,
+ * * `f1-f12`,
+ * * `` ` ``, `-`, `=`, `[`, `]`, `;`, `'`, `,`, `.`, `/`, `\`,
+ * * `arrow(left|up|right|bottom)`,
+ * * `backspace`, `delete`, `enter`, `esc`, `tab`,
+ * * `ctrl`, `cmd`, `shift`, `alt`.
+ */
+export declare const keyCodes: {
+    readonly [keyCode: string]: number;
+};
+/**
+ * Converts a key name or {@link module:utils/keyboard~KeystrokeInfo keystroke info} into a key code.
+ *
+ * Note: Key names are matched with {@link module:utils/keyboard#keyCodes} in a case-insensitive way.
+ *
+ * @param key A key name (see {@link module:utils/keyboard#keyCodes}) or a keystroke data object.
+ * @returns Key or keystroke code.
+ */
+export declare function getCode(key: string | Readonly<KeystrokeInfo>): number;
+/**
+ * Parses the keystroke and returns a keystroke code that will match the code returned by
+ * {@link module:utils/keyboard~getCode} for the corresponding {@link module:utils/keyboard~KeystrokeInfo keystroke info}.
+ *
+ * The keystroke can be passed in two formats:
+ *
+ * * as a single string – e.g. `ctrl + A`,
+ * * as an array of {@link module:utils/keyboard~keyCodes known key names} and key codes – e.g.:
+ *   * `[ 'ctrl', 32 ]` (ctrl + space),
+ *   * `[ 'ctrl', 'a' ]` (ctrl + A).
+ *
+ * Note: Key names are matched with {@link module:utils/keyboard#keyCodes} in a case-insensitive way.
+ *
+ * Note: Only keystrokes with a single non-modifier key are supported (e.g. `ctrl+A` is OK, but `ctrl+A+B` is not).
+ *
+ * Note: On macOS, keystroke handling is translating the `Ctrl` key to the `Cmd` key and handling only that keystroke.
+ * For example, a registered keystroke `Ctrl+A` will be translated to `Cmd+A` on macOS. To disable the translation of some keystroke,
+ * use the forced modifier: `Ctrl!+A` (note the exclamation mark).
+ *
+ * @param keystroke The keystroke definition.
+ * @returns Keystroke code.
+ */
+export declare function parseKeystroke(keystroke: string | ReadonlyArray<number | string>): number;
+/**
+ * Translates any keystroke string text like `"Ctrl+A"` to an
+ * environment–specific keystroke, i.e. `"⌘A"` on macOS.
+ *
+ * @param keystroke The keystroke text.
+ * @returns The keystroke text specific for the environment.
+ */
+export declare function getEnvKeystrokeText(keystroke: string): string;
+/**
+ * Returns `true` if the provided key code represents one of the arrow keys.
+ *
+ * @param keyCode A key code as in {@link module:utils/keyboard~KeystrokeInfo#keyCode}.
+ */
+export declare function isArrowKeyCode(keyCode: number): boolean;
+/**
+ * String representing a direction of an arrow key kode.
+ */
+export type ArrowKeyCodeDirection = 'left' | 'up' | 'right' | 'down';
+/**
+ * Returns the direction in which the {@link module:engine/model/documentselection~DocumentSelection selection}
+ * will move when the provided arrow key code is pressed considering the language direction of the editor content.
+ *
+ * For instance, in right–to–left (RTL) content languages, pressing the left arrow means moving the selection right (forward)
+ * in the model structure. Similarly, pressing the right arrow moves the selection left (backward).
+ *
+ * @param keyCode A key code as in {@link module:utils/keyboard~KeystrokeInfo#keyCode}.
+ * @param contentLanguageDirection The content language direction, corresponding to
+ * {@link module:utils/locale~Locale#contentLanguageDirection}.
+ * @returns Localized arrow direction or `undefined` for non-arrow key codes.
+ */
+export declare function getLocalizedArrowKeyCodeDirection(keyCode: number, contentLanguageDirection: LanguageDirection): ArrowKeyCodeDirection | undefined;
+/**
+ * Determines if the provided key code moves the {@link module:engine/model/documentselection~DocumentSelection selection}
+ * forward or backward considering the language direction of the editor content.
+ *
+ * For instance, in right–to–left (RTL) languages, pressing the left arrow means moving forward
+ * in the model structure. Similarly, pressing the right arrow moves the selection backward.
+ *
+ * @param keyCode A key code as in {@link module:utils/keyboard~KeystrokeInfo#keyCode}.
+ * @param contentLanguageDirection The content language direction, corresponding to
+ * {@link module:utils/locale~Locale#contentLanguageDirection}.
+ */
+export declare function isForwardArrowKeyCode(keyCode: number, contentLanguageDirection: LanguageDirection): boolean;
+/**
+ * Information about the keystroke.
+ */
+export interface KeystrokeInfo {
+    /**
+     * The [key code](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/keyCode).
+     */
+    keyCode: number;
+    /**
+     * Whether the <kbd>Alt</kbd> modifier was pressed.
+     */
+    altKey: boolean;
+    /**
+     * Whether the <kbd>Cmd</kbd> modifier was pressed.
+     */
+    metaKey: boolean;
+    /**
+     * Whether the <kbd>Ctrl</kbd> modifier was pressed.
+     */
+    ctrlKey: boolean;
+    /**
+     * Whether the <kbd>Shift</kbd> modifier was pressed.
+     */
+    shiftKey: boolean;
+}

package/dist/keystrokehandler.d.ts

@@ -0,0 +1,101 @@
+/**
+ * @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
+ */
+import type { Emitter } from './emittermixin.js';
+import { type KeystrokeInfo } from './keyboard.js';
+import type { PriorityString } from './priorities.js';
+/**
+ * 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.
+ *
+ */
+export default class KeystrokeHandler {
+    /**
+     * Listener used to listen to events for easier keystroke handler destruction.
+     */
+    private readonly _listener;
+    /**
+     * Creates an instance of the keystroke handler.
+     */
+    constructor();
+    /**
+     * Starts listening for `keydown` events from a given emitter.
+     */
+    listenTo(emitter: Emitter | HTMLElement | Window): void;
+    /**
+     * 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.
+     */
+    set(keystroke: string | ReadonlyArray<string | number>, callback: (ev: KeyboardEvent, cancel: () => void) => void, options?: KeystrokeHandlerOptions): void;
+    /**
+     * 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: Readonly<KeystrokeInfo>): boolean;
+    /**
+     * Stops listening to `keydown` events from the given emitter.
+     */
+    stopListening(emitter?: Emitter | HTMLElement | Window): void;
+    /**
+     * Destroys the keystroke handler.
+     */
+    destroy(): void;
+}
+/**
+ * {@link module:utils/keystrokehandler~KeystrokeHandler#set} method options.
+ */
+export interface KeystrokeHandlerOptions {
+    /**
+     * 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.
+     */
+    readonly priority?: PriorityString;
+    /**
+     * An optional callback function allowing for filtering keystrokes based on arbitrary criteria.
+     * The callback function receives `keydown` DOM event as a parameter.
+     */
+    readonly filter?: (keyEvtData: KeyboardEvent) => boolean;
+}

package/dist/language.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @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/language
+ */
+/**
+ * String representing a language direction.
+ */
+export type LanguageDirection = 'ltr' | 'rtl';
+/**
+ * Helps determine whether a language text direction is LTR or RTL.
+ *
+ * @param languageCode The ISO 639-1 or ISO 639-2 language code.
+ */
+export declare function getLanguageDirection(languageCode: string): LanguageDirection;

package/dist/locale.d.ts

@@ -0,0 +1,145 @@
+/**
+ * @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/locale
+ */
+import { type ArrayOrItem } from './toarray.js';
+import { type Message } from './translation-service.js';
+import { type LanguageDirection } from './language.js';
+/**
+ * Represents the localization services.
+ */
+export default 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.
+     */
+    readonly uiLanguage: string;
+    /**
+     * Text direction of the {@link #uiLanguage editor UI language}. Either `'ltr'` or `'rtl'`.
+     */
+    readonly uiLanguageDirection: LanguageDirection;
+    /**
+     * 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.
+     */
+    readonly contentLanguage: string;
+    /**
+     * 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'`.
+     */
+    readonly contentLanguageDirection: LanguageDirection;
+    /**
+     * 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' } );
+     * ```
+     */
+    readonly t: LocaleTranslate;
+    /**
+     * Object that contains translations.
+     */
+    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, contentLanguage, translations }?: {
+        readonly uiLanguage?: string;
+        readonly contentLanguage?: string;
+        readonly translations?: ArrayOrItem<Translations>;
+    });
+    /**
+     * 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(): string;
+    /**
+     * An unbound version of the {@link #t} method.
+     */
+    private _t;
+}
+/**
+ * @param message A message that will be localized (translated).
+ * @param values A value or an array of values that will fill message placeholders.
+ * For messages supporting plural forms the first value will determine the plural form.
+ */
+export type LocaleTranslate = (message: string | Message, values?: number | string | ReadonlyArray<number | string>) => string;
+/**
+ * Translations object definition.
+ */
+export type Translations = {
+    [language: string]: {
+        dictionary: {
+            [messageId: string]: string | ReadonlyArray<string>;
+        };
+        getPluralForm?: ((n: number) => number | boolean) | null;
+    };
+};

package/dist/mapsequal.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
+ */
+/**
+ * @module utils/mapsequal
+ */
+/**
+ * Checks whether given `Map`s are equal, that is has same size and same key-value pairs.
+ *
+ * @param mapA The first map to compare.
+ * @param mapB The second map to compare.
+ * @returns `true` if given maps are equal, `false` otherwise.
+ */
+export default function mapsEqual<Key>(mapA: Map<Key, unknown>, mapB: Map<Key, unknown>): boolean;

package/dist/mix.d.ts

@@ -0,0 +1,89 @@
+/**
+ * @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/mix
+ */
+/**
+ * Copies enumerable properties and symbols from the objects given as 2nd+ parameters to the
+ * prototype of first object (a constructor).
+ *
+ * ```
+ * class Editor {
+ * 	...
+ * }
+ *
+ * const SomeMixin = {
+ * 	a() {
+ * 		return 'a';
+ * 	}
+ * };
+ *
+ * mix( Editor, SomeMixin, ... );
+ *
+ * new Editor().a(); // -> 'a'
+ * ```
+ *
+ * Note: Properties which already exist in the base class will not be overriden.
+ *
+ * @deprecated Use mixin pattern, see: https://www.typescriptlang.org/docs/handbook/mixins.html.
+ * @param baseClass Class which prototype will be extended.
+ * @param mixins Objects from which to get properties.
+ */
+export default function mix(baseClass: Function, ...mixins: Array<object>): void;
+/**
+ * Helper type that represents constructor creating given objects. Can be used as a type constraint.
+ *
+ * ```ts
+ * // The function accepts any class constructor.
+ * function MyFunction<Ctor extends Constructor>( ctor: Ctor ) {
+ * 	// ...
+ * }
+ *
+ * // The function accepts any class constructor of type derived from `MyBase`.
+ * function MyFunction<Ctor extends Constructor<MyBase>>( ctor: Ctor ) {
+ * 	// ...
+ * }
+ * ```
+ */
+export type Constructor<Instance = object> = abstract new (...args: Array<any>) => Instance;
+/**
+ * Helper type that creates constructor types from a base class and a mixin interface.
+ *
+ * ```ts
+ * interface MyMixinInterface {
+ * 	mixinMethod(): void;
+ * }
+ *
+ * function MyMixin<Base extends Constructor>( base: Base ): Mixed<Base, MyMixinInterface> {
+ * 	// ...
+ * }
+ *
+ * class BaseClass {
+ * 	baseMethod(): void {
+ * 		// ...
+ * 	}
+ * }
+ *
+ * const MixedClass = MyMixin( BaseClass );
+ *
+ * // Contains both `mixinMethod()` and `baseMethod()`.
+ * const myObject = new MixedClass();
+ * myObject.mixinMethod();
+ * myObject.baseMethod();
+ * ```
+ *
+ * @typeParam Base A type of constructor of a class to apply mixin to.
+ * @typeParam Mixin An interface representing mixin.
+ */
+export type Mixed<Base extends Constructor, Mixin extends object> = {
+    new (...args: ConstructorParameters<Base>): Mixin & InstanceType<Base>;
+    prototype: Mixin & InstanceType<Base>;
+} & {
+    [K in keyof Base]: Base[K];
+};

package/dist/nth.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/nth
+ */
+/**
+ * Returns `nth` (starts from `0` of course) item of the given `iterable`.
+ *
+ * If the iterable is a generator, then it consumes **all its items**.
+ * If it's a normal iterator, then it consumes **all items up to the given index**.
+ * Refer to the [Iterators and Generators](https://developer.mozilla.org/en/docs/Web/JavaScript/Guide/Iterators_and_Generators)
+ * guide to learn differences between these interfaces.
+ */
+export default function nth<T>(index: number, iterable: Iterable<T>): T | null;

package/dist/objecttomap.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @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/objecttomap
+ */
+/**
+ * Transforms object to map.
+ *
+ * ```ts
+ * const map = objectToMap( { 'foo': 1, 'bar': 2 } );
+ * map.get( 'foo' ); // 1
+ * ```
+ *
+ * **Note**: For mixed data (`Object` or `Iterable`) there's a dedicated {@link module:utils/tomap~toMap} function.
+ *
+ * @param obj Object to transform.
+ * @returns Map created from object.
+ */
+export default function objectToMap<T>(obj: {
+    readonly [key: string]: T;
+} | null | undefined): Map<string, T>;