@ckeditor/ckeditor5-engine 38.1.1 → 38.2.0-alpha.1

package/src/model/item.d.ts

@@ -1,14 +1,14 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-import type Node from './node';
-import type TextProxy from './textproxy';
-/**
- * @module engine/model/item
- */
-/**
- * Item is a {@link module:engine/model/node~Node} or {@link module:engine/model/textproxy~TextProxy}.
- */
-type Item = Node | TextProxy;
-export default Item;
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+import type Node from './node.js';
+import type TextProxy from './textproxy.js';
+/**
+ * @module engine/model/item
+ */
+/**
+ * Item is a {@link module:engine/model/node~Node} or {@link module:engine/model/textproxy~TextProxy}.
+ */
+type Item = Node | TextProxy;
+export default Item;

package/src/model/item.js

@@ -1,5 +1,5 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-export {};
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+export {};

package/src/model/liveposition.d.ts

@@ -1,77 +1,77 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-/**
- * @module engine/model/liveposition
- */
-import Position, { type PositionOffset, type PositionStickiness } from './position';
-import type DocumentFragment from './documentfragment';
-import type Item from './item';
-import type RootElement from './rootelement';
-declare const LivePosition_base: import("@ckeditor/ckeditor5-utils").Mixed<typeof Position, import("@ckeditor/ckeditor5-utils").Emitter>;
-/**
- * `LivePosition` is a type of {@link module:engine/model/position~Position Position}
- * that updates itself as {@link module:engine/model/document~Document document}
- * is changed through operations. It may be used as a bookmark.
- *
- * **Note:** Contrary to {@link module:engine/model/position~Position}, `LivePosition` works only in roots that are
- * {@link module:engine/model/rootelement~RootElement}.
- * If {@link module:engine/model/documentfragment~DocumentFragment} is passed, error will be thrown.
- *
- * **Note:** Be very careful when dealing with `LivePosition`. Each `LivePosition` instance bind events that might
- * have to be unbound.
- * Use {@link module:engine/model/liveposition~LivePosition#detach} whenever you don't need `LivePosition` anymore.
- */
-export default class LivePosition extends LivePosition_base {
-    /**
-     * Root of the position path.
-     */
-    readonly root: RootElement;
-    /**
-     * Creates a live position.
-     *
-     * @see module:engine/model/position~Position
-     */
-    constructor(root: RootElement, path: Array<number>, stickiness?: PositionStickiness);
-    /**
-     * Unbinds all events previously bound by `LivePosition`. Use it whenever you don't need `LivePosition` instance
-     * anymore (i.e. when leaving scope in which it was declared or before re-assigning variable that was
-     * referring to it).
-     */
-    detach(): void;
-    /**
-     * Creates a {@link module:engine/model/position~Position position instance}, which is equal to this live position.
-     */
-    toPosition(): Position;
-    /**
-     * Creates a `LivePosition` instance that is equal to position.
-     */
-    static fromPosition(position: Position, stickiness?: PositionStickiness): LivePosition;
-    /**
-     * @internal
-     * @see module:engine/model/position~Position._createAfter
-     */
-    static readonly _createAfter: (item: Item | DocumentFragment, stickiness?: PositionStickiness) => LivePosition;
-    /**
-     * @internal
-     * @see module:engine/model/position~Position._createBefore
-     */
-    static readonly _createBefore: (item: Item | DocumentFragment, stickiness?: PositionStickiness) => LivePosition;
-    /**
-     * @internal
-     * @see module:engine/model/position~Position._createAt
-     */
-    static readonly _createAt: (itemOrPosition: Item | Position | DocumentFragment, offset?: PositionOffset, stickiness?: PositionStickiness) => LivePosition;
-}
-/**
- * Fired when `LivePosition` instance is changed due to changes on {@link module:engine/model/document~Document}.
- *
- * @eventName ~LivePosition#change
- * @param oldPosition Position equal to this live position before it got changed.
- */
-export type LivePositionChangeEvent = {
-    name: 'change';
-    args: [oldPosition: Position];
-};
-export {};
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module engine/model/liveposition
+ */
+import Position, { type PositionOffset, type PositionStickiness } from './position.js';
+import type DocumentFragment from './documentfragment.js';
+import type Item from './item.js';
+import type RootElement from './rootelement.js';
+declare const LivePosition_base: import("@ckeditor/ckeditor5-utils").Mixed<typeof Position, import("@ckeditor/ckeditor5-utils").Emitter>;
+/**
+ * `LivePosition` is a type of {@link module:engine/model/position~Position Position}
+ * that updates itself as {@link module:engine/model/document~Document document}
+ * is changed through operations. It may be used as a bookmark.
+ *
+ * **Note:** Contrary to {@link module:engine/model/position~Position}, `LivePosition` works only in roots that are
+ * {@link module:engine/model/rootelement~RootElement}.
+ * If {@link module:engine/model/documentfragment~DocumentFragment} is passed, error will be thrown.
+ *
+ * **Note:** Be very careful when dealing with `LivePosition`. Each `LivePosition` instance bind events that might
+ * have to be unbound.
+ * Use {@link module:engine/model/liveposition~LivePosition#detach} whenever you don't need `LivePosition` anymore.
+ */
+export default class LivePosition extends LivePosition_base {
+    /**
+     * Root of the position path.
+     */
+    readonly root: RootElement;
+    /**
+     * Creates a live position.
+     *
+     * @see module:engine/model/position~Position
+     */
+    constructor(root: RootElement, path: Array<number>, stickiness?: PositionStickiness);
+    /**
+     * Unbinds all events previously bound by `LivePosition`. Use it whenever you don't need `LivePosition` instance
+     * anymore (i.e. when leaving scope in which it was declared or before re-assigning variable that was
+     * referring to it).
+     */
+    detach(): void;
+    /**
+     * Creates a {@link module:engine/model/position~Position position instance}, which is equal to this live position.
+     */
+    toPosition(): Position;
+    /**
+     * Creates a `LivePosition` instance that is equal to position.
+     */
+    static fromPosition(position: Position, stickiness?: PositionStickiness): LivePosition;
+    /**
+     * @internal
+     * @see module:engine/model/position~Position._createAfter
+     */
+    static readonly _createAfter: (item: Item | DocumentFragment, stickiness?: PositionStickiness) => LivePosition;
+    /**
+     * @internal
+     * @see module:engine/model/position~Position._createBefore
+     */
+    static readonly _createBefore: (item: Item | DocumentFragment, stickiness?: PositionStickiness) => LivePosition;
+    /**
+     * @internal
+     * @see module:engine/model/position~Position._createAt
+     */
+    static readonly _createAt: (itemOrPosition: Item | Position | DocumentFragment, offset?: PositionOffset, stickiness?: PositionStickiness) => LivePosition;
+}
+/**
+ * Fired when `LivePosition` instance is changed due to changes on {@link module:engine/model/document~Document}.
+ *
+ * @eventName ~LivePosition#change
+ * @param oldPosition Position equal to this live position before it got changed.
+ */
+export type LivePositionChangeEvent = {
+    name: 'change';
+    args: [oldPosition: Position];
+};
+export {};

package/src/model/liveposition.js

@@ -1,93 +1,93 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-/**
- * @module engine/model/liveposition
- */
-import Position from './position';
-import { CKEditorError, EmitterMixin } from '@ckeditor/ckeditor5-utils';
-/**
- * `LivePosition` is a type of {@link module:engine/model/position~Position Position}
- * that updates itself as {@link module:engine/model/document~Document document}
- * is changed through operations. It may be used as a bookmark.
- *
- * **Note:** Contrary to {@link module:engine/model/position~Position}, `LivePosition` works only in roots that are
- * {@link module:engine/model/rootelement~RootElement}.
- * If {@link module:engine/model/documentfragment~DocumentFragment} is passed, error will be thrown.
- *
- * **Note:** Be very careful when dealing with `LivePosition`. Each `LivePosition` instance bind events that might
- * have to be unbound.
- * Use {@link module:engine/model/liveposition~LivePosition#detach} whenever you don't need `LivePosition` anymore.
- */
-export default class LivePosition extends EmitterMixin(Position) {
-    /**
-     * Creates a live position.
-     *
-     * @see module:engine/model/position~Position
-     */
-    constructor(root, path, stickiness = 'toNone') {
-        super(root, path, stickiness);
-        if (!this.root.is('rootElement')) {
-            /**
-             * LivePosition's root has to be an instance of RootElement.
-             *
-             * @error model-liveposition-root-not-rootelement
-             */
-            throw new CKEditorError('model-liveposition-root-not-rootelement', root);
-        }
-        bindWithDocument.call(this);
-    }
-    /**
-     * Unbinds all events previously bound by `LivePosition`. Use it whenever you don't need `LivePosition` instance
-     * anymore (i.e. when leaving scope in which it was declared or before re-assigning variable that was
-     * referring to it).
-     */
-    detach() {
-        this.stopListening();
-    }
-    /**
-     * Creates a {@link module:engine/model/position~Position position instance}, which is equal to this live position.
-     */
-    toPosition() {
-        return new Position(this.root, this.path.slice(), this.stickiness);
-    }
-    /**
-     * Creates a `LivePosition` instance that is equal to position.
-     */
-    static fromPosition(position, stickiness) {
-        return new this(position.root, position.path.slice(), stickiness ? stickiness : position.stickiness);
-    }
-}
-// The magic of type inference using `is` method is centralized in `TypeCheckable` class.
-// Proper overload would interfere with that.
-LivePosition.prototype.is = function (type) {
-    return type === 'livePosition' || type === 'model:livePosition' ||
-        // From super.is(). This is highly utilised method and cannot call super. See ckeditor/ckeditor5#6529.
-        type == 'position' || type === 'model:position';
-};
-/**
- * Binds this `LivePosition` to the {@link module:engine/model/document~Document document} that owns
- * this position's {@link module:engine/model/position~Position#root root}.
- */
-function bindWithDocument() {
-    this.listenTo(this.root.document.model, 'applyOperation', (event, args) => {
-        const operation = args[0];
-        if (!operation.isDocumentOperation) {
-            return;
-        }
-        transform.call(this, operation);
-    }, { priority: 'low' });
-}
-/**
- * Updates this position accordingly to the updates applied to the model. Bases on change events.
- */
-function transform(operation) {
-    const result = this.getTransformedByOperation(operation);
-    if (!this.isEqual(result)) {
-        const oldPosition = this.toPosition();
-        this.path = result.path;
-        this.root = result.root;
-        this.fire('change', oldPosition);
-    }
-}
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module engine/model/liveposition
+ */
+import Position from './position.js';
+import { CKEditorError, EmitterMixin } from '@ckeditor/ckeditor5-utils';
+/**
+ * `LivePosition` is a type of {@link module:engine/model/position~Position Position}
+ * that updates itself as {@link module:engine/model/document~Document document}
+ * is changed through operations. It may be used as a bookmark.
+ *
+ * **Note:** Contrary to {@link module:engine/model/position~Position}, `LivePosition` works only in roots that are
+ * {@link module:engine/model/rootelement~RootElement}.
+ * If {@link module:engine/model/documentfragment~DocumentFragment} is passed, error will be thrown.
+ *
+ * **Note:** Be very careful when dealing with `LivePosition`. Each `LivePosition` instance bind events that might
+ * have to be unbound.
+ * Use {@link module:engine/model/liveposition~LivePosition#detach} whenever you don't need `LivePosition` anymore.
+ */
+export default class LivePosition extends EmitterMixin(Position) {
+    /**
+     * Creates a live position.
+     *
+     * @see module:engine/model/position~Position
+     */
+    constructor(root, path, stickiness = 'toNone') {
+        super(root, path, stickiness);
+        if (!this.root.is('rootElement')) {
+            /**
+             * LivePosition's root has to be an instance of RootElement.
+             *
+             * @error model-liveposition-root-not-rootelement
+             */
+            throw new CKEditorError('model-liveposition-root-not-rootelement', root);
+        }
+        bindWithDocument.call(this);
+    }
+    /**
+     * Unbinds all events previously bound by `LivePosition`. Use it whenever you don't need `LivePosition` instance
+     * anymore (i.e. when leaving scope in which it was declared or before re-assigning variable that was
+     * referring to it).
+     */
+    detach() {
+        this.stopListening();
+    }
+    /**
+     * Creates a {@link module:engine/model/position~Position position instance}, which is equal to this live position.
+     */
+    toPosition() {
+        return new Position(this.root, this.path.slice(), this.stickiness);
+    }
+    /**
+     * Creates a `LivePosition` instance that is equal to position.
+     */
+    static fromPosition(position, stickiness) {
+        return new this(position.root, position.path.slice(), stickiness ? stickiness : position.stickiness);
+    }
+}
+// The magic of type inference using `is` method is centralized in `TypeCheckable` class.
+// Proper overload would interfere with that.
+LivePosition.prototype.is = function (type) {
+    return type === 'livePosition' || type === 'model:livePosition' ||
+        // From super.is(). This is highly utilised method and cannot call super. See ckeditor/ckeditor5#6529.
+        type == 'position' || type === 'model:position';
+};
+/**
+ * Binds this `LivePosition` to the {@link module:engine/model/document~Document document} that owns
+ * this position's {@link module:engine/model/position~Position#root root}.
+ */
+function bindWithDocument() {
+    this.listenTo(this.root.document.model, 'applyOperation', (event, args) => {
+        const operation = args[0];
+        if (!operation.isDocumentOperation) {
+            return;
+        }
+        transform.call(this, operation);
+    }, { priority: 'low' });
+}
+/**
+ * Updates this position accordingly to the updates applied to the model. Bases on change events.
+ */
+function transform(operation) {
+    const result = this.getTransformedByOperation(operation);
+    if (!this.isEqual(result)) {
+        const oldPosition = this.toPosition();
+        this.path = result.path;
+        this.root = result.root;
+        this.fire('change', oldPosition);
+    }
+}

package/src/model/liverange.d.ts

@@ -1,102 +1,102 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-/**
- * @module engine/model/liverange
- */
-import Range from './range';
-import type DocumentFragment from './documentfragment';
-import type Element from './element';
-import type Item from './item';
-import type Position from './position';
-declare const LiveRange_base: import("@ckeditor/ckeditor5-utils").Mixed<typeof Range, import("@ckeditor/ckeditor5-utils").Emitter>;
-/**
- * `LiveRange` is a type of {@link module:engine/model/range~Range Range}
- * that updates itself as {@link module:engine/model/document~Document document}
- * is changed through operations. It may be used as a bookmark.
- *
- * **Note:** Be very careful when dealing with `LiveRange`. Each `LiveRange` instance bind events that might
- * have to be unbound. Use {@link module:engine/model/liverange~LiveRange#detach detach} whenever you don't need `LiveRange` anymore.
- */
-export default class LiveRange extends LiveRange_base {
-    /**
-     * Creates a live range.
-     *
-     * @see module:engine/model/range~Range
-     */
-    constructor(start: Position, end?: Position | null);
-    /**
-     * Unbinds all events previously bound by `LiveRange`. Use it whenever you don't need `LiveRange` instance
-     * anymore (i.e. when leaving scope in which it was declared or before re-assigning variable that was
-     * referring to it).
-     */
-    detach(): void;
-    /**
-     * Creates a {@link module:engine/model/range~Range range instance} that is equal to this live range.
-     */
-    toRange(): Range;
-    /**
-     * Creates a `LiveRange` instance that is equal to the given range.
-     */
-    static fromRange(range: Range): LiveRange;
-    /**
-     * @see module:engine/model/range~Range._createIn
-     * @internal
-     */
-    static readonly _createIn: (element: Element | DocumentFragment) => LiveRange;
-    /**
-     * @see module:engine/model/range~Range._createOn
-     * @internal
-     */
-    static readonly _createOn: (element: Item | DocumentFragment) => LiveRange;
-    /**
-     * @see module:engine/model/range~Range._createFromPositionAndShift
-     * @internal
-     */
-    static readonly _createFromPositionAndShift: (position: Position, shift: number) => LiveRange;
-}
-/**
- * Fired when `LiveRange` instance boundaries have changed due to changes in the
- * {@link module:engine/model/document~Document document}.
- *
- * @eventName ~LiveRange#change:range
- * @param oldRange Range with start and end position equal to start and end position of this live
- * range before it got changed.
- * @param data Object with additional information about the change.
- * @param data.deletionPosition Source position for remove and merge changes.
- * Available if the range was moved to the graveyard root, `null` otherwise.
- */
-export type LiveRangeChangeRangeEvent = {
-    name: 'change' | 'change:range';
-    args: [range: Range, data: {
-        deletionPosition: Position | null;
-    }];
-};
-/**
- * Fired when `LiveRange` instance boundaries have not changed after a change in {@link module:engine/model/document~Document document}
- * but the change took place inside the range, effectively changing its content.
- *
- * @eventName ~LiveRange#change:content
- * @param range Range with start and end position equal to start and end position of
- * change range.
- * @param data Object with additional information about the change.
- * @param data.deletionPosition Due to the nature of this event, this property is always set to `null`. It is passed
- * for compatibility with the {@link module:engine/model/liverange~LiveRange#event:change:range} event.
- */
-export type LiveRangeChangeContentEvent = {
-    name: 'change' | 'change:content';
-    args: [range: Range, data: {
-        deletionPosition: null;
-    }];
-};
-/**
- * Describes `change:range` or `change:content` event.
- */
-export type LiveRangeChangeEvent = {
-    name: 'change' | 'change:range' | 'change:content';
-    args: [range: Range, data: {
-        deletionPosition: Position | null;
-    }];
-};
-export {};
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module engine/model/liverange
+ */
+import Range from './range.js';
+import type DocumentFragment from './documentfragment.js';
+import type Element from './element.js';
+import type Item from './item.js';
+import type Position from './position.js';
+declare const LiveRange_base: import("@ckeditor/ckeditor5-utils").Mixed<typeof Range, import("@ckeditor/ckeditor5-utils").Emitter>;
+/**
+ * `LiveRange` is a type of {@link module:engine/model/range~Range Range}
+ * that updates itself as {@link module:engine/model/document~Document document}
+ * is changed through operations. It may be used as a bookmark.
+ *
+ * **Note:** Be very careful when dealing with `LiveRange`. Each `LiveRange` instance bind events that might
+ * have to be unbound. Use {@link module:engine/model/liverange~LiveRange#detach detach} whenever you don't need `LiveRange` anymore.
+ */
+export default class LiveRange extends LiveRange_base {
+    /**
+     * Creates a live range.
+     *
+     * @see module:engine/model/range~Range
+     */
+    constructor(start: Position, end?: Position | null);
+    /**
+     * Unbinds all events previously bound by `LiveRange`. Use it whenever you don't need `LiveRange` instance
+     * anymore (i.e. when leaving scope in which it was declared or before re-assigning variable that was
+     * referring to it).
+     */
+    detach(): void;
+    /**
+     * Creates a {@link module:engine/model/range~Range range instance} that is equal to this live range.
+     */
+    toRange(): Range;
+    /**
+     * Creates a `LiveRange` instance that is equal to the given range.
+     */
+    static fromRange(range: Range): LiveRange;
+    /**
+     * @see module:engine/model/range~Range._createIn
+     * @internal
+     */
+    static readonly _createIn: (element: Element | DocumentFragment) => LiveRange;
+    /**
+     * @see module:engine/model/range~Range._createOn
+     * @internal
+     */
+    static readonly _createOn: (element: Item | DocumentFragment) => LiveRange;
+    /**
+     * @see module:engine/model/range~Range._createFromPositionAndShift
+     * @internal
+     */
+    static readonly _createFromPositionAndShift: (position: Position, shift: number) => LiveRange;
+}
+/**
+ * Fired when `LiveRange` instance boundaries have changed due to changes in the
+ * {@link module:engine/model/document~Document document}.
+ *
+ * @eventName ~LiveRange#change:range
+ * @param oldRange Range with start and end position equal to start and end position of this live
+ * range before it got changed.
+ * @param data Object with additional information about the change.
+ * @param data.deletionPosition Source position for remove and merge changes.
+ * Available if the range was moved to the graveyard root, `null` otherwise.
+ */
+export type LiveRangeChangeRangeEvent = {
+    name: 'change' | 'change:range';
+    args: [range: Range, data: {
+        deletionPosition: Position | null;
+    }];
+};
+/**
+ * Fired when `LiveRange` instance boundaries have not changed after a change in {@link module:engine/model/document~Document document}
+ * but the change took place inside the range, effectively changing its content.
+ *
+ * @eventName ~LiveRange#change:content
+ * @param range Range with start and end position equal to start and end position of
+ * change range.
+ * @param data Object with additional information about the change.
+ * @param data.deletionPosition Due to the nature of this event, this property is always set to `null`. It is passed
+ * for compatibility with the {@link module:engine/model/liverange~LiveRange#event:change:range} event.
+ */
+export type LiveRangeChangeContentEvent = {
+    name: 'change' | 'change:content';
+    args: [range: Range, data: {
+        deletionPosition: null;
+    }];
+};
+/**
+ * Describes `change:range` or `change:content` event.
+ */
+export type LiveRangeChangeEvent = {
+    name: 'change' | 'change:range' | 'change:content';
+    args: [range: Range, data: {
+        deletionPosition: Position | null;
+    }];
+};
+export {};