@ckeditor/ckeditor5-utils 47.6.1 → 48.0.0-alpha.0

package/src/comparearrays.js

@@ -1,47 +0,0 @@
-/**
- * @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 utils/comparearrays
- */
-/**
- * Compares how given arrays relate to each other. One array can be: same as another array, prefix of another array
- * or completely different. If arrays are different, first index at which they differ is returned. Otherwise,
- * a flag specifying the relation is returned. Flags are negative numbers, so whenever a number >= 0 is returned
- * it means that arrays differ.
- *
- * ```ts
- * compareArrays( [ 0, 2 ], [ 0, 2 ] );		// 'same'
- * compareArrays( [ 0, 2 ], [ 0, 2, 1 ] );		// 'prefix'
- * compareArrays( [ 0, 2 ], [ 0 ] );			// 'extension'
- * compareArrays( [ 0, 2 ], [ 1, 2 ] );		// 0
- * compareArrays( [ 0, 2 ], [ 0, 1 ] );		// 1
- * ```
- *
- * @param a Array that is compared.
- * @param b Array to compare with.
- * @returns How array `a` is related to `b`.
- */
-export function compareArrays(a, b) {
-    const minLen = Math.min(a.length, b.length);
-    for (let i = 0; i < minLen; i++) {
-        if (a[i] != b[i]) {
-            // The arrays are different.
-            return i;
-        }
-    }
-    // Both arrays were same at all points.
-    if (a.length == b.length) {
-        // If their length is also same, they are the same.
-        return 'same';
-    }
-    else if (a.length < b.length) {
-        // Compared array is shorter so it is a prefix of the other array.
-        return 'prefix';
-    }
-    else {
-        // Compared array is longer so it is an extension of the other array.
-        return 'extension';
-    }
-}

package/src/config.js

@@ -1,167 +0,0 @@
-/**
- * @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 utils/config
- */
-import { isPlainObject, isElement, cloneDeepWith } from 'es-toolkit/compat';
-/**
- * Handles a configuration dictionary.
- *
- * @typeParam Cfg A type of the configuration dictionary.
- */
-export class Config {
-    /**
-     * Store for the whole configuration.
-     */
-    _config;
-    /**
-     * Creates an instance of the {@link ~Config} class.
-     *
-     * @param configurations The initial configurations to be set. Usually, provided by the user.
-     * @param defaultConfigurations The default configurations. Usually, provided by the system.
-     */
-    constructor(configurations, defaultConfigurations) {
-        this._config = Object.create(null);
-        // Set default configuration.
-        if (defaultConfigurations) {
-            // Clone the configuration to make sure that the properties will not be shared
-            // between editors and make the watchdog feature work correctly.
-            this.define(cloneConfig(defaultConfigurations));
-        }
-        // Set initial configuration.
-        if (configurations) {
-            this._setObjectToTarget(this._config, configurations);
-        }
-    }
-    set(name, value) {
-        this._setToTarget(this._config, name, value);
-    }
-    define(name, value) {
-        const isDefine = true;
-        this._setToTarget(this._config, name, value, isDefine);
-    }
-    /**
-     * Gets the value for a configuration entry.
-     *
-     * ```ts
-     * config.get( 'name' );
-     * ```
-     *
-     * Deep configurations can be retrieved by separating each part with a dot.
-     *
-     * ```ts
-     * config.get( 'toolbar.collapsed' );
-     * ```
-     *
-     * @param name The configuration name. Configuration names are case-sensitive.
-     * @returns The configuration value or `undefined` if the configuration entry was not found.
-     */
-    get(name) {
-        return this._getFromSource(this._config, name);
-    }
-    /**
-     * Iterates over all top level configuration names.
-     */
-    *names() {
-        for (const name of Object.keys(this._config)) {
-            yield name;
-        }
-    }
-    /**
-     * Saves passed configuration to the specified target (nested object).
-     *
-     * @param target Nested config object.
-     * @param name The configuration name or an object from which take properties as
-     * configuration entries. Configuration names are case-sensitive.
-     * @param value The configuration value. Used if a name is passed.
-     * @param isDefine Define if passed configuration should overwrite existing one.
-     */
-    _setToTarget(target, name, value, isDefine = false) {
-        // In case of an object, iterate through it and call `_setToTarget` again for each property.
-        if (isPlainObject(name)) {
-            this._setObjectToTarget(target, name, isDefine);
-            return;
-        }
-        // The configuration name should be split into parts if it has dots. E.g. `resize.width` -> [`resize`, `width`].
-        const parts = name.split('.');
-        // Take the name of the configuration out of the parts. E.g. `resize.width` -> `width`.
-        name = parts.pop();
-        // Iterate over parts to check if currently stored configuration has proper structure.
-        for (const part of parts) {
-            // If there is no object for specified part then create one.
-            if (!isPlainObject(target[part])) {
-                target[part] = Object.create(null);
-            }
-            // Nested object becomes a target.
-            target = target[part];
-        }
-        // In case of value is an object.
-        if (isPlainObject(value)) {
-            // We take care of proper config structure.
-            if (!isPlainObject(target[name])) {
-                target[name] = Object.create(null);
-            }
-            target = target[name];
-            // And iterate through this object calling `_setToTarget` again for each property.
-            this._setObjectToTarget(target, value, isDefine);
-            return;
-        }
-        // Do nothing if we are defining configuration for non empty name.
-        if (isDefine && typeof target[name] != 'undefined') {
-            return;
-        }
-        target[name] = value;
-    }
-    /**
-     * Get specified configuration from specified source (nested object).
-     *
-     * @param source level of nested object.
-     * @param name The configuration name. Configuration names are case-sensitive.
-     * @returns The configuration value or `undefined` if the configuration entry was not found.
-     */
-    _getFromSource(source, name) {
-        // The configuration name should be split into parts if it has dots. E.g. `resize.width` -> [`resize`, `width`].
-        const parts = name.split('.');
-        // Take the name of the configuration out of the parts. E.g. `resize.width` -> `width`.
-        name = parts.pop();
-        // Iterate over parts to check if currently stored configuration has proper structure.
-        for (const part of parts) {
-            if (!isPlainObject(source[part])) {
-                source = null;
-                break;
-            }
-            // Nested object becomes a source.
-            source = source[part];
-        }
-        // Always returns undefined for non existing configuration.
-        return source ? cloneConfig(source[name]) : undefined;
-    }
-    /**
-     * Iterates through passed object and calls {@link #_setToTarget} method with object key and value for each property.
-     *
-     * @param target Nested config object.
-     * @param configuration Configuration data set
-     * @param isDefine Defines if passed configuration is default configuration or not.
-     */
-    _setObjectToTarget(target, configuration, isDefine) {
-        Object.keys(configuration).forEach(key => {
-            this._setToTarget(target, key, configuration[key], isDefine);
-        });
-    }
-}
-/**
- * Clones configuration object or value.
- */
-function cloneConfig(source) {
-    return cloneDeepWith(source, leaveItemReferences);
-}
-/**
- * A customized function for cloneDeepWith.
- * In case if it's a DOM Element it will leave references to DOM Elements instead of cloning them.
- * If it's a function it will leave reference to actuall function.
- */
-function leaveItemReferences(value) {
-    return isElement(value) || typeof value === 'function' ? value : undefined;
-}

package/src/count.js

@@ -1,25 +0,0 @@
-/**
- * @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 utils/count
- */
-/**
- * Returns the number of items return by the iterator.
- *
- * ```ts
- * count( [ 1, 2, 3, 4, 5 ] ); // 5;
- * ```
- *
- * @param iterable Any iterable.
- * @returns Number of items returned by that iterable.
- */
-export function count(iterable) {
-    let count = 0;
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    for (const _ of iterable) {
-        count++;
-    }
-    return count;
-}

package/src/crc32.js

@@ -1,61 +0,0 @@
-/**
- * @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 utils/crc32
- */
-/**
- * Generates a CRC lookup table.
- * This function creates and returns a 256-element array of pre-computed CRC values for quick CRC calculation.
- * It uses the polynomial 0xEDB88320 to compute each value in the loop, optimizing future CRC calculations.
- */
-function makeCrcTable() {
-    const crcTable = [];
-    for (let n = 0; n < 256; n++) {
-        let c = n;
-        for (let k = 0; k < 8; k++) {
-            if (c & 1) {
-                c = 0xEDB88320 ^ (c >>> 1);
-            }
-            else {
-                c = c >>> 1;
-            }
-        }
-        crcTable[n] = c;
-    }
-    return crcTable;
-}
-/**
- * Calculates CRC-32 checksum for a given inputData to verify the integrity of data.
- *
- * @param inputData Accepts a single value (string, number, boolean), an array of strings, or an array of all of the above types.
- * Non-string values are converted to strings before calculating the checksum.
- * The checksum calculation is based on the concatenated string representation of the input values:
- * * `crc32('foo')` is equivalent to `crc32(['foo'])`
- * * `crc32(123)` is equivalent to `crc32(['123'])`
- * * `crc32(true)` is equivalent to `crc32(['true'])`
- * * `crc32(['foo', 123, true])` produces the same result as `crc32('foo123true')`
- * * Nested arrays of strings are flattened, so `crc32([['foo', 'bar'], 'baz'])` is equivalent to `crc32(['foobar', 'baz'])`
- *
- * @returns The CRC-32 checksum, returned as a hexadecimal string.
- */
-export function crc32(inputData) {
-    const dataArray = Array.isArray(inputData) ? inputData : [inputData];
-    const crcTable = makeCrcTable();
-    let crc = 0 ^ (-1);
-    // Convert data to a single string.
-    const dataString = dataArray.map(item => {
-        if (Array.isArray(item)) {
-            return item.join('');
-        }
-        return String(item);
-    }).join('');
-    // Calculate the CRC for the resulting string.
-    for (let i = 0; i < dataString.length; i++) {
-        const byte = dataString.charCodeAt(i);
-        crc = (crc >>> 8) ^ crcTable[(crc ^ byte) & 0xFF];
-    }
-    crc = (crc ^ (-1)) >>> 0; // Force unsigned integer.
-    return crc.toString(16).padStart(8, '0');
-}

package/src/decodelicensekey.js

@@ -1,30 +0,0 @@
-/**
- * @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 utils/decodelicensekey
-*/
-import { parseBase64EncodedObject } from './parsebase64encodedobject.js';
-/**
- * Parses the provided license key and returns the decoded object, or null if the decoding was unsuccessful.
- *
- * @param licenseKey The license key to decode.
- */
-export function decodeLicenseKey(licenseKey) {
-    if (!licenseKey) {
-        return null;
-    }
-    const encodedPayload = getLicenseKeyPayload(licenseKey);
-    if (!encodedPayload) {
-        return null;
-    }
-    return parseBase64EncodedObject(encodedPayload);
-}
-function getLicenseKeyPayload(licenseKey) {
-    const parts = licenseKey.split('.');
-    if (parts.length != 3) {
-        return null;
-    }
-    return parts[1];
-}

package/src/delay.js

@@ -1,25 +0,0 @@
-/**
- * @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 utils/delay
- */
-/**
- * Returns a function wrapper that will trigger a function after a specified wait time.
- * The timeout can be canceled by calling the cancel function on the returned wrapped function.
- *
- * @param func The function to wrap.
- * @param wait The timeout in ms.
- */
-export function delay(func, wait) {
-    let timer;
-    function delayed(...args) {
-        delayed.cancel();
-        timer = setTimeout(() => func(...args), wait);
-    }
-    delayed.cancel = () => {
-        clearTimeout(timer);
-    };
-    return delayed;
-}

package/src/diff.js

@@ -1,115 +0,0 @@
-/**
- * @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 utils/diff
- */
-import { fastDiff } from './fastdiff.js';
-// 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 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.js

@@ -1,79 +0,0 @@
-/**
- * @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 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 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.js

@@ -1,40 +0,0 @@
-/**
- * @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 utils/dom/createelement
- */
-import { isIterable } from '../isiterable.js';
-import { isString } from 'es-toolkit/compat';
-/**
- * Creates an HTML or SVG element with attributes and children elements.
- *
- * ```ts
- * createElement( document, 'p' ); // <p>
- * createElement( document, 'mask', { xmlns: 'http://www.w3.org/2000/svg' } ); // <mask>
- * ```
- *
- * @param doc Document used to create the element.
- * @param name Name of the 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 or SVG element.
- */
-export function createElement(doc, name, attributes = {}, children = []) {
-    const namespace = attributes && attributes.xmlns;
-    const element = namespace ? doc.createElementNS(namespace, name) : doc.createElement(name);
-    for (const key in attributes) {
-        element.setAttribute(key, attributes[key]);
-    }
-    if (isString(children) || !isIterable(children)) {
-        children = [children];
-    }
-    for (let child of children) {
-        if (isString(child)) {
-            child = doc.createTextNode(child);
-        }
-        element.appendChild(child);
-    }
-    return element;
-}