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

package/src/fastdiff.js

@@ -1,248 +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/fastdiff
- */
-/**
- * Finds positions of the first and last change in the given string/array and generates a set of changes:
- *
- * ```ts
- * fastDiff( '12a', '12xyza' );
- * // [ { index: 2, type: 'insert', values: [ 'x', 'y', 'z' ] } ]
- *
- * fastDiff( '12a', '12aa' );
- * // [ { index: 3, type: 'insert', values: [ 'a' ] } ]
- *
- * fastDiff( '12xyza', '12a' );
- * // [ { index: 2, type: 'delete', howMany: 3 } ]
- *
- * fastDiff( [ '1', '2', 'a', 'a' ], [ '1', '2', 'a' ] );
- * // [ { index: 3, type: 'delete', howMany: 1 } ]
- *
- * fastDiff( [ '1', '2', 'a', 'b', 'c', '3' ], [ '2', 'a', 'b' ] );
- * // [ { index: 0, type: 'insert', values: [ '2', 'a', 'b' ] }, { index: 3, type: 'delete', howMany: 6 } ]
- * ```
- *
- * Passed arrays can contain any type of data, however to compare them correctly custom comparator function
- * should be passed as a third parameter:
- *
- * ```ts
- * fastDiff( [ { value: 1 }, { value: 2 } ], [ { value: 1 }, { value: 3 } ], ( a, b ) => {
- * 	return a.value === b.value;
- * } );
- * // [ { index: 1, type: 'insert', values: [ { value: 3 } ] }, { index: 2, type: 'delete', howMany: 1 } ]
- * ```
- *
- * The resulted set of changes can be applied to the input in order to transform it into the output, for example:
- *
- * ```ts
- * let input = '12abc3';
- * const output = '2ab';
- * const changes = fastDiff( input, output );
- *
- * changes.forEach( change => {
- * 	if ( change.type == 'insert' ) {
- * 		input = input.substring( 0, change.index ) + change.values.join( '' ) + input.substring( change.index );
- * 	} else if ( change.type == 'delete' ) {
- * 		input = input.substring( 0, change.index ) + input.substring( change.index + change.howMany );
- * 	}
- * } );
- *
- * // input equals output now
- * ```
- *
- * or in case of arrays:
- *
- * ```ts
- * let input = [ '1', '2', 'a', 'b', 'c', '3' ];
- * const output = [ '2', 'a', 'b' ];
- * const changes = fastDiff( input, output );
- *
- * changes.forEach( change => {
- * 	if ( change.type == 'insert' ) {
- * 		input = input.slice( 0, change.index ).concat( change.values, input.slice( change.index ) );
- * 	} else if ( change.type == 'delete' ) {
- * 		input = input.slice( 0, change.index ).concat( input.slice( change.index + change.howMany ) );
- * 	}
- * } );
- *
- * // input equals output now
- * ```
- *
- * By passing `true` as the fourth parameter (`atomicChanges`) the output of this function will become compatible with
- * the {@link module:utils/diff~diff `diff()`} function:
- *
- * ```ts
- * fastDiff( '12a', '12xyza', undefined, true );
- * // [ 'equal', 'equal', 'insert', 'insert', 'insert', 'equal' ]
- * ```
- *
- * The default output format of this function is compatible with the output format of
- * {@link module:utils/difftochanges~diffToChanges `diffToChanges()`}. The `diffToChanges()` input format is, in turn,
- * compatible with the output of {@link module:utils/diff~diff `diff()`}:
- *
- * ```ts
- * const a = '1234';
- * const b = '12xyz34';
- *
- * // Both calls will return the same results (grouped changes format).
- * fastDiff( a, b );
- * diffToChanges( diff( a, b ) );
- *
- * // Again, both calls will return the same results (atomic changes format).
- * fastDiff( a, b, undefined, true );
- * diff( a, b );
- * ```
- *
- * @typeParam T The type of array elements.
- * @typeParam AtomicChanges The type of `atomicChanges` parameter (selects the result type).
- * @param a Input array or string.
- * @param b Input array or string.
- * @param cmp Optional function used to compare array values, by default `===` (strict equal operator) is used.
- * @param atomicChanges Whether an array of `inset|delete|equal` operations should
- * be returned instead of changes set. This makes this function compatible with {@link module:utils/diff~diff `diff()`}.
- * Defaults to `false`.
- * @returns Array of changes. The elements are either {@link module:utils/diff~DiffResult} or {@link module:utils/difftochanges~Change},
- * depending on `atomicChanges` parameter.
- */
-export function fastDiff(a, b, cmp, atomicChanges) {
-    // Set the comparator function.
-    cmp = cmp || function (a, b) {
-        return a === b;
-    };
-    // Convert the string (or any array-like object - eg. NodeList) to an array by using the slice() method because,
-    // unlike Array.from(), it returns array of UTF-16 code units instead of the code points of a string.
-    // One code point might be a surrogate pair of two code units. All text offsets are expected to be in code units.
-    // See ckeditor/ckeditor5#3147.
-    //
-    // We need to make sure here that fastDiff() works identical to diff().
-    const arrayA = Array.isArray(a) ? a : Array.prototype.slice.call(a);
-    const arrayB = Array.isArray(b) ? b : Array.prototype.slice.call(b);
-    // Find first and last change.
-    const changeIndexes = findChangeBoundaryIndexes(arrayA, arrayB, cmp);
-    // Transform into changes array.
-    const result = atomicChanges ?
-        changeIndexesToAtomicChanges(changeIndexes, arrayB.length) :
-        changeIndexesToChanges(arrayB, changeIndexes);
-    return result;
-}
-/**
- * Finds position of the first and last change in the given arrays. For example:
- *
- * ```ts
- * const indexes = findChangeBoundaryIndexes( [ '1', '2', '3', '4' ], [ '1', '3', '4', '2', '4' ] );
- * console.log( indexes ); // { firstIndex: 1, lastIndexOld: 3, lastIndexNew: 4 }
- * ```
- *
- * The above indexes means that in the first array the modified part is `1[23]4` and in the second array it is `1[342]4`.
- * Based on such indexes, array with `insert`/`delete` operations which allows transforming first value into the second one
- * can be generated.
- */
-function findChangeBoundaryIndexes(arr1, arr2, cmp) {
-    // Find the first difference between passed values.
-    const firstIndex = findFirstDifferenceIndex(arr1, arr2, cmp);
-    // If arrays are equal return -1 indexes object.
-    if (firstIndex === -1) {
-        return { firstIndex: -1, lastIndexOld: -1, lastIndexNew: -1 };
-    }
-    // Remove the common part of each value and reverse them to make it simpler to find the last difference between them.
-    const oldArrayReversed = cutAndReverse(arr1, firstIndex);
-    const newArrayReversed = cutAndReverse(arr2, firstIndex);
-    // Find the first difference between reversed values.
-    // It should be treated as "how many elements from the end the last difference occurred".
-    //
-    // For example:
-    //
-    // 				initial	->	after cut	-> reversed:
-    // oldValue:	'321ba'	->	'21ba'		-> 'ab12'
-    // newValue:	'31xba'	->	'1xba'		-> 'abx1'
-    // lastIndex:							-> 2
-    //
-    // So the last change occurred two characters from the end of the arrays.
-    const lastIndex = findFirstDifferenceIndex(oldArrayReversed, newArrayReversed, cmp);
-    // Use `lastIndex` to calculate proper offset, starting from the beginning (`lastIndex` kind of starts from the end).
-    const lastIndexOld = arr1.length - lastIndex;
-    const lastIndexNew = arr2.length - lastIndex;
-    return { firstIndex, lastIndexOld, lastIndexNew };
-}
-/**
- * Returns a first index on which given arrays differ. If both arrays are the same, -1 is returned.
- */
-function findFirstDifferenceIndex(arr1, arr2, cmp) {
-    for (let i = 0; i < Math.max(arr1.length, arr2.length); i++) {
-        if (arr1[i] === undefined || arr2[i] === undefined || !cmp(arr1[i], arr2[i])) {
-            return i;
-        }
-    }
-    return -1; // Return -1 if arrays are equal.
-}
-/**
- * Returns a copy of the given array with `howMany` elements removed starting from the beginning and in reversed order.
- *
- * @param arr Array to be processed.
- * @param howMany How many elements from array beginning to remove.
- * @returns Shortened and reversed array.
- */
-function cutAndReverse(arr, howMany) {
-    return arr.slice(howMany).reverse();
-}
-/**
- * Generates changes array based on change indexes from `findChangeBoundaryIndexes` function. This function will
- * generate array with 0 (no changes), 1 (deletion or insertion) or 2 records (insertion and deletion).
- *
- * @param newArray New array for which change indexes were calculated.
- * @param changeIndexes Change indexes object from `findChangeBoundaryIndexes` function.
- * @returns Array of changes compatible with {@link module:utils/difftochanges~diffToChanges} format.
- */
-function changeIndexesToChanges(newArray, changeIndexes) {
-    const result = [];
-    const { firstIndex, lastIndexOld, lastIndexNew } = changeIndexes;
-    // Order operations as 'insert', 'delete' array to keep compatibility with {@link module:utils/difftochanges~diffToChanges}
-    // in most cases. However, 'diffToChanges' does not stick to any order so in some cases
-    // (for example replacing '12345' with 'abcd') it will generate 'delete', 'insert' order.
-    if (lastIndexNew - firstIndex > 0) {
-        result.push({
-            index: firstIndex,
-            type: 'insert',
-            values: newArray.slice(firstIndex, lastIndexNew)
-        });
-    }
-    if (lastIndexOld - firstIndex > 0) {
-        result.push({
-            index: firstIndex + (lastIndexNew - firstIndex), // Increase index of what was inserted.
-            type: 'delete',
-            howMany: lastIndexOld - firstIndex
-        });
-    }
-    return result;
-}
-/**
- * Generates array with set `equal|insert|delete` operations based on change indexes from `findChangeBoundaryIndexes` function.
- *
- * @param changeIndexes Change indexes object from `findChangeBoundaryIndexes` function.
- * @param newLength Length of the new array on which `findChangeBoundaryIndexes` calculated change indexes.
- * @returns Array of changes compatible with {@link module:utils/diff~diff} format.
- */
-function changeIndexesToAtomicChanges(changeIndexes, newLength) {
-    const { firstIndex, lastIndexOld, lastIndexNew } = changeIndexes;
-    // No changes.
-    if (firstIndex === -1) {
-        return Array(newLength).fill('equal');
-    }
-    let result = [];
-    if (firstIndex > 0) {
-        result = result.concat(Array(firstIndex).fill('equal'));
-    }
-    if (lastIndexNew - firstIndex > 0) {
-        result = result.concat(Array(lastIndexNew - firstIndex).fill('insert'));
-    }
-    if (lastIndexOld - firstIndex > 0) {
-        result = result.concat(Array(lastIndexOld - firstIndex).fill('delete'));
-    }
-    if (lastIndexNew < newLength) {
-        result = result.concat(Array(newLength - lastIndexNew).fill('equal'));
-    }
-    return result;
-}

package/src/first.js

@@ -1,17 +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/first
- */
-/**
- * Returns first item of the given `iterator`.
- */
-export function first(iterator) {
-    const iteratorItem = iterator.next();
-    if (iteratorItem.done) {
-        return null;
-    }
-    return iteratorItem.value;
-}

package/src/focustracker.js

@@ -1,329 +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/focustracker
- */
-import { DomEmitterMixin } from './dom/emittermixin.js';
-import { ObservableMixin } from './observablemixin.js';
-import { CKEditorError } from './ckeditorerror.js';
-import { isElement as _isElement } from 'es-toolkit/compat';
-/**
- * Allows observing a group of DOM `Element`s or {@link module:ui/view~View view instances} whether at least one of them (or their child)
- * is focused.
- *
- * Used by the {@link module:core/editor/editor~Editor} in order to track whether the focus is still within the application,
- * or were used outside of its UI.
- *
- * **Note** `focus` and `blur` listeners use event capturing, so it is only needed to register wrapper `Element`
- * which contain other `focusable` elements. But note that this wrapper element has to be focusable too
- * (have e.g. `tabindex="-1"`).
- *
- * Check out the {@glink framework/deep-dive/ui/focus-tracking "Deep dive into focus tracking"} guide to learn more.
- */
-export class FocusTracker extends /* #__PURE__ */ DomEmitterMixin(/* #__PURE__ */ ObservableMixin()) {
-    /**
-     * List of registered DOM elements.
-     *
-     * @internal
-     */
-    _elements = new Set();
-    /**
-     * List of views with external focus trackers that contribute to the state of this focus tracker.
-     *
-     * @internal
-     */
-    _externalViews = new Set();
-    /**
-     * Asynchronous blur event timeout.
-     */
-    _blurTimeout = null;
-    // @if CK_DEBUG_FOCUSTRACKER // public _label?: string;
-    constructor() {
-        super();
-        this.set('isFocused', false);
-        this.set('focusedElement', null);
-        // @if CK_DEBUG_FOCUSTRACKER // FocusTracker._instances.push( this );
-    }
-    /**
-     * List of registered DOM elements.
-     *
-     * **Note**: The list does do not include elements from {@link #externalViews}.
-     */
-    get elements() {
-        return Array.from(this._elements.values());
-    }
-    /**
-     * List of external focusable views that contribute to the state of this focus tracker. See {@link #add} to learn more.
-     */
-    get externalViews() {
-        return Array.from(this._externalViews.values());
-    }
-    /**
-     * Starts tracking a specified DOM element or a {@link module:ui/view~View} instance.
-     *
-     * * If a DOM element is passed, the focus tracker listens to the `focus` and `blur` events on this element.
-     * Tracked elements are listed in {@link #elements}.
-     * * If a {@link module:ui/view~View} instance is passed that has a `FocusTracker` instance ({@link ~ViewWithFocusTracker}),
-     * the external focus tracker's state ({@link #isFocused}, {@link #focusedElement}) starts contributing to the current tracker instance.
-     * This allows for increasing the "reach" of a focus tracker instance, by connecting two or more focus trackers together when DOM
-     * elements they track are located in different subtrees in DOM. External focus trackers are listed in {@link #externalViews}.
-     * * If a {@link module:ui/view~View} instance is passed that has no `FocusTracker` (**not** a {@link ~ViewWithFocusTracker}),
-     * its {@link module:ui/view~View#element} is used to track focus like any other DOM element.
-     */
-    add(elementOrView) {
-        if (isElement(elementOrView)) {
-            this._addElement(elementOrView);
-        }
-        else {
-            if (isViewWithFocusTracker(elementOrView)) {
-                this._addView(elementOrView);
-            }
-            else {
-                if (!elementOrView.element) {
-                    /**
-                     * The {@link module:ui/view~View} added to the {@link module:utils/focustracker~FocusTracker} does not have an
-                     * {@link module:ui/view~View#element}. Make sure the view is {@link module:ui/view~View#render} before adding
-                     * it to the focus tracker.
-                     *
-                     * @error focustracker-add-view-missing-element
-                     */
-                    throw new CKEditorError('focustracker-add-view-missing-element', {
-                        focusTracker: this,
-                        view: elementOrView
-                    });
-                }
-                this._addElement(elementOrView.element);
-            }
-        }
-    }
-    /**
-     * Stops tracking focus in the specified DOM element or a {@link module:ui/view~View view instance}. See {@link #add} to learn more.
-     */
-    remove(elementOrView) {
-        if (isElement(elementOrView)) {
-            this._removeElement(elementOrView);
-        }
-        else {
-            if (isViewWithFocusTracker(elementOrView)) {
-                this._removeView(elementOrView);
-            }
-            else {
-                // Assuming that if the view was successfully added, it must have come with an existing #element.
-                this._removeElement(elementOrView.element);
-            }
-        }
-    }
-    /**
-     * Adds a DOM element to the focus tracker and starts listening to the `focus` and `blur` events on it.
-     */
-    _addElement(element) {
-        if (this._elements.has(element)) {
-            /**
-             * This element is already tracked by {@link module:utils/focustracker~FocusTracker}.
-             *
-             * @error focustracker-add-element-already-exist
-             */
-            throw new CKEditorError('focustracker-add-element-already-exist', this);
-        }
-        this.listenTo(element, 'focus', () => {
-            // @if CK_DEBUG_FOCUSTRACKER // console.log( `"${ getName( this ) }": Focus with useCapture on DOM element` );
-            const externalFocusedViewInSubtree = this.externalViews.find(view => isExternalViewSubtreeFocused(element, view));
-            if (externalFocusedViewInSubtree) {
-                this._focus(externalFocusedViewInSubtree.element);
-            }
-            else {
-                this._focus(element);
-            }
-        }, { useCapture: true });
-        this.listenTo(element, 'blur', () => {
-            // @if CK_DEBUG_FOCUSTRACKER // console.log( `"${ getName( this ) }": Blur with useCapture on DOM element` );
-            this._blur();
-        }, { useCapture: true });
-        this._elements.add(element);
-    }
-    /**
-     * Removes a DOM element from the focus tracker.
-     */
-    _removeElement(element) {
-        if (this._elements.has(element)) {
-            this.stopListening(element);
-            this._elements.delete(element);
-        }
-        if (element === this.focusedElement) {
-            this._blur();
-        }
-    }
-    /**
-     * Adds an external {@link module:ui/view~View view instance} to this focus tracker and makes it contribute to this focus tracker's
-     * state either by its `View#element` or by its `View#focusTracker` instance.
-     */
-    _addView(view) {
-        if (view.element) {
-            this._addElement(view.element);
-        }
-        this.listenTo(view.focusTracker, 'change:focusedElement', () => {
-            // @if CK_DEBUG_FOCUSTRACKER // console.log(
-            // @if CK_DEBUG_FOCUSTRACKER // 	`"${ getName( this ) }": Related "${ getName( view.focusTracker ) }"#focusedElement = `,
-            // @if CK_DEBUG_FOCUSTRACKER // 	view.focusTracker.focusedElement
-            // @if CK_DEBUG_FOCUSTRACKER // );
-            if (view.focusTracker.focusedElement) {
-                if (view.element) {
-                    this._focus(view.element);
-                }
-            }
-            else {
-                this._blur();
-            }
-        });
-        this._externalViews.add(view);
-    }
-    /**
-     * Removes an external {@link module:ui/view~View view instance} from this focus tracker.
-     */
-    _removeView(view) {
-        if (view.element) {
-            this._removeElement(view.element);
-        }
-        this.stopListening(view.focusTracker);
-        this._externalViews.delete(view);
-    }
-    /**
-     * Destroys the focus tracker by:
-     * - Disabling all event listeners attached to tracked elements or external views.
-     * - Removing all tracked elements and views that were previously added.
-     */
-    destroy() {
-        this.stopListening();
-        this._elements.clear();
-        this._externalViews.clear();
-        this.isFocused = false;
-        this.focusedElement = null;
-    }
-    /**
-     * Stores currently focused element as {@link #focusedElement} and sets {@link #isFocused} `true`.
-     */
-    _focus(element) {
-        // @if CK_DEBUG_FOCUSTRACKER // console.log( `"${ getName( this ) }": _focus() on element`, element );
-        this._clearBlurTimeout();
-        this.focusedElement = element;
-        this.isFocused = true;
-    }
-    /**
-     * Clears currently {@link #focusedElement} and sets {@link #isFocused} `false`.
-     *
-     * This method uses `setTimeout()` to change order of `blur` and `focus` events calls, ensuring that moving focus between
-     * two elements within a single focus tracker's scope, will not cause `[ blurA, focusB ]` sequence but just `[ focusB ]`.
-     * The former would cause a momentary change of `#isFocused` to `false` which is not desired because any logic listening to
-     * a focus tracker state would experience UI flashes and glitches as the user focus travels across the UI.
-     */
-    _blur() {
-        const isAnyElementFocused = this.elements.find(element => element.contains(document.activeElement));
-        // Avoid blurs originating from external FTs when the focus still remains in one of the #elements.
-        if (isAnyElementFocused) {
-            return;
-        }
-        const isAnyExternalViewFocused = this.externalViews.find(view => {
-            // Do not consider external views's focus trackers as focused if there's a blur timeout pending.
-            return view.focusTracker.isFocused && !view.focusTracker._blurTimeout;
-        });
-        // Avoid unnecessary DOM blurs coming from #elements when the focus still remains in one of #externalViews.
-        if (isAnyExternalViewFocused) {
-            return;
-        }
-        this._clearBlurTimeout();
-        this._blurTimeout = setTimeout(() => {
-            // @if CK_DEBUG_FOCUSTRACKER // console.log( `"${ getName( this ) }": Blur.` );
-            this.focusedElement = null;
-            this.isFocused = false;
-        }, 0);
-    }
-    /**
-     * Clears the asynchronous blur event timeout on demand. See {@link #_blur} to learn more.
-     */
-    _clearBlurTimeout() {
-        clearTimeout(this._blurTimeout);
-        this._blurTimeout = null;
-    }
-}
-/**
- * Checks whether a view is an instance of {@link ~ViewWithFocusTracker}.
- */
-export function isViewWithFocusTracker(view) {
-    return 'focusTracker' in view && view.focusTracker instanceof FocusTracker;
-}
-function isElement(value) {
-    return _isElement(value);
-}
-function isExternalViewSubtreeFocused(subTreeRoot, view) {
-    if (isFocusedView(subTreeRoot, view)) {
-        return true;
-    }
-    return !!view.focusTracker.externalViews.find(view => isFocusedView(subTreeRoot, view));
-}
-function isFocusedView(subTreeRoot, view) {
-    // Note: You cannot depend on externalView.focusTracker.focusedElement because blurs are asynchronous and the value may
-    // be outdated when moving focus between two elements. Using document.activeElement instead.
-    return !!view.element && view.element.contains(document.activeElement) && subTreeRoot.contains(view.element);
-}
-// @if CK_DEBUG_FOCUSTRACKER // declare global {
-// @if CK_DEBUG_FOCUSTRACKER // 	interface Window {
-// @if CK_DEBUG_FOCUSTRACKER // 		logFocusTrackers: Function;
-// @if CK_DEBUG_FOCUSTRACKER // 	}
-// @if CK_DEBUG_FOCUSTRACKER // }
-// @if CK_DEBUG_FOCUSTRACKER //
-// @if CK_DEBUG_FOCUSTRACKER // function getName( focusTracker: FocusTracker ): string {
-// @if CK_DEBUG_FOCUSTRACKER // 	return focusTracker._label || 'Unknown';
-// @if CK_DEBUG_FOCUSTRACKER // }
-// @if CK_DEBUG_FOCUSTRACKER //
-// @if CK_DEBUG_FOCUSTRACKER // function logState(
-// @if CK_DEBUG_FOCUSTRACKER // 	focusTracker: FocusTracker,
-// @if CK_DEBUG_FOCUSTRACKER // 	keysToLog: Array<string> = [ 'isFocused', 'focusedElement' ]
-// @if CK_DEBUG_FOCUSTRACKER // ): string {
-// @if CK_DEBUG_FOCUSTRACKER // 	keysToLog.forEach( key => { console.log( `${ key }=`, focusTracker[ key ] ) } );
-// @if CK_DEBUG_FOCUSTRACKER // 	console.log( 'elements', focusTracker.elements );
-// @if CK_DEBUG_FOCUSTRACKER // 	console.log( 'externalViews', focusTracker.externalViews );
-// @if CK_DEBUG_FOCUSTRACKER // }
-// @if CK_DEBUG_FOCUSTRACKER //
-// @if CK_DEBUG_FOCUSTRACKER // window.logFocusTrackers = (
-// @if CK_DEBUG_FOCUSTRACKER // 	filter = () => true,
-// @if CK_DEBUG_FOCUSTRACKER // 	keysToLog: Array<string>
-// @if CK_DEBUG_FOCUSTRACKER // ): void => {
-// @if CK_DEBUG_FOCUSTRACKER // 	console.group( 'FocusTrackers' );
-// @if CK_DEBUG_FOCUSTRACKER //
-// @if CK_DEBUG_FOCUSTRACKER // 	for ( const focusTracker of FocusTracker._instances ) {
-// @if CK_DEBUG_FOCUSTRACKER // 		if ( filter( focusTracker ) ) {
-// @if CK_DEBUG_FOCUSTRACKER // 			console.group( `"${ getName( focusTracker ) }"` );
-// @if CK_DEBUG_FOCUSTRACKER // 			logState( focusTracker, keysToLog );
-// @if CK_DEBUG_FOCUSTRACKER // 			console.groupEnd();
-// @if CK_DEBUG_FOCUSTRACKER // 		}
-// @if CK_DEBUG_FOCUSTRACKER // 	}
-// @if CK_DEBUG_FOCUSTRACKER //
-// @if CK_DEBUG_FOCUSTRACKER // 	console.groupEnd();
-// @if CK_DEBUG_FOCUSTRACKER // };
-// @if CK_DEBUG_FOCUSTRACKER //
-// @if CK_DEBUG_FOCUSTRACKER // window.logFocusTrackerTree = (
-// @if CK_DEBUG_FOCUSTRACKER // 	rootFocusTracker: FocusTracker,
-// @if CK_DEBUG_FOCUSTRACKER // 	filter = () => true,
-// @if CK_DEBUG_FOCUSTRACKER // 	keysToLog: Array<string>
-// @if CK_DEBUG_FOCUSTRACKER // ): void => {
-// @if CK_DEBUG_FOCUSTRACKER // 	console.group( 'FocusTrackers tree' );
-// @if CK_DEBUG_FOCUSTRACKER //
-// @if CK_DEBUG_FOCUSTRACKER // 	logBranch( rootFocusTracker, filter );
-// @if CK_DEBUG_FOCUSTRACKER //
-// @if CK_DEBUG_FOCUSTRACKER // 	function logBranch( focusTracker, filter ) {
-// @if CK_DEBUG_FOCUSTRACKER // 		console.group( `"${ getName( focusTracker ) }"` );
-// @if CK_DEBUG_FOCUSTRACKER // 		logState( focusTracker, keysToLog );
-// @if CK_DEBUG_FOCUSTRACKER //
-// @if CK_DEBUG_FOCUSTRACKER // 		for ( const externalView of focusTracker.externalViews ) {
-// @if CK_DEBUG_FOCUSTRACKER // 			if ( filter( externalView.focusTracker ) ) {
-// @if CK_DEBUG_FOCUSTRACKER // 				logBranch( externalView.focusTracker, filter );
-// @if CK_DEBUG_FOCUSTRACKER // 			}
-// @if CK_DEBUG_FOCUSTRACKER // 		}
-// @if CK_DEBUG_FOCUSTRACKER //
-// @if CK_DEBUG_FOCUSTRACKER // 		console.groupEnd();
-// @if CK_DEBUG_FOCUSTRACKER // 	}
-// @if CK_DEBUG_FOCUSTRACKER //
-// @if CK_DEBUG_FOCUSTRACKER // 	console.groupEnd();
-// @if CK_DEBUG_FOCUSTRACKER // };