@ckeditor/ckeditor5-utils 40.0.0 → 40.2.0

package/src/diff.js

@@ -1,115 +1,115 @@
-/**
- * @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 utils/diff
- */
-import fastDiff from './fastdiff';
-// The following code is based on the "O(NP) Sequence Comparison Algorithm"
-// by Sun Wu, Udi Manber, Gene Myers, Webb Miller.
-/**
- * Calculates the difference between two arrays or strings producing an array containing a list of changes
- * necessary to transform input into output.
- *
- * ```ts
- * diff( 'aba', 'acca' ); // [ 'equal', 'insert', 'insert', 'delete', 'equal' ]
- * ```
- *
- * This function is based on the "O(NP) Sequence Comparison Algorithm" by Sun Wu, Udi Manber, Gene Myers, Webb Miller.
- * Unfortunately, while it gives the most precise results, its to complex for longer strings/arrow (above 200 items).
- * Therefore, `diff()` automatically switches to {@link module:utils/fastdiff~fastDiff `fastDiff()`} when detecting
- * such a scenario. The return formats of both functions are identical.
- *
- * @param a Input array or string.
- * @param b Output array or string.
- * @param cmp Optional function used to compare array values, by default === is used.
- * @returns Array of changes.
- */
-export default function diff(a, b, cmp) {
-    // Set the comparator function.
-    cmp = cmp || function (a, b) {
-        return a === b;
-    };
-    const aLength = a.length;
-    const bLength = b.length;
-    // Perform `fastDiff` for longer strings/arrays (see #269).
-    if (aLength > 200 || bLength > 200 || aLength + bLength > 300) {
-        return diff.fastDiff(a, b, cmp, true);
-    }
-    // Temporary action type statics.
-    let _insert, _delete;
-    // Swapped the arrays to use the shorter one as the first one.
-    if (bLength < aLength) {
-        const tmp = a;
-        a = b;
-        b = tmp;
-        // We swap the action types as well.
-        _insert = 'delete';
-        _delete = 'insert';
-    }
-    else {
-        _insert = 'insert';
-        _delete = 'delete';
-    }
-    const m = a.length;
-    const n = b.length;
-    const delta = n - m;
-    // Edit scripts, for each diagonal.
-    const es = {};
-    // Furthest points, the furthest y we can get on each diagonal.
-    const fp = {};
-    function snake(k) {
-        // We use -1 as an alternative below to handle initial values ( instead of filling the fp with -1 first ).
-        // Furthest points (y) on the diagonal below k.
-        const y1 = (fp[k - 1] !== undefined ? fp[k - 1] : -1) + 1;
-        // Furthest points (y) on the diagonal above k.
-        const y2 = fp[k + 1] !== undefined ? fp[k + 1] : -1;
-        // The way we should go to get further.
-        const dir = y1 > y2 ? -1 : 1;
-        // Clone previous changes array (if any).
-        if (es[k + dir]) {
-            es[k] = es[k + dir].slice(0);
-        }
-        // Create changes array.
-        if (!es[k]) {
-            es[k] = [];
-        }
-        // Push the action.
-        es[k].push(y1 > y2 ? _insert : _delete);
-        // Set the beginning coordinates.
-        let y = Math.max(y1, y2);
-        let x = y - k;
-        // Traverse the diagonal as long as the values match.
-        while (x < m && y < n && cmp(a[x], b[y])) {
-            x++;
-            y++;
-            // Push no change action.
-            es[k].push('equal');
-        }
-        return y;
-    }
-    let p = 0;
-    let k;
-    // Traverse the graph until we reach the end of the longer string.
-    do {
-        // Updates furthest points and edit scripts for diagonals below delta.
-        for (k = -p; k < delta; k++) {
-            fp[k] = snake(k);
-        }
-        // Updates furthest points and edit scripts for diagonals above delta.
-        for (k = delta + p; k > delta; k--) {
-            fp[k] = snake(k);
-        }
-        // Updates furthest point and edit script for the delta diagonal.
-        // note that the delta diagonal is the one which goes through the sink (m, n).
-        fp[delta] = snake(delta);
-        p++;
-    } while (fp[delta] !== n);
-    // Return the final list of edit changes.
-    // We remove the first item that represents the action for the injected nulls.
-    return es[delta].slice(1);
-}
-// Store the API in static property to easily overwrite it in tests.
-// Too bad dependency injection does not work in Webpack + ES 6 (const) + Babel.
-diff.fastDiff = fastDiff;
+/**
+ * @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 utils/diff
+ */
+import fastDiff from './fastdiff';
+// The following code is based on the "O(NP) Sequence Comparison Algorithm"
+// by Sun Wu, Udi Manber, Gene Myers, Webb Miller.
+/**
+ * Calculates the difference between two arrays or strings producing an array containing a list of changes
+ * necessary to transform input into output.
+ *
+ * ```ts
+ * diff( 'aba', 'acca' ); // [ 'equal', 'insert', 'insert', 'delete', 'equal' ]
+ * ```
+ *
+ * This function is based on the "O(NP) Sequence Comparison Algorithm" by Sun Wu, Udi Manber, Gene Myers, Webb Miller.
+ * Unfortunately, while it gives the most precise results, its to complex for longer strings/arrow (above 200 items).
+ * Therefore, `diff()` automatically switches to {@link module:utils/fastdiff~fastDiff `fastDiff()`} when detecting
+ * such a scenario. The return formats of both functions are identical.
+ *
+ * @param a Input array or string.
+ * @param b Output array or string.
+ * @param cmp Optional function used to compare array values, by default === is used.
+ * @returns Array of changes.
+ */
+export default function diff(a, b, cmp) {
+    // Set the comparator function.
+    cmp = cmp || function (a, b) {
+        return a === b;
+    };
+    const aLength = a.length;
+    const bLength = b.length;
+    // Perform `fastDiff` for longer strings/arrays (see #269).
+    if (aLength > 200 || bLength > 200 || aLength + bLength > 300) {
+        return diff.fastDiff(a, b, cmp, true);
+    }
+    // Temporary action type statics.
+    let _insert, _delete;
+    // Swapped the arrays to use the shorter one as the first one.
+    if (bLength < aLength) {
+        const tmp = a;
+        a = b;
+        b = tmp;
+        // We swap the action types as well.
+        _insert = 'delete';
+        _delete = 'insert';
+    }
+    else {
+        _insert = 'insert';
+        _delete = 'delete';
+    }
+    const m = a.length;
+    const n = b.length;
+    const delta = n - m;
+    // Edit scripts, for each diagonal.
+    const es = {};
+    // Furthest points, the furthest y we can get on each diagonal.
+    const fp = {};
+    function snake(k) {
+        // We use -1 as an alternative below to handle initial values ( instead of filling the fp with -1 first ).
+        // Furthest points (y) on the diagonal below k.
+        const y1 = (fp[k - 1] !== undefined ? fp[k - 1] : -1) + 1;
+        // Furthest points (y) on the diagonal above k.
+        const y2 = fp[k + 1] !== undefined ? fp[k + 1] : -1;
+        // The way we should go to get further.
+        const dir = y1 > y2 ? -1 : 1;
+        // Clone previous changes array (if any).
+        if (es[k + dir]) {
+            es[k] = es[k + dir].slice(0);
+        }
+        // Create changes array.
+        if (!es[k]) {
+            es[k] = [];
+        }
+        // Push the action.
+        es[k].push(y1 > y2 ? _insert : _delete);
+        // Set the beginning coordinates.
+        let y = Math.max(y1, y2);
+        let x = y - k;
+        // Traverse the diagonal as long as the values match.
+        while (x < m && y < n && cmp(a[x], b[y])) {
+            x++;
+            y++;
+            // Push no change action.
+            es[k].push('equal');
+        }
+        return y;
+    }
+    let p = 0;
+    let k;
+    // Traverse the graph until we reach the end of the longer string.
+    do {
+        // Updates furthest points and edit scripts for diagonals below delta.
+        for (k = -p; k < delta; k++) {
+            fp[k] = snake(k);
+        }
+        // Updates furthest points and edit scripts for diagonals above delta.
+        for (k = delta + p; k > delta; k--) {
+            fp[k] = snake(k);
+        }
+        // Updates furthest point and edit script for the delta diagonal.
+        // note that the delta diagonal is the one which goes through the sink (m, n).
+        fp[delta] = snake(delta);
+        p++;
+    } while (fp[delta] !== n);
+    // Return the final list of edit changes.
+    // We remove the first item that represents the action for the injected nulls.
+    return es[delta].slice(1);
+}
+// Store the API in static property to easily overwrite it in tests.
+// Too bad dependency injection does not work in Webpack + ES 6 (const) + Babel.
+diff.fastDiff = fastDiff;

package/src/difftochanges.d.ts

@@ -1,59 +1,59 @@
-/**
- * @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 { DiffResult } from './diff';
-/**
- * @module utils/difftochanges
- */
-/**
- * Creates a set of changes which need to be applied to the input in order to transform
- * it into the output. This function can be used with strings or arrays.
- *
- * ```ts
- * const input = Array.from( 'abc' );
- * const output = Array.from( 'xaby' );
- * const changes = diffToChanges( diff( input, output ), output );
- *
- * changes.forEach( change => {
- * 	if ( change.type == 'insert' ) {
- * 		input.splice( change.index, 0, ...change.values );
- * 	} else if ( change.type == 'delete' ) {
- * 		input.splice( change.index, change.howMany );
- * 	}
- * } );
- *
- * input.join( '' ) == output.join( '' ); // -> true
- * ```
- *
- * @typeParam T The type of output array element.
- * @param diff Result of {@link module:utils/diff~diff}.
- * @param output The string or array which was passed as diff's output.
- * @returns Set of changes (insert or delete) which need to be applied to the input
- * in order to transform it into the output.
- */
-export default function diffToChanges<T>(diff: ReadonlyArray<DiffResult>, output: ArrayLike<T>): Array<Change<T>>;
-/**
- * An object describing insertion change.
- *
- * @typeParam T The type of output array element.
- */
-export interface InsertChange<T> {
-    type: 'insert';
-    index: number;
-    values: Array<T>;
-}
-/**
- * An object describing deletion change.
- */
-export interface DeleteChange {
-    type: 'delete';
-    index: number;
-    howMany: number;
-}
-/**
- * The element of the result of {@link module:utils/difftochanges~diffToChanges} function.
- *
- * @typeParam T The type of output array element.
- */
-export type Change<T> = InsertChange<T> | DeleteChange;
+/**
+ * @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 { DiffResult } from './diff';
+/**
+ * @module utils/difftochanges
+ */
+/**
+ * Creates a set of changes which need to be applied to the input in order to transform
+ * it into the output. This function can be used with strings or arrays.
+ *
+ * ```ts
+ * const input = Array.from( 'abc' );
+ * const output = Array.from( 'xaby' );
+ * const changes = diffToChanges( diff( input, output ), output );
+ *
+ * changes.forEach( change => {
+ * 	if ( change.type == 'insert' ) {
+ * 		input.splice( change.index, 0, ...change.values );
+ * 	} else if ( change.type == 'delete' ) {
+ * 		input.splice( change.index, change.howMany );
+ * 	}
+ * } );
+ *
+ * input.join( '' ) == output.join( '' ); // -> true
+ * ```
+ *
+ * @typeParam T The type of output array element.
+ * @param diff Result of {@link module:utils/diff~diff}.
+ * @param output The string or array which was passed as diff's output.
+ * @returns Set of changes (insert or delete) which need to be applied to the input
+ * in order to transform it into the output.
+ */
+export default function diffToChanges<T>(diff: ReadonlyArray<DiffResult>, output: ArrayLike<T>): Array<Change<T>>;
+/**
+ * An object describing insertion change.
+ *
+ * @typeParam T The type of output array element.
+ */
+export interface InsertChange<T> {
+    type: 'insert';
+    index: number;
+    values: Array<T>;
+}
+/**
+ * An object describing deletion change.
+ */
+export interface DeleteChange {
+    type: 'delete';
+    index: number;
+    howMany: number;
+}
+/**
+ * The element of the result of {@link module:utils/difftochanges~diffToChanges} function.
+ *
+ * @typeParam T The type of output array element.
+ */
+export type Change<T> = InsertChange<T> | DeleteChange;

package/src/difftochanges.js

@@ -1,79 +1,79 @@
-/**
- * @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 utils/difftochanges
- */
-/**
- * Creates a set of changes which need to be applied to the input in order to transform
- * it into the output. This function can be used with strings or arrays.
- *
- * ```ts
- * const input = Array.from( 'abc' );
- * const output = Array.from( 'xaby' );
- * const changes = diffToChanges( diff( input, output ), output );
- *
- * changes.forEach( change => {
- * 	if ( change.type == 'insert' ) {
- * 		input.splice( change.index, 0, ...change.values );
- * 	} else if ( change.type == 'delete' ) {
- * 		input.splice( change.index, change.howMany );
- * 	}
- * } );
- *
- * input.join( '' ) == output.join( '' ); // -> true
- * ```
- *
- * @typeParam T The type of output array element.
- * @param diff Result of {@link module:utils/diff~diff}.
- * @param output The string or array which was passed as diff's output.
- * @returns Set of changes (insert or delete) which need to be applied to the input
- * in order to transform it into the output.
- */
-export default function diffToChanges(diff, output) {
-    const changes = [];
-    let index = 0;
-    let lastOperation = null;
-    diff.forEach(change => {
-        if (change == 'equal') {
-            pushLast();
-            index++;
-        }
-        else if (change == 'insert') {
-            if (lastOperation && lastOperation.type == 'insert') {
-                lastOperation.values.push(output[index]);
-            }
-            else {
-                pushLast();
-                lastOperation = {
-                    type: 'insert',
-                    index,
-                    values: [output[index]]
-                };
-            }
-            index++;
-        }
-        else /* if ( change == 'delete' ) */ {
-            if (lastOperation && lastOperation.type == 'delete') {
-                lastOperation.howMany++;
-            }
-            else {
-                pushLast();
-                lastOperation = {
-                    type: 'delete',
-                    index,
-                    howMany: 1
-                };
-            }
-        }
-    });
-    pushLast();
-    return changes;
-    function pushLast() {
-        if (lastOperation) {
-            changes.push(lastOperation);
-            lastOperation = null;
-        }
-    }
-}
+/**
+ * @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 utils/difftochanges
+ */
+/**
+ * Creates a set of changes which need to be applied to the input in order to transform
+ * it into the output. This function can be used with strings or arrays.
+ *
+ * ```ts
+ * const input = Array.from( 'abc' );
+ * const output = Array.from( 'xaby' );
+ * const changes = diffToChanges( diff( input, output ), output );
+ *
+ * changes.forEach( change => {
+ * 	if ( change.type == 'insert' ) {
+ * 		input.splice( change.index, 0, ...change.values );
+ * 	} else if ( change.type == 'delete' ) {
+ * 		input.splice( change.index, change.howMany );
+ * 	}
+ * } );
+ *
+ * input.join( '' ) == output.join( '' ); // -> true
+ * ```
+ *
+ * @typeParam T The type of output array element.
+ * @param diff Result of {@link module:utils/diff~diff}.
+ * @param output The string or array which was passed as diff's output.
+ * @returns Set of changes (insert or delete) which need to be applied to the input
+ * in order to transform it into the output.
+ */
+export default function diffToChanges(diff, output) {
+    const changes = [];
+    let index = 0;
+    let lastOperation = null;
+    diff.forEach(change => {
+        if (change == 'equal') {
+            pushLast();
+            index++;
+        }
+        else if (change == 'insert') {
+            if (lastOperation && lastOperation.type == 'insert') {
+                lastOperation.values.push(output[index]);
+            }
+            else {
+                pushLast();
+                lastOperation = {
+                    type: 'insert',
+                    index,
+                    values: [output[index]]
+                };
+            }
+            index++;
+        }
+        else /* if ( change == 'delete' ) */ {
+            if (lastOperation && lastOperation.type == 'delete') {
+                lastOperation.howMany++;
+            }
+            else {
+                pushLast();
+                lastOperation = {
+                    type: 'delete',
+                    index,
+                    howMany: 1
+                };
+            }
+        }
+    });
+    pushLast();
+    return changes;
+    function pushLast() {
+        if (lastOperation) {
+            changes.push(lastOperation);
+            lastOperation = null;
+        }
+    }
+}

package/src/dom/createelement.d.ts

@@ -1,57 +1,57 @@
-/**
- * @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
- */
-/**
- * Attributes to be applied to the HTML element.
- */
-type HTMLElementAttributes = {
-    readonly [key: string]: string;
-};
-/**
- * Attributes to be applied to the SVG element.
- */
-type SVGElementAttributes = HTMLElementAttributes & {
-    xmlns: string;
-};
-/**
- * Element or elements that will be added to the created element as children. Strings will be automatically turned into Text nodes.
- */
-type ChildrenElements = Node | string | Iterable<Node | string>;
-/**
- * Creates an HTML element with attributes and children elements.
- *
- * ```ts
- * createElement( document, 'p' ); // <p>
- * createElement( document, 'p', { class: 'foo' } ); // <p class="foo">
- * createElement( document, 'p', null, 'foo' ); // <p>foo</p>
- * createElement( document, 'p', null, [ createElement(...) ] ); // <p><...></p>
- * ```
- *
- * @label HTML_ELEMENT
- * @param doc Document used to create the element.
- * @param name Name of the HTML element.
- * @param attributes Object where keys represent attribute keys and values represent attribute values.
- * @param children Child or any iterable of children. Strings will be automatically turned into Text nodes.
- * @returns HTML element.
- */
-export default function createElement<T extends keyof HTMLElementTagNameMap>(doc: Document, name: T, attributes?: HTMLElementAttributes, children?: ChildrenElements): HTMLElementTagNameMap[T];
-/**
- * Creates an SVG element with attributes and children elements.
- *
- * ```ts
- * createElement( document, 'mask', { xmlns: 'http://www.w3.org/2000/svg' } ); // <mask>
- * createElement( document, 'mask', { xmlns: 'http://www.w3.org/2000/svg', id: 'foo' } ); // <mask id="foo">
- * createElement( document, 'mask', { xmlns: 'http://www.w3.org/2000/svg' }, 'foo' ); // <mask>foo</mask>
- * createElement( document, 'mask', { xmlns: 'http://www.w3.org/2000/svg' }, [ createElement(...) ] ); // <mask><...></mask>
- * ```
- *
- * @label SVG_ELEMENT
- * @param doc Document used to create the element.
- * @param name Name of the SVG element.
- * @param attributes Object where keys represent attribute keys and values represent attribute values.
- * @param children Child or any iterable of children. Strings will be automatically turned into Text nodes.
- * @returns SVG element.
- */
-export default function createElement<T extends keyof SVGElementTagNameMap>(doc: Document, name: T, attributes: SVGElementAttributes, children?: ChildrenElements): SVGElementTagNameMap[T];
-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
+ */
+/**
+ * Attributes to be applied to the HTML element.
+ */
+type HTMLElementAttributes = {
+    readonly [key: string]: string;
+};
+/**
+ * Attributes to be applied to the SVG element.
+ */
+type SVGElementAttributes = HTMLElementAttributes & {
+    xmlns: string;
+};
+/**
+ * Element or elements that will be added to the created element as children. Strings will be automatically turned into Text nodes.
+ */
+type ChildrenElements = Node | string | Iterable<Node | string>;
+/**
+ * Creates an SVG element with attributes and children elements.
+ *
+ * ```ts
+ * createElement( document, 'mask', { xmlns: 'http://www.w3.org/2000/svg' } ); // <mask>
+ * createElement( document, 'mask', { xmlns: 'http://www.w3.org/2000/svg', id: 'foo' } ); // <mask id="foo">
+ * createElement( document, 'mask', { xmlns: 'http://www.w3.org/2000/svg' }, 'foo' ); // <mask>foo</mask>
+ * createElement( document, 'mask', { xmlns: 'http://www.w3.org/2000/svg' }, [ createElement(...) ] ); // <mask><...></mask>
+ * ```
+ *
+ * @label SVG_ELEMENT
+ * @param doc Document used to create the element.
+ * @param name Name of the SVG element.
+ * @param attributes Object where keys represent attribute keys and values represent attribute values.
+ * @param children Child or any iterable of children. Strings will be automatically turned into Text nodes.
+ * @returns SVG element.
+ */
+export default function createElement<T extends keyof SVGElementTagNameMap>(doc: Document, name: T, attributes: SVGElementAttributes, children?: ChildrenElements): SVGElementTagNameMap[T];
+/**
+ * Creates an HTML element with attributes and children elements.
+ *
+ * ```ts
+ * createElement( document, 'p' ); // <p>
+ * createElement( document, 'p', { class: 'foo' } ); // <p class="foo">
+ * createElement( document, 'p', null, 'foo' ); // <p>foo</p>
+ * createElement( document, 'p', null, [ createElement(...) ] ); // <p><...></p>
+ * ```
+ *
+ * @label HTML_ELEMENT
+ * @param doc Document used to create the element.
+ * @param name Name of the HTML element.
+ * @param attributes Object where keys represent attribute keys and values represent attribute values.
+ * @param children Child or any iterable of children. Strings will be automatically turned into Text nodes.
+ * @returns HTML element.
+ */
+export default function createElement<T extends keyof HTMLElementTagNameMap>(doc: Document, name: T, attributes?: HTMLElementAttributes, children?: ChildrenElements): HTMLElementTagNameMap[T];
+export {};