@ckeditor/ckeditor5-utils 0.0.0-internal-20241017.0

package/src/config.d.ts

@@ -0,0 +1,163 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * Handles a configuration dictionary.
+ *
+ * @typeParam Cfg A type of the configuration dictionary.
+ */
+export default class Config<Cfg> {
+    /**
+     * Store for the whole configuration.
+     */
+    private readonly _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?: Partial<Cfg>, defaultConfigurations?: Partial<Cfg>);
+    /**
+     * Set configuration values.
+     *
+     * It also accepts setting a "deep configuration" by using dots in the name. For example, `'resize.width'` sets
+     * the value for the `width` configuration in the `resize` subset.
+     *
+     * ```ts
+     * config.set( 'resize.width', 500 );
+     * ```
+     *
+     * It accepts both a name/value pair or an object, which properties and values will be used to set
+     * configurations. See {@link #set:CONFIG_OBJECT}.
+     *
+     * @label KEY_VALUE
+     * @param name The configuration name. Configuration names are case-sensitive.
+     * @param value The configuration value.
+     */
+    set<K extends string>(name: K, value: GetSubConfig<Cfg, K>): void;
+    /**
+     * Set configuration values.
+     *
+     * It accepts an object, which properties and values will be used to set configurations.
+     *
+     * ```ts
+     * config.set( {
+     * 	width: 500
+     * 	toolbar: {
+     * 		collapsed: true
+     * 	}
+     * } );
+     *
+     * // Equivalent to:
+     * config.set( 'width', 500 );
+     * config.set( 'toolbar.collapsed', true );
+     * ```
+     *
+     * Passing an object as the value will amend the configuration, not replace it.
+     *
+     * ```ts
+     * config.set( 'toolbar', {
+     * 	collapsed: true,
+     * } );
+     *
+     * config.set( 'toolbar', {
+     * 	color: 'red',
+     * } );
+     *
+     * config.get( 'toolbar.collapsed' ); // true
+     * config.get( 'toolbar.color' ); // 'red'
+     * ```
+     *
+     * It accepts both a name/value pair or an object, which properties and values will be used to set
+     * configurations. See {@link #set:KEY_VALUE}.
+     *
+     * @label CONFIG_OBJECT
+     * @param config The configuration object from which take properties as
+     * configuration entries. Configuration names are case-sensitive.
+     */
+    set(config: Partial<Cfg>): void;
+    /**
+     * Does exactly the same as {@link #set:KEY_VALUE} with one exception – passed configuration extends
+     * existing one, but does not overwrite already defined values.
+     *
+     * This method is supposed to be called by plugin developers to setup plugin's configurations. It would be
+     * rarely used for other needs.
+     *
+     * @label KEY_VALUE
+     * @param name The configuration name. Configuration names are case-sensitive.
+     * @param value The configuration value.
+     */
+    define<K extends string>(name: K, value: GetSubConfig<Cfg, K>): void;
+    /**
+     * Does exactly the same as {@link #set:CONFIG_OBJECT} with one exception – passed configuration extends
+     * existing one, but does not overwrite already defined values.
+     *
+     * This method is supposed to be called by plugin developers to setup plugin's configurations. It would be
+     * rarely used for other needs.
+     *
+     * @label CONFIG_OBJECT
+     * @param config The configuration object from which take properties as
+     * configuration entries. Configuration names are case-sensitive.
+     */
+    define(config: Partial<Cfg>): void;
+    /**
+     * 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<K extends string>(name: K): GetSubConfig<Cfg, K> | undefined;
+    /**
+     * Iterates over all top level configuration names.
+     */
+    names(): Iterable<string>;
+    /**
+     * 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.
+     */
+    private _setToTarget;
+    /**
+     * 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.
+     */
+    private _getFromSource;
+    /**
+     * 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.
+     */
+    private _setObjectToTarget;
+}
+/**
+ * An utility type excluding primitive values and arrays from the union.
+ */
+export type OnlyObject<T> = Exclude<T, undefined | null | string | number | boolean | Array<any>>;
+/**
+ * An utility type extracting configuration value from the given name.
+ *
+ * @typeParam T The type of a configuration dictionary.
+ * @typeParam K The literal type of configuration name (dot-separated path).
+ */
+export type GetSubConfig<T, K> = K extends keyof T ? T[K] : K extends `${infer K1}.${infer K2}` ? K1 extends keyof T ? GetSubConfig<OnlyObject<T[K1]>, K2> : unknown : unknown;

package/src/config.js

@@ -0,0 +1,163 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module utils/config
+ */
+import { isPlainObject, isElement, cloneDeepWith } from 'lodash-es';
+/**
+ * Handles a configuration dictionary.
+ *
+ * @typeParam Cfg A type of the configuration dictionary.
+ */
+export default class 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.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module 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 default function count(iterable: Iterable<unknown>): number;

package/src/count.js

@@ -0,0 +1,25 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module 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 default 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.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * 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 default function crc32(inputData: CRCData): string;
+/**
+ * The input data for the CRC-32 checksum calculation.
+ * Can be a single value (string, number, boolean), an array of strings, or an array of all of the above types.
+ */
+export type CRCData = CRCValue | Array<CRCValue>;
+type CRCValue = string | number | boolean | Array<string>;
+export {};

package/src/crc32.js

@@ -0,0 +1,61 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module utils/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 default 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/delay.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module utils/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 default function delay<T extends (...args: Array<any>) => any>(func: T, wait: number): DelayedFunc<T>;
+export interface DelayedFunc<T extends (...args: Array<any>) => any> {
+    (...args: Parameters<T>): void;
+    cancel(): void;
+}

package/src/delay.js

@@ -0,0 +1,26 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module utils/delay
+ */
+/* globals setTimeout, clearTimeout */
+/**
+ * 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 default 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.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * 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.
+ */
+declare function diff<T>(a: ArrayLike<T>, b: ArrayLike<T>, cmp?: (a: T, b: T) => boolean): Array<DiffResult>;
+declare namespace diff {
+    var fastDiff: typeof import("./fastdiff.js").default;
+}
+export default diff;
+/**
+ * The element of the result of {@link module:utils/diff~diff} function.
+ */
+export type DiffResult = 'equal' | 'insert' | 'delete';

package/src/diff.js

@@ -0,0 +1,115 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module utils/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 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;