@ckeditor/ckeditor5-core 41.3.1 → 41.4.0

package/dist/types/plugin.d.ts

@@ -0,0 +1,278 @@
+/**
+ * @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 Editor from './editor/editor.js';
+declare const Plugin_base: {
+    new (): import("@ckeditor/ckeditor5-utils").Observable;
+    prototype: import("@ckeditor/ckeditor5-utils").Observable;
+};
+/**
+ * The base class for CKEditor plugin classes.
+ */
+export default class Plugin extends Plugin_base implements PluginInterface {
+    /**
+     * The editor instance.
+     *
+     * Note that most editors implement the {@link module:core/editor/editor~Editor#ui} property.
+     * However, editors with an external UI (i.e. Bootstrap-based) or a headless editor may not have this property or
+     * throw an error when accessing it.
+     *
+     * Because of above, to make plugins more universal, it is recommended to split features into:
+     *  - The "editing" part that uses the {@link module:core/editor/editor~Editor} class without `ui` property.
+     *  - The "UI" part that uses the {@link module:core/editor/editor~Editor} class and accesses `ui` property.
+     */
+    readonly editor: Editor;
+    /**
+     * Flag indicating whether a plugin is enabled or disabled.
+     * A disabled plugin will not transform text.
+     *
+     * Plugin can be simply disabled like that:
+     *
+     * ```ts
+     * // Disable the plugin so that no toolbars are visible.
+     * editor.plugins.get( 'TextTransformation' ).isEnabled = false;
+     * ```
+     *
+     * You can also use {@link #forceDisabled} method.
+     *
+     * @observable
+     * @readonly
+     */
+    isEnabled: boolean;
+    /**
+     * Holds identifiers for {@link #forceDisabled} mechanism.
+     */
+    private _disableStack;
+    /**
+     * @inheritDoc
+     */
+    constructor(editor: Editor);
+    /**
+     * Disables the plugin.
+     *
+     * Plugin may be disabled by multiple features or algorithms (at once). When disabling a plugin, unique id should be passed
+     * (e.g. feature name). The same identifier should be used when {@link #clearForceDisabled enabling back} the plugin.
+     * The plugin becomes enabled only after all features {@link #clearForceDisabled enabled it back}.
+     *
+     * Disabling and enabling a plugin:
+     *
+     * ```ts
+     * plugin.isEnabled; // -> true
+     * plugin.forceDisabled( 'MyFeature' );
+     * plugin.isEnabled; // -> false
+     * plugin.clearForceDisabled( 'MyFeature' );
+     * plugin.isEnabled; // -> true
+     * ```
+     *
+     * Plugin disabled by multiple features:
+     *
+     * ```ts
+     * plugin.forceDisabled( 'MyFeature' );
+     * plugin.forceDisabled( 'OtherFeature' );
+     * plugin.clearForceDisabled( 'MyFeature' );
+     * plugin.isEnabled; // -> false
+     * plugin.clearForceDisabled( 'OtherFeature' );
+     * plugin.isEnabled; // -> true
+     * ```
+     *
+     * Multiple disabling with the same identifier is redundant:
+     *
+     * ```ts
+     * plugin.forceDisabled( 'MyFeature' );
+     * plugin.forceDisabled( 'MyFeature' );
+     * plugin.clearForceDisabled( 'MyFeature' );
+     * plugin.isEnabled; // -> true
+     * ```
+     *
+     * **Note:** some plugins or algorithms may have more complex logic when it comes to enabling or disabling certain plugins,
+     * so the plugin 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 plugin.
+     */
+    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;
+    /**
+     * @inheritDoc
+     */
+    destroy(): void;
+    /**
+     * @inheritDoc
+     */
+    static get isContextPlugin(): false;
+}
+/**
+ * The base interface for CKEditor plugins.
+ *
+ * In its minimal form a plugin can be a simple function that accepts {@link module:core/editor/editor~Editor the editor}
+ * as a parameter:
+ *
+ * ```ts
+ * // A simple plugin that enables a data processor.
+ * function MyPlugin( editor ) {
+ * 	editor.data.processor = new MyDataProcessor();
+ * }
+ * ```
+ *
+ * In most cases however, you will want to inherit from the {@link ~Plugin} class which implements the
+ * {@link module:utils/observablemixin~Observable} and is, therefore, more convenient:
+ *
+ * ```ts
+ * class MyPlugin extends Plugin {
+ * 	init() {
+ * 		// `listenTo()` and `editor` are available thanks to `Plugin`.
+ * 		// By using `listenTo()` you will ensure that the listener is removed when
+ * 		// the plugin is destroyed.
+ * 		this.listenTo( this.editor.data, 'ready', () => {
+ * 			// Do something when the data is ready.
+ * 		} );
+ * 	}
+ * }
+ * ```
+ *
+ * The plugin class can have `pluginName` and `requires` static members. See {@link ~PluginStaticMembers} for more details.
+ *
+ * The plugin can also implement methods (e.g. {@link ~PluginInterface#init `init()`} or
+ * {@link ~PluginInterface#destroy `destroy()`}) which, when present, will be used to properly
+ * initialize and destroy the plugin.
+ *
+ * **Note:** When defined as a plain function, the plugin acts as a constructor and will be
+ * called in parallel with other plugins' {@link ~PluginConstructor constructors}.
+ * This means the code of that plugin will be executed **before** {@link ~PluginInterface#init `init()`} and
+ * {@link ~PluginInterface#afterInit `afterInit()`} methods of other plugins and, for instance,
+ * you cannot use it to extend other plugins' {@glink framework/architecture/editing-engine#schema schema}
+ * rules as they are defined later on during the `init()` stage.
+ */
+export interface PluginInterface {
+    /**
+     * The second stage (after plugin constructor) of the plugin initialization.
+     * Unlike the plugin constructor this method can be asynchronous.
+     *
+     * A plugin's `init()` method is called after its {@link ~PluginStaticMembers#requires dependencies} are initialized,
+     * so in the same order as the constructors of these plugins.
+     *
+     * **Note:** This method is optional. A plugin instance does not need to have it defined.
+     */
+    init?(): Promise<unknown> | null | undefined | void;
+    /**
+     * The third (and last) stage of the plugin initialization. See also {@link ~PluginConstructor} and {@link ~PluginInterface#init}.
+     *
+     * **Note:** This method is optional. A plugin instance does not need to have it defined.
+     */
+    afterInit?(): Promise<unknown> | null | undefined | void;
+    /**
+     * Destroys the plugin.
+     *
+     * **Note:** This method is optional. A plugin instance does not need to have it defined.
+     */
+    destroy?(): Promise<unknown> | null | undefined | void;
+}
+/**
+ * Creates a new plugin instance. This is the first step of the plugin initialization.
+ * See also {@link ~PluginInterface#init} and {@link ~PluginInterface#afterInit}.
+ *
+ * The plugin static properties should conform to {@link ~PluginStaticMembers `PluginStaticMembers` interface}.
+ *
+ * A plugin is always instantiated after its {@link ~PluginStaticMembers#requires dependencies} and the
+ * {@link ~PluginInterface#init} and {@link ~PluginInterface#afterInit} methods are called in the same order.
+ *
+ * Usually, you will want to put your plugin's initialization code in the {@link ~PluginInterface#init} method.
+ * The constructor can be understood as "before init" and used in special cases, just like
+ * {@link ~PluginInterface#afterInit} serves the special "after init" scenarios (e.g.the code which depends on other
+ * plugins, but which does not {@link ~PluginStaticMembers#requires explicitly require} them).
+ */
+export type PluginConstructor<TContext = Editor> = (PluginClassConstructor<TContext> | PluginFunctionConstructor<TContext>) & PluginStaticMembers<TContext>;
+/**
+ * In most cases, you will want to inherit from the {@link ~Plugin} class which implements the
+ * {@link module:utils/observablemixin~Observable} and is, therefore, more convenient:
+ *
+ * ```ts
+ * class MyPlugin extends Plugin {
+ * 	init() {
+ * 		// `listenTo()` and `editor` are available thanks to `Plugin`.
+ * 		// By using `listenTo()` you will ensure that the listener is removed when
+ * 		// the plugin is destroyed.
+ * 		this.listenTo( this.editor.data, 'ready', () => {
+ * 			// Do something when the data is ready.
+ * 		} );
+ * 	}
+ * }
+ * ```
+ */
+export type PluginClassConstructor<TContext = Editor> = new (editor: TContext) => PluginInterface;
+/**
+ * In its minimal form a plugin can be a simple function that accepts {@link module:core/editor/editor~Editor the editor}
+ * as a parameter:
+ *
+ * ```ts
+ * // A simple plugin that enables a data processor.
+ * function MyPlugin( editor ) {
+ * 	editor.data.processor = new MyDataProcessor();
+ * }
+ * ```
+ */
+export type PluginFunctionConstructor<TContext = Editor> = (editor: TContext) => void;
+/**
+ * Static properties of a plugin.
+ */
+export interface PluginStaticMembers<TContext = Editor> {
+    /**
+     * An array of plugins required by this plugin.
+     *
+     * To keep the plugin class definition tight it is recommended to define this property as a static getter:
+     *
+     * ```ts
+     * import Image from './image.js';
+     *
+     * export default class ImageCaption {
+     * 	static get requires() {
+     * 		return [ Image ];
+     * 	}
+     * }
+     * ```
+     */
+    readonly requires?: PluginDependencies<TContext>;
+    /**
+     * An optional name of the plugin. If set, the plugin will be available in
+     * {@link module:core/plugincollection~PluginCollection#get} by its
+     * name and its constructor. If not, then only by its constructor.
+     *
+     * The name should reflect the constructor name.
+     *
+     * To keep the plugin class definition tight, it is recommended to define this property as a static getter:
+     *
+     * ```ts
+     * export default class ImageCaption {
+     * 	static get pluginName() {
+     * 		return 'ImageCaption';
+     * 	}
+     * }
+     * ```
+     *
+     * Note: The native `Function.name` property could not be used to keep the plugin name because
+     * it will be mangled during code minification.
+     *
+     * Naming a plugin is necessary to enable removing it through the
+     * {@link module:core/editor/editorconfig~EditorConfig#removePlugins `config.removePlugins`} option.
+     */
+    readonly pluginName?: string;
+    /**
+     * A flag which defines if a plugin is allowed or not allowed to be used directly by a {@link module:core/context~Context}.
+     */
+    readonly isContextPlugin?: boolean;
+}
+export type PluginDependencies<TContext = Editor> = ReadonlyArray<PluginConstructor<TContext> | string>;
+/**
+ * An array of loaded plugins.
+ */
+export type LoadedPlugins = Array<PluginInterface>;
+export {};

package/dist/types/plugincollection.d.ts

@@ -0,0 +1,121 @@
+/**
+ * @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 { LoadedPlugins, PluginClassConstructor, PluginConstructor, PluginInterface } from './plugin.js';
+declare const PluginCollection_base: {
+    new (): import("@ckeditor/ckeditor5-utils").Emitter;
+    prototype: import("@ckeditor/ckeditor5-utils").Emitter;
+};
+/**
+ * Manages a list of CKEditor plugins, including loading, resolving dependencies and initialization.
+ */
+export default class PluginCollection<TContext extends object> extends PluginCollection_base implements Iterable<PluginEntry<TContext>> {
+    private _context;
+    private _plugins;
+    /**
+     * A map of plugin constructors that can be retrieved by their names.
+     */
+    private _availablePlugins;
+    /**
+     * Map of {@link module:core/contextplugin~ContextPlugin context plugins} which can be retrieved by their constructors or instances.
+     */
+    private _contextPlugins;
+    /**
+     * Creates an instance of the plugin collection class.
+     * Allows loading and initializing plugins and their dependencies.
+     * Allows providing a list of already loaded plugins. These plugins will not be destroyed along with this collection.
+     *
+     * @param availablePlugins Plugins (constructors) which the collection will be able to use
+     * when {@link module:core/plugincollection~PluginCollection#init} is used with the plugin names (strings, instead of constructors).
+     * Usually, the editor will pass its built-in plugins to the collection so they can later be
+     * used in `config.plugins` or `config.removePlugins` by names.
+     * @param contextPlugins A list of already initialized plugins represented by a `[ PluginConstructor, pluginInstance ]` pair.
+     */
+    constructor(context: TContext, availablePlugins?: Iterable<PluginConstructor<TContext>>, contextPlugins?: Iterable<PluginEntry<TContext>>);
+    /**
+     * Iterable interface.
+     *
+     * Returns `[ PluginConstructor, pluginInstance ]` pairs.
+     */
+    [Symbol.iterator](): IterableIterator<PluginEntry<TContext>>;
+    get<TConstructor extends PluginClassConstructor<TContext>>(key: TConstructor): InstanceType<TConstructor>;
+    get<TName extends string>(key: TName): PluginsMap[TName];
+    /**
+     * Checks if a plugin is loaded.
+     *
+     * ```ts
+     * // Check if the 'Clipboard' plugin was loaded.
+     * if ( editor.plugins.has( 'ClipboardPipeline' ) ) {
+     * 	// Now use the clipboard plugin instance:
+     * 	const clipboard = editor.plugins.get( 'ClipboardPipeline' );
+     *
+     * 	// ...
+     * }
+     * ```
+     *
+     * @param key The plugin constructor or {@link module:core/plugin~PluginStaticMembers#pluginName name}.
+     */
+    has(key: PluginConstructor<TContext> | string): boolean;
+    /**
+     * Initializes a set of plugins and adds them to the collection.
+     *
+     * @param plugins An array of {@link module:core/plugin~PluginInterface plugin constructors}
+     * or {@link module:core/plugin~PluginStaticMembers#pluginName plugin names}.
+     * @param pluginsToRemove Names of the plugins or plugin constructors
+     * that should not be loaded (despite being specified in the `plugins` array).
+     * @param pluginsSubstitutions An array of {@link module:core/plugin~PluginInterface plugin constructors}
+     * that will be used to replace plugins of the same names that were passed in `plugins` or that are in their dependency tree.
+     * A useful option for replacing built-in plugins while creating tests (for mocking their APIs). Plugins that will be replaced
+     * must follow these rules:
+     *   * The new plugin must be a class.
+     *   * The new plugin must be named.
+     *   * Both plugins must not depend on other plugins.
+     * @returns A promise which gets resolved once all plugins are loaded and available in the collection.
+     */
+    init(plugins: ReadonlyArray<PluginConstructor<TContext> | string>, pluginsToRemove?: ReadonlyArray<PluginConstructor<TContext> | string>, pluginsSubstitutions?: ReadonlyArray<PluginConstructor<TContext>>): Promise<LoadedPlugins>;
+    /**
+     * Destroys all loaded plugins.
+     */
+    destroy(): Promise<unknown>;
+    /**
+     * Adds the plugin to the collection. Exposed mainly for testing purposes.
+     *
+     * @param PluginConstructor The plugin constructor.
+     * @param plugin The instance of the plugin.
+     */
+    private _add;
+}
+/**
+ * A `[ PluginConstructor, pluginInstance ]` pair.
+ */
+export type PluginEntry<TContext> = [PluginConstructor<TContext>, PluginInterface];
+/**
+ * Helper type that maps plugin names to their types.
+ * It is meant to be extended with module augmentation.
+ *
+ * ```ts
+ * class MyPlugin extends Plugin {
+ * 	public static pluginName() {
+ * 		return 'MyPlugin' as const;
+ * 	}
+ * }
+ *
+ * declare module '@ckeditor/ckeditor5-core' {
+ * 	interface PluginsMap {
+ * 		[ MyPlugin.pluginName ]: MyPlugin;
+ * 	}
+ * }
+ *
+ * // Returns `MyPlugin`.
+ * const myPlugin = editor.plugins.get( 'MyPlugin' );
+ * ```
+ */
+export interface PluginsMap {
+    [name: string]: PluginInterface;
+}
+export {};

package/dist/types/typings.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @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 core/typings
+ */
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type NonEmptyArray<A> = Array<A> & {
+    0: A;
+};
+export type HexColor<S extends string = string> = `#${S}`;

package/lang/translations/ti.po

@@ -0,0 +1,126 @@
+# Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+#
+#                                     !!! IMPORTANT !!!
+#
+#         Before you edit this file, please keep in mind that contributing to the project
+#                translations is possible ONLY via the Transifex online service.
+#
+#         To submit your translations, visit https://www.transifex.com/ckeditor/ckeditor5.
+#
+#                   To learn more, check out the official contributor's guide:
+#     https://ckeditor.com/docs/ckeditor5/latest/framework/guides/contributing/contributing.html
+#
+msgid ""
+msgstr ""
+"Language-Team: Tigrinya (https://app.transifex.com/ckeditor/teams/11143/ti/)\n"
+"Language: ti\n"
+"Plural-Forms: nplurals=2; plural=(n > 1);\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+
+msgctxt "Label for the Cancel button."
+msgid "Cancel"
+msgstr "ንጸግ"
+
+msgctxt "Label for the Clear button."
+msgid "Clear"
+msgstr "ደምስስ"
+
+msgctxt "The label used by a button next to the color palette in the color picker that removes the color (resets it to an empty value, example usages in font color or table properties)."
+msgid "Remove color"
+msgstr "ሕብሪ ኣወግድ"
+
+msgctxt "The label used by a button next to the color palette in the color picker that restores the default value if the default table properties are specified."
+msgid "Restore default"
+msgstr ""
+
+msgctxt "Label for the Save button."
+msgid "Save"
+msgstr "ጠቁብ"
+
+msgctxt "Label of a toolbar button which reveals more toolbar items."
+msgid "Show more items"
+msgstr ""
+
+msgctxt "Label for an ‘X of Y’ status of a typical next/previous navigation. For instance, ‘Page 5 of 20’ or 'Search result 5 of 20'."
+msgid "%0 of %1"
+msgstr ""
+
+msgctxt "A generic error message displayed on upload failure. The file name is concatenated to this text."
+msgid "Cannot upload file:"
+msgstr "ፋይል ምድያብ ኣይተኸኣለን"
+
+msgctxt "Accessible label of the specific editing area of the editor acting as a root of the entire application."
+msgid "Rich Text Editor. Editing area: %0"
+msgstr ""
+
+msgctxt "The label for the insert image with the file manager toolbar button with visible label in insert image dropdown."
+msgid "Insert with file manager"
+msgstr ""
+
+msgctxt "The label for the replace image with the file manager toolbar button with visible label in insert image dropdown."
+msgid "Replace with file manager"
+msgstr "ፋይል ማናጀር ብምጥቃም ተክእ"
+
+msgctxt "The label for the insert image with the file manager toolbar button."
+msgid "Insert image with file manager"
+msgstr ""
+
+msgctxt "The label for the replace image with the file manager toolbar button."
+msgid "Replace image with file manager"
+msgstr ""
+
+msgctxt "The button label for the object (e.g. image, table) toolbar for hiding the attached caption."
+msgid "Toggle caption off"
+msgstr ""
+
+msgctxt "The button label for the object (e.g. image, table) toolbar for showing the attached caption."
+msgid "Toggle caption on"
+msgstr ""
+
+msgctxt "Accessibility help dialog category header text for keystrokes related to content creation."
+msgid "Content editing keystrokes"
+msgstr ""
+
+msgctxt "Accessibility help dialog text further explaining the purpose of the \"Content editing keystrokes\" category."
+msgid "These keyboard shortcuts allow for quick access to content editing features."
+msgstr ""
+
+msgctxt "Accessibility help dialog category header text for keystrokes related to navigation in the user interface."
+msgid "User interface and content navigation keystrokes"
+msgstr ""
+
+msgctxt "Accessibility help dialog text further explaining the purpose of the \"User interface and content navigation keystrokes\" category."
+msgid "Use the following keystrokes for more efficient navigation in the CKEditor 5 user interface."
+msgstr ""
+
+msgctxt "Keystroke description for assistive technologies: keystroke for closing contextual balloons, dropdowns, and dialogs."
+msgid "Close contextual balloons, dropdowns, and dialogs"
+msgstr ""
+
+msgctxt "Keystroke description for assistive technologies: keystroke for opening the accessibility help dialog."
+msgid "Open the accessibility help dialog"
+msgstr ""
+
+msgctxt "Keystroke description for assistive technologies: keystroke for moving between fields."
+msgid "Move focus between form fields (inputs, buttons, etc.)"
+msgstr ""
+
+msgctxt "Keystroke description for assistive technologies: keystroke for moving focus to the menu bar."
+msgid "Move focus to the menu bar, navigate between menu bars"
+msgstr ""
+
+msgctxt "Keystroke description for assistive technologies: keystroke for moving focus to the toolbar."
+msgid "Move focus to the toolbar, navigate between toolbars"
+msgstr ""
+
+msgctxt "Keystroke description for assistive technologies: keystroke for navigating through the toolbar."
+msgid "Navigate through the toolbar or menu bar"
+msgstr ""
+
+msgctxt "Keystroke description for assistive technologies: keystroke for executing currently focused button."
+msgid "Execute the currently focused button. Executing buttons that interact with the editor content moves the focus back to the content."
+msgstr ""
+
+msgctxt "Label of the button confirming the changes done in the current interface."
+msgid "Accept"
+msgstr ""

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ckeditor/ckeditor5-core",
-  "version": "41.3.1",
+  "version": "41.4.0",
   "description": "The core architecture of CKEditor 5 – the best browser-based rich text editor.",
   "keywords": [
     "wysiwyg",
@@ -24,8 +24,8 @@
   "type": "module",
   "main": "src/index.js",
   "dependencies": {
-    "@ckeditor/ckeditor5-engine": "41.3.1",
-    "@ckeditor/ckeditor5-utils": "41.3.1",
+    "@ckeditor/ckeditor5-engine": "41.4.0",
+    "@ckeditor/ckeditor5-utils": "41.4.0",
     "lodash-es": "4.17.21"
   },
   "author": "CKSource (http://cksource.com/)",
@@ -38,6 +38,7 @@
     "directory": "packages/ckeditor5-core"
   },
   "files": [
+    "dist",
     "lang",
     "src/**/*.js",
     "src/**/*.d.ts",

package/src/index.d.ts

@@ -13,7 +13,7 @@ export type { PluginsMap, default as PluginCollection } from './plugincollection
 export { default as Context, type ContextConfig } from './context.js';
 export { default as ContextPlugin, type ContextPluginDependencies } from './contextplugin.js';
 export { type EditingKeystrokeCallback } from './editingkeystrokehandler.js';
-export type { PartialBy, NonEmptyArray } from './typings.js';
+export type { PartialBy, NonEmptyArray, HexColor } from './typings.js';
 export { default as Editor, type EditorReadyEvent, type EditorDestroyEvent } from './editor/editor.js';
 export type { EditorConfig, LanguageConfig, ToolbarConfig, ToolbarConfigItem, UiConfig } from './editor/editorconfig.js';
 export { default as attachToForm } from './editor/utils/attachtoform.js';
@@ -58,6 +58,7 @@ export declare const icons: {
     objectInline: string;
     objectBlockLeft: string;
     objectBlockRight: string;
+    objectSizeCustom: string;
     objectSizeFull: string;
     objectSizeLarge: string;
     objectSizeSmall: string;

package/src/index.js

@@ -47,6 +47,7 @@ import objectInline from './../theme/icons/object-inline.svg';
 import objectLeft from './../theme/icons/object-inline-left.svg';
 import objectRight from './../theme/icons/object-inline-right.svg';
 import objectSizeFull from './../theme/icons/object-size-full.svg';
+import objectSizeCustom from './../theme/icons/object-size-custom.svg';
 import objectSizeLarge from './../theme/icons/object-size-large.svg';
 import objectSizeSmall from './../theme/icons/object-size-small.svg';
 import objectSizeMedium from './../theme/icons/object-size-medium.svg';
@@ -114,6 +115,7 @@ export const icons = {
     objectInline,
     objectBlockLeft,
     objectBlockRight,
+    objectSizeCustom,
     objectSizeFull,
     objectSizeLarge,
     objectSizeSmall,

package/src/typings.d.ts

@@ -9,3 +9,4 @@ export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export type NonEmptyArray<A> = Array<A> & {
     0: A;
 };
+export type HexColor<S extends string = string> = `#${S}`;

package/theme/icons/object-size-custom.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:v="https://vecta.io/nano" viewBox="0 0 20 20"><path d="M.95 1.43a.95.95 0 0 0-.95.95v3.1a.95.95 0 0 0 .95.95h.75v6.3H.95a.95.95 0 0 0-.95.95v3.1a.95.95 0 0 0 .95.95h3.1a.95.95 0 0 0 .95-.95v-.65h1.932l1.539-1.5H5v-.95a.95.95 0 0 0-.95-.95H3.2v-6.3h.85A.95.95 0 0 0 5 5.48v-.55h10v.55a.95.95 0 0 0 .95.95h3.1a.95.95 0 0 0 .95-.95v-3.1a.95.95 0 0 0-.95-.95h-3.1a.95.95 0 0 0-.95.95v1.05H5V2.38a.95.95 0 0 0-.95-.95H.95zm.55 3.5v-2h2v2h-2zm0 9.3v2h2v-2h-2zm15-11.3v2h2v-2h-2z"/><path d="M8.139 20.004v-2.388l7.045-7.048 2.391 2.391-7.046 7.046h-2.39zm11.421-9.101a.64.64 0 0 1-.138.206l-1.165 1.168-2.391-2.391 1.167-1.163a.63.63 0 0 1 .206-.138.635.635 0 0 1 .243-.049.63.63 0 0 1 .449.187l1.491 1.488c.059.059.108.129.138.206s.049.16.049.243a.6.6 0 0 1-.049.243z"/></svg>