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

package/src/formathtml.js

@@ -1,164 +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/formathtml
- */
-/**
- * A simple (and naive) HTML code formatter that returns a formatted HTML markup that can be easily
- * parsed by human eyes. It beautifies the HTML code by adding new lines between elements that behave like block elements
- * (https://developer.mozilla.org/en-US/docs/Web/HTML/Block-level_elements
- * and a few more like `tr`, `td`, and similar ones) and inserting indents for nested content.
- *
- * WARNING: This function works only on a text that does not contain any indentations or new lines.
- * Calling this function on the already formatted text will damage the formatting.
- *
- * @param input An HTML string to format.
- */
-export function formatHtml(input) {
-    // A list of block-like elements around which the new lines should be inserted, and within which
-    // the indentation of their children should be increased.
-    // The list is partially based on https://developer.mozilla.org/en-US/docs/Web/HTML/Block-level_elements that contains
-    // a full list of HTML block-level elements.
-    // A void element is an element that cannot have any child - https://html.spec.whatwg.org/multipage/syntax.html#void-elements.
-    // Note that <pre> element is not listed on this list to avoid breaking whitespace formatting.
-    // Note that <br> element is not listed and handled separately so no additional white spaces are injected.
-    const elementsToFormat = [
-        { name: 'address', isVoid: false },
-        { name: 'article', isVoid: false },
-        { name: 'aside', isVoid: false },
-        { name: 'blockquote', isVoid: false },
-        { name: 'details', isVoid: false },
-        { name: 'dialog', isVoid: false },
-        { name: 'dd', isVoid: false },
-        { name: 'div', isVoid: false },
-        { name: 'dl', isVoid: false },
-        { name: 'dt', isVoid: false },
-        { name: 'fieldset', isVoid: false },
-        { name: 'figcaption', isVoid: false },
-        { name: 'figure', isVoid: false },
-        { name: 'footer', isVoid: false },
-        { name: 'form', isVoid: false },
-        { name: 'h1', isVoid: false },
-        { name: 'h2', isVoid: false },
-        { name: 'h3', isVoid: false },
-        { name: 'h4', isVoid: false },
-        { name: 'h5', isVoid: false },
-        { name: 'h6', isVoid: false },
-        { name: 'header', isVoid: false },
-        { name: 'hgroup', isVoid: false },
-        { name: 'hr', isVoid: true },
-        { name: 'li', isVoid: false },
-        { name: 'main', isVoid: false },
-        { name: 'nav', isVoid: false },
-        { name: 'ol', isVoid: false },
-        { name: 'p', isVoid: false },
-        { name: 'section', isVoid: false },
-        { name: 'table', isVoid: false },
-        { name: 'tbody', isVoid: false },
-        { name: 'td', isVoid: false },
-        { name: 'th', isVoid: false },
-        { name: 'thead', isVoid: false },
-        { name: 'tr', isVoid: false },
-        { name: 'ul', isVoid: false }
-    ];
-    const elementNamesToFormat = elementsToFormat.map(element => element.name).join('|');
-    // It is not the fastest way to format the HTML markup but the performance should be good enough.
-    const lines = input
-        // Add new line before and after `<tag>` and `</tag>`.
-        // It may separate individual elements with two new lines, but this will be fixed below.
-        .replace(new RegExp(`</?(${elementNamesToFormat})( .*?)?>`, 'g'), '\n$&\n')
-        // Keep `<br>`s at the end of line to avoid adding additional whitespaces before `<br>`.
-        .replace(/<br[^>]*>/g, '$&\n')
-        // Divide input string into lines, which start with either an opening tag, a closing tag, or just a text.
-        .split('\n');
-    let indentCount = 0;
-    let isPreformattedLine = false;
-    return lines
-        .map(line => {
-        isPreformattedLine = isPreformattedBlockLine(line, isPreformattedLine);
-        // Ignore empty lines outside a <pre> block.
-        if (!line.length && !isPreformattedLine) {
-            return '';
-        }
-        if (isNonVoidOpeningTag(line, elementsToFormat)) {
-            return indentLine(line, indentCount++);
-        }
-        if (isClosingTag(line, elementsToFormat)) {
-            return indentLine(line, --indentCount);
-        }
-        if (isPreformattedLine === 'middle' || isPreformattedLine === 'last') {
-            return indentLine(line, 0);
-        }
-        return indentLine(line, indentCount);
-    })
-        .join('')
-        .trimEnd();
-}
-/**
- * Checks, if an argument is an opening tag of a non-void element to be formatted.
- *
- * @param line String to check.
- * @param elementsToFormat Elements to be formatted.
- */
-function isNonVoidOpeningTag(line, elementsToFormat) {
-    return elementsToFormat.some(element => {
-        if (element.isVoid) {
-            return false;
-        }
-        if (!new RegExp(`<${element.name}( .*?)?>`).test(line)) {
-            return false;
-        }
-        return true;
-    });
-}
-/**
- * Checks, if an argument is a closing tag.
- *
- * @param line String to check.
- * @param elementsToFormat Elements to be formatted.
- */
-function isClosingTag(line, elementsToFormat) {
-    return elementsToFormat.some(element => {
-        return new RegExp(`</${element.name}>`).test(line);
-    });
-}
-/**
- * Indents a line by a specified number of characters.
- *
- * @param line Line to indent.
- * @param indentCount Number of characters to use for indentation.
- * @param indentChar Indentation character(s). 4 spaces by default.
- */
-function indentLine(line, indentCount, indentChar = '    ') {
-    // More about Math.max() here in https://github.com/ckeditor/ckeditor5/issues/10698.
-    return `${indentChar.repeat(Math.max(0, indentCount))}${line}\n`;
-}
-/**
- * Checks whether a line belongs to a preformatted (`<pre>`) block.
- *
- * @param line Line to check.
- * @param isPreviousLinePreFormatted Information on whether the previous line was preformatted (and how).
- */
-function isPreformattedBlockLine(line, isPreviousLinePreFormatted) {
-    const isPreOpen = /<pre( .*?)?>/.test(line);
-    const isPreClose = /<\/pre>/.test(line);
-    if (isPreOpen && isPreClose) {
-        // If both an opening and closing a <pre> tag, no special treatment needed.
-        return false;
-    }
-    else if (isPreOpen) {
-        return 'first';
-    }
-    else if (isPreClose) {
-        return 'last';
-    }
-    else if (isPreviousLinePreFormatted === 'first' || isPreviousLinePreFormatted === 'middle') {
-        // This line is just after a 'first' or 'middle' line of a multi-line pre-block.
-        return 'middle';
-    }
-    else {
-        return false;
-    }
-}

package/src/index.js

@@ -1,78 +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/index
- */
-export { env, getUserAgent as _getUserAgent, isMac as _isMac, isWindows as _isWindows, isGecko as _isGecko, isSafari as _isSafari, isiOS as _isiOS, isAndroid as _isAndroid, isBlink as _isBlink, isRegExpUnicodePropertySupported as _isRegExpUnicodePropertySupported, isMediaForcedColors as _isMediaForcedColors, isMotionReduced as _isMotionReduced } from './env.js';
-export { diff } from './diff.js';
-export { fastDiff } from './fastdiff.js';
-export { diffToChanges } from './difftochanges.js';
-export { areConnectedThroughProperties } from './areconnectedthroughproperties.js';
-export { _getEmitterListenedTo, _setEmitterId, _getEmitterId, EmitterMixin } from './emittermixin.js';
-export { EventInfo } from './eventinfo.js';
-export { ObservableMixin } from './observablemixin.js';
-export { CKEditorError, logError, logWarning, DOCUMENTATION_URL } from './ckeditorerror.js';
-export { ElementReplacer } from './elementreplacer.js';
-export { abortableDebounce } from './abortabledebounce.js';
-export { count } from './count.js';
-export { compareArrays } from './comparearrays.js';
-export { createElement } from './dom/createelement.js';
-export { Config } from './config.js';
-export { isIterable } from './isiterable.js';
-export { DomEmitterMixin } from './dom/emittermixin.js';
-export { findClosestScrollableAncestor } from './dom/findclosestscrollableancestor.js';
-export { global } from './dom/global.js';
-export { getAncestors } from './dom/getancestors.js';
-export { getDataFromElement } from './dom/getdatafromelement.js';
-export { getBorderWidths } from './dom/getborderwidths.js';
-export { getRangeFromMouseEvent } from './dom/getrangefrommouseevent.js';
-export { getCommonAncestor } from './dom/getcommonancestor.js';
-export { getPositionedAncestor } from './dom/getpositionedancestor.js';
-export { isText } from './dom/istext.js';
-export { isWindow } from './dom/iswindow.js';
-export { Rect } from './dom/rect.js';
-export { ResizeObserver } from './dom/resizeobserver.js';
-export { setDataInElement } from './dom/setdatainelement.js';
-export { toUnit } from './dom/tounit.js';
-export { indexOf } from './dom/indexof.js';
-export { insertAt } from './dom/insertat.js';
-export { isComment } from './dom/iscomment.js';
-export { isNode } from './dom/isnode.js';
-export { isRange } from './dom/isrange.js';
-export { isValidAttributeName } from './dom/isvalidattributename.js';
-export { isVisible } from './dom/isvisible.js';
-export { getOptimalPosition, getConstrainedViewportRect } from './dom/position.js';
-export { remove } from './dom/remove.js';
-export { getVisualViewportOffset } from './dom/getvisualviewportoffset.js';
-export { scrollAncestorsToShowTarget, scrollViewportToShowTarget } from './dom/scroll.js';
-export { keyCodes, getCode, parseKeystroke, getEnvKeystrokeText, isArrowKeyCode, getLocalizedArrowKeyCodeDirection, isForwardArrowKeyCode } from './keyboard.js';
-export { getLanguageDirection } from './language.js';
-export { Locale } from './locale.js';
-export { Collection } from './collection.js';
-export { first } from './first.js';
-export { nth } from './nth.js';
-export { FocusTracker, isViewWithFocusTracker } from './focustracker.js';
-export { KeystrokeHandler } from './keystrokehandler.js';
-export { toArray } from './toarray.js';
-export { toMap } from './tomap.js';
-export { mapsEqual } from './mapsequal.js';
-export { objectToMap } from './objecttomap.js';
-export { add, _translate, _clear as _clearTranslations, _unifyTranslations } from './translation-service.js';
-export { priorities } from './priorities.js';
-export { retry, exponentialDelay } from './retry.js';
-export { insertToPriorityArray } from './inserttopriorityarray.js';
-export { spliceArray } from './splicearray.js';
-export { uid } from './uid.js';
-export { delay } from './delay.js';
-export { wait } from './wait.js';
-export { parseBase64EncodedObject } from './parsebase64encodedobject.js';
-export { crc32 } from './crc32.js';
-export { collectStylesheets } from './collectstylesheets.js';
-export { formatHtml } from './formathtml.js';
-export { spy } from './spy.js';
-export { isCombiningMark, isHighSurrogateHalf, isLowSurrogateHalf, isInsideSurrogatePair, isInsideCombinedSymbol, isInsideEmojiSequence } from './unicode.js';
-export { decodeLicenseKey } from './decodelicensekey.js';
-export { isFeatureBlockedByLicenseKey } from './isfeatureblockedbylicensekey.js';
-export { version, releaseDate } from './version.js';

package/src/inserttopriorityarray.js

@@ -1,28 +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
- */
-import { priorities } from './priorities.js';
-/**
- * Inserts any object with priority at correct index by priority so registered objects are always sorted from highest to lowest priority.
- *
- * @param objects Array of objects with priority to insert object to.
- * @param objectToInsert Object with `priority` property.
- */
-export function insertToPriorityArray(objects, objectToInsert) {
-    const priority = priorities.get(objectToInsert.priority);
-    // Binary search for better performance in large tables.
-    let left = 0;
-    let right = objects.length;
-    while (left < right) {
-        const mid = (left + right) >> 1; // Use bitwise operator for faster floor division by 2.
-        const midPriority = priorities.get(objects[mid].priority);
-        if (midPriority < priority) {
-            right = mid;
-        }
-        else {
-            left = mid + 1;
-        }
-    }
-    objects.splice(left, 0, objectToInsert);
-}

package/src/isfeatureblockedbylicensekey.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/isfeatureblockedbylicensekey
- */
-/**
- * Checks whether a feature (represented by an unique id) is blocked by the provided license key.
- *
- * @param licensePayload Decoded license key.
- * @param licenseFeatureCode An unique feature id to check.
- */
-export function isFeatureBlockedByLicenseKey(licensePayload, licenseFeatureCode) {
-    const blockedFeatures = licensePayload.removeFeatures || [];
-    return blockedFeatures.includes(licenseFeatureCode);
-}

package/src/isiterable.js

@@ -1,16 +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/isiterable
- */
-/**
- * Checks if value implements iterator interface.
- *
- * @param value The value to check.
- * @returns True if value implements iterator interface.
- */
-export function isIterable(value) {
-    return !!(value && value[Symbol.iterator]);
-}

package/src/keyboard.js

@@ -1,256 +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
- */
-import { CKEditorError } from './ckeditorerror.js';
-import { env } from './env.js';
-const modifiersToGlyphsMac = {
-    ctrl: '⌃',
-    cmd: '⌘',
-    alt: '⌥',
-    shift: '⇧'
-};
-const modifiersToGlyphsNonMac = {
-    ctrl: 'Ctrl+',
-    alt: 'Alt+',
-    shift: 'Shift+'
-};
-const keyCodesToGlyphs = {
-    37: '←',
-    38: '↑',
-    39: '→',
-    40: '↓',
-    9: '⇥',
-    33: 'Page Up',
-    34: 'Page Down'
-};
-/**
- * An object with `keyName => keyCode` pairs for a set of known keys.
- *
- * Contains:
- *
- * * `a-z`,
- * * `0-9`,
- * * `f1-f12`,
- * * `` ` ``, `-`, `=`, `[`, `]`, `;`, `'`, `,`, `.`, `/`, `\`,
- * * `arrow(left|up|right|bottom)`,
- * * `backspace`, `delete`, `end`, `enter`, `esc`, `home`, `tab`,
- * * `ctrl`, `cmd`, `shift`, `alt`.
- */
-export const keyCodes = /* #__PURE__ */ generateKnownKeyCodes();
-const keyCodeNames = /* #__PURE__ */ Object.fromEntries(
-/* #__PURE__ */ Object.entries(keyCodes).map(([name, code]) => {
-    let prettyKeyName;
-    if (code in keyCodesToGlyphs) {
-        prettyKeyName = keyCodesToGlyphs[code];
-    }
-    else {
-        prettyKeyName = name.charAt(0).toUpperCase() + name.slice(1);
-    }
-    return [code, prettyKeyName];
-}));
-/**
- * Converts a key name or {@link module:utils/keyboard~KeystrokeInfo keystroke info} into a key code.
- *
- * Note: Key names are matched with {@link module:utils/keyboard#keyCodes} in a case-insensitive way.
- *
- * @param key A key name (see {@link module:utils/keyboard#keyCodes}) or a keystroke data object.
- * @returns Key or keystroke code.
- */
-export function getCode(key) {
-    let keyCode;
-    if (typeof key == 'string') {
-        keyCode = keyCodes[key.toLowerCase()];
-        if (!keyCode) {
-            /**
-             * Unknown key name. Only key names included in the {@link module:utils/keyboard#keyCodes} can be used.
-             *
-             * @error keyboard-unknown-key
-             * @param {string} key Ths specified key name.
-             */
-            throw new CKEditorError('keyboard-unknown-key', null, { key });
-        }
-    }
-    else {
-        keyCode = key.keyCode +
-            (key.altKey ? keyCodes.alt : 0) +
-            (key.ctrlKey ? keyCodes.ctrl : 0) +
-            (key.shiftKey ? keyCodes.shift : 0) +
-            (key.metaKey ? keyCodes.cmd : 0);
-    }
-    return keyCode;
-}
-/**
- * Parses the keystroke and returns a keystroke code that will match the code returned by
- * {@link module:utils/keyboard~getCode} for the corresponding {@link module:utils/keyboard~KeystrokeInfo keystroke info}.
- *
- * The keystroke can be passed in two formats:
- *
- * * as a single string – e.g. `ctrl + A`,
- * * as an array of {@link module:utils/keyboard~keyCodes known key names} and key codes – e.g.:
- *   * `[ 'ctrl', 32 ]` (ctrl + space),
- *   * `[ 'ctrl', 'a' ]` (ctrl + A).
- *
- * Note: Key names are matched with {@link module:utils/keyboard#keyCodes} in a case-insensitive way.
- *
- * Note: Only keystrokes with a single non-modifier key are supported (e.g. `ctrl+A` is OK, but `ctrl+A+B` is not).
- *
- * Note: On macOS, keystroke handling is translating the `Ctrl` key to the `Cmd` key and handling only that keystroke.
- * For example, a registered keystroke `Ctrl+A` will be translated to `Cmd+A` on macOS. To disable the translation of some keystroke,
- * use the forced modifier: `Ctrl!+A` (note the exclamation mark).
- *
- * @param keystroke The keystroke definition.
- * @returns Keystroke code.
- */
-export function parseKeystroke(keystroke) {
-    if (typeof keystroke == 'string') {
-        keystroke = splitKeystrokeText(keystroke);
-    }
-    return keystroke
-        .map(key => (typeof key == 'string') ? getEnvKeyCode(key) : key)
-        .reduce((key, sum) => sum + key, 0);
-}
-/**
- * Translates any keystroke string text like `"Ctrl+A"` to an
- * environment–specific keystroke, i.e. `"⌘A"` on macOS.
- *
- * @param keystroke The keystroke text.
- * @param [forcedEnv] The environment to force the key translation to. If not provided, the current environment is used.
- * @returns The keystroke text specific for the environment.
- */
-export function getEnvKeystrokeText(keystroke, forcedEnv) {
-    let keystrokeCode = parseKeystroke(keystroke);
-    const isMac = forcedEnv ? forcedEnv === 'Mac' : env.isMac || env.isiOS;
-    const modifiersToGlyphs = Object.entries(isMac ? modifiersToGlyphsMac : modifiersToGlyphsNonMac);
-    const modifiers = modifiersToGlyphs.reduce((modifiers, [name, glyph]) => {
-        // Modifier keys are stored as a bit mask so extract those from the keystroke code.
-        if ((keystrokeCode & keyCodes[name]) != 0) {
-            keystrokeCode &= ~keyCodes[name];
-            modifiers += glyph;
-        }
-        return modifiers;
-    }, '');
-    return modifiers + (keystrokeCode ? keyCodeNames[keystrokeCode] : '');
-}
-/**
- * Returns `true` if the provided key code represents one of the arrow keys.
- *
- * @param keyCode A key code as in {@link module:utils/keyboard~KeystrokeInfo#keyCode}.
- */
-export function isArrowKeyCode(keyCode) {
-    return keyCode == keyCodes.arrowright ||
-        keyCode == keyCodes.arrowleft ||
-        keyCode == keyCodes.arrowup ||
-        keyCode == keyCodes.arrowdown;
-}
-/**
- * Returns the direction in which the {@link module:engine/model/documentselection~ModelDocumentSelection selection}
- * will move when the provided arrow key code is pressed considering the language direction of the editor content.
- *
- * For instance, in right–to–left (RTL) content languages, pressing the left arrow means moving the selection right (forward)
- * in the model structure. Similarly, pressing the right arrow moves the selection left (backward).
- *
- * @param keyCode A key code as in {@link module:utils/keyboard~KeystrokeInfo#keyCode}.
- * @param contentLanguageDirection The content language direction, corresponding to
- * {@link module:utils/locale~Locale#contentLanguageDirection}.
- * @returns Localized arrow direction or `undefined` for non-arrow key codes.
- */
-export function getLocalizedArrowKeyCodeDirection(keyCode, contentLanguageDirection) {
-    const isLtrContent = contentLanguageDirection === 'ltr';
-    switch (keyCode) {
-        case keyCodes.arrowleft:
-            return isLtrContent ? 'left' : 'right';
-        case keyCodes.arrowright:
-            return isLtrContent ? 'right' : 'left';
-        case keyCodes.arrowup:
-            return 'up';
-        case keyCodes.arrowdown:
-            return 'down';
-    }
-}
-/**
- * Converts a key name to the key code with mapping based on the env.
- *
- * See: {@link module:utils/keyboard~getCode}.
- *
- * @param key The key name (see {@link module:utils/keyboard#keyCodes}).
- * @returns Key code.
- */
-function getEnvKeyCode(key) {
-    // Don't remap modifier key for forced modifiers.
-    if (key.endsWith('!')) {
-        return getCode(key.slice(0, -1));
-    }
-    const code = getCode(key);
-    return (env.isMac || env.isiOS) && code == keyCodes.ctrl ? keyCodes.cmd : code;
-}
-/**
- * Determines if the provided key code moves the {@link module:engine/model/documentselection~ModelDocumentSelection selection}
- * forward or backward considering the language direction of the editor content.
- *
- * For instance, in right–to–left (RTL) languages, pressing the left arrow means moving forward
- * in the model structure. Similarly, pressing the right arrow moves the selection backward.
- *
- * @param keyCode A key code as in {@link module:utils/keyboard~KeystrokeInfo#keyCode}.
- * @param contentLanguageDirection The content language direction, corresponding to
- * {@link module:utils/locale~Locale#contentLanguageDirection}.
- */
-export function isForwardArrowKeyCode(keyCode, contentLanguageDirection) {
-    const localizedKeyCodeDirection = getLocalizedArrowKeyCodeDirection(keyCode, contentLanguageDirection);
-    return localizedKeyCodeDirection === 'down' || localizedKeyCodeDirection === 'right';
-}
-function generateKnownKeyCodes() {
-    const keyCodes = {
-        pageup: 33,
-        pagedown: 34,
-        end: 35,
-        home: 36,
-        arrowleft: 37,
-        arrowup: 38,
-        arrowright: 39,
-        arrowdown: 40,
-        backspace: 8,
-        delete: 46,
-        enter: 13,
-        space: 32,
-        esc: 27,
-        tab: 9,
-        // The idea about these numbers is that they do not collide with any real key codes, so we can use them
-        // like bit masks.
-        ctrl: 0x110000,
-        shift: 0x220000,
-        alt: 0x440000,
-        cmd: 0x880000
-    };
-    // a-z
-    for (let code = 65; code <= 90; code++) {
-        const letter = String.fromCharCode(code);
-        keyCodes[letter.toLowerCase()] = code;
-    }
-    // 0-9
-    for (let code = 48; code <= 57; code++) {
-        keyCodes[code - 48] = code;
-    }
-    // F1-F12
-    for (let code = 112; code <= 123; code++) {
-        keyCodes['f' + (code - 111)] = code;
-    }
-    // other characters
-    Object.assign(keyCodes, {
-        '\'': 222,
-        ',': 108,
-        '-': 109,
-        '.': 110,
-        '/': 111,
-        ';': 186,
-        '=': 187,
-        '[': 219,
-        '\\': 220,
-        ']': 221,
-        '`': 223
-    });
-    return keyCodes;
-}
-function splitKeystrokeText(keystroke) {
-    return keystroke.split('+').map(key => key.trim());
-}