@ckeditor/ckeditor5-core 44.1.0-alpha.5 → 44.2.0-alpha.0

package/dist/command.d.ts

@@ -1,193 +0,0 @@
-/**
- * @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-licensing-options
- */
-/**
- * @module core/command
- */
-import { type DecoratedMethodEvent } from '@ckeditor/ckeditor5-utils';
-import type Editor from './editor/editor.js';
-declare const Command_base: {
-    new (): import("@ckeditor/ckeditor5-utils").Observable;
-    prototype: import("@ckeditor/ckeditor5-utils").Observable;
-};
-/**
- * Base class for the CKEditor commands.
- *
- * Commands are the main way to manipulate the editor contents and state. They are mostly used by UI elements (or by other
- * commands) to make changes in the model. Commands are available in every part of the code that has access to
- * the {@link module:core/editor/editor~Editor editor} instance.
- *
- * Instances of registered commands can be retrieved from {@link module:core/editor/editor~Editor#commands `editor.commands`}.
- * The easiest way to execute a command is through {@link module:core/editor/editor~Editor#execute `editor.execute()`}.
- *
- * By default, commands are disabled when the editor is in the {@link module:core/editor/editor~Editor#isReadOnly read-only} mode
- * but commands with the {@link module:core/command~Command#affectsData `affectsData`} flag set to `false` will not be disabled.
- */
-export default class Command extends /* #__PURE__ */ Command_base {
-    /**
-     * The editor on which this command will be used.
-     */
-    readonly editor: Editor;
-    /**
-     * The value of the command. A given command class should define what it represents for it.
-     *
-     * For example, the `'bold'` command's value indicates whether the selection starts in a bolded text.
-     * And the value of the `'link'` command may be an object with link details.
-     *
-     * It is possible for a command to have no value (e.g. for stateless actions such as `'uploadImage'`).
-     *
-     * A given command class should control this value by overriding the {@link #refresh `refresh()`} method.
-     *
-     * @observable
-     * @readonly
-     */
-    value: unknown;
-    /**
-     * Flag indicating whether a command is enabled or disabled.
-     * A disabled command will do nothing when executed.
-     *
-     * A given command class should control this value by overriding the {@link #refresh `refresh()`} method.
-     *
-     * It is possible to disable a command "from outside" using {@link #forceDisabled} method.
-     *
-     * @observable
-     * @readonly
-     */
-    isEnabled: boolean;
-    /**
-     * A flag indicating whether a command's `isEnabled` state should be changed depending on where the document
-     * selection is placed.
-     *
-     * By default, it is set to `true`. If the document selection is placed in a
-     * {@link module:engine/model/model~Model#canEditAt non-editable} place (such as non-editable root), the command becomes disabled.
-     *
-     * The flag should be changed to `false` in a concrete command's constructor if the command should not change its `isEnabled`
-     * accordingly to the document selection.
-     */
-    protected _isEnabledBasedOnSelection: boolean;
-    /**
-     * A flag indicating whether a command execution changes the editor data or not.
-     *
-     * @see #affectsData
-     */
-    private _affectsData;
-    /**
-     * Holds identifiers for {@link #forceDisabled} mechanism.
-     */
-    private readonly _disableStack;
-    /**
-     * Creates a new `Command` instance.
-     *
-     * @param editor The editor on which this command will be used.
-     */
-    constructor(editor: Editor);
-    /**
-     * A flag indicating whether a command execution changes the editor data or not.
-     *
-     * Commands with `affectsData` set to `false` will not be automatically disabled in
-     * the {@link module:core/editor/editor~Editor#isReadOnly read-only mode} and
-     * {@glink features/read-only#related-features other editor modes} with restricted user write permissions.
-     *
-     * **Note:** You do not have to set it for your every command. It is `true` by default.
-     *
-     * @default true
-     */
-    get affectsData(): boolean;
-    protected set affectsData(affectsData: boolean);
-    /**
-     * Refreshes the command. The command should update its {@link #isEnabled} and {@link #value} properties
-     * in this method.
-     *
-     * This method is automatically called when
-     * {@link module:engine/model/document~Document#event:change any changes are applied to the document}.
-     */
-    refresh(): void;
-    /**
-     * Disables the command.
-     *
-     * Command may be disabled by multiple features or algorithms (at once). When disabling a command, unique id should be passed
-     * (e.g. the feature name). The same identifier should be used when {@link #clearForceDisabled enabling back} the command.
-     * The command becomes enabled only after all features {@link #clearForceDisabled enabled it back}.
-     *
-     * Disabling and enabling a command:
-     *
-     * ```ts
-     * command.isEnabled; // -> true
-     * command.forceDisabled( 'MyFeature' );
-     * command.isEnabled; // -> false
-     * command.clearForceDisabled( 'MyFeature' );
-     * command.isEnabled; // -> true
-     * ```
-     *
-     * Command disabled by multiple features:
-     *
-     * ```ts
-     * command.forceDisabled( 'MyFeature' );
-     * command.forceDisabled( 'OtherFeature' );
-     * command.clearForceDisabled( 'MyFeature' );
-     * command.isEnabled; // -> false
-     * command.clearForceDisabled( 'OtherFeature' );
-     * command.isEnabled; // -> true
-     * ```
-     *
-     * Multiple disabling with the same identifier is redundant:
-     *
-     * ```ts
-     * command.forceDisabled( 'MyFeature' );
-     * command.forceDisabled( 'MyFeature' );
-     * command.clearForceDisabled( 'MyFeature' );
-     * command.isEnabled; // -> true
-     * ```
-     *
-     * **Note:** some commands or algorithms may have more complex logic when it comes to enabling or disabling certain commands,
-     * so the command might be still disabled after {@link #clearForceDisabled} was used.
-     *
-     * @param id Unique identifier for disabling. Use the same id when {@link #clearForceDisabled enabling back} the command.
-     */
-    forceDisabled(id: string): void;
-    /**
-     * Clears forced disable previously set through {@link #forceDisabled}. See {@link #forceDisabled}.
-     *
-     * @param id Unique identifier, equal to the one passed in {@link #forceDisabled} call.
-     */
-    clearForceDisabled(id: string): void;
-    /**
-     * Executes the command.
-     *
-     * A command may accept parameters. They will be passed from {@link module:core/editor/editor~Editor#execute `editor.execute()`}
-     * to the command.
-     *
-     * The `execute()` method will automatically abort when the command is disabled ({@link #isEnabled} is `false`).
-     * This behavior is implemented by a high priority listener to the {@link #event:execute} event.
-     *
-     * In order to see how to disable a command from "outside" see the {@link #isEnabled} documentation.
-     *
-     * This method may return a value, which would be forwarded all the way down to the
-     * {@link module:core/editor/editor~Editor#execute `editor.execute()`}.
-     *
-     * @fires execute
-     */
-    execute(...args: Array<unknown>): unknown;
-    /**
-     * Destroys the command.
-     */
-    destroy(): void;
-}
-/**
- * Event fired by the {@link module:core/command~Command#execute} method. The command action is a listener to this event so it's
- * possible to change/cancel the behavior of the command by listening to this event.
- *
- * See {@link module:utils/observablemixin~Observable#decorate} for more information and samples.
- *
- * **Note:** This event is fired even if command is disabled. However, it is automatically blocked
- * by a high priority listener in order to prevent command execution.
- *
- * @eventName ~Command#execute
- */
-export type CommandExecuteEvent = DecoratedMethodEvent<Command, 'execute'>;
-export {};

package/dist/commandcollection.d.ts

@@ -1,87 +0,0 @@
-/**
- * @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-licensing-options
- */
-import type Command from './command.js';
-/**
- * Collection of commands. Its instance is available in {@link module:core/editor/editor~Editor#commands `editor.commands`}.
- */
-export default class CommandCollection implements Iterable<[string, Command]> {
-    /**
-     * Command map.
-     */
-    private _commands;
-    /**
-     * Creates collection instance.
-     */
-    constructor();
-    /**
-     * Registers a new command.
-     *
-     * @param commandName The name of the command.
-     */
-    add<TName extends string>(commandName: TName, command: CommandsMap[TName]): void;
-    /**
-     * Retrieves a command from the collection.
-     *
-     * @param commandName The name of the command.
-     */
-    get<TName extends string>(commandName: TName): CommandsMap[TName] | undefined;
-    /**
-     * Executes a command.
-     *
-     * @param commandName The name of the command.
-     * @param commandParams Command parameters.
-     * @returns The value returned by the {@link module:core/command~Command#execute `command.execute()`}.
-     */
-    execute<TName extends string>(commandName: TName, ...commandParams: Parameters<CommandsMap[TName]['execute']>): ReturnType<CommandsMap[TName]['execute']>;
-    /**
-     * Returns iterator of command names.
-     */
-    names(): IterableIterator<string>;
-    /**
-     * Returns iterator of command instances.
-     */
-    commands(): IterableIterator<Command>;
-    /**
-     * Iterable interface.
-     *
-     * Returns `[ commandName, commandInstance ]` pairs.
-     */
-    [Symbol.iterator](): Iterator<[string, Command]>;
-    /**
-     * Destroys all collection commands.
-     */
-    destroy(): void;
-}
-/**
- * Helper type that maps command names to their types.
- * It is meant to be extended with module augmentation.
- *
- * ```ts
- * class MyCommand extends Command {
- * 	public execute( parameter: A ): B {
- * 		// ...
- * 	}
- * }
- *
- * declare module '@ckeditor/ckeditor5-core' {
- * 	interface CommandsMap {
- * 		myCommand: MyCommand;
- * 	}
- * }
- *
- * // Returns `MyCommand | undefined`.
- * const myCommand = editor.commands.get( 'myCommand' );
- *
- * // Expects `A` type as parameter and returns `B`.
- * const value = editor.commands.execute( 'myCommand', new A() );
- * ```
- */
-export interface CommandsMap {
-    [name: string]: Command;
-}

package/dist/context.d.ts

@@ -1,241 +0,0 @@
-/**
- * @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-licensing-options
- */
-/**
- * @module core/context
- */
-import { Config, Collection, Locale, type LocaleTranslate } from '@ckeditor/ckeditor5-utils';
-import PluginCollection from './plugincollection.js';
-import type Editor from './editor/editor.js';
-import type { LoadedPlugins, PluginConstructor } from './plugin.js';
-import type { EditorConfig } from './editor/editorconfig.js';
-/**
- * Provides a common, higher-level environment for solutions that use multiple {@link module:core/editor/editor~Editor editors}
- * or plugins that work outside the editor. Use it instead of {@link module:core/editor/editor~Editor.create `Editor.create()`}
- * in advanced application integrations.
- *
- * All configuration options passed to a context will be used as default options for the editor instances initialized in that context.
- *
- * {@link module:core/contextplugin~ContextPlugin Context plugins} passed to a context instance will be shared among all
- * editor instances initialized in this context. These will be the same plugin instances for all the editors.
- *
- * **Note:** The context can only be initialized with {@link module:core/contextplugin~ContextPlugin context plugins}
- * (e.g. [comments](https://ckeditor.com/collaboration/comments/)). Regular {@link module:core/plugin~Plugin plugins} require an
- * editor instance to work and cannot be added to a context.
- *
- * **Note:** You can add a context plugin to an editor instance, though.
- *
- * If you are using multiple editor instances on one page and use any context plugins, create a context to share the configuration and
- * plugins among these editors. Some plugins will use the information about all existing editors to better integrate between them.
- *
- * If you are using plugins that do not require an editor to work (e.g. [comments](https://ckeditor.com/collaboration/comments/)),
- * enable and configure them using the context.
- *
- * If you are using only a single editor on each page, use {@link module:core/editor/editor~Editor.create `Editor.create()`} instead.
- * In such a case, a context instance will be created by the editor instance in a transparent way.
- *
- * See {@link ~Context.create `Context.create()`} for usage examples.
- */
-export default class Context {
-    /**
-     * Stores all the configurations specific to this context instance.
-     */
-    readonly config: Config<ContextConfig>;
-    /**
-     * The plugins loaded and in use by this context instance.
-     */
-    readonly plugins: PluginCollection<Context | Editor>;
-    readonly locale: Locale;
-    /**
-     * Shorthand for {@link module:utils/locale~Locale#t}.
-     */
-    readonly t: LocaleTranslate;
-    /**
-     * A list of editors that this context instance is injected to.
-     */
-    readonly editors: Collection<Editor>;
-    /**
-     * The default configuration which is built into the `Context` class.
-     *
-     * It is used in CKEditor 5 builds featuring `Context` to provide the default configuration options which are later used during the
-     * context initialization.
-     *
-     * ```ts
-     * Context.defaultConfig = {
-     * 	foo: 1,
-     * 	bar: 2
-     * };
-     *
-     * Context
-     * 	.create()
-     * 	.then( context => {
-     * 		context.config.get( 'foo' ); // -> 1
-     * 		context.config.get( 'bar' ); // -> 2
-     * 	} );
-     *
-     * // The default options can be overridden by the configuration passed to create().
-     * Context
-     * 	.create( { bar: 3 } )
-     * 	.then( context => {
-     * 		context.config.get( 'foo' ); // -> 1
-     * 		context.config.get( 'bar' ); // -> 3
-     * 	} );
-     * ```
-     *
-     * See also {@link module:core/context~Context.builtinPlugins `Context.builtinPlugins`}
-     * and {@link module:core/editor/editor~Editor.defaultConfig `Editor.defaultConfig`}.
-     */
-    static defaultConfig: ContextConfig;
-    /**
-     * An array of plugins built into the `Context` class.
-     *
-     * It is used in CKEditor 5 builds featuring `Context` to provide a list of context plugins which are later automatically initialized
-     * during the context initialization.
-     *
-     * They will be automatically initialized by `Context` unless `config.plugins` is passed.
-     *
-     * ```ts
-     * // Build some context plugins into the Context class first.
-     * Context.builtinPlugins = [ FooPlugin, BarPlugin ];
-     *
-     * // Normally, you need to define config.plugins, but since Context.builtinPlugins was
-     * // defined, now you can call create() without any configuration.
-     * Context
-     * 	.create()
-     * 	.then( context => {
-     * 		context.plugins.get( FooPlugin ); // -> An instance of the Foo plugin.
-     * 		context.plugins.get( BarPlugin ); // -> An instance of the Bar plugin.
-     * 	} );
-     * ```
-     *
-     * See also {@link module:core/context~Context.defaultConfig `Context.defaultConfig`}
-     * and {@link module:core/editor/editor~Editor.builtinPlugins `Editor.builtinPlugins`}.
-     */
-    static builtinPlugins: Array<PluginConstructor<Context | Editor>>;
-    /**
-     * Reference to the editor which created the context.
-     * Null when the context was created outside of the editor.
-     *
-     * It is used to destroy the context when removing the editor that has created the context.
-     */
-    private _contextOwner;
-    /**
-     * Creates a context instance with a given configuration.
-     *
-     * Usually not to be used directly. See the static {@link module:core/context~Context.create `create()`} method.
-     *
-     * @param config The context configuration.
-     */
-    constructor(config?: ContextConfig);
-    /**
-     * Loads and initializes plugins specified in the configuration.
-     *
-     * @returns A promise which resolves once the initialization is completed, providing an array of loaded plugins.
-     */
-    initPlugins(): Promise<LoadedPlugins>;
-    /**
-     * Destroys the context instance and all editors used with the context,
-     * releasing all resources used by the context.
-     *
-     * @returns A promise that resolves once the context instance is fully destroyed.
-     */
-    destroy(): Promise<unknown>;
-    /**
-     * Adds a reference to the editor which is used with this context.
-     *
-     * When the given editor has created the context, the reference to this editor will be stored
-     * as a {@link ~Context#_contextOwner}.
-     *
-     * This method should only be used by the editor.
-     *
-     * @internal
-     * @param isContextOwner Stores the given editor as a context owner.
-     */
-    _addEditor(editor: Editor, isContextOwner: boolean): void;
-    /**
-     * Removes a reference to the editor which was used with this context.
-     * When the context was created by the given editor, the context will be destroyed.
-     *
-     * This method should only be used by the editor.
-     *
-     * @internal
-     * @return A promise that resolves once the editor is removed from the context or when the context was destroyed.
-     */
-    _removeEditor(editor: Editor): Promise<unknown>;
-    /**
-     * Returns the context configuration which will be copied to the editors created using this context.
-     *
-     * The configuration returned by this method has the plugins configuration removed &ndash; plugins are shared with all editors
-     * through another mechanism.
-     *
-     * This method should only be used by the editor.
-     *
-     * @internal
-     * @returns Configuration as a plain object.
-     */
-    _getEditorConfig(): Partial<EditorConfig>;
-    /**
-     * Creates and initializes a new context instance.
-     *
-     * ```ts
-     * const commonConfig = { ... }; // Configuration for all the plugins and editors.
-     * const editorPlugins = [ ... ]; // Regular plugins here.
-     *
-     * Context
-     * 	.create( {
-     * 		// Only context plugins here.
-     * 		plugins: [ ... ],
-     *
-     * 		// Configure the language for all the editors (it cannot be overwritten).
-     * 		language: { ... },
-     *
-     * 		// Configuration for context plugins.
-     * 		comments: { ... },
-     * 		...
-     *
-     * 		// Default configuration for editor plugins.
-     * 		toolbar: { ... },
-     * 		image: { ... },
-     * 		...
-     * 	} )
-     * 	.then( context => {
-     * 		const promises = [];
-     *
-     * 		promises.push( ClassicEditor.create(
-     * 			document.getElementById( 'editor1' ),
-     * 			{
-     * 				editorPlugins,
-     * 				context
-     * 			}
-     * 		) );
-     *
-     * 		promises.push( ClassicEditor.create(
-     * 			document.getElementById( 'editor2' ),
-     * 			{
-     * 				editorPlugins,
-     * 				context,
-     * 				toolbar: { ... } // You can overwrite the configuration of the context.
-     * 			}
-     * 		) );
-     *
-     * 		return Promise.all( promises );
-     * 	} );
-     * ```
-     *
-     * @param config The context configuration.
-     * @returns A promise resolved once the context is ready. The promise resolves with the created context instance.
-     */
-    static create(config?: ContextConfig): Promise<Context>;
-}
-/**
- * The context configuration.
- */
-export type ContextConfig = {
-    plugins?: Array<PluginConstructor<Context | Editor>>;
-    substitutePlugins?: Array<PluginConstructor<Context | Editor>>;
-} & Omit<EditorConfig, 'plugins' | 'substitutePlugins' | 'removePlugins' | 'extraPlugins'>;

package/dist/contextplugin.d.ts

@@ -1,73 +0,0 @@
-/**
- * @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-licensing-options
- */
-/**
- * @module core/contextplugin
- */
-import { type Collection, type Config, type Locale, type LocaleTranslate } from '@ckeditor/ckeditor5-utils';
-import type Editor from './editor/editor.js';
-import type { EditorConfig } from './editor/editorconfig.js';
-import type Context from './context.js';
-import type { PluginDependencies, PluginInterface } from './plugin.js';
-import type PluginCollection from './plugincollection.js';
-declare const ContextPlugin_base: {
-    new (): import("@ckeditor/ckeditor5-utils").Observable;
-    prototype: import("@ckeditor/ckeditor5-utils").Observable;
-};
-/**
- * The base class for {@link module:core/context~Context} plugin classes.
- *
- * A context plugin can either be initialized for an {@link module:core/editor/editor~Editor editor} or for
- * a {@link module:core/context~Context context}. In other words, it can either
- * work within one editor instance or with one or more editor instances that use a single context.
- * It is the context plugin's role to implement handling for both modes.
- *
- * There are a few rules for interaction between the editor plugins and context plugins:
- *
- * * A context plugin can require another context plugin.
- * * An {@link module:core/plugin~Plugin editor plugin} can require a context plugin.
- * * A context plugin MUST NOT require an {@link module:core/plugin~Plugin editor plugin}.
- */
-export default class ContextPlugin extends /* #__PURE__ */ ContextPlugin_base implements PluginInterface {
-    /**
-     * The context or editor instance.
-     */
-    readonly context: ContextInterface;
-    /**
-     * Creates a new plugin instance.
-     */
-    constructor(context: Context | Editor);
-    /**
-     * @inheritDoc
-     */
-    destroy(): void;
-    /**
-     * @inheritDoc
-     */
-    static get isContextPlugin(): true;
-    /**
-     * @inheritDoc
-     */
-    static get isOfficialPlugin(): boolean;
-    /**
-     * @inheritDoc
-     */
-    static get isPremiumPlugin(): boolean;
-}
-/**
- * The common interface of {@link module:core/context~Context} and {@link module:core/editor/editor~Editor}.
- */
-export interface ContextInterface {
-    config: Config<Omit<EditorConfig, 'plugins' | 'substitutePlugins' | 'removePlugins' | 'extraPlugins'>>;
-    plugins: PluginCollection<Context | Editor>;
-    locale: Locale;
-    t: LocaleTranslate;
-    editors?: Collection<Editor>;
-}
-export type ContextPluginDependencies = PluginDependencies<Context | Editor>;
-export {};

package/dist/editingkeystrokehandler.d.ts

@@ -1,60 +0,0 @@
-/**
- * @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-licensing-options
- */
-/**
- * @module core/editingkeystrokehandler
- */
-import { KeystrokeHandler, type PriorityString } from '@ckeditor/ckeditor5-utils';
-import type Editor from './editor/editor.js';
-/**
- * A keystroke handler for editor editing. Its instance is available
- * in {@link module:core/editor/editor~Editor#keystrokes} so plugins
- * can register their keystrokes.
- *
- * E.g. an undo plugin would do this:
- *
- * ```ts
- * editor.keystrokes.set( 'Ctrl+Z', 'undo' );
- * editor.keystrokes.set( 'Ctrl+Shift+Z', 'redo' );
- * editor.keystrokes.set( 'Ctrl+Y', 'redo' );
- * ```
- */
-export default class EditingKeystrokeHandler extends KeystrokeHandler {
-    /**
-     * The editor instance.
-     */
-    readonly editor: Editor;
-    /**
-     * Creates an instance of the keystroke handler.
-     */
-    constructor(editor: Editor);
-    /**
-     * Registers a handler for the specified keystroke.
-     *
-     * The handler can be specified as a command name or a callback.
-     *
-     * @param keystroke Keystroke defined in a format accepted by
-     * the {@link module:utils/keyboard~parseKeystroke} function.
-     * @param callback If a string is passed, then the keystroke will
-     * {@link module:core/editor/editor~Editor#execute execute a command}.
-     * If a function, then it will be called with the
-     * {@link module:engine/view/observer/keyobserver~KeyEventData key event data} object and
-     * a `cancel()` helper to both `preventDefault()` and `stopPropagation()` of the 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: string | Array<string | number>, callback: EditingKeystrokeCallback, options?: {
-        readonly priority?: PriorityString;
-    }): void;
-}
-/**
- * Command name or a callback to be executed when a given keystroke is pressed.
- */
-export type EditingKeystrokeCallback = string | ((ev: KeyboardEvent, cancel: () => void) => void);