;
+ /**
+ * The view that is filtered by the search query.
+ */
+ filteredView: FilteredView;
+ /**
+ * The view that displays the information about the search results.
+ */
+ infoView?: {
+ /**
+ * The view that displays the information about the search results. If not specified,
+ * {@link module:ui/search/searchinfoview~SearchInfoView} is used.
+ */
+ instance?: FocusableView;
+ /**
+ * The configuration of text labels displayed in the {@link #infoView} in different states
+ * of the search component.
+ *
+ * **Note**: This configuration is only used when the {@link #infoView} is **not** specified.
+ * In other cases, please use the {@link module:ui/search/searchview~SearchTextViewSearchEvent} to bring about
+ * your own info text logic.
+ */
+ text?: {
+ notFound?: {
+ primary: SearchTextViewDefaultInfoText;
+ secondary?: SearchTextViewDefaultInfoText;
+ };
+ noSearchableItems?: {
+ primary: SearchTextViewDefaultInfoText;
+ secondary?: SearchTextViewDefaultInfoText;
+ };
+ };
+ };
+ /**
+ * The custom CSS class name to be added to the search view element.
+ */
+ class?: string;
+}
+/**
+ * Describes value of a info text configuration in {@link module:ui/search/text/searchtextview~SearchTextViewConfig}.
+ * A string or a function that returns a string with the information about the search results.
+ */
+export type SearchTextViewDefaultInfoText = string | ((query: string, resultsCount: number, totalItemsCount: number) => string);
+/**
+ * An event fired when the search query changes fired by {@link module:ui/search/text/searchtextview~SearchTextView#search}.
+ *
+ * @eventName ~SearchTextView#search
+ */
+export type SearchTextViewSearchEvent = {
+ name: 'search';
+ args: [SearchTextViewSearchEventData];
+};
+export type SearchTextViewSearchEventData = {
+ /**
+ * The search query string.
+ */
+ query: string;
+ /**
+ * The number of results found for the current search query.
+ */
+ resultsCount: number;
+ /**
+ * The number of the items that can be searched.
+ */
+ totalItemsCount: number;
+};
diff --git a/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/spinner/spinnerview.d.ts b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/spinner/spinnerview.d.ts
new file mode 100644
index 00000000..46ef0f3b
--- /dev/null
+++ b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/spinner/spinnerview.d.ts
@@ -0,0 +1,25 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module ui/spinner/spinnerview
+ */
+import View from '@ckeditor/ckeditor5-ui/src/view.js';
+import '@ckeditor/ckeditor5-ui/theme/components/spinner/spinner.css';
+/**
+ * The spinner view class.
+ */
+export default class SpinnerView extends View {
+ /**
+ * Controls whether the spinner is visible.
+ *
+ * @observable
+ * @default false
+ */
+ isVisible: boolean;
+ /**
+ * @inheritDoc
+ */
+ constructor();
+}
diff --git a/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/template.d.ts b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/template.d.ts
new file mode 100644
index 00000000..d13d9aa5
--- /dev/null
+++ b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/template.d.ts
@@ -0,0 +1,942 @@
+/**
+ * @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 ui/template
+ */
+import View from '@ckeditor/ckeditor5-ui/src/view.js';
+import ViewCollection from '@ckeditor/ckeditor5-ui/src/viewcollection.js';
+import { type ArrayOrItem, type Emitter, type Observable } from '@ckeditor/ckeditor5-utils';
+declare const Template_base: {
+ new (): Emitter;
+ prototype: Emitter;
+};
+/**
+ * A basic Template class. It renders a DOM HTML element or text from a
+ * {@link module:ui/template~TemplateDefinition definition} and supports element attributes, children,
+ * bindings to {@link module:utils/observablemixin~Observable observables} and DOM event propagation.
+ *
+ * A simple template can look like this:
+ *
+ * ```ts
+ * const bind = Template.bind( observable, emitter );
+ *
+ * new Template( {
+ * tag: 'p',
+ * attributes: {
+ * class: 'foo',
+ * style: {
+ * backgroundColor: 'yellow'
+ * }
+ * },
+ * on: {
+ * click: bind.to( 'clicked' )
+ * },
+ * children: [
+ * 'A paragraph.'
+ * ]
+ * } ).render();
+ * ```
+ *
+ * and it will render the following HTML element:
+ *
+ * ```html
+ * A paragraph.
+ * ```
+ *
+ * Additionally, the `observable` will always fire `clicked` upon clicking `` in the DOM.
+ *
+ * See {@link module:ui/template~TemplateDefinition} to know more about templates and complex
+ * template definitions.
+ */
+export default class Template extends Template_base {
+ ns?: string;
+ /**
+ * The tag (`tagName`) of this template, e.g. `div`. It also indicates that the template
+ * renders to an HTML element.
+ */
+ tag?: string;
+ /**
+ * The text of the template. It also indicates that the template renders to a DOM text node.
+ */
+ text?: Array;
+ /**
+ * The attributes of the template, e.g. `{ id: [ 'ck-id' ] }`, corresponding with
+ * the attributes of an HTML element.
+ *
+ * **Note**: This property only makes sense when {@link #tag} is defined.
+ */
+ attributes?: Record;
+ /**
+ * The children of the template. They can be either:
+ * * independent instances of {@link ~Template} (sub–templates),
+ * * native DOM Nodes.
+ *
+ * **Note**: This property only makes sense when {@link #tag} is defined.
+ */
+ children?: Array;
+ /**
+ * The DOM event listeners of the template.
+ */
+ eventListeners?: Record>;
+ /**
+ * Indicates whether this particular Template instance has been
+ * {@link #render rendered}.
+ */
+ private _isRendered;
+ /**
+ * The data used by the {@link #revert} method to restore a node to its original state.
+ *
+ * See: {@link #apply}.
+ */
+ private _revertData;
+ /**
+ * Creates an instance of the {@link ~Template} class.
+ *
+ * @param def The definition of the template.
+ */
+ constructor(def: TemplateDefinition);
+ /**
+ * Renders a DOM Node (an HTML element or text) out of the template.
+ *
+ * ```ts
+ * const domNode = new Template( { ... } ).render();
+ * ```
+ *
+ * See: {@link #apply}.
+ */
+ render(): HTMLElement | Text;
+ /**
+ * Applies the template to an existing DOM Node, either HTML element or text.
+ *
+ * **Note:** No new DOM nodes will be created. Applying extends:
+ *
+ * {@link module:ui/template~TemplateDefinition attributes},
+ * {@link module:ui/template~TemplateDefinition event listeners}, and
+ * `textContent` of {@link module:ui/template~TemplateDefinition children} only.
+ *
+ * **Note:** Existing `class` and `style` attributes are extended when a template
+ * is applied to an HTML element, while other attributes and `textContent` are overridden.
+ *
+ * **Note:** The process of applying a template can be easily reverted using the
+ * {@link module:ui/template~Template#revert} method.
+ *
+ * ```ts
+ * const element = document.createElement( 'div' );
+ * const observable = new Model( { divClass: 'my-div' } );
+ * const emitter = Object.create( EmitterMixin );
+ * const bind = Template.bind( observable, emitter );
+ *
+ * new Template( {
+ * attributes: {
+ * id: 'first-div',
+ * class: bind.to( 'divClass' )
+ * },
+ * on: {
+ * click: bind( 'elementClicked' ) // Will be fired by the observable.
+ * },
+ * children: [
+ * 'Div text.'
+ * ]
+ * } ).apply( element );
+ *
+ * console.log( element.outerHTML ); // -> ''
+ * ```
+ *
+ * @see module:ui/template~Template#render
+ * @see module:ui/template~Template#revert
+ * @param node Root node for the template to apply.
+ */
+ apply(node: HTMLElement | Text): HTMLElement | Text;
+ /**
+ * Reverts a template {@link module:ui/template~Template#apply applied} to a DOM node.
+ *
+ * @param node The root node for the template to revert. In most of the cases, it is the
+ * same node used by {@link module:ui/template~Template#apply}.
+ */
+ revert(node: HTMLElement | Text): void;
+ /**
+ * Returns an iterator which traverses the template in search of {@link module:ui/view~View}
+ * instances and returns them one by one.
+ *
+ * ```ts
+ * const viewFoo = new View();
+ * const viewBar = new View();
+ * const viewBaz = new View();
+ * const template = new Template( {
+ * tag: 'div',
+ * children: [
+ * viewFoo,
+ * {
+ * tag: 'div',
+ * children: [
+ * viewBar
+ * ]
+ * },
+ * viewBaz
+ * ]
+ * } );
+ *
+ * // Logs: viewFoo, viewBar, viewBaz
+ * for ( const view of template.getViews() ) {
+ * console.log( view );
+ * }
+ * ```
+ */
+ getViews(): IterableIterator;
+ /**
+ * An entry point to the interface which binds DOM nodes to
+ * {@link module:utils/observablemixin~Observable observables}.
+ * There are two types of bindings:
+ *
+ * * HTML element attributes or text `textContent` synchronized with attributes of an
+ * {@link module:utils/observablemixin~Observable}. Learn more about {@link module:ui/template~BindChain#to}
+ * and {@link module:ui/template~BindChain#if}.
+ *
+ * ```ts
+ * const bind = Template.bind( observable, emitter );
+ *
+ * new Template( {
+ * attributes: {
+ * // Binds the element "class" attribute to observable#classAttribute.
+ * class: bind.to( 'classAttribute' )
+ * }
+ * } ).render();
+ * ```
+ *
+ * * DOM events fired on HTML element propagated through
+ * {@link module:utils/observablemixin~Observable}. Learn more about {@link module:ui/template~BindChain#to}.
+ *
+ * ```ts
+ * const bind = Template.bind( observable, emitter );
+ *
+ * new Template( {
+ * on: {
+ * // Will be fired by the observable.
+ * click: bind( 'elementClicked' )
+ * }
+ * } ).render();
+ * ```
+ *
+ * Also see {@link module:ui/view~View#bindTemplate}.
+ *
+ * @param observable An observable which provides boundable attributes.
+ * @param emitter An emitter that listens to observable attribute
+ * changes or DOM Events (depending on the kind of the binding). Usually, a {@link module:ui/view~View} instance.
+ */
+ static bind(observable: TObservable, emitter: Emitter): BindChain;
+ /**
+ * Extends an existing {@link module:ui/template~Template} instance with some additional content
+ * from another {@link module:ui/template~TemplateDefinition}.
+ *
+ * ```ts
+ * const bind = Template.bind( observable, emitter );
+ *
+ * const template = new Template( {
+ * tag: 'p',
+ * attributes: {
+ * class: 'a',
+ * data-x: bind.to( 'foo' )
+ * },
+ * children: [
+ * {
+ * tag: 'span',
+ * attributes: {
+ * class: 'b'
+ * },
+ * children: [
+ * 'Span'
+ * ]
+ * }
+ * ]
+ * } );
+ *
+ * // Instance-level extension.
+ * Template.extend( template, {
+ * attributes: {
+ * class: 'b',
+ * data-x: bind.to( 'bar' )
+ * },
+ * children: [
+ * {
+ * attributes: {
+ * class: 'c'
+ * }
+ * }
+ * ]
+ * } );
+ *
+ * // Child extension.
+ * Template.extend( template.children[ 0 ], {
+ * attributes: {
+ * class: 'd'
+ * }
+ * } );
+ * ```
+ *
+ * the `outerHTML` of `template.render()` is:
+ *
+ * ```html
+ *
+ * Span
+ *
+ * ```
+ *
+ * @param template An existing template instance to be extended.
+ * @param def Additional definition to be applied to a template.
+ */
+ static extend(template: Template, def: Partial): void;
+ /**
+ * Renders a DOM Node (either an HTML element or text) out of the template.
+ *
+ * @param data Rendering data.
+ */
+ private _renderNode;
+ /**
+ * Renders an HTML element out of the template.
+ *
+ * @param data Rendering data.
+ */
+ private _renderElement;
+ /**
+ * Renders a text node out of {@link module:ui/template~Template#text}.
+ *
+ * @param data Rendering data.
+ */
+ private _renderText;
+ /**
+ * Renders HTML element attributes out of {@link module:ui/template~Template#attributes}.
+ *
+ * @param data Rendering data.
+ */
+ private _renderAttributes;
+ /**
+ * Renders the `style` attribute of an HTML element based on
+ * {@link module:ui/template~Template#attributes}.
+ *
+ * A style attribute is an object with static values:
+ *
+ * ```ts
+ * attributes: {
+ * style: {
+ * color: 'red'
+ * }
+ * }
+ * ```
+ *
+ * or values bound to {@link module:ui/model~Model} properties:
+ *
+ * ```ts
+ * attributes: {
+ * style: {
+ * color: bind.to( ... )
+ * }
+ * }
+ * ```
+ *
+ * Note: The `style` attribute is rendered without setting the namespace. It does not seem to be
+ * needed.
+ *
+ * @param styles Styles located in `attributes.style` of {@link module:ui/template~TemplateDefinition}.
+ * @param data Rendering data.
+ */
+ private _renderStyleAttribute;
+ /**
+ * Recursively renders HTML element's children from {@link module:ui/template~Template#children}.
+ *
+ * @param data Rendering data.
+ */
+ private _renderElementChildren;
+ /**
+ * Activates `on` event listeners from the {@link module:ui/template~TemplateDefinition}
+ * on an HTML element.
+ *
+ * @param data Rendering data.
+ */
+ private _setUpListeners;
+ /**
+ * For a given {@link module:ui/template~TemplateValueSchema} containing {@link module:ui/template~TemplateBinding}
+ * activates the binding and sets its initial value.
+ *
+ * Note: {@link module:ui/template~TemplateValueSchema} can be for HTML element attributes or
+ * text node `textContent`.
+ *
+ * @param options Binding options.
+ * @param options.updater A function which updates the DOM (like attribute or text).
+ * @param options.data Rendering data.
+ */
+ private _bindToObservable;
+ /**
+ * Reverts {@link module:ui/template~RenderData#revertData template data} from a node to
+ * return it to the original state.
+ *
+ * @param node A node to be reverted.
+ * @param revertData An object that stores information about what changes have been made by
+ * {@link #apply} to the node. See {@link module:ui/template~RenderData#revertData} for more information.
+ */
+ private _revertTemplateFromNode;
+}
+type AttributeValues = Array | [
+ NamespacedValue>
+];
+/**
+ * Describes a binding created by the {@link module:ui/template~Template.bind} interface.
+ *
+ * @internal
+ */
+export declare abstract class TemplateBinding {
+ /**
+ * The name of the {@link module:ui/template~TemplateBinding#observable observed attribute}.
+ */
+ readonly attribute: string;
+ /**
+ * An observable instance of the binding. It either:
+ *
+ * * provides the attribute with the value,
+ * * or passes the event when a corresponding DOM event is fired.
+ */
+ readonly observable: Observable;
+ /**
+ * An {@link module:utils/emittermixin~Emitter} used by the binding to:
+ *
+ * * listen to the attribute change in the {@link module:ui/template~TemplateBinding#observable},
+ * * or listen to the event in the DOM.
+ */
+ readonly emitter: Emitter;
+ /**
+ * A custom function to process the value of the {@link module:ui/template~TemplateBinding#attribute}.
+ */
+ readonly callback?: (value: any, node: Node) => TemplateSimpleValue;
+ /**
+ * Creates an instance of the {@link module:ui/template~TemplateBinding} class.
+ *
+ * @param def The definition of the binding.
+ */
+ constructor(def: {
+ attribute: string;
+ observable: Observable;
+ emitter: Emitter;
+ callback?: (value: any, node: Node) => TemplateSimpleValue;
+ });
+ /**
+ * Returns the value of the binding. It is the value of the {@link module:ui/template~TemplateBinding#attribute} in
+ * {@link module:ui/template~TemplateBinding#observable}. The value may be processed by the
+ * {@link module:ui/template~TemplateBinding#callback}, if such has been passed to the binding.
+ *
+ * @param node A native DOM node, passed to the custom {@link module:ui/template~TemplateBinding#callback}.
+ * @returns The value of {@link module:ui/template~TemplateBinding#attribute} in
+ * {@link module:ui/template~TemplateBinding#observable}.
+ */
+ getValue(node: Node): TemplateSimpleValue;
+ /**
+ * Activates the listener which waits for changes of the {@link module:ui/template~TemplateBinding#attribute} in
+ * {@link module:ui/template~TemplateBinding#observable}, then updates the DOM with the aggregated
+ * value of {@link module:ui/template~TemplateValueSchema}.
+ *
+ * @param schema A full schema to generate an attribute or text in the DOM.
+ * @param updater A DOM updater function used to update the native DOM attribute or text.
+ * @param data Rendering data.
+ * @returns A function to sever the listener binding.
+ */
+ activateAttributeListener(schema: Array, updater: Updater, data: RenderData): () => void;
+}
+/**
+ * Describes either:
+ *
+ * * a binding to an {@link module:utils/observablemixin~Observable},
+ * * or a native DOM event binding.
+ *
+ * It is created by the {@link module:ui/template~BindChain#to} method.
+ *
+ * @internal
+ */
+export declare class TemplateToBinding extends TemplateBinding {
+ readonly eventNameOrFunction: string | ((domEvent: Event) => void);
+ constructor(def: ConstructorParameters[0] & {
+ eventNameOrFunction: string | ((domEvent: Event) => void);
+ });
+ /**
+ * Activates the listener for the native DOM event, which when fired, is propagated by
+ * the {@link module:ui/template~TemplateBinding#emitter}.
+ *
+ * @param domEvtName The name of the native DOM event.
+ * @param domSelector The selector in the DOM to filter delegated events.
+ * @param data Rendering data.
+ * @returns A function to sever the listener binding.
+ */
+ activateDomEventListener(domEvtName: string, domSelector: string, data: {
+ node: any;
+ }): () => void;
+}
+/**
+ * Describes a binding to {@link module:utils/observablemixin~Observable} created by the {@link module:ui/template~BindChain#if}
+ * method.
+ *
+ * @internal
+ */
+export declare class TemplateIfBinding extends TemplateBinding {
+ /**
+ * The value of the DOM attribute or text to be set if the {@link module:ui/template~TemplateBinding#attribute} in
+ * {@link module:ui/template~TemplateBinding#observable} is `true`.
+ */
+ readonly valueIfTrue?: string;
+ constructor(def: ConstructorParameters[0] & {
+ valueIfTrue?: string;
+ });
+ /**
+ * @inheritDoc
+ */
+ getValue(node: Node): TemplateSimpleValue;
+}
+interface Updater {
+ set(value: any): void;
+ remove(): void;
+}
+/**
+ * A definition of the {@link module:ui/template~Template}. It describes what kind of
+ * node a template will render (HTML element or text), attributes of an element, DOM event
+ * listeners and children.
+ *
+ * Also see:
+ * * {@link module:ui/template~TemplateValueSchema} to learn about HTML element attributes,
+ * * {@link module:ui/template~TemplateListenerSchema} to learn about DOM event listeners.
+ *
+ * A sample definition on an HTML element can look like this:
+ *
+ * ```ts
+ * new Template( {
+ * tag: 'p',
+ * children: [
+ * {
+ * tag: 'span',
+ * attributes: { ... },
+ * children: [ ... ],
+ * },
+ * {
+ * text: 'static–text'
+ * },
+ * 'also-static–text',
+ * ],
+ * attributes: {
+ * class: {@link module:ui/template~TemplateValueSchema},
+ * id: {@link module:ui/template~TemplateValueSchema},
+ * style: {@link module:ui/template~TemplateValueSchema}
+ *
+ * // ...
+ * },
+ * on: {
+ * 'click': {@link module:ui/template~TemplateListenerSchema}
+ *
+ * // Document.querySelector format is also accepted.
+ * 'keyup@a.some-class': {@link module:ui/template~TemplateListenerSchema}
+ *
+ * // ...
+ * }
+ * } );
+ * ```
+ *
+ * A {@link module:ui/view~View}, another {@link module:ui/template~Template} or a native DOM node
+ * can also become a child of a template. When a view is passed, its {@link module:ui/view~View#element} is used:
+ *
+ * ```ts
+ * const view = new SomeView();
+ * const childTemplate = new Template( { ... } );
+ * const childNode = document.createElement( 'b' );
+ *
+ * new Template( {
+ * tag: 'p',
+ *
+ * children: [
+ * // view#element will be added as a child of this .
+ * view,
+ *
+ * // The output of childTemplate.render() will be added here.
+ * childTemplate,
+ *
+ * // Native DOM nodes are included directly in the rendered output.
+ * childNode
+ * ]
+ * } );
+ * ```
+ *
+ * An entire {@link module:ui/viewcollection~ViewCollection} can be used as a child in the definition:
+ *
+ * ```ts
+ * const collection = new ViewCollection();
+ * collection.add( someView );
+ *
+ * new Template( {
+ * tag: 'p',
+ *
+ * children: collection
+ * } );
+ * ```
+ */
+export type TemplateDefinition = string | Template | TemplateElementDefinition | TemplateTextDefinition;
+export type TemplateElementDefinition = {
+ /**
+ * See the template {@link module:ui/template~Template#tag} property.
+ */
+ tag: string;
+ /**
+ * See the template {@link module:ui/template~Template#attributes} property.
+ */
+ attributes?: Record;
+ /**
+ * See the template {@link module:ui/template~Template#children} property.
+ */
+ children?: Iterable;
+ /**
+ * See the template {@link module:ui/template~Template#eventListeners} property.
+ */
+ on?: Record;
+};
+export type TemplateTextDefinition = {
+ /**
+ * See the template {@link module:ui/template~Template#text} property.
+ */
+ text: ArrayOrItem;
+};
+export type FalsyValue = false | null | undefined | '';
+export type NamespacedValue = {
+ ns: string;
+ value: T;
+};
+export type TemplateSimpleValue = string | boolean | number | null | undefined;
+export type TemplateSimpleValueSchema = TemplateSimpleValue | AttributeBinding;
+/**
+ * Describes a value of an HTML element attribute or `textContent`. It allows combining multiple
+ * data sources like static values and {@link module:utils/observablemixin~Observable} attributes.
+ *
+ * Also see:
+ * * {@link module:ui/template~TemplateDefinition} to learn where to use it,
+ * * {@link module:ui/template~Template.bind} to learn how to configure
+ * {@link module:utils/observablemixin~Observable} attribute bindings,
+ * * {@link module:ui/template~Template#render} to learn how to render a template,
+ * * {@link module:ui/template~BindChain#to `to()`} and {@link module:ui/template~BindChain#if `if()`}
+ * methods to learn more about bindings.
+ *
+ * Attribute values can be described in many different ways:
+ *
+ * ```ts
+ * // Bind helper will create bindings to attributes of the observable.
+ * const bind = Template.bind( observable, emitter );
+ *
+ * new Template( {
+ * tag: 'p',
+ * attributes: {
+ * // A plain string schema.
+ * 'class': 'static-text',
+ *
+ * // An object schema, binds to the "foo" attribute of the
+ * // observable and follows its value.
+ * 'class': bind.to( 'foo' ),
+ *
+ * // An array schema, combines the above.
+ * 'class': [
+ * 'static-text',
+ * bind.to( 'bar', () => { ... } ),
+ *
+ * // Bindings can also be conditional.
+ * bind.if( 'baz', 'class-when-baz-is-true' )
+ * ],
+ *
+ * // An array schema, with a custom namespace, e.g. useful for creating SVGs.
+ * 'class': {
+ * ns: 'http://ns.url',
+ * value: [
+ * bind.if( 'baz', 'value-when-true' ),
+ * 'static-text'
+ * ]
+ * },
+ *
+ * // An object schema, specific for styles.
+ * style: {
+ * color: 'red',
+ * backgroundColor: bind.to( 'qux', () => { ... } )
+ * }
+ * }
+ * } );
+ * ```
+ *
+ * Text nodes can also have complex values:
+ *
+ * ```ts
+ * const bind = Template.bind( observable, emitter );
+ *
+ * // Will render a "foo" text node.
+ * new Template( {
+ * text: 'foo'
+ * } );
+ *
+ * // Will render a "static text: {observable.foo}" text node.
+ * // The text of the node will be updated as the "foo" attribute changes.
+ * new Template( {
+ * text: [
+ * 'static text: ',
+ * bind.to( 'foo', () => { ... } )
+ * ]
+ * } );
+ * ```
+ */
+export type TemplateValueSchema = ArrayOrItem> | Record;
+/**
+ * Describes an event listener attached to an HTML element. Such listener can propagate DOM events
+ * through an {@link module:utils/observablemixin~Observable} instance, execute custom callbacks
+ * or both, if necessary.
+ *
+ * Also see:
+ * * {@link module:ui/template~TemplateDefinition} to learn more about template definitions,
+ * * {@link module:ui/template~BindChain#to `to()`} method to learn more about bindings.
+ *
+ * Check out different ways of attaching event listeners below:
+ *
+ * ```ts
+ * // Bind helper will propagate events through the observable.
+ * const bind = Template.bind( observable, emitter );
+ *
+ * new Template( {
+ * tag: 'p',
+ * on: {
+ * // An object schema. The observable will fire the "clicked" event upon DOM "click".
+ * click: bind.to( 'clicked' )
+ *
+ * // An object schema. It will work for "click" event on "a.foo" children only.
+ * 'click@a.foo': bind.to( 'clicked' )
+ *
+ * // An array schema, makes the observable propagate multiple events.
+ * click: [
+ * bind.to( 'clicked' ),
+ * bind.to( 'executed' )
+ * ],
+ *
+ * // An array schema with a custom callback.
+ * 'click@a.foo': {
+ * bind.to( 'clicked' ),
+ * bind.to( evt => {
+ * console.log( `${ evt.target } has been clicked!` );
+ * } }
+ * }
+ * }
+ * } );
+ * ```
+ */
+export type TemplateListenerSchema = ArrayOrItem;
+declare const AttributeBindingSymbol: unique symbol;
+declare const ListenerBindingSymbol: unique symbol;
+export interface AttributeBinding {
+ _opaqueAttributeBinding: typeof AttributeBindingSymbol;
+}
+export interface ListenerBinding {
+ _opaqueListenerBinding: typeof ListenerBindingSymbol;
+}
+/**
+ * The return value of {@link ~Template.bind `Template.bind()`}. It provides `to()` and `if()`
+ * methods to create the {@link module:utils/observablemixin~Observable observable} attribute and event bindings.
+ */
+export interface BindChain {
+ /**
+ * Binds an {@link module:utils/observablemixin~Observable observable} to either:
+ *
+ * * an HTML element attribute or a text node `textContent`, so it remains in sync with the observable
+ * attribute as it changes,
+ * * or an HTML element DOM event, so the DOM events are propagated through an observable.
+ *
+ * Some common use cases of `to()` bindings are presented below:
+ *
+ * ```ts
+ * const bind = Template.bind( observable, emitter );
+ *
+ * new Template( {
+ * tag: 'p',
+ * attributes: {
+ * // class="..." attribute gets bound to `observable#a`
+ * class: bind.to( 'a' )
+ * },
+ * children: [
+ * // ...
gets bound to observable#b; always `toUpperCase()`.
+ * {
+ * text: bind.to( 'b', ( value, node ) => value.toUpperCase() )
+ * }
+ * ],
+ * on: {
+ * click: [
+ * // An observable will fire "clicked" upon "click" in the DOM.
+ * bind.to( 'clicked' ),
+ *
+ * // A custom callback will be executed upon "click" in the DOM.
+ * bind.to( () => {
+ * ...
+ * } )
+ * ]
+ * }
+ * } ).render();
+ * ```
+ *
+ * Learn more about using `to()` in the {@link module:ui/template~TemplateValueSchema} and
+ * {@link module:ui/template~TemplateListenerSchema}.
+ *
+ * @label ATTRIBUTE
+ * @param attribute An attribute name of {@link module:utils/observablemixin~Observable}.
+ */
+ to(attribute: TAttribute): AttributeBinding & ListenerBinding;
+ /**
+ * Binds an {@link module:utils/observablemixin~Observable observable} to either:
+ *
+ * * an HTML element attribute or a text node `textContent`, so it remains in sync with the observable
+ * attribute as it changes,
+ * * or an HTML element DOM event, so the DOM events are propagated through an observable.
+ *
+ * Some common use cases of `to()` bindings are presented below:
+ *
+ * ```ts
+ * const bind = Template.bind( observable, emitter );
+ *
+ * new Template( {
+ * tag: 'p',
+ * attributes: {
+ * // class="..." attribute gets bound to `observable#a`
+ * class: bind.to( 'a' )
+ * },
+ * children: [
+ * // ...
gets bound to observable#b; always `toUpperCase()`.
+ * {
+ * text: bind.to( 'b', ( value, node ) => value.toUpperCase() )
+ * }
+ * ],
+ * on: {
+ * click: [
+ * // An observable will fire "clicked" upon "click" in the DOM.
+ * bind.to( 'clicked' ),
+ *
+ * // A custom callback will be executed upon "click" in the DOM.
+ * bind.to( () => {
+ * ...
+ * } )
+ * ]
+ * }
+ * } ).render();
+ * ```
+ *
+ * Learn more about using `to()` in the {@link module:ui/template~TemplateValueSchema} and
+ * {@link module:ui/template~TemplateListenerSchema}.
+ *
+ * @label ATTRIBUTE_CALLBACK
+ * @param attribute An attribute name of {@link module:utils/observablemixin~Observable}.
+ * @param callback Allows for processing of the value. Accepts `Node` and `value` as arguments.
+ */
+ to(attribute: TAttribute, callback: (value: TObservable[TAttribute], node: Node) => (TemplateSimpleValue)): AttributeBinding;
+ /**
+ * Binds an {@link module:utils/observablemixin~Observable observable} to either:
+ *
+ * * an HTML element attribute or a text node `textContent`, so it remains in sync with the observable
+ * attribute as it changes,
+ * * or an HTML element DOM event, so the DOM events are propagated through an observable.
+ *
+ * Some common use cases of `to()` bindings are presented below:
+ *
+ * ```ts
+ * const bind = Template.bind( observable, emitter );
+ *
+ * new Template( {
+ * tag: 'p',
+ * attributes: {
+ * // class="..." attribute gets bound to `observable#a`
+ * class: bind.to( 'a' )
+ * },
+ * children: [
+ * // ...
gets bound to observable#b; always `toUpperCase()`.
+ * {
+ * text: bind.to( 'b', ( value, node ) => value.toUpperCase() )
+ * }
+ * ],
+ * on: {
+ * click: [
+ * // An observable will fire "clicked" upon "click" in the DOM.
+ * bind.to( 'clicked' ),
+ *
+ * // A custom callback will be executed upon "click" in the DOM.
+ * bind.to( () => {
+ * ...
+ * } )
+ * ]
+ * }
+ * } ).render();
+ * ```
+ *
+ * Learn more about using `to()` in the {@link module:ui/template~TemplateValueSchema} and
+ * {@link module:ui/template~TemplateListenerSchema}.
+ *
+ * @label EVENT
+ * @param eventNameOrCallback A DOM event name or an event callback.
+ */
+ to(eventNameOrCallback: string | ((domEvent: Event) => void)): ListenerBinding;
+ /**
+ * Binds an {@link module:utils/observablemixin~Observable observable} to an HTML element attribute or a text
+ * node `textContent` so it remains in sync with the observable attribute as it changes.
+ *
+ * Unlike {@link module:ui/template~BindChain#to}, it controls the presence of the attribute or `textContent`
+ * depending on the "falseness" of an {@link module:utils/observablemixin~Observable} attribute.
+ *
+ * ```ts
+ * const bind = Template.bind( observable, emitter );
+ *
+ * new Template( {
+ * tag: 'input',
+ * attributes: {
+ * // when `observable#a` is not undefined/null/false/''
+ * // when `observable#a` is undefined/null/false
+ * checked: bind.if( 'a' )
+ * },
+ * children: [
+ * {
+ * // "b-is-not-set" when `observable#b` is undefined/null/false/''
+ * // when `observable#b` is not "falsy"
+ * text: bind.if( 'b', 'b-is-not-set', ( value, node ) => !value )
+ * }
+ * ]
+ * } ).render();
+ * ```
+ *
+ * Learn more about using `if()` in the {@link module:ui/template~TemplateValueSchema}.
+ *
+ * @param attribute An attribute name of {@link module:utils/observablemixin~Observable} used in the binding.
+ * @param valueIfTrue Value set when the {@link module:utils/observablemixin~Observable} attribute is not
+ * undefined/null/false/'' (empty string).
+ * @param callback Allows for processing of the value. Accepts `Node` and `value` as arguments.
+ */
+ if(attribute: TAttribute, valueIfTrue?: unknown, callback?: (value: TObservable[TAttribute], node: Node) => (boolean | FalsyValue)): AttributeBinding;
+}
+/**
+ * The {@link module:ui/template~Template#_renderNode} configuration.
+ */
+export interface RenderData {
+ /**
+ * A node which is being rendered.
+ */
+ node: HTMLElement | Text;
+ /**
+ * Tells {@link module:ui/template~Template#_renderNode} to render
+ * children into `DocumentFragment` first and then append the fragment
+ * to the parent element. It is a speed optimization.
+ */
+ intoFragment: boolean;
+ /**
+ * Indicates whether the {@link #node} has been provided by {@link module:ui/template~Template#apply}.
+ */
+ isApplying: boolean;
+ /**
+ * An object storing the data that helps {@link module:ui/template~Template#revert}
+ * bringing back an element to its initial state, i.e. before
+ * {@link module:ui/template~Template#apply} was called.
+ */
+ revertData?: RevertData;
+}
+interface RevertData {
+ text?: string | null;
+ children: Array;
+ bindings: Array void>>;
+ attributes: Record;
+}
+export {};
diff --git a/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/textarea/textareaview.d.ts b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/textarea/textareaview.d.ts
new file mode 100644
index 00000000..bedca4d2
--- /dev/null
+++ b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/textarea/textareaview.d.ts
@@ -0,0 +1,104 @@
+/**
+ * @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 ui/textarea/textareaview
+ */
+import { type Locale } from '@ckeditor/ckeditor5-utils';
+import InputBase from '@ckeditor/ckeditor5-ui/src/input/inputbase.js';
+import '@ckeditor/ckeditor5-ui/theme/components/input/input.css';
+import '@ckeditor/ckeditor5-ui/theme/components/textarea/textarea.css';
+/**
+ * The textarea view class.
+ *
+ * ```ts
+ * const textareaView = new TextareaView();
+ *
+ * textareaView.minRows = 2;
+ * textareaView.maxRows = 10;
+ *
+ * textareaView.render();
+ *
+ * document.body.append( textareaView.element );
+ * ```
+ */
+export default class TextareaView extends InputBase {
+ /**
+ * Specifies the visible height of a text area, in lines.
+ *
+ * @observable
+ * @default 2
+ */
+ minRows: number;
+ /**
+ * Specifies the maximum number of rows.
+ *
+ * @observable
+ * @default 5
+ */
+ maxRows: number;
+ /**
+ * Specifies the value of HTML attribute that indicates whether the user can resize the element.
+ *
+ * @observable
+ * @default 'none'
+ */
+ resize: 'both' | 'horizontal' | 'vertical' | 'none';
+ /**
+ * An internal property that stores the current height of the textarea. Used for the DOM binding.
+ *
+ * @observable
+ * @default null
+ * @internal
+ */
+ _height: number | null;
+ /**
+ * An instance of the resize observer used to detect when the view is visible or not and update
+ * its height if any changes that affect it were made while it was invisible.
+ *
+ * **Note:** Created in {@link #render}.
+ */
+ private _resizeObserver;
+ /**
+ * A flag that indicates whether the {@link #_updateAutoGrowHeight} method should be called when the view becomes
+ * visible again. See {@link #_resizeObserver}.
+ */
+ private _isUpdateAutoGrowHeightPending;
+ /**
+ * @inheritDoc
+ */
+ constructor(locale?: Locale);
+ /**
+ * @inheritDoc
+ */
+ render(): void;
+ /**
+ * @inheritDoc
+ */
+ destroy(): void;
+ /**
+ * @inheritDoc
+ */
+ reset(): void;
+ /**
+ * Updates the {@link #_height} of the view depending on {@link #minRows}, {@link #maxRows}, and the current content size.
+ *
+ * **Note**: This method overrides manual resize done by the user using a handle. It's a known bug.
+ */
+ private _updateAutoGrowHeight;
+ /**
+ * Validates the {@link #minRows} and {@link #maxRows} properties and warns in the console if the configuration is incorrect.
+ */
+ private _validateMinMaxRows;
+}
+/**
+ * Fired every time the layout of the {@link module:ui/textarea/textareaview~TextareaView} possibly changed as a result
+ * of the user input or the value change via {@link module:ui/textarea/textareaview~TextareaView#value}.
+ *
+ * @eventName ~TextareaView#update
+ */
+export type TextareaViewUpdateEvent = {
+ name: 'update';
+ args: [];
+};
diff --git a/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/toolbar/balloon/balloontoolbar.d.ts b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/toolbar/balloon/balloontoolbar.d.ts
new file mode 100644
index 00000000..ba909831
--- /dev/null
+++ b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/toolbar/balloon/balloontoolbar.d.ts
@@ -0,0 +1,117 @@
+/**
+ * @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 ui/toolbar/balloon/balloontoolbar
+ */
+import ContextualBalloon from '@ckeditor/ckeditor5-ui/src/panel/balloon/contextualballoon.js';
+import ToolbarView from '@ckeditor/ckeditor5-ui/src/toolbar/toolbarview.js';
+import { Plugin, type Editor } from '@ckeditor/ckeditor5-core';
+import { FocusTracker } from '@ckeditor/ckeditor5-utils';
+/**
+ * The contextual toolbar.
+ *
+ * It uses the {@link module:ui/panel/balloon/contextualballoon~ContextualBalloon contextual balloon plugin}.
+ */
+export default class BalloonToolbar extends Plugin {
+ /**
+ * The toolbar view displayed in the balloon.
+ */
+ readonly toolbarView: ToolbarView;
+ /**
+ * Tracks the focus of the {@link module:ui/editorui/editorui~EditorUI#getEditableElement editable element}
+ * and the {@link #toolbarView}. When both are blurred then the toolbar should hide.
+ */
+ readonly focusTracker: FocusTracker;
+ /**
+ * A cached and normalized `config.balloonToolbar` object.
+ */
+ private _balloonConfig;
+ /**
+ * An instance of the resize observer that allows to respond to changes in editable's geometry
+ * so the toolbar can stay within its boundaries (and group toolbar items that do not fit).
+ *
+ * **Note**: Used only when `shouldNotGroupWhenFull` was **not** set in the
+ * {@link module:core/editor/editorconfig~EditorConfig#balloonToolbar configuration}.
+ *
+ * **Note:** Created in {@link #init}.
+ */
+ private _resizeObserver;
+ /**
+ * The contextual balloon plugin instance.
+ */
+ private readonly _balloon;
+ /**
+ * Fires `_selectionChangeDebounced` event using `lodash#debounce`.
+ *
+ * This event is an internal plugin event which is fired 200 ms after model selection last change.
+ * This is to makes easy test debounced action without need to use `setTimeout`.
+ *
+ * This function is stored as a plugin property to make possible to cancel
+ * trailing debounced invocation on destroy.
+ */
+ private readonly _fireSelectionChangeDebounced;
+ /**
+ * @inheritDoc
+ */
+ static get pluginName(): "BalloonToolbar";
+ /**
+ * @inheritDoc
+ */
+ static get requires(): readonly [typeof ContextualBalloon];
+ /**
+ * @inheritDoc
+ */
+ constructor(editor: Editor);
+ /**
+ * @inheritDoc
+ */
+ init(): void;
+ /**
+ * Creates the toolbar view instance.
+ */
+ private _createToolbarView;
+ /**
+ * Shows the toolbar and attaches it to the selection.
+ *
+ * Fires {@link #event:show} event which can be stopped to prevent the toolbar from showing up.
+ *
+ * @param showForCollapsedSelection When set `true`, the toolbar will show despite collapsed selection in the
+ * editing view.
+ */
+ show(showForCollapsedSelection?: boolean): void;
+ /**
+ * Hides the toolbar.
+ */
+ hide(): void;
+ /**
+ * Returns positioning options for the {@link #_balloon}. They control the way balloon is attached
+ * to the selection.
+ */
+ private _getBalloonPositionData;
+ /**
+ * Updates the position of the {@link #_balloon} to make up for changes:
+ *
+ * * in the geometry of the selection it is attached to (e.g. the selection moved in the viewport or expanded or shrunk),
+ * * or the geometry of the balloon toolbar itself (e.g. the toolbar has grouped or ungrouped some items and it is shorter or longer).
+ */
+ private _updatePosition;
+ /**
+ * @inheritDoc
+ */
+ destroy(): void;
+ /**
+ * Returns toolbar positions for the given direction of the selection.
+ */
+ private _getBalloonPositions;
+}
+/**
+ * This event is fired just before the toolbar shows up. Stopping this event will prevent this.
+ *
+ * @eventName ~BalloonToolbar#show
+ */
+export type BalloonToolbarShowEvent = {
+ name: 'show';
+ args: [];
+};
diff --git a/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/toolbar/block/blockbuttonview.d.ts b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/toolbar/block/blockbuttonview.d.ts
new file mode 100644
index 00000000..2f3173be
--- /dev/null
+++ b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/toolbar/block/blockbuttonview.d.ts
@@ -0,0 +1,35 @@
+/**
+ * @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 ui/toolbar/block/blockbuttonview
+ */
+import ButtonView from '@ckeditor/ckeditor5-ui/src/button/buttonview.js';
+import { type Locale } from '@ckeditor/ckeditor5-utils';
+import '@ckeditor/ckeditor5-ui/theme/components/toolbar/blocktoolbar.css';
+/**
+ * The block button view class.
+ *
+ * This view represents a button attached next to block element where the selection is anchored.
+ *
+ * See {@link module:ui/toolbar/block/blocktoolbar~BlockToolbar}.
+ */
+export default class BlockButtonView extends ButtonView {
+ /**
+ * Top offset.
+ *
+ * @observable
+ */
+ top: number;
+ /**
+ * Left offset.
+ *
+ * @observable
+ */
+ left: number;
+ /**
+ * @inheritDoc
+ */
+ constructor(locale?: Locale);
+}
diff --git a/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/toolbar/block/blocktoolbar.d.ts b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/toolbar/block/blocktoolbar.d.ts
new file mode 100644
index 00000000..8b19864f
--- /dev/null
+++ b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/toolbar/block/blocktoolbar.d.ts
@@ -0,0 +1,153 @@
+/**
+ * @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 ui/toolbar/block/blocktoolbar
+ */
+import { Plugin, type Editor } from '@ckeditor/ckeditor5-core';
+import BlockButtonView from '@ckeditor/ckeditor5-ui/src/toolbar/block/blockbuttonview.js';
+import BalloonPanelView from '@ckeditor/ckeditor5-ui/src/panel/balloon/balloonpanelview.js';
+import ToolbarView from '@ckeditor/ckeditor5-ui/src/toolbar/toolbarview.js';
+/**
+ * The block toolbar plugin.
+ *
+ * This plugin provides a button positioned next to the block of content where the selection is anchored.
+ * Upon clicking the button, a dropdown providing access to editor features shows up, as configured in
+ * {@link module:core/editor/editorconfig~EditorConfig#blockToolbar}.
+ *
+ * By default, the button is displayed next to all elements marked in {@link module:engine/model/schema~Schema}
+ * as `$block` for which the toolbar provides at least one option.
+ *
+ * By default, the button is attached so its right boundary is touching the
+ * {@link module:engine/view/editableelement~EditableElement}:
+ *
+ * ```
+ * __ |
+ * | || This is a block of content that the
+ * ¯¯ | button is attached to. This is a
+ * | block of content that the button is
+ * | attached to.
+ * ```
+ *
+ * The position of the button can be adjusted using the CSS `transform` property:
+ *
+ * ```css
+ * .ck-block-toolbar-button {
+ * transform: translateX( -10px );
+ * }
+ * ```
+ *
+ * ```
+ * __ |
+ * | | | This is a block of content that the
+ * ¯¯ | button is attached to. This is a
+ * | block of content that the button is
+ * | attached to.
+ * ```
+ *
+ * **Note**: If you plan to run the editor in a right–to–left (RTL) language, keep in mind the button
+ * will be attached to the **right** boundary of the editable area. In that case, make sure the
+ * CSS position adjustment works properly by adding the following styles:
+ *
+ * ```css
+ * .ck[dir="rtl"] .ck-block-toolbar-button {
+ * transform: translateX( 10px );
+ * }
+ * ```
+ */
+export default class BlockToolbar extends Plugin {
+ /**
+ * The toolbar view.
+ */
+ readonly toolbarView: ToolbarView;
+ /**
+ * The balloon panel view, containing the {@link #toolbarView}.
+ */
+ readonly panelView: BalloonPanelView;
+ /**
+ * The button view that opens the {@link #toolbarView}.
+ */
+ readonly buttonView: BlockButtonView;
+ /**
+ * An instance of the resize observer that allows to respond to changes in editable's geometry
+ * so the toolbar can stay within its boundaries (and group toolbar items that do not fit).
+ *
+ * **Note**: Used only when `shouldNotGroupWhenFull` was **not** set in the
+ * {@link module:core/editor/editorconfig~EditorConfig#blockToolbar configuration}.
+ */
+ private _resizeObserver;
+ /**
+ * A cached and normalized `config.blockToolbar` object.
+ */
+ private _blockToolbarConfig;
+ /**
+ * @inheritDoc
+ */
+ static get pluginName(): "BlockToolbar";
+ /**
+ * @inheritDoc
+ */
+ constructor(editor: Editor);
+ /**
+ * @inheritDoc
+ */
+ init(): void;
+ /**
+ * @inheritDoc
+ */
+ destroy(): void;
+ /**
+ * Creates the {@link #toolbarView}.
+ */
+ private _createToolbarView;
+ /**
+ * Creates the {@link #panelView}.
+ */
+ private _createPanelView;
+ /**
+ * Creates the {@link #buttonView}.
+ */
+ private _createButtonView;
+ /**
+ * Shows or hides the button.
+ * When all the conditions for displaying the button are matched, it shows the button. Hides otherwise.
+ */
+ private _updateButton;
+ /**
+ * Hides the button.
+ */
+ private _hideButton;
+ /**
+ * Shows the {@link #toolbarView} attached to the {@link #buttonView}.
+ * If the toolbar is already visible, then it simply repositions it.
+ */
+ private _showPanel;
+ /**
+ * Returns currently selected editable, based on the model selection.
+ */
+ private _getSelectedEditableElement;
+ /**
+ * Hides the {@link #toolbarView}.
+ *
+ * @param focusEditable When `true`, the editable will be focused after hiding the panel.
+ */
+ private _hidePanel;
+ /**
+ * Attaches the {@link #buttonView} to the target block of content.
+ *
+ * @param targetElement Target element.
+ */
+ private _attachButtonToElement;
+ /**
+ * Creates a resize observer that observes selected editable and resizes the toolbar panel accordingly.
+ */
+ private _setupToolbarResize;
+ /**
+ * Gets the {@link #toolbarView} max-width, based on given `editableElement` width plus the distance between the farthest
+ * edge of the {@link #buttonView} and the editable.
+ *
+ * @returns A maximum width that toolbar can have, in pixels.
+ */
+ private _getToolbarMaxWidth;
+}
diff --git a/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/toolbar/toolbarlinebreakview.d.ts b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/toolbar/toolbarlinebreakview.d.ts
new file mode 100644
index 00000000..fd758e4e
--- /dev/null
+++ b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/toolbar/toolbarlinebreakview.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
+ */
+/**
+ * @module ui/toolbar/toolbarlinebreakview
+ */
+import View from '@ckeditor/ckeditor5-ui/src/view.js';
+import type { Locale } from '@ckeditor/ckeditor5-utils';
+/**
+ * The toolbar line break view class.
+ */
+export default class ToolbarLineBreakView extends View {
+ /**
+ * @inheritDoc
+ */
+ constructor(locale?: Locale);
+}
diff --git a/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/toolbar/toolbarseparatorview.d.ts b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/toolbar/toolbarseparatorview.d.ts
new file mode 100644
index 00000000..470a6044
--- /dev/null
+++ b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/toolbar/toolbarseparatorview.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
+ */
+/**
+ * @module ui/toolbar/toolbarseparatorview
+ */
+import View from '@ckeditor/ckeditor5-ui/src/view.js';
+import type { Locale } from '@ckeditor/ckeditor5-utils';
+/**
+ * The toolbar separator view class.
+ */
+export default class ToolbarSeparatorView extends View {
+ /**
+ * @inheritDoc
+ */
+ constructor(locale?: Locale);
+}
diff --git a/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/toolbar/toolbarview.d.ts b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/toolbar/toolbarview.d.ts
new file mode 100644
index 00000000..5a7ab368
--- /dev/null
+++ b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/toolbar/toolbarview.d.ts
@@ -0,0 +1,267 @@
+/**
+ * @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 ui/toolbar/toolbarview
+ */
+import View from '@ckeditor/ckeditor5-ui/src/view.js';
+import { type FocusableView } from '@ckeditor/ckeditor5-ui/src/focuscycler.js';
+import type ComponentFactory from '@ckeditor/ckeditor5-ui/src/componentfactory.js';
+import type ViewCollection from '@ckeditor/ckeditor5-ui/src/viewcollection.js';
+import type DropdownPanelFocusable from '@ckeditor/ckeditor5-ui/src/dropdown/dropdownpanelfocusable.js';
+import { FocusTracker, KeystrokeHandler, type Locale } from '@ckeditor/ckeditor5-utils';
+import { type ToolbarConfig } from '@ckeditor/ckeditor5-core';
+import '@ckeditor/ckeditor5-ui/theme/components/toolbar/toolbar.css';
+export declare const NESTED_TOOLBAR_ICONS: Record;
+/**
+ * The toolbar view class.
+ */
+export default class ToolbarView extends View implements DropdownPanelFocusable {
+ /**
+ * A reference to the options object passed to the constructor.
+ */
+ readonly options: ToolbarOptions;
+ /**
+ * A collection of toolbar items (buttons, dropdowns, etc.).
+ */
+ readonly items: ViewCollection;
+ /**
+ * Tracks information about the DOM focus in the toolbar.
+ */
+ readonly focusTracker: FocusTracker;
+ /**
+ * An instance of the {@link module:utils/keystrokehandler~KeystrokeHandler}
+ * to handle keyboard navigation in the toolbar.
+ */
+ readonly keystrokes: KeystrokeHandler;
+ /**
+ * A (child) view containing {@link #items toolbar items}.
+ */
+ readonly itemsView: ItemsView;
+ /**
+ * A top–level collection aggregating building blocks of the toolbar.
+ *
+ * ┌───────────────── ToolbarView ─────────────────┐
+ * | ┌──────────────── #children ────────────────┐ |
+ * | | ┌──────────── #itemsView ───────────┐ | |
+ * | | | [ item1 ] [ item2 ] ... [ itemN ] | | |
+ * | | └──────────────────────────────────-┘ | |
+ * | └───────────────────────────────────────────┘ |
+ * └───────────────────────────────────────────────┘
+ *
+ * By default, it contains the {@link #itemsView} but it can be extended with additional
+ * UI elements when necessary.
+ */
+ readonly children: ViewCollection;
+ /**
+ * A collection of {@link #items} that take part in the focus cycling
+ * (i.e. navigation using the keyboard). Usually, it contains a subset of {@link #items} with
+ * some optional UI elements that also belong to the toolbar and should be focusable
+ * by the user.
+ */
+ readonly focusables: ViewCollection;
+ locale: Locale;
+ /**
+ * Label used by assistive technologies to describe this toolbar element.
+ *
+ * @observable
+ * @default 'Editor toolbar'
+ */
+ ariaLabel: string;
+ /**
+ * The maximum width of the toolbar element.
+ *
+ * **Note**: When set to a specific value (e.g. `'200px'`), the value will affect the behavior of the
+ * {@link module:ui/toolbar/toolbarview~ToolbarOptions#shouldGroupWhenFull}
+ * option by changing the number of {@link #items} that will be displayed in the toolbar at a time.
+ *
+ * @observable
+ * @default 'auto'
+ */
+ maxWidth: string;
+ /**
+ * An additional CSS class added to the {@link #element}.
+ *
+ * @observable
+ * @member {String} #class
+ */
+ class: string | undefined;
+ /**
+ * When set true, makes the toolbar look compact with {@link #element}.
+ *
+ * @observable
+ * @default false
+ */
+ isCompact: boolean;
+ /**
+ * Controls the orientation of toolbar items. Only available when
+ * {@link module:ui/toolbar/toolbarview~ToolbarOptions#shouldGroupWhenFull dynamic items grouping}
+ * is **disabled**.
+ *
+ * @observable
+ */
+ isVertical: boolean;
+ /**
+ * Helps cycling over {@link #focusables focusable items} in the toolbar.
+ */
+ private readonly _focusCycler;
+ /**
+ * An instance of the active toolbar behavior that shapes its look and functionality.
+ *
+ * See {@link module:ui/toolbar/toolbarview~ToolbarBehavior} to learn more.
+ */
+ private readonly _behavior;
+ /**
+ * Creates an instance of the {@link module:ui/toolbar/toolbarview~ToolbarView} class.
+ *
+ * Also see {@link #render}.
+ *
+ * @param locale The localization services instance.
+ * @param options Configuration options of the toolbar.
+ */
+ constructor(locale: Locale, options?: ToolbarOptions);
+ /**
+ * @inheritDoc
+ */
+ render(): void;
+ /**
+ * @inheritDoc
+ */
+ destroy(): void;
+ /**
+ * Focuses the first focusable in {@link #focusables}.
+ */
+ focus(): void;
+ /**
+ * Focuses the last focusable in {@link #focusables}.
+ */
+ focusLast(): void;
+ /**
+ * A utility that expands the plain toolbar configuration into
+ * {@link module:ui/toolbar/toolbarview~ToolbarView#items} using a given component factory.
+ *
+ * @param itemsOrConfig The toolbar items or the entire toolbar configuration object.
+ * @param factory A factory producing toolbar items.
+ * @param removeItems An array of items names to be removed from the configuration. When present, applies
+ * to this toolbar and all nested ones as well.
+ */
+ fillFromConfig(itemsOrConfig: ToolbarConfig | undefined, factory: ComponentFactory, removeItems?: Array): void;
+ /**
+ * A utility that expands the plain toolbar configuration into a list of view items using a given component factory.
+ *
+ * @param itemsOrConfig The toolbar items or the entire toolbar configuration object.
+ * @param factory A factory producing toolbar items.
+ * @param removeItems An array of items names to be removed from the configuration. When present, applies
+ * to this toolbar and all nested ones as well.
+ */
+ private _buildItemsFromConfig;
+ /**
+ * Cleans up the {@link module:ui/toolbar/toolbarview~ToolbarView#items} of the toolbar by removing unwanted items and
+ * duplicated (obsolete) separators or line breaks.
+ *
+ * @param items The toolbar items configuration.
+ * @param factory A factory producing toolbar items.
+ * @param removeItems An array of items names to be removed from the configuration.
+ * @returns Items after the clean-up.
+ */
+ private _cleanItemsConfiguration;
+ /**
+ * Remove leading, trailing, and duplicated separators (`-` and `|`).
+ *
+ * @returns Toolbar items after the separator and line break clean-up.
+ */
+ private _cleanSeparatorsAndLineBreaks;
+ /**
+ * Creates a user-defined dropdown containing a toolbar with items.
+ *
+ * @param definition A definition of the nested toolbar dropdown.
+ * @param definition.label A label of the dropdown.
+ * @param definition.icon An icon of the drop-down. One of 'bold', 'plus', 'text', 'importExport', 'alignLeft',
+ * 'paragraph' or an SVG string. When `false` is passed, no icon will be used.
+ * @param definition.withText When set `true`, the label of the dropdown will be visible. See
+ * {@link module:ui/button/buttonview~ButtonView#withText} to learn more.
+ * @param definition.tooltip A tooltip of the dropdown button. See
+ * {@link module:ui/button/buttonview~ButtonView#tooltip} to learn more. Defaults to `true`.
+ * @param componentFactory Component factory used to create items
+ * of the nested toolbar.
+ */
+ private _createNestedToolbarDropdown;
+}
+/**
+ * Fired when some toolbar {@link ~ToolbarView#items} were grouped or ungrouped as a result of some change
+ * in the toolbar geometry.
+ *
+ * **Note**: This event is always fired **once** regardless of the number of items that were be
+ * grouped or ungrouped at a time.
+ *
+ * **Note**: This event is fired only if the items grouping functionality was enabled in
+ * the first place (see {@link module:ui/toolbar/toolbarview~ToolbarOptions#shouldGroupWhenFull}).
+ *
+ * @eventName ~ToolbarView#groupedItemsUpdate
+ */
+export type ToolbarViewGroupedItemsUpdateEvent = {
+ name: 'groupedItemsUpdate';
+ args: [];
+};
+/**
+ * An inner block of the {@link module:ui/toolbar/toolbarview~ToolbarView} hosting its
+ * {@link module:ui/toolbar/toolbarview~ToolbarView#items}.
+ */
+declare class ItemsView extends View {
+ /**
+ * A collection of items (buttons, dropdowns, etc.).
+ */
+ readonly children: ViewCollection;
+ /**
+ * @inheritDoc
+ */
+ constructor(locale?: Locale);
+}
+/**
+ * Options passed to the {@link module:ui/toolbar/toolbarview~ToolbarView#constructor} of the toolbar.
+ */
+export interface ToolbarOptions {
+ /**
+ * When set to `true`, the toolbar will automatically group {@link module:ui/toolbar/toolbarview~ToolbarView#items} that
+ * would normally wrap to the next line when there is not enough space to display them in a single row, for
+ * instance, if the parent container of the toolbar is narrow. For toolbars in absolutely positioned containers
+ * without width restrictions also the {@link module:ui/toolbar/toolbarview~ToolbarOptions#isFloating} option is required to be `true`.
+ *
+ * See also: {@link module:ui/toolbar/toolbarview~ToolbarView#maxWidth}.
+ */
+ shouldGroupWhenFull?: boolean;
+ /**
+ * This option should be enabled for toolbars in absolutely positioned containers without width restrictions
+ * to enable automatic {@link module:ui/toolbar/toolbarview~ToolbarView#items} grouping.
+ * When this option is set to `true`, the items will stop wrapping to the next line
+ * and together with {@link module:ui/toolbar/toolbarview~ToolbarOptions#shouldGroupWhenFull},
+ * this will allow grouping them when there is not enough space in a single row.
+ */
+ isFloating?: boolean;
+}
+/**
+ * A class interface defining the behavior of the {@link module:ui/toolbar/toolbarview~ToolbarView}.
+ *
+ * Toolbar behaviors extend its look and functionality and have an impact on the
+ * {@link module:ui/toolbar/toolbarview~ToolbarView#element} template or
+ * {@link module:ui/toolbar/toolbarview~ToolbarView#render rendering}. They can be enabled
+ * conditionally, e.g. depending on the configuration of the toolbar.
+ */
+export interface ToolbarBehavior {
+ /**
+ * A method called after the toolbar has been {@link module:ui/toolbar/toolbarview~ToolbarView#render rendered}.
+ * It can be used to, for example, customize the behavior of the toolbar when its
+ * {@link module:ui/toolbar/toolbarview~ToolbarView#element} is available.
+ *
+ * @param view An instance of the toolbar being rendered.
+ */
+ render(view: ToolbarView): void;
+ /**
+ * A method called after the toolbar has been {@link module:ui/toolbar/toolbarview~ToolbarView#destroy destroyed}.
+ * It allows cleaning up after the toolbar behavior, for instance, this is the right place to detach
+ * event listeners, free up references, etc.
+ */
+ destroy(): void;
+}
+export {};
diff --git a/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/tooltipmanager.d.ts b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/tooltipmanager.d.ts
new file mode 100644
index 00000000..f0719153
--- /dev/null
+++ b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/tooltipmanager.d.ts
@@ -0,0 +1,195 @@
+/**
+ * @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 ui/tooltipmanager
+ */
+import View from '@ckeditor/ckeditor5-ui/src/view.js';
+import BalloonPanelView from '@ckeditor/ckeditor5-ui/src/panel/balloon/balloonpanelview.js';
+import { type PositioningFunction } from '@ckeditor/ckeditor5-utils';
+import type { Editor } from '@ckeditor/ckeditor5-core';
+import '@ckeditor/ckeditor5-ui/theme/components/tooltip/tooltip.css';
+declare const TooltipManager_base: {
+ new (): import("@ckeditor/ckeditor5-utils").DomEmitter;
+ prototype: import("@ckeditor/ckeditor5-utils").DomEmitter;
+};
+/**
+ * A tooltip manager class for the UI of the editor.
+ *
+ * **Note**: Most likely you do not have to use the `TooltipManager` API listed below in order to display tooltips. Popular
+ * {@glink framework/architecture/ui-library UI components} support tooltips out-of-the-box via observable properties
+ * (see {@link module:ui/button/buttonview~ButtonView#tooltip} and {@link module:ui/button/buttonview~ButtonView#tooltipPosition}).
+ *
+ * # Displaying tooltips
+ *
+ * To display a tooltip, set `data-cke-tooltip-text` attribute on any DOM element:
+ *
+ * ```ts
+ * domElement.dataset.ckeTooltipText = 'My tooltip';
+ * ```
+ *
+ * The tooltip will show up whenever the user moves the mouse over the element or the element gets focus in DOM.
+ *
+ * # Positioning tooltips
+ *
+ * To change the position of the tooltip, use the `data-cke-tooltip-position` attribute (`s`, `se`, `sw`, `n`, `e`, or `w`):
+ *
+ * ```ts
+ * domElement.dataset.ckeTooltipText = 'Tooltip to the north';
+ * domElement.dataset.ckeTooltipPosition = 'n';
+ * ```
+ *
+ * # Disabling tooltips
+ *
+ * In order to disable the tooltip temporarily, use the `data-cke-tooltip-disabled` attribute:
+ *
+ * ```ts
+ * domElement.dataset.ckeTooltipText = 'Disabled. For now.';
+ * domElement.dataset.ckeTooltipDisabled = 'true';
+ * ```
+ *
+ * # Styling tooltips
+ *
+ * By default, the tooltip has `.ck-tooltip` class and its text inner `.ck-tooltip__text`.
+ *
+ * If your tooltip requires custom styling, using `data-cke-tooltip-class` attribute will add additional class to the balloon
+ * displaying the tooltip:
+ *
+ * ```ts
+ * domElement.dataset.ckeTooltipText = 'Tooltip with a red text';
+ * domElement.dataset.ckeTooltipClass = 'my-class';
+ * ```
+ *
+ * ```css
+ * .ck.ck-tooltip.my-class { color: red }
+ * ```
+ *
+ * **Note**: This class is a singleton. All editor instances re-use the same instance loaded by
+ * {@link module:ui/editorui/editorui~EditorUI} of the first editor.
+ */
+export default class TooltipManager extends TooltipManager_base {
+ /**
+ * The view rendering text of the tooltip.
+ */
+ readonly tooltipTextView: View & {
+ text: string;
+ };
+ /**
+ * The instance of the balloon panel that renders and positions the tooltip.
+ */
+ readonly balloonPanelView: BalloonPanelView;
+ /**
+ * A set of default {@link module:utils/dom/position~PositioningFunction positioning functions} used by the `TooltipManager`
+ * to pin tooltips in different positions.
+ */
+ static defaultBalloonPositions: Record;
+ /**
+ * Stores the reference to the DOM element the tooltip is attached to. `null` when there's no tooltip
+ * in the UI.
+ */
+ private _currentElementWithTooltip;
+ /**
+ * Stores the current tooltip position. `null` when there's no tooltip in the UI.
+ */
+ private _currentTooltipPosition;
+ /**
+ * An instance of the resize observer that keeps track on target element visibility,
+ * when it hides the tooltip should also disappear.
+ *
+ * {@link module:core/editor/editorconfig~EditorConfig#balloonToolbar configuration}.
+ */
+ private _resizeObserver;
+ /**
+ * An instance of the mutation observer that keeps track on target element attributes changes.
+ */
+ private _mutationObserver;
+ /**
+ * A debounced version of {@link #_pinTooltip}. Tooltips show with a delay to avoid flashing and
+ * to improve the UX.
+ */
+ private _pinTooltipDebounced;
+ /**
+ * A debounced version of {@link #_unpinTooltip}. Tooltips hide with a delay to allow hovering of their titles.
+ */
+ private _unpinTooltipDebounced;
+ private readonly _watchdogExcluded;
+ /**
+ * A set of editors the single tooltip manager instance must listen to.
+ * This is mostly to handle `EditorUI#update` listeners from individual editors.
+ */
+ private static _editors;
+ /**
+ * A reference to the `TooltipManager` instance. The class is a singleton and as such,
+ * successive attempts at creating instances should return this instance.
+ */
+ private static _instance;
+ /**
+ * Creates an instance of the tooltip manager.
+ */
+ constructor(editor: Editor);
+ /**
+ * Destroys the tooltip manager.
+ *
+ * **Note**: The manager singleton cannot be destroyed until all editors that use it are destroyed.
+ *
+ * @param editor The editor the manager was created for.
+ */
+ destroy(editor: Editor): void;
+ /**
+ * Returns {@link #balloonPanelView} {@link module:utils/dom/position~PositioningFunction positioning functions} for a given position
+ * name.
+ *
+ * @param position Name of the position (`s`, `se`, `sw`, `n`, `e`, or `w`).
+ * @returns Positioning functions to be used by the {@link #balloonPanelView}.
+ */
+ static getPositioningFunctions(position: TooltipPosition): Array;
+ /**
+ * Handles hiding tooltips on `keydown` in DOM.
+ *
+ * @param evt An object containing information about the fired event.
+ * @param domEvent The DOM event.
+ */
+ private _onKeyDown;
+ /**
+ * Handles displaying tooltips on `mouseenter` and `focus` in DOM.
+ *
+ * @param evt An object containing information about the fired event.
+ * @param domEvent The DOM event.
+ */
+ private _onEnterOrFocus;
+ /**
+ * Handles hiding tooltips on `mouseleave` and `blur` in DOM.
+ *
+ * @param evt An object containing information about the fired event.
+ * @param domEvent The DOM event.
+ */
+ private _onLeaveOrBlur;
+ /**
+ * Handles hiding tooltips on `scroll` in DOM.
+ *
+ * @param evt An object containing information about the fired event.
+ * @param domEvent The DOM event.
+ */
+ private _onScroll;
+ /**
+ * Pins the tooltip to a specific DOM element.
+ *
+ * @param options.text Text of the tooltip to display.
+ * @param options.position The position of the tooltip.
+ * @param options.cssClass Additional CSS class of the balloon with the tooltip.
+ */
+ private _pinTooltip;
+ /**
+ * Unpins the tooltip and cancels all queued pinning.
+ */
+ private _unpinTooltip;
+ /**
+ * Updates the position of the tooltip so it stays in sync with the element it is pinned to.
+ *
+ * Hides the tooltip when the element is no longer visible in DOM or the tooltip text was removed.
+ */
+ private _updateTooltipPosition;
+}
+export type TooltipPosition = 's' | 'n' | 'e' | 'w' | 'sw' | 'se';
+export {};
diff --git a/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/view.d.ts b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/view.d.ts
new file mode 100644
index 00000000..5f7838ab
--- /dev/null
+++ b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/view.d.ts
@@ -0,0 +1,422 @@
+/**
+ * @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 ui/view
+ */
+import ViewCollection from '@ckeditor/ckeditor5-ui/src/viewcollection.js';
+import Template, { type BindChain, type TemplateDefinition } from '@ckeditor/ckeditor5-ui/src/template.js';
+import { Collection, type DecoratedMethodEvent, type Locale, type LocaleTranslate } from '@ckeditor/ckeditor5-utils';
+import '@ckeditor/ckeditor5-ui/theme/globals/globals.css';
+declare const View_base: import("@ckeditor/ckeditor5-utils").Mixed<{
+ new (): import("@ckeditor/ckeditor5-utils").Observable;
+ prototype: import("@ckeditor/ckeditor5-utils").Observable;
+}, import("@ckeditor/ckeditor5-utils").DomEmitter>;
+/**
+ * The basic view class, which represents an HTML element created out of a
+ * {@link module:ui/view~View#template}. Views are building blocks of the user interface and handle
+ * interaction
+ *
+ * Views {@link module:ui/view~View#registerChild aggregate} children in
+ * {@link module:ui/view~View#createCollection collections} and manage the life cycle of DOM
+ * listeners e.g. by handling rendering and destruction.
+ *
+ * See the {@link module:ui/template~TemplateDefinition} syntax to learn more about shaping view
+ * elements, attributes and listeners.
+ *
+ * ```ts
+ * class SampleView extends View {
+ * constructor( locale ) {
+ * super( locale );
+ *
+ * const bind = this.bindTemplate;
+ *
+ * // Views define their interface (state) using observable attributes.
+ * this.set( 'elementClass', 'bar' );
+ *
+ * this.setTemplate( {
+ * tag: 'p',
+ *
+ * // The element of the view can be defined with its children.
+ * children: [
+ * 'Hello',
+ * {
+ * tag: 'b',
+ * children: [ 'world!' ]
+ * }
+ * ],
+ * attributes: {
+ * class: [
+ * 'foo',
+ *
+ * // Observable attributes control the state of the view in DOM.
+ * bind.to( 'elementClass' )
+ * ]
+ * },
+ * on: {
+ * // Views listen to DOM events and propagate them.
+ * click: bind.to( 'clicked' )
+ * }
+ * } );
+ * }
+ * }
+ *
+ * const view = new SampleView( locale );
+ *
+ * view.render();
+ *
+ * // Append Helloworld
to the
+ * document.body.appendChild( view.element );
+ *
+ * // Change the class attribute to Helloworld
+ * view.elementClass = 'baz';
+ *
+ * // Respond to the "click" event in DOM by executing a custom action.
+ * view.on( 'clicked', () => {
+ * console.log( 'The view has been clicked!' );
+ * } );
+ * ```
+ */
+export default class View extends View_base {
+ /**
+ * An HTML element of the view. `null` until {@link #render rendered}
+ * from the {@link #template}.
+ *
+ * ```ts
+ * class SampleView extends View {
+ * constructor() {
+ * super();
+ *
+ * // A template instance the #element will be created from.
+ * this.setTemplate( {
+ * tag: 'p'
+ *
+ * // ...
+ * } );
+ * }
+ * }
+ *
+ * const view = new SampleView();
+ *
+ * // Renders the #template.
+ * view.render();
+ *
+ * // Append the HTML element of the view to .
+ * document.body.appendChild( view.element );
+ * ```
+ *
+ * **Note**: The element of the view can also be assigned directly:
+ *
+ * ```ts
+ * view.element = document.querySelector( '#my-container' );
+ * ```
+ */
+ element: TElement | null;
+ /**
+ * Set `true` when the view has already been {@link module:ui/view~View#render rendered}.
+ *
+ * @readonly
+ */
+ isRendered: boolean;
+ /**
+ * A set of tools to localize the user interface.
+ *
+ * Also see {@link module:core/editor/editor~Editor#locale}.
+ *
+ * @readonly
+ */
+ locale: Locale | undefined;
+ /**
+ * Shorthand for {@link module:utils/locale~Locale#t}.
+ *
+ * Note: If {@link #locale} instance hasn't been passed to the view this method may not
+ * be available.
+ *
+ * @see module:utils/locale~Locale#t
+ */
+ t: LocaleTranslate | undefined;
+ /**
+ * Template of this view. It provides the {@link #element} representing
+ * the view in DOM, which is {@link #render rendered}.
+ */
+ template?: Template;
+ viewUid?: string;
+ /**
+ * Collections registered with {@link #createCollection}.
+ */
+ protected _viewCollections: Collection;
+ /**
+ * A collection of view instances, which have been added directly
+ * into the {@link module:ui/template~Template#children}.
+ */
+ protected _unboundChildren: ViewCollection;
+ /**
+ * Cached {@link module:ui/template~BindChain bind chain} object created by the
+ * {@link #template}. See {@link #bindTemplate}.
+ */
+ private _bindTemplate?;
+ /**
+ * Creates an instance of the {@link module:ui/view~View} class.
+ *
+ * Also see {@link #render}.
+ *
+ * @param locale The localization services instance.
+ */
+ constructor(locale?: Locale);
+ /**
+ * Shorthand for {@link module:ui/template~Template.bind}, a binding
+ * {@link module:ui/template~BindChain interface} pre–configured for the view instance.
+ *
+ * It provides {@link module:ui/template~BindChain#to `to()`} and
+ * {@link module:ui/template~BindChain#if `if()`} methods that initialize bindings with
+ * observable attributes and attach DOM listeners.
+ *
+ * ```ts
+ * class SampleView extends View {
+ * constructor( locale ) {
+ * super( locale );
+ *
+ * const bind = this.bindTemplate;
+ *
+ * // These {@link module:utils/observablemixin~Observable observable} attributes will control
+ * // the state of the view in DOM.
+ * this.set( {
+ * elementClass: 'foo',
+ * isEnabled: true
+ * } );
+ *
+ * this.setTemplate( {
+ * tag: 'p',
+ *
+ * attributes: {
+ * // The class HTML attribute will follow elementClass
+ * // and isEnabled view attributes.
+ * class: [
+ * bind.to( 'elementClass' )
+ * bind.if( 'isEnabled', 'present-when-enabled' )
+ * ]
+ * },
+ *
+ * on: {
+ * // The view will fire the "clicked" event upon clicking in DOM.
+ * click: bind.to( 'clicked' )
+ * }
+ * } );
+ * }
+ * }
+ * ```
+ */
+ get bindTemplate(): BindChain;
+ /**
+ * Creates a new collection of views, which can be used as
+ * {@link module:ui/template~Template#children} of this view.
+ *
+ * ```ts
+ * class SampleView extends View {
+ * constructor( locale ) {
+ * super( locale );
+ *
+ * const child = new ChildView( locale );
+ * this.items = this.createCollection( [ child ] );
+ *
+ * this.setTemplate( {
+ * tag: 'p',
+ *
+ * // `items` collection will render here.
+ * children: this.items
+ * } );
+ * }
+ * }
+ *
+ * const view = new SampleView( locale );
+ * view.render();
+ *
+ * // It will append
to the .
+ * document.body.appendChild( view.element );
+ * ```
+ *
+ * @param views Initial views of the collection.
+ * @returns A new collection of view instances.
+ */
+ createCollection(views?: Iterable): ViewCollection;
+ /**
+ * Registers a new child view under the view instance. Once registered, a child
+ * view is managed by its parent, including {@link #render rendering}
+ * and {@link #destroy destruction}.
+ *
+ * To revert this, use {@link #deregisterChild}.
+ *
+ * ```ts
+ * class SampleView extends View {
+ * constructor( locale ) {
+ * super( locale );
+ *
+ * this.childA = new SomeChildView( locale );
+ * this.childB = new SomeChildView( locale );
+ *
+ * this.setTemplate( { tag: 'p' } );
+ *
+ * // Register the children.
+ * this.registerChild( [ this.childA, this.childB ] );
+ * }
+ *
+ * render() {
+ * super.render();
+ *
+ * this.element.appendChild( this.childA.element );
+ * this.element.appendChild( this.childB.element );
+ * }
+ * }
+ *
+ * const view = new SampleView( locale );
+ *
+ * view.render();
+ *
+ * // Will append
.
+ * document.body.appendChild( view.element );
+ * ```
+ *
+ * **Note**: There's no need to add child views if they're already referenced in the
+ * {@link #template}:
+ *
+ * ```ts
+ * class SampleView extends View {
+ * constructor( locale ) {
+ * super( locale );
+ *
+ * this.childA = new SomeChildView( locale );
+ * this.childB = new SomeChildView( locale );
+ *
+ * this.setTemplate( {
+ * tag: 'p',
+ *
+ * // These children will be added automatically. There's no
+ * // need to call {@link #registerChild} for any of them.
+ * children: [ this.childA, this.childB ]
+ * } );
+ * }
+ *
+ * // ...
+ * }
+ * ```
+ *
+ * @param children Children views to be registered.
+ */
+ registerChild(children: View | Iterable): void;
+ /**
+ * The opposite of {@link #registerChild}. Removes a child view from this view instance.
+ * Once removed, the child is no longer managed by its parent, e.g. it can safely
+ * become a child of another parent view.
+ *
+ * @see #registerChild
+ * @param children Child views to be removed.
+ */
+ deregisterChild(children: View | Iterable): void;
+ /**
+ * Sets the {@link #template} of the view with with given definition.
+ *
+ * A shorthand for:
+ *
+ * ```ts
+ * view.setTemplate( definition );
+ * ```
+ *
+ * @param definition Definition of view's template.
+ */
+ setTemplate(definition: TemplateDefinition): void;
+ /**
+ * {@link module:ui/template~Template.extend Extends} the {@link #template} of the view with
+ * with given definition.
+ *
+ * A shorthand for:
+ *
+ * ```ts
+ * Template.extend( view.template, definition );
+ * ```
+ *
+ * **Note**: Is requires the {@link #template} to be already set. See {@link #setTemplate}.
+ *
+ * @param definition Definition which extends the {@link #template}.
+ */
+ extendTemplate(definition: Partial): void;
+ /**
+ * Recursively renders the view.
+ *
+ * Once the view is rendered:
+ * * the {@link #element} becomes an HTML element out of {@link #template},
+ * * the {@link #isRendered} flag is set `true`.
+ *
+ * **Note**: The children of the view:
+ * * defined directly in the {@link #template}
+ * * residing in collections created by the {@link #createCollection} method,
+ * * and added by {@link #registerChild}
+ * are also rendered in the process.
+ *
+ * In general, `render()` method is the right place to keep the code which refers to the
+ * {@link #element} and should be executed at the very beginning of the view's life cycle.
+ *
+ * It is possible to {@link module:ui/template~Template.extend} the {@link #template} before
+ * the view is rendered. To allow an early customization of the view (e.g. by its parent),
+ * such references should be done in `render()`.
+ *
+ * ```ts
+ * class SampleView extends View {
+ * constructor() {
+ * this.setTemplate( {
+ * // ...
+ * } );
+ * },
+ *
+ * render() {
+ * // View#element becomes available.
+ * super.render();
+ *
+ * // The "scroll" listener depends on #element.
+ * this.listenTo( window, 'scroll', () => {
+ * // A reference to #element would render the #template and make it non-extendable.
+ * if ( window.scrollY > 0 ) {
+ * this.element.scrollLeft = 100;
+ * } else {
+ * this.element.scrollLeft = 0;
+ * }
+ * } );
+ * }
+ * }
+ *
+ * const view = new SampleView();
+ *
+ * // Let's customize the view before it gets rendered.
+ * view.extendTemplate( {
+ * attributes: {
+ * class: [
+ * 'additional-class'
+ * ]
+ * }
+ * } );
+ *
+ * // Late rendering allows customization of the view.
+ * view.render();
+ * ```
+ */
+ render(): void;
+ /**
+ * Recursively destroys the view instance and child views added by {@link #registerChild} and
+ * residing in collections created by the {@link #createCollection}.
+ *
+ * Destruction disables all event listeners:
+ * * created on the view, e.g. `view.on( 'event', () => {} )`,
+ * * defined in the {@link #template} for DOM events.
+ */
+ destroy(): void;
+}
+/**
+ * Event fired by the {@link module:ui/view~View#render} method. Actual rendering is executed as a listener to
+ * this event with the default priority.
+ *
+ * See {@link module:utils/observablemixin~Observable#decorate} for more information and samples.
+ *
+ * @eventName ~View#render
+ */
+export type UIViewRenderEvent = DecoratedMethodEvent;
+export {};
diff --git a/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/viewcollection.d.ts b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/viewcollection.d.ts
new file mode 100644
index 00000000..37dd3056
--- /dev/null
+++ b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-ui/src/viewcollection.d.ts
@@ -0,0 +1,139 @@
+/**
+ * @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 ui/viewcollection
+ */
+import { Collection, type EmitterMixinDelegateChain } from '@ckeditor/ckeditor5-utils';
+import type View from '@ckeditor/ckeditor5-ui/src/view.js';
+/**
+ * Collects {@link module:ui/view~View} instances.
+ *
+ * ```ts
+ * const parentView = new ParentView( locale );
+ * const collection = new ViewCollection( locale );
+ *
+ * collection.setParent( parentView.element );
+ *
+ * const viewA = new ChildView( locale );
+ * const viewB = new ChildView( locale );
+ * ```
+ *
+ * View collection renders and manages view {@link module:ui/view~View#element elements}:
+ *
+ * ```ts
+ * collection.add( viewA );
+ * collection.add( viewB );
+ *
+ * console.log( parentView.element.firsChild ); // -> viewA.element
+ * console.log( parentView.element.lastChild ); // -> viewB.element
+ * ```
+ *
+ * It {@link module:ui/viewcollection~ViewCollection#delegate propagates} DOM events too:
+ *
+ * ```ts
+ * // Delegate #click and #keydown events from viewA and viewB to the parentView.
+ * collection.delegate( 'click' ).to( parentView );
+ *
+ * parentView.on( 'click', ( evt ) => {
+ * console.log( `${ evt.source } has been clicked.` );
+ * } );
+ *
+ * // This event will be delegated to the parentView.
+ * viewB.fire( 'click' );
+ * ```
+ *
+ * **Note**: A view collection can be used directly in the {@link module:ui/template~TemplateDefinition definition}
+ * of a {@link module:ui/template~Template template}.
+ */
+export default class ViewCollection extends Collection {
+ id?: string;
+ /**
+ * A parent element within which child views are rendered and managed in DOM.
+ */
+ private _parentElement;
+ /**
+ * Creates a new instance of the {@link module:ui/viewcollection~ViewCollection}.
+ *
+ * @param initialItems The initial items of the collection.
+ */
+ constructor(initialItems?: Iterable);
+ /**
+ * Destroys the view collection along with child views.
+ * See the view {@link module:ui/view~View#destroy} method.
+ */
+ destroy(): void;
+ /**
+ * Sets the parent HTML element of this collection. When parent is set, {@link #add adding} and
+ * {@link #remove removing} views in the collection synchronizes their
+ * {@link module:ui/view~View#element elements} in the parent element.
+ *
+ * @param element A new parent element.
+ */
+ setParent(elementOrDocFragment: DocumentFragment | HTMLElement): void;
+ /**
+ * Delegates selected events coming from within views in the collection to any
+ * {@link module:utils/emittermixin~Emitter}.
+ *
+ * For the following views and collection:
+ *
+ * ```ts
+ * const viewA = new View();
+ * const viewB = new View();
+ * const viewC = new View();
+ *
+ * const views = parentView.createCollection();
+ *
+ * views.delegate( 'eventX' ).to( viewB );
+ * views.delegate( 'eventX', 'eventY' ).to( viewC );
+ *
+ * views.add( viewA );
+ * ```
+ *
+ * the `eventX` is delegated (fired by) `viewB` and `viewC` along with `customData`:
+ *
+ * ```ts
+ * viewA.fire( 'eventX', customData );
+ * ```
+ *
+ * and `eventY` is delegated (fired by) `viewC` along with `customData`:
+ *
+ * ```ts
+ * viewA.fire( 'eventY', customData );
+ * ```
+ *
+ * See {@link module:utils/emittermixin~Emitter#delegate}.
+ *
+ * @param events {@link module:ui/view~View} event names to be delegated to another
+ * {@link module:utils/emittermixin~Emitter}.
+ * @returns Object with `to` property, a function which accepts the destination
+ * of {@link module:utils/emittermixin~Emitter#delegate delegated} events.
+ */
+ delegate(...events: Array): EmitterMixinDelegateChain;
+ /**
+ * This method {@link module:ui/view~View#render renders} a new view added to the collection.
+ *
+ * If the {@link #_parentElement parent element} of the collection is set, this method also adds
+ * the view's {@link module:ui/view~View#element} as a child of the parent in DOM at a specified index.
+ *
+ * **Note**: If index is not specified, the view's element is pushed as the last child
+ * of the parent element.
+ *
+ * @param view A new view added to the collection.
+ * @param index An index the view holds in the collection. When not specified,
+ * the view is added at the end.
+ */
+ private _renderViewIntoCollectionParent;
+ /**
+ * Removes a child view from the collection. If the {@link #setParent parent element} of the
+ * collection has been set, the {@link module:ui/view~View#element element} of the view is also removed
+ * in DOM, reflecting the order of the collection.
+ *
+ * See the {@link #add} method.
+ *
+ * @param subject The view to remove, its id or index in the collection.
+ * @returns The removed view.
+ */
+ remove(subject: TView | number | string): TView;
+}
diff --git a/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-undo/src/augmentation.d.ts b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-undo/src/augmentation.d.ts
new file mode 100644
index 00000000..9933fe55
--- /dev/null
+++ b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-undo/src/augmentation.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
+ */
+import type { Undo, UndoEditing, UndoUI, UndoCommand, RedoCommand } from '@ckeditor/ckeditor5-undo';
+declare module '@ckeditor/ckeditor5-core' {
+ interface CommandsMap {
+ undo: UndoCommand;
+ redo: RedoCommand;
+ }
+ interface PluginsMap {
+ [Undo.pluginName]: Undo;
+ [UndoEditing.pluginName]: UndoEditing;
+ [UndoUI.pluginName]: UndoUI;
+ }
+}
diff --git a/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-undo/src/index.d.ts b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-undo/src/index.d.ts
new file mode 100644
index 00000000..176f72cd
--- /dev/null
+++ b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-undo/src/index.d.ts
@@ -0,0 +1,13 @@
+/**
+ * @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 undo
+ */
+export { default as Undo } from '@ckeditor/ckeditor5-undo/src/undo.js';
+export { default as UndoEditing } from '@ckeditor/ckeditor5-undo/src/undoediting.js';
+export { default as UndoUI } from '@ckeditor/ckeditor5-undo/src/undoui.js';
+export type { default as UndoCommand } from '@ckeditor/ckeditor5-undo/src/undocommand.js';
+export type { default as RedoCommand } from '@ckeditor/ckeditor5-undo/src/redocommand.js';
+import '@ckeditor/ckeditor5-undo/src/augmentation.js';
diff --git a/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-undo/src/redocommand.d.ts b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-undo/src/redocommand.d.ts
new file mode 100644
index 00000000..6082605f
--- /dev/null
+++ b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-undo/src/redocommand.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
+ */
+/**
+ * @module undo/redocommand
+ */
+import BaseCommand from '@ckeditor/ckeditor5-undo/src/basecommand.js';
+/**
+ * The redo command stores {@link module:engine/model/batch~Batch batches} that were used to undo a batch by
+ * {@link module:undo/undocommand~UndoCommand}. It is able to redo a previously undone batch by reversing the undoing
+ * batches created by `UndoCommand`. The reversed batch is transformed by all the batches from
+ * {@link module:engine/model/document~Document#history history} that happened after the reversed undo batch.
+ *
+ * The redo command also takes care of restoring the {@link module:engine/model/document~Document#selection document selection}.
+ */
+export default class RedoCommand extends BaseCommand {
+ /**
+ * Executes the command. This method reverts the last {@link module:engine/model/batch~Batch batch} added to
+ * the command's stack, applies the reverted and transformed version on the
+ * {@link module:engine/model/document~Document document} and removes the batch from the stack.
+ * Then, it restores the {@link module:engine/model/document~Document#selection document selection}.
+ *
+ * @fires execute
+ */
+ execute(): void;
+}
diff --git a/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-undo/src/undo.d.ts b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-undo/src/undo.d.ts
new file mode 100644
index 00000000..3dd78a28
--- /dev/null
+++ b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-undo/src/undo.d.ts
@@ -0,0 +1,117 @@
+/**
+ * @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 undo/undo
+ */
+import { Plugin } from '@ckeditor/ckeditor5-core';
+import UndoEditing from '@ckeditor/ckeditor5-undo/src/undoediting.js';
+import UndoUI from '@ckeditor/ckeditor5-undo/src/undoui.js';
+/**
+ * The undo feature.
+ *
+ * This is a "glue" plugin which loads the {@link module:undo/undoediting~UndoEditing undo editing feature}
+ * and the {@link module:undo/undoui~UndoUI undo UI feature}.
+ *
+ * Below is an explanation of the undo mechanism working together with {@link module:engine/model/history~History History}:
+ *
+ * Whenever an {@link module:engine/model/operation/operation~Operation operation} is applied to the
+ * {@link module:engine/model/document~Document document}, it is saved to `History` as is.
+ * The {@link module:engine/model/batch~Batch batch} that owns that operation is also saved, in
+ * {@link module:undo/undocommand~UndoCommand}, together with the selection that was present in the document before the
+ * operation was applied. A batch is saved instead of the operation because changes are undone batch-by-batch, not operation-by-operation
+ * and a batch is seen as one undo step.
+ *
+ * After changes happen to the document, the `History` and `UndoCommand` stack can be represented as follows:
+ *
+ * ```
+ * History Undo stack
+ * ============== ==================================
+ * [operation A1] [ batch A ]
+ * [operation B1] [ batch B ]
+ * [operation B2] [ batch C ]
+ * [operation C1]
+ * [operation C2]
+ * [operation B3]
+ * [operation C3]
+ * ```
+ *
+ * Where operations starting with the same letter are from same batch.
+ *
+ * Undoing a batch means that a set of operations which will reverse the effects of that batch needs to be generated.
+ * For example, if a batch added several letters, undoing the batch should remove them. It is important to apply undoing
+ * operations in the reversed order, so if a batch has operation `X`, `Y`, `Z`, reversed operations `Zr`, `Yr` and `Xr`
+ * need to be applied. Otherwise reversed operation `Xr` would operate on a wrong document state, because operation `X`
+ * does not know that operations `Y` and `Z` happened.
+ *
+ * After operations from an undone batch got {@link module:engine/model/operation/operation~Operation#getReversed reversed},
+ * one needs to make sure if they are ready to be applied. In the scenario above, operation `C3` is the last operation and `C3r`
+ * bases on up-to-date document state, so it can be applied to the document.
+ *
+ * ```
+ * History Undo stack
+ * ================= ==================================
+ * [ operation A1 ] [ batch A ]
+ * [ operation B1 ] [ batch B ]
+ * [ operation B2 ] [ processing undoing batch C ]
+ * [ operation C1 ]
+ * [ operation C2 ]
+ * [ operation B3 ]
+ * [ operation C3 ]
+ * [ operation C3r ]
+ * ```
+ *
+ * Next is operation `C2`, reversed to `C2r`. `C2r` bases on `C2`, so it bases on the wrong document state. It needs to be
+ * transformed by operations from history that happened after it, so it "knows" about them. Let us assume that `C2' = C2r * B3 * C3 * C3r`,
+ * where `*` means "transformed by". Rest of operations from that batch are processed in the same fashion.
+ *
+ * ```
+ * History Undo stack Redo stack
+ * ================= ================================== ==================================
+ * [ operation A1 ] [ batch A ] [ batch Cr ]
+ * [ operation B1 ] [ batch B ]
+ * [ operation B2 ]
+ * [ operation C1 ]
+ * [ operation C2 ]
+ * [ operation B3 ]
+ * [ operation C3 ]
+ * [ operation C3r ]
+ * [ operation C2' ]
+ * [ operation C1' ]
+ * ```
+ *
+ * Selective undo works on the same basis, however, instead of undoing the last batch in the undo stack, any batch can be undone.
+ * The same algorithm applies: operations from a batch (i.e. `A1`) are reversed and then transformed by operations stored in history.
+ *
+ * Redo also is very similar to undo. It has its own stack that is filled with undoing (reversed batches). Operations from
+ * the batch that is re-done are reversed-back, transformed in proper order and applied to the document.
+ *
+ * ```
+ * History Undo stack Redo stack
+ * ================= ================================== ==================================
+ * [ operation A1 ] [ batch A ]
+ * [ operation B1 ] [ batch B ]
+ * [ operation B2 ] [ batch Crr ]
+ * [ operation C1 ]
+ * [ operation C2 ]
+ * [ operation B3 ]
+ * [ operation C3 ]
+ * [ operation C3r ]
+ * [ operation C2' ]
+ * [ operation C1' ]
+ * [ operation C1'r]
+ * [ operation C2'r]
+ * [ operation C3rr]
+ * ```
+ */
+export default class Undo extends Plugin {
+ /**
+ * @inheritDoc
+ */
+ static get requires(): readonly [typeof UndoEditing, typeof UndoUI];
+ /**
+ * @inheritDoc
+ */
+ static get pluginName(): "Undo";
+}
diff --git a/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-undo/src/undocommand.d.ts b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-undo/src/undocommand.d.ts
new file mode 100644
index 00000000..62508e0d
--- /dev/null
+++ b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-undo/src/undocommand.d.ts
@@ -0,0 +1,37 @@
+/**
+ * @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 undo/undocommand
+ */
+import BaseCommand from '@ckeditor/ckeditor5-undo/src/basecommand.js';
+import type { Batch } from '@ckeditor/ckeditor5-engine';
+/**
+ * The undo command stores {@link module:engine/model/batch~Batch batches} applied to the
+ * {@link module:engine/model/document~Document document} and is able to undo a batch by reversing it and transforming by
+ * batches from {@link module:engine/model/document~Document#history history} that happened after the reversed batch.
+ *
+ * The undo command also takes care of restoring the {@link module:engine/model/document~Document#selection document selection}.
+ */
+export default class UndoCommand extends BaseCommand {
+ /**
+ * Executes the command. This method reverts a {@link module:engine/model/batch~Batch batch} added to the command's stack, transforms
+ * and applies the reverted version on the {@link module:engine/model/document~Document document} and removes the batch from the stack.
+ * Then, it restores the {@link module:engine/model/document~Document#selection document selection}.
+ *
+ * @fires execute
+ * @fires revert
+ * @param batch A batch that should be undone. If not set, the last added batch will be undone.
+ */
+ execute(batch?: Batch | null): void;
+}
+/**
+ * Fired when execution of the command reverts some batch.
+ *
+ * @eventName ~UndoCommand#revert
+ */
+export type UndoCommandRevertEvent = {
+ name: 'revert';
+ args: [batch: Batch, undoingBatch: Batch];
+};
diff --git a/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-core/src/index.d.ts b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-core/src/index.d.ts
new file mode 100644
index 00000000..81aa7656
--- /dev/null
+++ b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-core/src/index.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
+ */
+/**
+ * @module core
+ */
+export { default as Plugin, type PluginDependencies, type PluginConstructor } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-core/src/plugin.js';
+export { default as Command, type CommandExecuteEvent } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-core/src/command.js';
+export { default as MultiCommand } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-core/src/multicommand.js';
+export type { CommandsMap } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-core/src/commandcollection.js';
+export type { PluginsMap, default as PluginCollection } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-core/src/plugincollection.js';
+export { default as Context, type ContextConfig } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-core/src/context.js';
+export { default as ContextPlugin, type ContextPluginDependencies } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-core/src/contextplugin.js';
+export { type EditingKeystrokeCallback } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-core/src/editingkeystrokehandler.js';
+export type { PartialBy, NonEmptyArray } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-core/src/typings.js';
+export { default as Editor, type EditorReadyEvent, type EditorDestroyEvent } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-core/src/editor/editor.js';
+export type { EditorConfig, LanguageConfig, ToolbarConfig, ToolbarConfigItem, UiConfig } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-core/src/editor/editorconfig.js';
+export { default as attachToForm } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-core/src/editor/utils/attachtoform.js';
+export { default as DataApiMixin, type DataApi } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-core/src/editor/utils/dataapimixin.js';
+export { default as ElementApiMixin, type ElementApi } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-core/src/editor/utils/elementapimixin.js';
+export { default as secureSourceElement } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-core/src/editor/utils/securesourceelement.js';
+export { default as PendingActions, type PendingAction } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-core/src/pendingactions.js';
+export type { KeystrokeInfos as KeystrokeInfoDefinitions, KeystrokeInfoGroup as KeystrokeInfoGroupDefinition, KeystrokeInfoCategory as KeystrokeInfoCategoryDefinition, KeystrokeInfoDefinition as KeystrokeInfoDefinition } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-core/src/accessibility.js';
+export declare const icons: {
+ bold: string;
+ cancel: string;
+ caption: string;
+ check: string;
+ cog: string;
+ colorPalette: string;
+ eraser: string;
+ history: string;
+ image: string;
+ imageUpload: string;
+ imageAssetManager: string;
+ imageUrl: string;
+ lowVision: string;
+ textAlternative: string;
+ loupe: string;
+ previousArrow: string;
+ nextArrow: string;
+ importExport: string;
+ paragraph: string;
+ plus: string;
+ text: string;
+ alignBottom: string;
+ alignMiddle: string;
+ alignTop: string;
+ alignLeft: string;
+ alignCenter: string;
+ alignRight: string;
+ alignJustify: string;
+ objectLeft: string;
+ objectCenter: string;
+ objectRight: string;
+ objectFullWidth: string;
+ objectInline: string;
+ objectBlockLeft: string;
+ objectBlockRight: string;
+ objectSizeFull: string;
+ objectSizeLarge: string;
+ objectSizeSmall: string;
+ objectSizeMedium: string;
+ pencil: string;
+ pilcrow: string;
+ quote: string;
+ threeVerticalDots: string;
+ dragIndicator: string;
+ redo: string;
+ undo: string;
+ bulletedList: string;
+ numberedList: string;
+ todoList: string;
+ codeBlock: string;
+ browseFiles: string;
+ heading1: string;
+ heading2: string;
+ heading3: string;
+ heading4: string;
+ heading5: string;
+ heading6: string;
+ horizontalLine: string;
+ html: string;
+ indent: string;
+ outdent: string;
+ table: string;
+};
+import '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-core/src/augmentation.js';
diff --git a/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/index.d.ts b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/index.d.ts
new file mode 100644
index 00000000..6adc9c5c
--- /dev/null
+++ b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/index.d.ts
@@ -0,0 +1,64 @@
+/**
+ * @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
+ */
+export { default as env } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/env.js';
+export { default as diff, type DiffResult } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/diff.js';
+export { default as fastDiff } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/fastdiff.js';
+export { default as diffToChanges } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/difftochanges.js';
+export { default as mix } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/mix.js';
+export type { Constructor, Mixed } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/mix.js';
+export { default as EmitterMixin, type Emitter, type BaseEvent, type CallbackOptions, type EmitterMixinDelegateChain, type GetCallback, type GetCallbackOptions, type GetEventInfo, type GetNameOrEventInfo } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/emittermixin.js';
+export { default as EventInfo } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/eventinfo.js';
+export { default as ObservableMixin, type Observable, type DecoratedMethodEvent, type ObservableChangeEvent, type ObservableSetEvent } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/observablemixin.js';
+export { default as CKEditorError, logError, logWarning } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/ckeditorerror.js';
+export { default as ElementReplacer } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/elementreplacer.js';
+export { default as abortableDebounce, type AbortableFunc } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/abortabledebounce.js';
+export { default as count } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/count.js';
+export { default as compareArrays } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/comparearrays.js';
+export { default as createElement } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/dom/createelement.js';
+export { default as Config } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/config.js';
+export { default as isIterable } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/isiterable.js';
+export { default as DomEmitterMixin, type DomEmitter } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/dom/emittermixin.js';
+export { default as findClosestScrollableAncestor } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/dom/findclosestscrollableancestor.js';
+export { default as global } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/dom/global.js';
+export { default as getAncestors } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/dom/getancestors.js';
+export { default as getDataFromElement } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/dom/getdatafromelement.js';
+export { default as getBorderWidths } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/dom/getborderwidths.js';
+export { default as isText } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/dom/istext.js';
+export { default as Rect, type RectSource } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/dom/rect.js';
+export { default as ResizeObserver } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/dom/resizeobserver.js';
+export { default as setDataInElement } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/dom/setdatainelement.js';
+export { default as toUnit } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/dom/tounit.js';
+export { default as indexOf } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/dom/indexof.js';
+export { default as insertAt } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/dom/insertat.js';
+export { default as isComment } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/dom/iscomment.js';
+export { default as isNode } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/dom/isnode.js';
+export { default as isRange } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/dom/isrange.js';
+export { default as isValidAttributeName } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/dom/isvalidattributename.js';
+export { default as isVisible } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/dom/isvisible.js';
+export { getOptimalPosition, type Options as PositionOptions, type PositioningFunction, type DomPoint } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/dom/position.js';
+export { default as remove } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/dom/remove.js';
+export * from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/dom/scroll.js';
+export * from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/keyboard.js';
+export * from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/language.js';
+export { default as Locale, type LocaleTranslate, type Translations } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/locale.js';
+export { default as Collection, type CollectionAddEvent, type CollectionChangeEvent, type CollectionRemoveEvent } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/collection.js';
+export { default as first } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/first.js';
+export { default as FocusTracker } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/focustracker.js';
+export { default as KeystrokeHandler } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/keystrokehandler.js';
+export { default as toArray, type ArrayOrItem, type ReadonlyArrayOrItem } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/toarray.js';
+export { default as toMap } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/tomap.js';
+export { default as priorities, type PriorityString } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/priorities.js';
+export { default as retry, exponentialDelay } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/retry.js';
+export { default as insertToPriorityArray } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/inserttopriorityarray.js';
+export { default as spliceArray } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/splicearray.js';
+export { default as uid } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/uid.js';
+export { default as delay, type DelayedFunc } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/delay.js';
+export { default as verifyLicense } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/verifylicense.js';
+export { default as wait } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/wait.js';
+export * from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/unicode.js';
+export { default as version, releaseDate } from '@ckeditor/ckeditor5-upload/node_modules/@ckeditor/ckeditor5-utils/src/version.js';
diff --git a/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-upload/src/adapters/base64uploadadapter.d.ts b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-upload/src/adapters/base64uploadadapter.d.ts
new file mode 100644
index 00000000..cdac1743
--- /dev/null
+++ b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-upload/src/adapters/base64uploadadapter.d.ts
@@ -0,0 +1,33 @@
+/**
+ * @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 upload/adapters/base64uploadadapter
+ */
+import { Plugin } from '@ckeditor/ckeditor5-core';
+import FileRepository from '@ckeditor/ckeditor5-upload/src/filerepository.js';
+/**
+ * A plugin that converts images inserted into the editor into [Base64 strings](https://en.wikipedia.org/wiki/Base64)
+ * in the {@glink installation/getting-started/getting-and-setting-data editor output}.
+ *
+ * This kind of image upload does not require server processing – images are stored with the rest of the text and
+ * displayed by the web browser without additional requests.
+ *
+ * Check out the {@glink features/images/image-upload/image-upload comprehensive "Image upload overview"} to learn about
+ * other ways to upload images into CKEditor 5.
+ */
+export default class Base64UploadAdapter extends Plugin {
+ /**
+ * @inheritDoc
+ */
+ static get requires(): readonly [typeof FileRepository];
+ /**
+ * @inheritDoc
+ */
+ static get pluginName(): "Base64UploadAdapter";
+ /**
+ * @inheritDoc
+ */
+ init(): void;
+}
diff --git a/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-upload/src/adapters/simpleuploadadapter.d.ts b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-upload/src/adapters/simpleuploadadapter.d.ts
new file mode 100644
index 00000000..23d898f4
--- /dev/null
+++ b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-upload/src/adapters/simpleuploadadapter.d.ts
@@ -0,0 +1,48 @@
+/**
+ * @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 upload/adapters/simpleuploadadapter
+ */
+import { Plugin } from '@ckeditor/ckeditor5-core';
+import FileRepository from '@ckeditor/ckeditor5-upload/src/filerepository.js';
+/**
+ * The Simple upload adapter allows uploading images to an application running on your server using
+ * the [`XMLHttpRequest`](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) API with a
+ * minimal {@link module:upload/uploadconfig~SimpleUploadConfig editor configuration}.
+ *
+ * ```ts
+ * ClassicEditor
+ * .create( document.querySelector( '#editor' ), {
+ * simpleUpload: {
+ * uploadUrl: 'http://example.com',
+ * headers: {
+ * ...
+ * }
+ * }
+ * } )
+ * .then( ... )
+ * .catch( ... );
+ * ```
+ *
+ * See the {@glink features/images/image-upload/simple-upload-adapter "Simple upload adapter"} guide to learn how to
+ * learn more about the feature (configuration, server–side requirements, etc.).
+ *
+ * Check out the {@glink features/images/image-upload/image-upload comprehensive "Image upload overview"} to learn about
+ * other ways to upload images into CKEditor 5.
+ */
+export default class SimpleUploadAdapter extends Plugin {
+ /**
+ * @inheritDoc
+ */
+ static get requires(): readonly [typeof FileRepository];
+ /**
+ * @inheritDoc
+ */
+ static get pluginName(): "SimpleUploadAdapter";
+ /**
+ * @inheritDoc
+ */
+ init(): void;
+}
diff --git a/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-upload/src/augmentation.d.ts b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-upload/src/augmentation.d.ts
new file mode 100644
index 00000000..800d5adf
--- /dev/null
+++ b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-upload/src/augmentation.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
+ */
+import type { SimpleUploadConfig, FileRepository, SimpleUploadAdapter, Base64UploadAdapter } from '@ckeditor/ckeditor5-upload';
+declare module '@ckeditor/ckeditor5-core' {
+ interface EditorConfig {
+ /**
+ * The configuration of the {@link module:upload/adapters/simpleuploadadapter~SimpleUploadAdapter simple upload adapter}.
+ *
+ * Read more in {@link module:upload/uploadconfig~SimpleUploadConfig}.
+ */
+ simpleUpload?: SimpleUploadConfig;
+ }
+ interface PluginsMap {
+ [FileRepository.pluginName]: FileRepository;
+ [SimpleUploadAdapter.pluginName]: SimpleUploadAdapter;
+ [Base64UploadAdapter.pluginName]: Base64UploadAdapter;
+ }
+}
diff --git a/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-upload/src/index.d.ts b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-upload/src/index.d.ts
new file mode 100644
index 00000000..f1d4b95e
--- /dev/null
+++ b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-upload/src/index.d.ts
@@ -0,0 +1,12 @@
+/**
+ * @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 upload
+ */
+export { default as FileRepository, type UploadAdapter, type UploadResponse, type FileLoader } from '@ckeditor/ckeditor5-upload/src/filerepository.js';
+export { default as Base64UploadAdapter } from '@ckeditor/ckeditor5-upload/src/adapters/base64uploadadapter.js';
+export { default as SimpleUploadAdapter } from '@ckeditor/ckeditor5-upload/src/adapters/simpleuploadadapter.js';
+export type { SimpleUploadConfig } from '@ckeditor/ckeditor5-upload/src/uploadconfig.js';
+import '@ckeditor/ckeditor5-upload/src/augmentation.js';
diff --git a/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-utils/src/collection.d.ts b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-utils/src/collection.d.ts
new file mode 100644
index 00000000..23588709
--- /dev/null
+++ b/vendor/ckeditor5/node_modules/@ckeditor/ckeditor5-utils/src/collection.d.ts
@@ -0,0 +1,433 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+declare const Collection_base: {
+ new (): import("@ckeditor/ckeditor5-utils/src/emittermixin.js").Emitter;
+ prototype: import("@ckeditor/ckeditor5-utils/src/emittermixin.js").Emitter;
+};
+/**
+ * Collections are ordered sets of objects. Items in the collection can be retrieved by their indexes
+ * in the collection (like in an array) or by their ids.
+ *
+ * If an object without an `id` property is being added to the collection, the `id` property will be generated
+ * automatically. Note that the automatically generated id is unique only within this single collection instance.
+ *
+ * By default an item in the collection is identified by its `id` property. The name of the identifier can be
+ * configured through the constructor of the collection.
+ *
+ * @typeParam T The type of the collection element.
+ */
+export default class Collection> extends Collection_base implements Iterable {
+ /**
+ * The internal list of items in the collection.
+ */
+ private readonly _items;
+ /**
+ * The internal map of items in the collection.
+ */
+ private readonly _itemMap;
+ /**
+ * The name of the property which is considered to identify an item.
+ */
+ private readonly _idProperty;
+ /**
+ * A collection instance this collection is bound to as a result
+ * of calling {@link #bindTo} method.
+ */
+ private _bindToCollection?;
+ /**
+ * A helper mapping external items of a bound collection ({@link #bindTo})
+ * and actual items of this collection. It provides information
+ * necessary to properly remove items bound to another collection.
+ *
+ * See {@link #_bindToInternalToExternalMap}.
+ */
+ private readonly _bindToExternalToInternalMap;
+ /**
+ * A helper mapping items of this collection to external items of a bound collection
+ * ({@link #bindTo}). It provides information necessary to manage the bindings, e.g.
+ * to avoid loops in two–way bindings.
+ *
+ * See {@link #_bindToExternalToInternalMap}.
+ */
+ private readonly _bindToInternalToExternalMap;
+ /**
+ * Stores indexes of skipped items from bound external collection.
+ */
+ private _skippedIndexesFromExternal;
+ /**
+ * Creates a new Collection instance.
+ *
+ * You can pass a configuration object as the argument of the constructor:
+ *
+ * ```ts
+ * const emptyCollection = new Collection<{ name: string }>( { idProperty: 'name' } );
+ * emptyCollection.add( { name: 'John' } );
+ * console.log( collection.get( 'John' ) ); // -> { name: 'John' }
+ * ```
+ *
+ * The collection is empty by default. You can add new items using the {@link #add} method:
+ *
+ * ```ts
+ * const collection = new Collection<{ id: string }>();
+ *
+ * collection.add( { id: 'John' } );
+ * console.log( collection.get( 0 ) ); // -> { id: 'John' }
+ * ```
+ *
+ * @label NO_ITEMS
+ * @param options The options object.
+ * @param options.idProperty The name of the property which is used to identify an item.
+ * Items that do not have such a property will be assigned one when added to the collection.
+ */
+ constructor(options?: {
+ readonly idProperty?: string;
+ });
+ /**
+ * Creates a new Collection instance with specified initial items.
+ *
+ * ```ts
+ * const collection = new Collection<{ id: string }>( [ { id: 'John' }, { id: 'Mike' } ] );
+ *
+ * console.log( collection.get( 0 ) ); // -> { id: 'John' }
+ * console.log( collection.get( 1 ) ); // -> { id: 'Mike' }
+ * console.log( collection.get( 'Mike' ) ); // -> { id: 'Mike' }
+ * ```
+ *
+ * You can always pass a configuration object as the last argument of the constructor:
+ *
+ * ```ts
+ * const nonEmptyCollection = new Collection<{ name: string }>( [ { name: 'John' } ], { idProperty: 'name' } );
+ * nonEmptyCollection.add( { name: 'George' } );
+ * console.log( collection.get( 'George' ) ); // -> { name: 'George' }
+ * console.log( collection.get( 'John' ) ); // -> { name: 'John' }
+ * ```
+ *
+ * @label INITIAL_ITEMS
+ * @param initialItems The initial items of the collection.
+ * @param options The options object.
+ * @param options.idProperty The name of the property which is used to identify an item.
+ * Items that do not have such a property will be assigned one when added to the collection.
+ */
+ constructor(initialItems: Iterable, options?: {
+ readonly idProperty?: string;
+ });
+ /**
+ * The number of items available in the collection.
+ */
+ get length(): number;
+ /**
+ * Returns the first item from the collection or null when collection is empty.
+ */
+ get first(): T | null;
+ /**
+ * Returns the last item from the collection or null when collection is empty.
+ */
+ get last(): T | null;
+ /**
+ * Adds an item into the collection.
+ *
+ * If the item does not have an id, then it will be automatically generated and set on the item.
+ *
+ * @param item
+ * @param index The position of the item in the collection. The item
+ * is pushed to the collection when `index` not specified.
+ * @fires add
+ * @fires change
+ */
+ add(item: T, index?: number): this;
+ /**
+ * Adds multiple items into the collection.
+ *
+ * Any item not containing an id will get an automatically generated one.
+ *
+ * @param items
+ * @param index The position of the insertion. Items will be appended if no `index` is specified.
+ * @fires add
+ * @fires change
+ */
+ addMany(items: Iterable, index?: number): this;
+ /**
+ * Gets an item by its ID or index.
+ *
+ * @param idOrIndex The item ID or index in the collection.
+ * @returns The requested item or `null` if such item does not exist.
+ */
+ get(idOrIndex: string | number): T | null;
+ /**
+ * Returns a Boolean indicating whether the collection contains an item.
+ *
+ * @param itemOrId The item or its ID in the collection.
+ * @returns `true` if the collection contains the item, `false` otherwise.
+ */
+ has(itemOrId: T | string): boolean;
+ /**
+ * Gets an index of an item in the collection.
+ * When an item is not defined in the collection, the index will equal -1.
+ *
+ * @param itemOrId The item or its ID in the collection.
+ * @returns The index of a given item.
+ */
+ getIndex(itemOrId: T | string): number;
+ /**
+ * Removes an item from the collection.
+ *
+ * @param subject The item to remove, its ID or index in the collection.
+ * @returns The removed item.
+ * @fires remove
+ * @fires change
+ */
+ remove(subject: T | number | string): T;
+ /**
+ * Executes the callback for each item in the collection and composes an array or values returned by this callback.
+ *
+ * @typeParam U The result type of the callback.
+ * @param callback
+ * @param ctx Context in which the `callback` will be called.
+ * @returns The result of mapping.
+ */
+ map(callback: (item: T, index: number) => U, ctx?: any): Array;
+ /**
+ * Performs the specified action for each item in the collection.
+ *
+ * @param ctx Context in which the `callback` will be called.
+ */
+ forEach(callback: (item: T, index: number) => unknown, ctx?: any): void;
+ /**
+ * Finds the first item in the collection for which the `callback` returns a true value.
+ *
+ * @param callback
+ * @param ctx Context in which the `callback` will be called.
+ * @returns The item for which `callback` returned a true value.
+ */
+ find(callback: (item: T, index: number) => boolean, ctx?: any): T | undefined;
+ /**
+ * Returns an array with items for which the `callback` returned a true value.
+ *
+ * @param callback
+ * @param ctx Context in which the `callback` will be called.
+ * @returns The array with matching items.
+ */
+ filter(callback: (item: T, index: number) => boolean, ctx?: any): Array;
+ /**
+ * Removes all items from the collection and destroys the binding created using
+ * {@link #bindTo}.
+ *
+ * @fires remove
+ * @fires change
+ */
+ clear(): void;
+ /**
+ * Binds and synchronizes the collection with another one.
+ *
+ * The binding can be a simple factory:
+ *
+ * ```ts
+ * class FactoryClass {
+ * public label: string;
+ *
+ * constructor( data: { label: string } ) {
+ * this.label = data.label;
+ * }
+ * }
+ *
+ * const source = new Collection<{ label: string }>( { idProperty: 'label' } );
+ * const target = new Collection();
+ *
+ * target.bindTo( source ).as( FactoryClass );
+ *
+ * source.add( { label: 'foo' } );
+ * source.add( { label: 'bar' } );
+ *
+ * console.log( target.length ); // 2
+ * console.log( target.get( 1 ).label ); // 'bar'
+ *
+ * source.remove( 0 );
+ * console.log( target.length ); // 1
+ * console.log( target.get( 0 ).label ); // 'bar'
+ * ```
+ *
+ * or the factory driven by a custom callback:
+ *
+ * ```ts
+ * class FooClass {
+ * public label: string;
+ *
+ * constructor( data: { label: string } ) {
+ * this.label = data.label;
+ * }
+ * }
+ *
+ * class BarClass {
+ * public label: string;
+ *
+ * constructor( data: { label: string } ) {
+ * this.label = data.label;
+ * }
+ * }
+ *
+ * const source = new Collection<{ label: string }>( { idProperty: 'label' } );
+ * const target = new Collection();
+ *
+ * target.bindTo( source ).using( ( item ) => {
+ * if ( item.label == 'foo' ) {
+ * return new FooClass( item );
+ * } else {
+ * return new BarClass( item );
+ * }
+ * } );
+ *
+ * source.add( { label: 'foo' } );
+ * source.add( { label: 'bar' } );
+ *
+ * console.log( target.length ); // 2
+ * console.log( target.get( 0 ) instanceof FooClass ); // true
+ * console.log( target.get( 1 ) instanceof BarClass ); // true
+ * ```
+ *
+ * or the factory out of property name:
+ *
+ * ```ts
+ * const source = new Collection<{ nested: { value: string } }>();
+ * const target = new Collection<{ value: string }>();
+ *
+ * target.bindTo( source ).using( 'nested' );
+ *
+ * source.add( { nested: { value: 'foo' } } );
+ * source.add( { nested: { value: 'bar' } } );
+ *
+ * console.log( target.length ); // 2
+ * console.log( target.get( 0 ).value ); // 'foo'
+ * console.log( target.get( 1 ).value ); // 'bar'
+ * ```
+ *
+ * It's possible to skip specified items by returning null value:
+ *
+ * ```ts
+ * const source = new Collection<{ hidden: boolean }>();
+ * const target = new Collection<{ hidden: boolean }>();
+ *
+ * target.bindTo( source ).using( item => {
+ * if ( item.hidden ) {
+ * return null;
+ * }
+ *
+ * return item;
+ * } );
+ *
+ * source.add( { hidden: true } );
+ * source.add( { hidden: false } );
+ *
+ * console.log( source.length ); // 2
+ * console.log( target.length ); // 1
+ * ```
+ *
+ * **Note**: {@link #clear} can be used to break the binding.
+ *
+ * @typeParam S The type of `externalCollection` element.
+ * @param externalCollection A collection to be bound.
+ * @returns The binding chain object.
+ */
+ bindTo>(externalCollection: Collection): CollectionBindToChain;
+ /**
+ * Finalizes and activates a binding initiated by {@link #bindTo}.
+ *
+ * @param factory A function which produces collection items.
+ */
+ private _setUpBindToBinding;
+ /**
+ * Returns an unique id property for a given `item`.
+ *
+ * The method will generate new id and assign it to the `item` if it doesn't have any.
+ *
+ * @param item Item to be added.
+ */
+ private _getItemIdBeforeAdding;
+ /**
+ * Core {@link #remove} method implementation shared in other functions.
+ *
+ * In contrast this method **does not** fire the {@link #event:change} event.
+ *
+ * @param subject The item to remove, its id or index in the collection.
+ * @returns Returns an array with the removed item and its index.
+ * @fires remove
+ */
+ private _remove;
+ /**
+ * Iterable interface.
+ */
+ [Symbol.iterator](): Iterator;
+}
+/**
+ * Fired when an item is added to the collection.
+ *
+ * @eventName ~Collection#add
+ * @param item The added item.
+ * @param index An index where the addition occurred.
+ */
+export type CollectionAddEvent = {
+ name: 'add';
+ args: [item: T, index: number];
+};
+/**
+ * Fired when the collection was changed due to adding or removing items.
+ *
+ * @eventName ~Collection#change
+ * @param data Changed items.
+ */
+export type CollectionChangeEvent