@ckeditor/ckeditor5-engine 48.2.0 → 48.3.0-alpha.0

package/dist/model/operation/splitoperation.d.ts

@@ -1,109 +1,109 @@
 /**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
 /**
- * @module engine/model/operation/splitoperation
- */
-import { Operation } from './operation.js';
-import { ModelPosition } from '../position.js';
-import { ModelRange } from '../range.js';
-import { type ModelDocument } from '../document.js';
-import type { ModelSelectable } from '../selection.js';
+* @module engine/model/operation/splitoperation
+*/
+import { Operation } from "./operation.js";
+import { ModelPosition } from "../position.js";
+import { ModelRange } from "../range.js";
+import { type ModelDocument } from "../document.js";
+import type { ModelSelectable } from "../selection.js";
 /**
- * Operation to split {@link module:engine/model/element~ModelElement an element} at given
- * {@link module:engine/model/operation/splitoperation~SplitOperation#splitPosition split position} into two elements,
- * both containing a part of the element's original content.
- */
+* Operation to split {@link module:engine/model/element~ModelElement an element} at given
+* {@link module:engine/model/operation/splitoperation~SplitOperation#splitPosition split position} into two elements,
+* both containing a part of the element's original content.
+*/
 export declare class SplitOperation extends Operation {
-    /**
-     * Position at which an element should be split.
-     */
-    splitPosition: ModelPosition;
-    /**
-     * Total offset size of elements that are in the split element after `position`.
-     */
-    howMany: number;
-    /**
-     * Position at which the clone of split element (or element from graveyard) will be inserted.
-     */
-    insertionPosition: ModelPosition;
-    /**
-     * Position in the graveyard root before the element which should be used as a parent of the nodes after `position`.
-     * If it is not set, a copy of the the `position` parent will be used.
-     *
-     * The default behavior is to clone the split element. Element from graveyard is used during undo.
-     */
-    graveyardPosition: ModelPosition | null;
-    /**
-     * Creates a split operation.
-     *
-     * @param splitPosition Position at which an element should be split.
-     * @param howMany Total offset size of elements that are in the split element after `position`.
-     * @param insertionPosition Position at which the clone of split element (or element from graveyard) will be inserted.
-     * @param graveyardPosition Position in the graveyard root before the element which
-     * should be used as a parent of the nodes after `position`. If it is not set, a copy of the the `position` parent will be used.
-     * @param baseVersion Document {@link module:engine/model/document~ModelDocument#version} on which operation
-     * can be applied or `null` if the operation operates on detached (non-document) tree.
-     */
-    constructor(splitPosition: ModelPosition, howMany: number, insertionPosition: ModelPosition, graveyardPosition: ModelPosition | null, baseVersion: number | null);
-    /**
-     * @inheritDoc
-     */
-    get type(): 'split';
-    /**
-     * Position inside the new clone of a split element.
-     *
-     * This is a position where nodes that are after the split position will be moved to.
-     */
-    get moveTargetPosition(): ModelPosition;
-    /**
-     * Artificial range that contains all the nodes from the split element that will be moved to the new element.
-     * The range starts at {@link #splitPosition} and ends in the same parent, at `POSITIVE_INFINITY` offset.
-     */
-    get movedRange(): ModelRange;
-    /**
-     * @inheritDoc
-     */
-    get affectedSelectable(): ModelSelectable;
-    /**
-     * Creates and returns an operation that has the same parameters as this operation.
-     *
-     * @returns Clone of this operation.
-     */
-    clone(): SplitOperation;
-    /**
-     * See {@link module:engine/model/operation/operation~Operation#getReversed `Operation#getReversed()`}.
-     */
-    getReversed(): Operation;
-    /**
-     * @inheritDoc
-     * @internal
-     */
-    _validate(): void;
-    /**
-     * @inheritDoc
-     * @internal
-     */
-    _execute(): void;
-    /**
-     * @inheritDoc
-     */
-    toJSON(): unknown;
-    /**
-     * @inheritDoc
-     */
-    static get className(): string;
-    /**
-     * Helper function that returns a default insertion position basing on given `splitPosition`. The default insertion
-     * position is after the split element.
-     */
-    static getInsertionPosition(splitPosition: ModelPosition): ModelPosition;
-    /**
-     * Creates `SplitOperation` object from deserialized object, i.e. from parsed JSON string.
-     *
-     * @param json Deserialized JSON object.
-     * @param document Document on which this operation will be applied.
-     */
-    static fromJSON(json: any, document: ModelDocument): SplitOperation;
+	/**
+	* Position at which an element should be split.
+	*/
+	splitPosition: ModelPosition;
+	/**
+	* Total offset size of elements that are in the split element after `position`.
+	*/
+	howMany: number;
+	/**
+	* Position at which the clone of split element (or element from graveyard) will be inserted.
+	*/
+	insertionPosition: ModelPosition;
+	/**
+	* Position in the graveyard root before the element which should be used as a parent of the nodes after `position`.
+	* If it is not set, a copy of the the `position` parent will be used.
+	*
+	* The default behavior is to clone the split element. Element from graveyard is used during undo.
+	*/
+	graveyardPosition: ModelPosition | null;
+	/**
+	* Creates a split operation.
+	*
+	* @param splitPosition Position at which an element should be split.
+	* @param howMany Total offset size of elements that are in the split element after `position`.
+	* @param insertionPosition Position at which the clone of split element (or element from graveyard) will be inserted.
+	* @param graveyardPosition Position in the graveyard root before the element which
+	* should be used as a parent of the nodes after `position`. If it is not set, a copy of the the `position` parent will be used.
+	* @param baseVersion Document {@link module:engine/model/document~ModelDocument#version} on which operation
+	* can be applied or `null` if the operation operates on detached (non-document) tree.
+	*/
+	constructor(splitPosition: ModelPosition, howMany: number, insertionPosition: ModelPosition, graveyardPosition: ModelPosition | null, baseVersion: number | null);
+	/**
+	* @inheritDoc
+	*/
+	get type(): "split";
+	/**
+	* Position inside the new clone of a split element.
+	*
+	* This is a position where nodes that are after the split position will be moved to.
+	*/
+	get moveTargetPosition(): ModelPosition;
+	/**
+	* Artificial range that contains all the nodes from the split element that will be moved to the new element.
+	* The range starts at {@link #splitPosition} and ends in the same parent, at `POSITIVE_INFINITY` offset.
+	*/
+	get movedRange(): ModelRange;
+	/**
+	* @inheritDoc
+	*/
+	get affectedSelectable(): ModelSelectable;
+	/**
+	* Creates and returns an operation that has the same parameters as this operation.
+	*
+	* @returns Clone of this operation.
+	*/
+	clone(): SplitOperation;
+	/**
+	* See {@link module:engine/model/operation/operation~Operation#getReversed `Operation#getReversed()`}.
+	*/
+	getReversed(): Operation;
+	/**
+	* @inheritDoc
+	* @internal
+	*/
+	override _validate(): void;
+	/**
+	* @inheritDoc
+	* @internal
+	*/
+	_execute(): void;
+	/**
+	* @inheritDoc
+	*/
+	override toJSON(): unknown;
+	/**
+	* @inheritDoc
+	*/
+	static override get className(): string;
+	/**
+	* Helper function that returns a default insertion position basing on given `splitPosition`. The default insertion
+	* position is after the split element.
+	*/
+	static getInsertionPosition(splitPosition: ModelPosition): ModelPosition;
+	/**
+	* Creates `SplitOperation` object from deserialized object, i.e. from parsed JSON string.
+	*
+	* @param json Deserialized JSON object.
+	* @param document Document on which this operation will be applied.
+	*/
+	static override fromJSON(json: any, document: ModelDocument): SplitOperation;
 }

package/dist/model/operation/transform.d.ts

@@ -1,103 +1,103 @@
 /**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-import { type Operation } from './operation.js';
-import { type ModelDocument } from '../document.js';
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+import { type Operation } from "./operation.js";
+import { type ModelDocument } from "../document.js";
 /**
- * Transforms operation `a` by operation `b`.
- *
- * @param a Operation to be transformed.
- * @param b Operation to transform by.
- * @param context Transformation context for this transformation.
- * @returns Transformation result.
- * @internal
- */
+* Transforms operation `a` by operation `b`.
+*
+* @param a Operation to be transformed.
+* @param b Operation to transform by.
+* @param context Transformation context for this transformation.
+* @returns Transformation result.
+* @internal
+*/
 export declare function transform(a: Operation, b: Operation, context?: TransformationContext): Array<Operation>;
 /**
- * Performs a transformation of two sets of operations - `operationsA` and `operationsB`. The transformation is two-way -
- * both transformed `operationsA` and transformed `operationsB` are returned.
- *
- * Note, that the first operation in each set should base on the same document state (
- * {@link module:engine/model/document~ModelDocument#version document version}).
- *
- * It is assumed that `operationsA` are "more important" during conflict resolution between two operations.
- *
- * New copies of both passed arrays and operations inside them are returned. Passed arguments are not altered.
- *
- * Base versions of the transformed operations sets are updated accordingly. For example, assume that base versions are `4`
- * and there are `3` operations in `operationsA` and `5` operations in `operationsB`. Then:
- *
- * * transformed `operationsA` will start from base version `9` (`4` base version + `5` operations B),
- * * transformed `operationsB` will start from base version `7` (`4` base version + `3` operations A).
- *
- * If no operation was broken into two during transformation, then both sets will end up with an operation that bases on version `11`:
- *
- * * transformed `operationsA` start from `9` and there are `3` of them, so the last will have `baseVersion` equal to `11`,
- * * transformed `operationsB` start from `7` and there are `5` of them, so the last will have `baseVersion` equal to `11`.
- *
- * @param operationsA
- * @param operationsB
- * @param options Additional transformation options.
- * @param options.document Document which the operations change.
- * @param options.useRelations Whether during transformation relations should be used (used during undo for better conflict resolution).
- * @param options.padWithNoOps Whether additional {@link module:engine/model/operation/nooperation~NoOperation}s
- * should be added to the transformation results to force the same last base version for both transformed sets (in case
- * if some operations got broken into multiple operations during transformation).
- * @param options.forceWeakRemove If set to `false`, remove operation will be always stronger than move operation,
- * so the removed nodes won't end up back in the document root. When set to `true`, context data will be used.
- * @returns Transformation result.
- */
+* Performs a transformation of two sets of operations - `operationsA` and `operationsB`. The transformation is two-way -
+* both transformed `operationsA` and transformed `operationsB` are returned.
+*
+* Note, that the first operation in each set should base on the same document state (
+* {@link module:engine/model/document~ModelDocument#version document version}).
+*
+* It is assumed that `operationsA` are "more important" during conflict resolution between two operations.
+*
+* New copies of both passed arrays and operations inside them are returned. Passed arguments are not altered.
+*
+* Base versions of the transformed operations sets are updated accordingly. For example, assume that base versions are `4`
+* and there are `3` operations in `operationsA` and `5` operations in `operationsB`. Then:
+*
+* * transformed `operationsA` will start from base version `9` (`4` base version + `5` operations B),
+* * transformed `operationsB` will start from base version `7` (`4` base version + `3` operations A).
+*
+* If no operation was broken into two during transformation, then both sets will end up with an operation that bases on version `11`:
+*
+* * transformed `operationsA` start from `9` and there are `3` of them, so the last will have `baseVersion` equal to `11`,
+* * transformed `operationsB` start from `7` and there are `5` of them, so the last will have `baseVersion` equal to `11`.
+*
+* @param operationsA
+* @param operationsB
+* @param options Additional transformation options.
+* @param options.document Document which the operations change.
+* @param options.useRelations Whether during transformation relations should be used (used during undo for better conflict resolution).
+* @param options.padWithNoOps Whether additional {@link module:engine/model/operation/nooperation~NoOperation}s
+* should be added to the transformation results to force the same last base version for both transformed sets (in case
+* if some operations got broken into multiple operations during transformation).
+* @param options.forceWeakRemove If set to `false`, remove operation will be always stronger than move operation,
+* so the removed nodes won't end up back in the document root. When set to `true`, context data will be used.
+* @returns Transformation result.
+*/
 export declare function transformOperationSets(operationsA: Array<Operation>, operationsB: Array<Operation>, options: {
-    document: ModelDocument;
-    useRelations?: boolean;
-    padWithNoOps?: boolean;
-    forceWeakRemove?: boolean;
+	document: ModelDocument;
+	useRelations?: boolean;
+	padWithNoOps?: boolean;
+	forceWeakRemove?: boolean;
 }): TransformOperationSetsResult;
 /**
- * The result of {@link module:engine/model/operation/transform~transformOperationSets}.
- */
+* The result of {@link module:engine/model/operation/transform~transformOperationSets}.
+*/
 export interface TransformOperationSetsResult {
-    /**
-     * Transformed `operationsA`.
-     */
-    operationsA: Array<Operation>;
-    /**
-     * Transformed `operationsB`.
-     */
-    operationsB: Array<Operation>;
-    /**
-     * A map that links transformed operations to original operations. The keys are the transformed
-     * operations and the values are the original operations from the input (`operationsA` and `operationsB`).
-     */
-    originalOperations: Map<Operation, Operation>;
+	/**
+	* Transformed `operationsA`.
+	*/
+	operationsA: Array<Operation>;
+	/**
+	* Transformed `operationsB`.
+	*/
+	operationsB: Array<Operation>;
+	/**
+	* A map that links transformed operations to original operations. The keys are the transformed
+	* operations and the values are the original operations from the input (`operationsA` and `operationsB`).
+	*/
+	originalOperations: Map<Operation, Operation>;
 }
 /**
- * Holds additional contextual information about a transformed pair of operations (`a` and `b`). Those information
- * can be used for better conflict resolving.
- *
- * @internal
- */
+* Holds additional contextual information about a transformed pair of operations (`a` and `b`). Those information
+* can be used for better conflict resolving.
+*
+* @internal
+*/
 export type TransformationContext = {
-    /**
-     * Whether `a` is strong operation in this transformation, or weak.
-     */
-    aIsStrong?: boolean;
-    /**
-     * Whether `a` operation was undone.
-     */
-    aWasUndone?: boolean;
-    /**
-     * Whether `b` operation was undone.
-     */
-    bWasUndone?: boolean;
-    /**
-     * The relation between `a` operation and an operation undone by `b` operation.
-     */
-    abRelation?: any;
-    /**
-     * The relation between `b` operation and an operation undone by `a` operation.
-     */
-    baRelation?: any;
-    forceWeakRemove?: boolean;
+	/**
+	* Whether `a` is strong operation in this transformation, or weak.
+	*/
+	aIsStrong?: boolean;
+	/**
+	* Whether `a` operation was undone.
+	*/
+	aWasUndone?: boolean;
+	/**
+	* Whether `b` operation was undone.
+	*/
+	bWasUndone?: boolean;
+	/**
+	* The relation between `a` operation and an operation undone by `b` operation.
+	*/
+	abRelation?: any;
+	/**
+	* The relation between `b` operation and an operation undone by `a` operation.
+	*/
+	baRelation?: any;
+	forceWeakRemove?: boolean;
 };

package/dist/model/operation/utils.d.ts

@@ -1,72 +1,72 @@
 /**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
 /**
- * @module engine/model/operation/utils
- */
-import { ModelNode } from '../node.js';
-import { ModelRange } from '../range.js';
-import { type ModelDocumentFragment } from '../documentfragment.js';
-import { type ModelItem } from '../item.js';
-import { type ModelNodeList } from '../nodelist.js';
-import { type ModelPosition } from '../position.js';
+* @module engine/model/operation/utils
+*/
+import { ModelNode } from "../node.js";
+import { ModelRange } from "../range.js";
+import { type ModelDocumentFragment } from "../documentfragment.js";
+import { type ModelItem } from "../item.js";
+import { type ModelNodeList } from "../nodelist.js";
+import { type ModelPosition } from "../position.js";
 /**
- * Inserts given nodes at given position.
- *
- * @internal
- * @param position Position at which nodes should be inserted.
- * @param nodes Nodes to insert.
- * @returns Range spanning over inserted elements.
- */
+* Inserts given nodes at given position.
+*
+* @internal
+* @param position Position at which nodes should be inserted.
+* @param nodes Nodes to insert.
+* @returns Range spanning over inserted elements.
+*/
 export declare function _insert(position: ModelPosition, nodes: ModelNodeSet): ModelRange;
 /**
- * Removed nodes in given range. Only {@link module:engine/model/range~ModelRange#isFlat flat} ranges are accepted.
- *
- * @internal
- * @param range Range containing nodes to remove.
- */
+* Removed nodes in given range. Only {@link module:engine/model/range~ModelRange#isFlat flat} ranges are accepted.
+*
+* @internal
+* @param range Range containing nodes to remove.
+*/
 export declare function _remove(this: any, range: ModelRange): Array<ModelNode>;
 /**
- * Moves nodes in given range to given target position. Only {@link module:engine/model/range~ModelRange#isFlat flat} ranges are accepted.
- *
- * @internal
- * @param sourceRange Range containing nodes to move.
- * @param targetPosition Position to which nodes should be moved.
- * @returns Range containing moved nodes.
- */
+* Moves nodes in given range to given target position. Only {@link module:engine/model/range~ModelRange#isFlat flat} ranges are accepted.
+*
+* @internal
+* @param sourceRange Range containing nodes to move.
+* @param targetPosition Position to which nodes should be moved.
+* @returns Range containing moved nodes.
+*/
 export declare function _move(this: any, sourceRange: ModelRange, targetPosition: ModelPosition): ModelRange;
 /**
- * Sets given attribute on nodes in given range. The attributes are only set on top-level nodes of the range, not on its children.
- *
- * @internal
- * @param range Range containing nodes that should have the attribute set. Must be a flat range.
- * @param key Key of attribute to set.
- * @param value Attribute value.
- */
+* Sets given attribute on nodes in given range. The attributes are only set on top-level nodes of the range, not on its children.
+*
+* @internal
+* @param range Range containing nodes that should have the attribute set. Must be a flat range.
+* @param key Key of attribute to set.
+* @param value Attribute value.
+*/
 export declare function _setAttribute(range: ModelRange, key: string, value: unknown): void;
 /**
- * Normalizes given object or an array of objects to an array of {@link module:engine/model/node~ModelNode nodes}. See
- * {@link ~ModelNodeSet NodeSet} for details on how normalization is performed.
- *
- * @internal
- * @param nodes Objects to normalize.
- * @returns Normalized nodes.
- */
+* Normalizes given object or an array of objects to an array of {@link module:engine/model/node~ModelNode nodes}. See
+* {@link ~ModelNodeSet NodeSet} for details on how normalization is performed.
+*
+* @internal
+* @param nodes Objects to normalize.
+* @returns Normalized nodes.
+*/
 export declare function _normalizeNodes(nodes: ModelNodeSet): Array<ModelNode>;
 /**
- * Value that can be normalized to an array of {@link module:engine/model/node~ModelNode nodes}.
- *
- * Non-arrays are normalized as follows:
- * * {@link module:engine/model/node~ModelNode Node} is left as is,
- * * {@link module:engine/model/textproxy~ModelTextProxy TextProxy} and `string` are normalized to
- * {@link module:engine/model/text~ModelText Text},
- * * {@link module:engine/model/nodelist~ModelNodeList NodeList} is normalized to an array containing all nodes that are in that node list,
- * * {@link module:engine/model/documentfragment~ModelDocumentFragment ModelDocumentFragment} is normalized to an array containing all of
- * it's children.
- *
- * Arrays are processed item by item like non-array values and flattened to one array. Normalization always results in
- * a flat array of {@link module:engine/model/node~ModelNode nodes}. Consecutive text nodes (or items normalized to text nodes) will be
- * merged if they have same attributes.
- */
+* Value that can be normalized to an array of {@link module:engine/model/node~ModelNode nodes}.
+*
+* Non-arrays are normalized as follows:
+* * {@link module:engine/model/node~ModelNode Node} is left as is,
+* * {@link module:engine/model/textproxy~ModelTextProxy TextProxy} and `string` are normalized to
+* {@link module:engine/model/text~ModelText Text},
+* * {@link module:engine/model/nodelist~ModelNodeList NodeList} is normalized to an array containing all nodes that are in that node list,
+* * {@link module:engine/model/documentfragment~ModelDocumentFragment ModelDocumentFragment} is normalized to an array containing all of
+* it's children.
+*
+* Arrays are processed item by item like non-array values and flattened to one array. Normalization always results in
+* a flat array of {@link module:engine/model/node~ModelNode nodes}. Consecutive text nodes (or items normalized to text nodes) will be
+* merged if they have same attributes.
+*/
 export type ModelNodeSet = ModelItem | string | ModelNodeList | ModelDocumentFragment | Iterable<ModelItem | string | ModelNodeList | ModelDocumentFragment>;