@ckeditor/ckeditor5-image 0.0.0-internal-20241017.0

package/src/imageupload/utils.js

@@ -0,0 +1,112 @@
+/**
+ * @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 { global } from 'ckeditor5/src/utils.js';
+/**
+ * Creates a regular expression used to test for image files.
+ *
+ * ```ts
+ * const imageType = createImageTypeRegExp( [ 'png', 'jpeg', 'svg+xml', 'vnd.microsoft.icon' ] );
+ *
+ * console.log( 'is supported image', imageType.test( file.type ) );
+ * ```
+ */
+export function createImageTypeRegExp(types) {
+    // Sanitize the MIME type name which may include: "+", "-" or ".".
+    const regExpSafeNames = types.map(type => type.replace('+', '\\+'));
+    return new RegExp(`^image\\/(${regExpSafeNames.join('|')})$`);
+}
+/**
+ * Creates a promise that fetches the image local source (Base64 or blob) and resolves with a `File` object.
+ *
+ * @param image Image whose source to fetch.
+ * @returns A promise which resolves when an image source is fetched and converted to a `File` instance.
+ * It resolves with a `File` object. If there were any errors during file processing, the promise will be rejected.
+ */
+export function fetchLocalImage(image) {
+    return new Promise((resolve, reject) => {
+        const imageSrc = image.getAttribute('src');
+        // Fetch works asynchronously and so does not block browser UI when processing data.
+        fetch(imageSrc)
+            .then(resource => resource.blob())
+            .then(blob => {
+            const mimeType = getImageMimeType(blob, imageSrc);
+            const ext = mimeType.replace('image/', '');
+            const filename = `image.${ext}`;
+            const file = new File([blob], filename, { type: mimeType });
+            resolve(file);
+        })
+            .catch(err => {
+            // Fetch fails only, if it can't make a request due to a network failure or if anything prevented the request
+            // from completing, i.e. the Content Security Policy rules. It is not possible to detect the exact cause of failure,
+            // so we are just trying the fallback solution, if general TypeError is thrown.
+            return err && err.name === 'TypeError' ?
+                convertLocalImageOnCanvas(imageSrc).then(resolve).catch(reject) :
+                reject(err);
+        });
+    });
+}
+/**
+ * Checks whether a given node is an image element with a local source (Base64 or blob).
+ *
+ * @param node The node to check.
+ */
+export function isLocalImage(imageUtils, node) {
+    if (!imageUtils.isInlineImageView(node) || !node.getAttribute('src')) {
+        return false;
+    }
+    return !!node.getAttribute('src').match(/^data:image\/\w+;base64,/g) ||
+        !!node.getAttribute('src').match(/^blob:/g);
+}
+/**
+ * Extracts an image type based on its blob representation or its source.
+ * @param blob Image blob representation.
+ * @param src Image `src` attribute value.
+ */
+function getImageMimeType(blob, src) {
+    if (blob.type) {
+        return blob.type;
+    }
+    else if (src.match(/data:(image\/\w+);base64/)) {
+        return src.match(/data:(image\/\w+);base64/)[1].toLowerCase();
+    }
+    else {
+        // Fallback to 'jpeg' as common extension.
+        return 'image/jpeg';
+    }
+}
+/**
+ * Creates a promise that converts the image local source (Base64 or blob) to a blob using canvas and resolves
+ * with a `File` object.
+ * @param imageSrc Image `src` attribute value.
+ * @returns A promise which resolves when an image source is converted to a `File` instance.
+ * It resolves with a `File` object. If there were any errors during file processing, the promise will be rejected.
+ */
+function convertLocalImageOnCanvas(imageSrc) {
+    return getBlobFromCanvas(imageSrc).then(blob => {
+        const mimeType = getImageMimeType(blob, imageSrc);
+        const ext = mimeType.replace('image/', '');
+        const filename = `image.${ext}`;
+        return new File([blob], filename, { type: mimeType });
+    });
+}
+/**
+ * Creates a promise that resolves with a `Blob` object converted from the image source (Base64 or blob).
+ * @param imageSrc Image `src` attribute value.
+ */
+function getBlobFromCanvas(imageSrc) {
+    return new Promise((resolve, reject) => {
+        const image = global.document.createElement('img');
+        image.addEventListener('load', () => {
+            const canvas = global.document.createElement('canvas');
+            canvas.width = image.width;
+            canvas.height = image.height;
+            const ctx = canvas.getContext('2d');
+            ctx.drawImage(image, 0, 0);
+            canvas.toBlob(blob => blob ? resolve(blob) : reject());
+        });
+        image.addEventListener('error', () => reject());
+        image.src = imageSrc;
+    });
+}

package/src/imageupload.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @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 image/imageupload
+ */
+import { Plugin } from 'ckeditor5/src/core.js';
+import ImageUploadUI from './imageupload/imageuploadui.js';
+import ImageUploadProgress from './imageupload/imageuploadprogress.js';
+import ImageUploadEditing from './imageupload/imageuploadediting.js';
+/**
+ * The image upload plugin.
+ *
+ * For a detailed overview, check the {@glink features/images/image-upload/image-upload image upload feature} documentation.
+ *
+ * This plugin does not do anything directly, but it loads a set of specific plugins to enable image uploading:
+ *
+ * * {@link module:image/imageupload/imageuploadediting~ImageUploadEditing},
+ * * {@link module:image/imageupload/imageuploadui~ImageUploadUI},
+ * * {@link module:image/imageupload/imageuploadprogress~ImageUploadProgress}.
+ */
+export default class ImageUpload extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get pluginName(): "ImageUpload";
+    /**
+     * @inheritDoc
+     */
+    static get isOfficialPlugin(): true;
+    /**
+     * @inheritDoc
+     */
+    static get requires(): readonly [typeof ImageUploadEditing, typeof ImageUploadUI, typeof ImageUploadProgress];
+}

package/src/imageupload.js

@@ -0,0 +1,42 @@
+/**
+ * @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 image/imageupload
+ */
+import { Plugin } from 'ckeditor5/src/core.js';
+import ImageUploadUI from './imageupload/imageuploadui.js';
+import ImageUploadProgress from './imageupload/imageuploadprogress.js';
+import ImageUploadEditing from './imageupload/imageuploadediting.js';
+/**
+ * The image upload plugin.
+ *
+ * For a detailed overview, check the {@glink features/images/image-upload/image-upload image upload feature} documentation.
+ *
+ * This plugin does not do anything directly, but it loads a set of specific plugins to enable image uploading:
+ *
+ * * {@link module:image/imageupload/imageuploadediting~ImageUploadEditing},
+ * * {@link module:image/imageupload/imageuploadui~ImageUploadUI},
+ * * {@link module:image/imageupload/imageuploadprogress~ImageUploadProgress}.
+ */
+export default class ImageUpload extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get pluginName() {
+        return 'ImageUpload';
+    }
+    /**
+     * @inheritDoc
+     */
+    static get isOfficialPlugin() {
+        return true;
+    }
+    /**
+     * @inheritDoc
+     */
+    static get requires() {
+        return [ImageUploadEditing, ImageUploadUI, ImageUploadProgress];
+    }
+}

package/src/imageutils.d.ts

@@ -0,0 +1,129 @@
+/**
+ * @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 image/imageutils
+ */
+import type { Element, ViewElement, DocumentSelection, ViewDocumentSelection, Selection, ViewSelection, DowncastWriter, Position, ViewContainerElement } from 'ckeditor5/src/engine.js';
+import { Plugin } from 'ckeditor5/src/core.js';
+/**
+ * A set of helpers related to images.
+ */
+export default class ImageUtils extends Plugin {
+    /**
+     * DOM Emitter.
+     */
+    private _domEmitter;
+    /**
+     * @inheritDoc
+     */
+    static get pluginName(): "ImageUtils";
+    /**
+     * @inheritDoc
+     */
+    static get isOfficialPlugin(): true;
+    /**
+     * Checks if the provided model element is an `image` or `imageInline`.
+     */
+    isImage(modelElement?: Element | null): modelElement is Element & {
+        name: 'imageInline' | 'imageBlock';
+    };
+    /**
+     * Checks if the provided view element represents an inline image.
+     *
+     * Also, see {@link module:image/imageutils~ImageUtils#isImageWidget}.
+     */
+    isInlineImageView(element?: ViewElement | null): boolean;
+    /**
+     * Checks if the provided view element represents a block image.
+     *
+     * Also, see {@link module:image/imageutils~ImageUtils#isImageWidget}.
+     */
+    isBlockImageView(element?: ViewElement | null): boolean;
+    /**
+     * Handles inserting single file. This method unifies image insertion using {@link module:widget/utils~findOptimalInsertionRange}
+     * method.
+     *
+     * ```ts
+     * const imageUtils = editor.plugins.get( 'ImageUtils' );
+     *
+     * imageUtils.insertImage( { src: 'path/to/image.jpg' } );
+     * ```
+     *
+     * @param attributes Attributes of the inserted image.
+     * This method filters out the attributes which are disallowed by the {@link module:engine/model/schema~Schema}.
+     * @param selectable Place to insert the image. If not specified,
+     * the {@link module:widget/utils~findOptimalInsertionRange} logic will be applied for the block images
+     * and `model.document.selection` for the inline images.
+     *
+     * **Note**: If `selectable` is passed, this helper will not be able to set selection attributes (such as `linkHref`)
+     * and apply them to the new image. In this case, make sure all selection attributes are passed in `attributes`.
+     *
+     * @param imageType Image type of inserted image. If not specified,
+     * it will be determined automatically depending of editor config or place of the insertion.
+     * @param options.setImageSizes Specifies whether the image `width` and `height` attributes should be set automatically.
+     * The default is `true`.
+     * @return The inserted model image element.
+     */
+    insertImage(attributes?: Record<string, unknown>, selectable?: Selection | Position | null, imageType?: ('imageBlock' | 'imageInline' | null), options?: {
+        setImageSizes?: boolean;
+    }): Element | null;
+    /**
+     * Reads original image sizes and sets them as `width` and `height`.
+     *
+     * The `src` attribute may not be available if the user is using an upload adapter. In such a case,
+     * this method is called again after the upload process is complete and the `src` attribute is available.
+     */
+    setImageNaturalSizeAttributes(imageElement: Element): void;
+    /**
+     * Returns an image widget editing view element if one is selected or is among the selection's ancestors.
+     */
+    getClosestSelectedImageWidget(selection: ViewSelection | ViewDocumentSelection): ViewElement | null;
+    /**
+     * Returns a image model element if one is selected or is among the selection's ancestors.
+     */
+    getClosestSelectedImageElement(selection: Selection | DocumentSelection): Element | null;
+    /**
+     * Returns an image widget editing view based on the passed image view.
+     */
+    getImageWidgetFromImageView(imageView: ViewElement): ViewContainerElement | null;
+    /**
+     * Checks if image can be inserted at current model selection.
+     *
+     * @internal
+     */
+    isImageAllowed(): boolean;
+    /**
+     * Converts a given {@link module:engine/view/element~Element} to an image widget:
+     * * Adds a {@link module:engine/view/element~Element#_setCustomProperty custom property} allowing to recognize the image widget
+     * element.
+     * * Calls the {@link module:widget/utils~toWidget} function with the proper element's label creator.
+     *
+     * @param writer An instance of the view writer.
+     * @param label The element's label. It will be concatenated with the image `alt` attribute if one is present.
+     */
+    toImageWidget(viewElement: ViewElement, writer: DowncastWriter, label: string): ViewElement;
+    /**
+     * Checks if a given view element is an image widget.
+     */
+    protected isImageWidget(viewElement: ViewElement): boolean;
+    /**
+     * Checks if the provided model element is an `image`.
+     */
+    isBlockImage(modelElement?: Element | null): boolean;
+    /**
+     * Checks if the provided model element is an `imageInline`.
+     */
+    isInlineImage(modelElement?: Element | null): boolean;
+    /**
+     * Get the view `<img>` from another view element, e.g. a widget (`<figure class="image">`), a link (`<a>`).
+     *
+     * The `<img>` can be located deep in other elements, so this helper performs a deep tree search.
+     */
+    findViewImgElement(figureView: ViewElement): ViewElement | undefined;
+    /**
+     * @inheritDoc
+     */
+    destroy(): void;
+}

package/src/imageutils.js

@@ -0,0 +1,312 @@
+/**
+ * @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 { Plugin } from 'ckeditor5/src/core.js';
+import { findOptimalInsertionRange, isWidget, toWidget } from 'ckeditor5/src/widget.js';
+import { determineImageTypeForInsertionAtSelection } from './image/utils.js';
+import { DomEmitterMixin, global } from 'ckeditor5/src/utils.js';
+const IMAGE_WIDGETS_CLASSES_MATCH_REGEXP = /^(image|image-inline)$/;
+/**
+ * A set of helpers related to images.
+ */
+export default class ImageUtils extends Plugin {
+    constructor() {
+        super(...arguments);
+        /**
+         * DOM Emitter.
+         */
+        this._domEmitter = new (DomEmitterMixin())();
+    }
+    /**
+     * @inheritDoc
+     */
+    static get pluginName() {
+        return 'ImageUtils';
+    }
+    /**
+     * @inheritDoc
+     */
+    static get isOfficialPlugin() {
+        return true;
+    }
+    /**
+     * Checks if the provided model element is an `image` or `imageInline`.
+     */
+    isImage(modelElement) {
+        return this.isInlineImage(modelElement) || this.isBlockImage(modelElement);
+    }
+    /**
+     * Checks if the provided view element represents an inline image.
+     *
+     * Also, see {@link module:image/imageutils~ImageUtils#isImageWidget}.
+     */
+    isInlineImageView(element) {
+        return !!element && element.is('element', 'img');
+    }
+    /**
+     * Checks if the provided view element represents a block image.
+     *
+     * Also, see {@link module:image/imageutils~ImageUtils#isImageWidget}.
+     */
+    isBlockImageView(element) {
+        return !!element && element.is('element', 'figure') && element.hasClass('image');
+    }
+    /**
+     * Handles inserting single file. This method unifies image insertion using {@link module:widget/utils~findOptimalInsertionRange}
+     * method.
+     *
+     * ```ts
+     * const imageUtils = editor.plugins.get( 'ImageUtils' );
+     *
+     * imageUtils.insertImage( { src: 'path/to/image.jpg' } );
+     * ```
+     *
+     * @param attributes Attributes of the inserted image.
+     * This method filters out the attributes which are disallowed by the {@link module:engine/model/schema~Schema}.
+     * @param selectable Place to insert the image. If not specified,
+     * the {@link module:widget/utils~findOptimalInsertionRange} logic will be applied for the block images
+     * and `model.document.selection` for the inline images.
+     *
+     * **Note**: If `selectable` is passed, this helper will not be able to set selection attributes (such as `linkHref`)
+     * and apply them to the new image. In this case, make sure all selection attributes are passed in `attributes`.
+     *
+     * @param imageType Image type of inserted image. If not specified,
+     * it will be determined automatically depending of editor config or place of the insertion.
+     * @param options.setImageSizes Specifies whether the image `width` and `height` attributes should be set automatically.
+     * The default is `true`.
+     * @return The inserted model image element.
+     */
+    insertImage(attributes = {}, selectable = null, imageType = null, options = {}) {
+        const editor = this.editor;
+        const model = editor.model;
+        const selection = model.document.selection;
+        const determinedImageType = determineImageTypeForInsertion(editor, selectable || selection, imageType);
+        // Mix declarative attributes with selection attributes because the new image should "inherit"
+        // the latter for best UX. For instance, inline images inserted into existing links
+        // should not split them. To do that, they need to have "linkHref" inherited from the selection.
+        attributes = {
+            ...Object.fromEntries(selection.getAttributes()),
+            ...attributes
+        };
+        for (const attributeName in attributes) {
+            if (!model.schema.checkAttribute(determinedImageType, attributeName)) {
+                delete attributes[attributeName];
+            }
+        }
+        return model.change(writer => {
+            const { setImageSizes = true } = options;
+            const imageElement = writer.createElement(determinedImageType, attributes);
+            model.insertObject(imageElement, selectable, null, {
+                setSelection: 'on',
+                // If we want to insert a block image (for whatever reason) then we don't want to split text blocks.
+                // This applies only when we don't have the selectable specified (i.e., we insert multiple block images at once).
+                findOptimalPosition: !selectable && determinedImageType != 'imageInline' ? 'auto' : undefined
+            });
+            // Inserting an image might've failed due to schema regulations.
+            if (imageElement.parent) {
+                if (setImageSizes) {
+                    this.setImageNaturalSizeAttributes(imageElement);
+                }
+                return imageElement;
+            }
+            return null;
+        });
+    }
+    /**
+     * Reads original image sizes and sets them as `width` and `height`.
+     *
+     * The `src` attribute may not be available if the user is using an upload adapter. In such a case,
+     * this method is called again after the upload process is complete and the `src` attribute is available.
+     */
+    setImageNaturalSizeAttributes(imageElement) {
+        const src = imageElement.getAttribute('src');
+        if (!src) {
+            return;
+        }
+        if (imageElement.getAttribute('width') || imageElement.getAttribute('height')) {
+            return;
+        }
+        this.editor.model.change(writer => {
+            const img = new global.window.Image();
+            this._domEmitter.listenTo(img, 'load', () => {
+                if (!imageElement.getAttribute('width') && !imageElement.getAttribute('height')) {
+                    // We use writer.batch to be able to undo (in a single step) width and height setting
+                    // along with any change that triggered this action (e.g. image resize or image style change).
+                    this.editor.model.enqueueChange(writer.batch, writer => {
+                        writer.setAttribute('width', img.naturalWidth, imageElement);
+                        writer.setAttribute('height', img.naturalHeight, imageElement);
+                    });
+                }
+                this._domEmitter.stopListening(img, 'load');
+            });
+            img.src = src;
+        });
+    }
+    /**
+     * Returns an image widget editing view element if one is selected or is among the selection's ancestors.
+     */
+    getClosestSelectedImageWidget(selection) {
+        const selectionPosition = selection.getFirstPosition();
+        if (!selectionPosition) {
+            return null;
+        }
+        const viewElement = selection.getSelectedElement();
+        if (viewElement && this.isImageWidget(viewElement)) {
+            return viewElement;
+        }
+        let parent = selectionPosition.parent;
+        while (parent) {
+            if (parent.is('element') && this.isImageWidget(parent)) {
+                return parent;
+            }
+            parent = parent.parent;
+        }
+        return null;
+    }
+    /**
+     * Returns a image model element if one is selected or is among the selection's ancestors.
+     */
+    getClosestSelectedImageElement(selection) {
+        const selectedElement = selection.getSelectedElement();
+        return this.isImage(selectedElement) ? selectedElement : selection.getFirstPosition().findAncestor('imageBlock');
+    }
+    /**
+     * Returns an image widget editing view based on the passed image view.
+     */
+    getImageWidgetFromImageView(imageView) {
+        return imageView.findAncestor({ classes: IMAGE_WIDGETS_CLASSES_MATCH_REGEXP });
+    }
+    /**
+     * Checks if image can be inserted at current model selection.
+     *
+     * @internal
+     */
+    isImageAllowed() {
+        const model = this.editor.model;
+        const selection = model.document.selection;
+        return isImageAllowedInParent(this.editor, selection) && isNotInsideImage(selection);
+    }
+    /**
+     * Converts a given {@link module:engine/view/element~Element} to an image widget:
+     * * Adds a {@link module:engine/view/element~Element#_setCustomProperty custom property} allowing to recognize the image widget
+     * element.
+     * * Calls the {@link module:widget/utils~toWidget} function with the proper element's label creator.
+     *
+     * @param writer An instance of the view writer.
+     * @param label The element's label. It will be concatenated with the image `alt` attribute if one is present.
+     */
+    toImageWidget(viewElement, writer, label) {
+        writer.setCustomProperty('image', true, viewElement);
+        const labelCreator = () => {
+            const imgElement = this.findViewImgElement(viewElement);
+            const altText = imgElement.getAttribute('alt');
+            return altText ? `${altText} ${label}` : label;
+        };
+        return toWidget(viewElement, writer, { label: labelCreator });
+    }
+    /**
+     * Checks if a given view element is an image widget.
+     */
+    isImageWidget(viewElement) {
+        return !!viewElement.getCustomProperty('image') && isWidget(viewElement);
+    }
+    /**
+     * Checks if the provided model element is an `image`.
+     */
+    isBlockImage(modelElement) {
+        return !!modelElement && modelElement.is('element', 'imageBlock');
+    }
+    /**
+     * Checks if the provided model element is an `imageInline`.
+     */
+    isInlineImage(modelElement) {
+        return !!modelElement && modelElement.is('element', 'imageInline');
+    }
+    /**
+     * Get the view `<img>` from another view element, e.g. a widget (`<figure class="image">`), a link (`<a>`).
+     *
+     * The `<img>` can be located deep in other elements, so this helper performs a deep tree search.
+     */
+    findViewImgElement(figureView) {
+        if (this.isInlineImageView(figureView)) {
+            return figureView;
+        }
+        const editingView = this.editor.editing.view;
+        for (const { item } of editingView.createRangeIn(figureView)) {
+            if (this.isInlineImageView(item)) {
+                return item;
+            }
+        }
+    }
+    /**
+     * @inheritDoc
+     */
+    destroy() {
+        this._domEmitter.stopListening();
+        return super.destroy();
+    }
+}
+/**
+ * Checks if image is allowed by schema in optimal insertion parent.
+ */
+function isImageAllowedInParent(editor, selection) {
+    const imageType = determineImageTypeForInsertion(editor, selection, null);
+    if (imageType == 'imageBlock') {
+        const parent = getInsertImageParent(selection, editor.model);
+        if (editor.model.schema.checkChild(parent, 'imageBlock')) {
+            return true;
+        }
+    }
+    else if (editor.model.schema.checkChild(selection.focus, 'imageInline')) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Checks if selection is not placed inside an image (e.g. its caption).
+ */
+function isNotInsideImage(selection) {
+    return [...selection.focus.getAncestors()].every(ancestor => !ancestor.is('element', 'imageBlock'));
+}
+/**
+ * Returns a node that will be used to insert image with `model.insertContent`.
+ */
+function getInsertImageParent(selection, model) {
+    const insertionRange = findOptimalInsertionRange(selection, model);
+    const parent = insertionRange.start.parent;
+    if (parent.isEmpty && !parent.is('element', '$root')) {
+        return parent.parent;
+    }
+    return parent;
+}
+/**
+ * Determine image element type name depending on editor config or place of insertion.
+ *
+ * @param imageType Image element type name. Used to force return of provided element name,
+ * but only if there is proper plugin enabled.
+ */
+function determineImageTypeForInsertion(editor, selectable, imageType) {
+    const schema = editor.model.schema;
+    const configImageInsertType = editor.config.get('image.insert.type');
+    if (!editor.plugins.has('ImageBlockEditing')) {
+        return 'imageInline';
+    }
+    if (!editor.plugins.has('ImageInlineEditing')) {
+        return 'imageBlock';
+    }
+    if (imageType) {
+        return imageType;
+    }
+    if (configImageInsertType === 'inline') {
+        return 'imageInline';
+    }
+    if (configImageInsertType !== 'auto') {
+        return 'imageBlock';
+    }
+    // Try to replace the selected widget (e.g. another image).
+    if (selectable.is('selection')) {
+        return determineImageTypeForInsertionAtSelection(schema, selectable);
+    }
+    return schema.checkChild(selectable, 'imageInline') ? 'imageInline' : 'imageBlock';
+}

package/src/index.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @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 image
+ */
+export { default as AutoImage } from './autoimage.js';
+export { default as Image } from './image.js';
+export { default as ImageEditing } from './image/imageediting.js';
+export { default as ImageCaptionUtils } from './imagecaption/imagecaptionutils.js';
+export { default as ImageCaption } from './imagecaption.js';
+export { default as ImageCaptionEditing } from './imagecaption/imagecaptionediting.js';
+export { default as ImageInsert } from './imageinsert.js';
+export { default as ImageInsertUI } from './imageinsert/imageinsertui.js';
+export { default as ImageResize } from './imageresize.js';
+export { default as ImageResizeButtons } from './imageresize/imageresizebuttons.js';
+export { default as ImageResizeEditing } from './imageresize/imageresizeediting.js';
+export { default as ImageResizeHandles } from './imageresize/imageresizehandles.js';
+export { default as ImageCustomResizeUI } from './imageresize/imagecustomresizeui.js';
+export { default as ImageSizeAttributes } from './imagesizeattributes.js';
+export { default as ImageStyle } from './imagestyle.js';
+export { default as ImageStyleEditing } from './imagestyle/imagestyleediting.js';
+export { default as ImageStyleUI } from './imagestyle/imagestyleui.js';
+export { default as ImageTextAlternative } from './imagetextalternative.js';
+export { default as ImageTextAlternativeEditing } from './imagetextalternative/imagetextalternativeediting.js';
+export { default as ImageTextAlternativeUI } from './imagetextalternative/imagetextalternativeui.js';
+export { default as ImageToolbar } from './imagetoolbar.js';
+export { default as ImageUpload } from './imageupload.js';
+export { default as ImageUploadEditing, type ImageUploadCompleteEvent } from './imageupload/imageuploadediting.js';
+export { default as ImageUploadProgress } from './imageupload/imageuploadprogress.js';
+export { default as ImageUploadUI } from './imageupload/imageuploadui.js';
+export { default as PictureEditing } from './pictureediting.js';
+export { default as ImageBlock } from './imageblock.js';
+export { default as ImageInline } from './imageinline.js';
+export { default as ImageInsertViaUrl } from './imageinsertviaurl.js';
+export { default as ImageUtils } from './imageutils.js';
+export { default as ImageBlockEditing } from './image/imageblockediting.js';
+export { default as ImageCaptionUI } from './imagecaption/imagecaptionui.js';
+export { createImageTypeRegExp } from './imageupload/utils.js';
+export type { ImageConfig } from './imageconfig.js';
+export type { default as ImageTypeCommand } from './image/imagetypecommand.js';
+export type { default as InsertImageCommand } from './image/insertimagecommand.js';
+export type { default as ReplaceImageSourceCommand } from './image/replaceimagesourcecommand.js';
+export type { default as ToggleImageCaptionCommand } from './imagecaption/toggleimagecaptioncommand.js';
+export type { default as ResizeImageCommand } from './imageresize/resizeimagecommand.js';
+export type { default as ImageStyleCommand } from './imagestyle/imagestylecommand.js';
+export type { default as ImageTextAlternativeCommand } from './imagetextalternative/imagetextalternativecommand.js';
+export type { default as UploadImageCommand } from './imageupload/uploadimagecommand.js';
+import './augmentation.js';