jodit 4.12.35 → 4.12.37

package/es5/plugins/debug/debug.css

@@ -1,7 +1,7 @@
 /*!
  * jodit - Jodit is an awesome and useful wysiwyg editor with filebrowser
  * Author: Chupurnov <chupurnov@gmail.com> (https://xdsoft.net/jodit/)
- * Version: v4.12.35
+ * Version: v4.12.37
  * Url: https://xdsoft.net/jodit/
  * License(s): MIT
  */

package/es5/plugins/debug/debug.js

@@ -1,7 +1,7 @@
 /*!
  * jodit - Jodit is an awesome and useful wysiwyg editor with filebrowser
  * Author: Chupurnov <chupurnov@gmail.com> (https://xdsoft.net/jodit/)
- * Version: v4.12.35
+ * Version: v4.12.37
  * Url: https://xdsoft.net/jodit/
  * License(s): MIT
  */

package/es5/plugins/debug/debug.min.js

@@ -1,7 +1,7 @@
 /*!
  * jodit - Jodit is an awesome and useful wysiwyg editor with filebrowser
  * Author: Chupurnov <chupurnov@gmail.com> (https://xdsoft.net/jodit/)
- * Version: v4.12.35
+ * Version: v4.12.37
  * Url: https://xdsoft.net/jodit/
  * License(s): MIT
  */

package/es5/plugins/speech-recognize/speech-recognize.css

@@ -1,7 +1,7 @@
 /*!
  * jodit - Jodit is an awesome and useful wysiwyg editor with filebrowser
  * Author: Chupurnov <chupurnov@gmail.com> (https://xdsoft.net/jodit/)
- * Version: v4.12.35
+ * Version: v4.12.37
  * Url: https://xdsoft.net/jodit/
  * License(s): MIT
  */

package/es5/plugins/speech-recognize/speech-recognize.js

@@ -1,7 +1,7 @@
 /*!
  * jodit - Jodit is an awesome and useful wysiwyg editor with filebrowser
  * Author: Chupurnov <chupurnov@gmail.com> (https://xdsoft.net/jodit/)
- * Version: v4.12.35
+ * Version: v4.12.37
  * Url: https://xdsoft.net/jodit/
  * License(s): MIT
  */

package/es5/plugins/speech-recognize/speech-recognize.min.js

@@ -1,7 +1,7 @@
 /*!
  * jodit - Jodit is an awesome and useful wysiwyg editor with filebrowser
  * Author: Chupurnov <chupurnov@gmail.com> (https://xdsoft.net/jodit/)
- * Version: v4.12.35
+ * Version: v4.12.37
  * Url: https://xdsoft.net/jodit/
  * License(s): MIT
  */

package/es5/polyfills.fat.min.js

@@ -1,7 +1,7 @@
 /*!
  * jodit - Jodit is an awesome and useful wysiwyg editor with filebrowser
  * Author: Chupurnov <chupurnov@gmail.com> (https://xdsoft.net/jodit/)
- * Version: v4.12.35
+ * Version: v4.12.37
  * Url: https://xdsoft.net/jodit/
  * License(s): MIT
  */

package/es5/polyfills.js

@@ -1,7 +1,7 @@
 /*!
  * jodit - Jodit is an awesome and useful wysiwyg editor with filebrowser
  * Author: Chupurnov <chupurnov@gmail.com> (https://xdsoft.net/jodit/)
- * Version: v4.12.35
+ * Version: v4.12.37
  * Url: https://xdsoft.net/jodit/
  * License(s): MIT
  */

package/es5/polyfills.min.js

@@ -1,7 +1,7 @@
 /*!
  * jodit - Jodit is an awesome and useful wysiwyg editor with filebrowser
  * Author: Chupurnov <chupurnov@gmail.com> (https://xdsoft.net/jodit/)
- * Version: v4.12.35
+ * Version: v4.12.37
  * Url: https://xdsoft.net/jodit/
  * License(s): MIT
  */

package/esm/config.d.ts

@@ -1678,15 +1678,22 @@ interface Config {
      */
     sourceEditor: 'area' | 'ace' | ((jodit: IJodit) => ISourceEditor);
     /**
-     * Options for [ace](https://ace.c9.io/#config) editor
+     * Options for [ace](https://ace.c9.io/#config) editor.
+     *
+     * Besides the named keys below, any other native ACE option is
+     * forwarded to `editor.setOptions()` as is, so e.g. `fontSize`,
+     * `tabSize` or `useSoftTabs` work too.
      *
      * ```js
      * Jodit.make('#editor', {
-     * 	showGutter: true,
-     * 	theme: 'ace/theme/idle_fingers',
-     * 	mode: 'ace/mode/html',
-     * 	wrap: true,
-     * 	highlightActiveLine: true
+     * 	sourceEditorNativeOptions: {
+     * 		showGutter: true,
+     * 		theme: 'ace/theme/idle_fingers',
+     * 		mode: 'ace/mode/html',
+     * 		wrap: true,
+     * 		highlightActiveLine: true,
+     * 		fontSize: '16px'
+     * 	}
      * })
      * ```
      */
@@ -1696,6 +1703,7 @@ interface Config {
         mode: string;
         wrap: string | boolean | number;
         highlightActiveLine: boolean;
+        [option: string]: string | boolean | number | undefined;
     };
     /**
      * Beautify HTML then it possible

package/esm/core/constants.js

@@ -3,7 +3,7 @@
  * Released under MIT see LICENSE.txt in the project root for license information.
  * Copyright (c) 2013-2026 Valerii Chupurnov. All rights reserved. https://xdsoft.net
  */
-export const APP_VERSION = "4.12.35";
+export const APP_VERSION = "4.12.37";
 // prettier-ignore
 export const ES = "es2020";
 export const IS_ES_MODERN = true;

package/esm/core/dom/dom.d.ts

@@ -34,7 +34,11 @@ export declare class Dom {
      */
     static unwrap(node: Node): void;
     /**
-     * Call functions for all nodes between `start` and `end`
+     * Call callback for all nodes between `start` and `end` in document order
+     * (`start` and `end` are not included). Iteration stops when the callback returns `true`.
+     *
+     * `end` must be positioned after `start` in the document (e.g. selection markers),
+     * otherwise iteration will stop only at the end of the tree.
      */
     static between(start: Node, end: Node, callback: (node: Node) => void | boolean): void;
     /**
@@ -46,14 +50,18 @@ export declare class Dom {
      * @param notMoveContent - false - Move content from elm to newTagName
      * @example
      * ```javascript
-     * Jodit.modules.Dom.replace(parent.editor.getElementsByTagName('span')[0], 'p');
-     * // Replace the first <span> element to the < p >
+     * Jodit.modules.Dom.replace(
+     *   parent.editor.getElementsByTagName('span')[0],
+     *   'p',
+     *   parent.createInside
+     * );
+     * // Replace the first <span> element to the <p>
      * ```
      */
-    static replace<T extends HTMLElement>(elm: Node, newTagName: HTMLTagNames): T;
     static replace<T extends HTMLElement>(elm: Node, newTagName: HTMLTagNames, create: ICreate, withAttributes?: boolean, notMoveContent?: boolean): T;
-    static replace<T extends Node>(elm: Node, newTagName: T): T;
-    static replace<T extends Node>(elm: Node, newTagName: T | string, create?: ICreate, withAttributes?: boolean, notMoveContent?: boolean): T;
+    static replace<T extends Node>(elm: Node, newElement: T, create?: ICreate, withAttributes?: boolean, notMoveContent?: boolean): T;
+    static replace<T extends Node>(elm: Node, html: string, create: ICreate, withAttributes?: boolean, notMoveContent?: boolean): T;
+    static replace<T extends Node>(elm: Node, newTagNameOrElement: HTMLTagNames | T, create: ICreate, withAttributes?: boolean, notMoveContent?: boolean): T;
     /**
      * Checks whether the Node text and blank (in this case it may contain invisible auxiliary characters ,
      * it is also empty )
@@ -80,9 +88,9 @@ export declare class Dom {
      */
     static isCell(elm: unknown): elm is HTMLTableCellElement;
     /**
-     * Check if element is a list	element UL or OL
+     * Check if element is a list element UL or OL
      */
-    static isList(elm: Nullable<Node>): elm is HTMLOListElement;
+    static isList(elm: Nullable<Node>): elm is HTMLUListElement | HTMLOListElement;
     /**
      * Check if element is a part of list	element LI
      */
@@ -103,7 +111,7 @@ export declare class Dom {
     /**
      * Check if element is comment node
      */
-    static isComment(node: Node): node is Comment;
+    static isComment(node: Nullable<Node> | false): node is Comment;
     /**
      * Check if element is element node
      */
@@ -147,7 +155,9 @@ export declare class Dom {
      */
     static find<T extends Node = Node>(node: Node, condition: NodeCondition, root: HTMLElement, leftToRight?: boolean, withChild?: boolean): Nullable<T>;
     /**
-     * Find next/prev node what `condition(next) === true`
+     * Lazily iterate over all nodes what follow after `start` (in document order
+     * for `leftToRight = true`, in reverse order otherwise) inside `root`.
+     * Ancestors of `start` are not yielded.
      */
     static nextGen(start: Node, root: HTMLElement, leftToRight?: boolean, withChild?: boolean): Generator<Node>;
     /**
@@ -159,7 +169,7 @@ export declare class Dom {
      * ```javascript
      * Jodit.modules.Dom.each(editor.s.current(), function (node) {
      *  if (node.nodeType === Node.TEXT_NODE) {
-     *      node.nodeValue = node.nodeValue.replace(Jodit.INVISIBLE_SPACE_REG_EX, '') // remove all of the text element codes invisible character
+     *      node.nodeValue = node.nodeValue.replace(Jodit.INVISIBLE_SPACE_REG_EXP(), '') // remove all of the text element codes invisible character
      *  }
      * });
      * ```
@@ -183,9 +193,16 @@ export declare class Dom {
      * Returns the nearest non-empty neighbor
      */
     static findNotEmptyNeighbor(node: Node, left: boolean, root: HTMLElement): Nullable<Node>;
+    /**
+     * Returns the previous (`left = true`) or next sibling of the node
+     */
     static sibling(node: Node, left?: boolean): Nullable<Node>;
     /**
      * It goes through all the elements in ascending order, and checks to see if they meet the predetermined condition
+     *
+     * The condition is checked for the `node` itself too. The `root` reached
+     * while ascending is checked only when `checkRoot = true`
+     * (but if `node === root` it is checked in any case).
      */
     static up<T extends HTMLElement>(node: Nullable<Node>, condition: NodeCondition, root?: Node, checkRoot?: boolean): Nullable<T>;
     /**
@@ -232,6 +249,12 @@ export declare class Dom {
      * Safe remove element from DOM
      */
     static safeRemove(...nodes: unknown[]): void;
+    /**
+     * Insert a node into the range and collapse the range to the start of
+     * the inserted content. Unlike the native `Range.insertNode` it does not
+     * split inseparable elements (BR, HR, IMG etc.) and removes empty text
+     * nodes produced by the split of a text container.
+     */
     static safeInsertNode(range: Range, node: Node): void;
     /**
      * Hide element
@@ -259,7 +282,7 @@ export declare class Dom {
      */
     static isMarker(elm: Nullable<Node>): elm is HTMLElement;
     /**
-     * Replace temporary elements from string
+     * Unwrap temporary elements inside a HTML string (keeps their content)
      */
     static replaceTemporaryFromString(value: string): string;
     /**

package/esm/core/dom/dom.js

@@ -19,6 +19,7 @@ import { css } from "../helpers/utils/css.js";
 import { dataBind } from "../helpers/utils/data-bind.js";
 import { error } from "../helpers/utils/error/index.js";
 import { call } from "../helpers/utils/utils.js";
+const TEMP_ELEMENT_REG_EXP = new RegExp(`<([a-z]+)[^>]+${TEMP_ATTR}[^>]*>(.+?)</\\1>`, 'gi');
 /**
  * Module for working with DOM
  */
@@ -129,7 +130,11 @@ export class Dom {
         }
     }
     /**
-     * Call functions for all nodes between `start` and `end`
+     * Call callback for all nodes between `start` and `end` in document order
+     * (`start` and `end` are not included). Iteration stops when the callback returns `true`.
+     *
+     * `end` must be positioned after `start` in the document (e.g. selection markers),
+     * otherwise iteration will stop only at the end of the tree.
      */
     static between(start, end, callback) {
         let next = start;
@@ -141,6 +146,10 @@ export class Dom {
             if (!step) {
                 while (next && !next.nextSibling) {
                     next = next.parentNode;
+                    // `end` was reached while ascending - all nodes between were visited
+                    if (next === end) {
+                        return;
+                    }
                 }
                 step = next === null || next === void 0 ? void 0 : next.nextSibling;
             }
@@ -240,7 +249,7 @@ export class Dom {
         return (Dom.isNode(elm) && (elm.nodeName === 'TD' || elm.nodeName === 'TH'));
     }
     /**
-     * Check if element is a list	element UL or OL
+     * Check if element is a list element UL or OL
      */
     static isList(elm) {
         return Dom.isTag(elm, LIST_TAGS);
@@ -294,12 +303,13 @@ export class Dom {
      * Check if element is document fragment
      */
     static isFragment(node) {
-        var _a;
         if (!Dom.isNode(node)) {
             return false;
         }
-        const win = (_a = node.ownerDocument) === null || _a === void 0 ? void 0 : _a.defaultView;
-        return Boolean(win && node.nodeType === Node.DOCUMENT_FRAGMENT_NODE);
+        // no `defaultView` requirement — fragments of an inert document
+        // (`template.content`, `DOMParser`, `implementation.createHTMLDocument`)
+        // are still fragments
+        return node.nodeType === Node.DOCUMENT_FRAGMENT_NODE;
     }
     /**
      * Check if element is HTMLElement node
@@ -424,7 +434,9 @@ export class Dom {
         return null;
     }
     /**
-     * Find next/prev node what `condition(next) === true`
+     * Lazily iterate over all nodes what follow after `start` (in document order
+     * for `leftToRight = true`, in reverse order otherwise) inside `root`.
+     * Ancestors of `start` are not yielded.
      */
     static *nextGen(start, root, leftToRight = true, withChild = true) {
         const stack = [];
@@ -434,9 +446,10 @@ export class Dom {
                 ? currentNode.nextSibling
                 : currentNode.previousSibling;
             while (next) {
-                stack.unshift(next);
+                stack.push(next);
                 next = leftToRight ? next.nextSibling : next.previousSibling;
             }
+            stack.reverse();
             yield* this.runInStack(start, stack, leftToRight, withChild);
             currentNode = currentNode.parentNode;
         } while (currentNode && currentNode !== root);
@@ -451,7 +464,7 @@ export class Dom {
      * ```javascript
      * Jodit.modules.Dom.each(editor.s.current(), function (node) {
      *  if (node.nodeType === Node.TEXT_NODE) {
-     *      node.nodeValue = node.nodeValue.replace(Jodit.INVISIBLE_SPACE_REG_EX, '') // remove all of the text element codes invisible character
+     *      node.nodeValue = node.nodeValue.replace(Jodit.INVISIBLE_SPACE_REG_EXP(), '') // remove all of the text element codes invisible character
      *  }
      * });
      * ```
@@ -539,11 +552,18 @@ export class Dom {
             (!(Dom.isText(n) || Dom.isComment(n)) ||
                 trim((n === null || n === void 0 ? void 0 : n.nodeValue) || '').length)), root);
     }
+    /**
+     * Returns the previous (`left = true`) or next sibling of the node
+     */
     static sibling(node, left) {
         return left ? node.previousSibling : node.nextSibling;
     }
     /**
      * It goes through all the elements in ascending order, and checks to see if they meet the predetermined condition
+     *
+     * The condition is checked for the `node` itself too. The `root` reached
+     * while ascending is checked only when `checkRoot = true`
+     * (but if `node === root` it is checked in any case).
      */
     static up(node, condition, root, checkRoot = false) {
         let start = node;
@@ -689,6 +709,12 @@ export class Dom {
             node.parentNode &&
             node.parentNode.removeChild(node));
     }
+    /**
+     * Insert a node into the range and collapse the range to the start of
+     * the inserted content. Unlike the native `Range.insertNode` it does not
+     * split inseparable elements (BR, HR, IMG etc.) and removes empty text
+     * nodes produced by the split of a text container.
+     */
     static safeInsertNode(range, node) {
         range.collapsed || range.deleteContents();
         const child = Dom.isFragment(node) ? node.lastChild : node;
@@ -730,22 +756,18 @@ export class Dom {
         }
     }
     static isTag(node, tagNames) {
+        if (Array.isArray(tagNames)) {
+            throw new TypeError('Dom.isTag does not support array');
+        }
         if (!this.isElement(node)) {
             return false;
         }
         const nameL = node.tagName.toLowerCase();
-        const nameU = node.tagName.toUpperCase();
         if (tagNames instanceof Set) {
-            return tagNames.has(nameL) || tagNames.has(nameU);
-        }
-        if (Array.isArray(tagNames)) {
-            throw new TypeError('Dom.isTag does not support array');
-        }
-        const tags = tagNames;
-        if (nameL === tags || nameU === tags) {
-            return true;
+            return (tagNames.has(nameL) ||
+                tagNames.has(node.tagName.toUpperCase()));
         }
-        return false;
+        return (nameL === tagNames || node.tagName.toUpperCase() === tagNames);
     }
     /**
      * Marks an item as temporary
@@ -773,10 +795,10 @@ export class Dom {
             elm.hasAttribute('data-' + MARKER_CLASS));
     }
     /**
-     * Replace temporary elements from string
+     * Unwrap temporary elements inside a HTML string (keeps their content)
      */
     static replaceTemporaryFromString(value) {
-        return value.replace(/<([a-z]+)[^>]+data-jodit-temp[^>]+>(.+?)<\/\1>/gi, '$2');
+        return value.replace(TEMP_ELEMENT_REG_EXP, '$2');
     }
     /**
      * Get temporary list

package/esm/core/dom/lazy-walker.d.ts

@@ -8,6 +8,16 @@
  */
 import type { IAsync, IDestructible } from "../../types/index";
 import { Eventify } from "../event-emitter/eventify";
+/**
+ * Walks the DOM tree in small chunks between browser tasks so that even huge
+ * documents do not block the main thread.
+ *
+ * Events:
+ * - `visit` - is called for every node; return `true` to mark the pass as
+ *   "had effect" (it will be passed into the `end` event)
+ * - `break` - the pass was interrupted via [[LazyWalker.break]]
+ * - `end` - the pass is finished, receives `true` if some `visit` handler returned `true`
+ */
 export declare class LazyWalker extends Eventify<{
     visit: (node: Node) => boolean;
     break: (reason?: string) => void;
@@ -16,17 +26,24 @@ export declare class LazyWalker extends Eventify<{
     private readonly async;
     private readonly options;
     private workNodes;
+    /**
+     * Starts a new pass over the `root` tree.
+     * If a previous pass is still running it will be stopped first.
+     */
     setWork(root: Node): this;
     private hadAffect;
     private isWorked;
     private isFinished;
     constructor(async: IAsync, options?: {
+        /** Visit only nodes with this `nodeType` (e.g. `Node.ELEMENT_NODE`) */
         readonly whatToShow?: number;
+        /** Walk the tree from the last node to the first */
         readonly reverse?: boolean;
+        /** How many nodes are processed per one chunk. Default: 50 */
         readonly timeoutChunkSize?: number;
+        /** Delay between chunks in ms */
         readonly timeout?: number;
     });
-    private idleId;
     private __schedulerController;
     private _requestStarting;
     break(reason?: string): void;

package/esm/core/dom/lazy-walker.js

@@ -16,13 +16,32 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { autobind } from "../decorators/autobind/autobind.js";
 import { Dom } from "./dom.js";
 import { Eventify } from "../event-emitter/eventify.js";
+/**
+ * Walks the DOM tree in small chunks between browser tasks so that even huge
+ * documents do not block the main thread.
+ *
+ * Events:
+ * - `visit` - is called for every node; return `true` to mark the pass as
+ *   "had effect" (it will be passed into the `end` event)
+ * - `break` - the pass was interrupted via [[LazyWalker.break]]
+ * - `end` - the pass is finished, receives `true` if some `visit` handler returned `true`
+ */
 export class LazyWalker extends Eventify {
+    /**
+     * Starts a new pass over the `root` tree.
+     * If a previous pass is still running it will be stopped first.
+     */
     setWork(root) {
         if (this.isWorked) {
             this.break();
         }
+        else {
+            // cancel a not yet started pass scheduled by the previous `setWork` call
+            this.stop();
+        }
         this.workNodes = Dom.eachGen(root, !this.options.reverse);
         this.isFinished = false;
+        this.hadAffect = false;
         this._requestStarting();
         return this;
     }
@@ -34,7 +53,6 @@ export class LazyWalker extends Eventify {
         this.hadAffect = false;
         this.isWorked = false;
         this.isFinished = false;
-        this.idleId = 0;
         this.__schedulerController = null;
     }
     _requestStarting() {
@@ -60,10 +78,12 @@ export class LazyWalker extends Eventify {
         }
     }
     stop() {
+        var _a;
         this.isWorked = false;
         this.isFinished = true;
         this.workNodes = null;
-        this.async.cancelIdleCallback(this.idleId);
+        (_a = this.__schedulerController) === null || _a === void 0 ? void 0 : _a.abort();
+        this.__schedulerController = null;
     }
     destruct() {
         super.destruct();
@@ -75,7 +95,7 @@ export class LazyWalker extends Eventify {
             this.isWorked = true;
             let count = 0;
             const chunkSize = (_a = this.options.timeoutChunkSize) !== null && _a !== void 0 ? _a : 50;
-            while (!this.isFinished && count <= chunkSize) {
+            while (!this.isFinished && count < chunkSize) {
                 const item = this.workNodes.next();
                 count += 1;
                 if (this.visitNode(item.value)) {

package/esm/core/selection/helpers/index.d.ts

@@ -6,7 +6,9 @@
 export * from "./move-node-inside-start";
 export * from "./move-the-node-along-the-edge-outward";
 /**
- * Check if the cursor is at the edge of the string
+ * Despite the name, returns `true` when the cursor is NOT at the checked edge
+ * of the text node: there is significant (non invisible-space) text between
+ * the offset and the start (`start = true`) or the end (`end = true`) of the string.
  * @private
  */
 export declare function cursorInTheEdgeOfString(container: Node, offset: number, start: boolean, end: boolean): boolean;

package/esm/core/selection/helpers/index.js

@@ -11,7 +11,9 @@ import { Dom } from "../../dom/dom.js";
 export * from "./move-node-inside-start.js";
 export * from "./move-the-node-along-the-edge-outward.js";
 /**
- * Check if the cursor is at the edge of the string
+ * Despite the name, returns `true` when the cursor is NOT at the checked edge
+ * of the text node: there is significant (non invisible-space) text between
+ * the offset and the start (`start = true`) or the end (`end = true`) of the string.
  * @private
  */
 export function cursorInTheEdgeOfString(container, offset, start, end) {

package/esm/core/selection/selection.d.ts

@@ -90,6 +90,11 @@ export declare class Selection implements ISelect {
      * Restores user selections using marker invisible elements in the DOM.
      */
     restore(): void;
+    /**
+     * Inserts invisible fake nodes on the boundaries of the current selection
+     * and returns them. Unlike [[Select.save]] the selection stays valid while
+     * the DOM around it is being modified. Restore it later with [[Select.restoreFakes]].
+     */
     fakes(): [
     ] | [
         Node
@@ -97,6 +102,10 @@ export declare class Selection implements ISelect {
         Node,
         Node
     ];
+    /**
+     * Restores the selection previously saved with [[Select.fakes]]
+     * and removes the fake nodes (disconnected fakes are ignored).
+     */
     restoreFakes(fakes: [
     ] | [
         Node
@@ -244,5 +253,10 @@ export declare class Selection implements ISelect {
      * Split selection on two parts: left and right
      */
     splitSelection(currentBox: HTMLElement, edge?: Node): Nullable<Element>;
+    /**
+     * Expands the non-collapsed selection outward: boundaries positioned on the
+     * edge of their parents are moved out of them (e.g. `<p><b>|test|</b></p>`
+     * becomes `<p>|<b>test</b>|</p>`)
+     */
     expandSelection(): this;
 }

package/esm/core/selection/selection.js

@@ -178,7 +178,7 @@ export class Selection {
      * Remove all markers
      */
     removeMarkers() {
-        Dom.safeRemove.apply(null, this.markers);
+        Dom.safeRemove(...this.markers);
     }
     /**
      * Create marker element
@@ -244,6 +244,11 @@ export class Selection {
             this.selectRange(range);
         }
     }
+    /**
+     * Inserts invisible fake nodes on the boundaries of the current selection
+     * and returns them. Unlike [[Select.save]] the selection stays valid while
+     * the DOM around it is being modified. Restore it later with [[Select.restoreFakes]].
+     */
     fakes() {
         const sel = this.sel;
         if (!sel || !sel.rangeCount) {
@@ -268,6 +273,10 @@ export class Selection {
         this.selectRange(range);
         return result;
     }
+    /**
+     * Restores the selection previously saved with [[Select.fakes]]
+     * and removes the fake nodes (disconnected fakes are ignored).
+     */
     restoreFakes(fakes) {
         var _a, _b, _c, _d;
         const nodes = fakes.filter(n => n.isConnected);
@@ -523,7 +532,6 @@ export class Selection {
         }
         const node = this.j.createInside.div();
         const fragment = this.j.createInside.fragment();
-        let lastChild;
         if (!this.isFocused() && this.j.isEditorMode()) {
             this.focus();
             this.restore();
@@ -538,12 +546,10 @@ export class Selection {
             this.j.e.fire('insertHTML', node.innerHTML) === false) {
             return;
         }
-        lastChild = node.lastChild;
-        if (!lastChild) {
+        if (!node.lastChild) {
             return;
         }
         while (node.firstChild) {
-            lastChild = node.firstChild;
             fragment.appendChild(node.firstChild);
         }
         this.insertNode(fragment, insertCursorAfter, false);
@@ -678,7 +684,8 @@ export class Selection {
             if (Dom.isEmptyTextNode(start)) {
                 nodes.push(start);
             }
-            if (start.firstChild) {
+            // `start` can be undefined for an empty root
+            if (start === null || start === void 0 ? void 0 : start.firstChild) {
                 nodes.push(start.firstChild);
             }
         }
@@ -694,8 +701,7 @@ export class Selection {
      * @returns true - the cursor is at the end(start) block, null - cursor somewhere outside
      */
     cursorInTheEdge(start, parentBlock, fake = null) {
-        var _a;
-        const end = !start, range = (_a = this.sel) === null || _a === void 0 ? void 0 : _a.getRangeAt(0);
+        const end = !start, sel = this.sel, range = (sel === null || sel === void 0 ? void 0 : sel.rangeCount) ? sel.getRangeAt(0) : null;
         fake !== null && fake !== void 0 ? fake : (fake = this.current(false));
         if (!range || !fake || !Dom.isOrContains(parentBlock, fake, true)) {
             return null;
@@ -1076,6 +1082,11 @@ export class Selection {
         }
         return currentBox.previousElementSibling;
     }
+    /**
+     * Expands the non-collapsed selection outward: boundaries positioned on the
+     * edge of their parents are moved out of them (e.g. `<p><b>|test|</b></p>`
+     * becomes `<p>|<b>test</b>|</p>`)
+     */
     expandSelection() {
         if (this.isCollapsed()) {
             return this;