jodit-pro 4.13.1 → 4.13.2

package/es2015/jodit.js

@@ -1,7 +1,7 @@
 /*!
  * jodit-pro - PRO Version of Jodit Editor
  * Author: Chupurnov Valerii <chupurnov@gmail.com>
- * Version: v4.13.1
+ * Version: v4.13.2
  * Url: https://xdsoft.net/jodit/pro/
  * License(s): SEE LICENSE IN LICENSE.md
  */
@@ -1805,7 +1805,7 @@ __webpack_require__.r(__webpack_exports__);
  * ```
  * @packageDocumentation
  * @module constants
- */ const APP_VERSION = "4.13.1";
+ */ const APP_VERSION = "4.13.2";
 // prettier-ignore
 const ES = "es2015";
 const IS_ES_MODERN = true;
@@ -2935,6 +2935,7 @@ function wait(condition) {
 
 
 
+const TEMP_ELEMENT_REG_EXP = new RegExp(`<([a-z]+)[^>]+${_constants_js__WEBPACK_IMPORTED_MODULE_0__.TEMP_ATTR}[^>]*>(.+?)</\\1>`, 'gi');
 /**
  * Module for working with DOM
  */ class Dom {
@@ -3035,7 +3036,11 @@ function wait(condition) {
         }
     }
     /**
-     * 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;
         while(next && next !== end){
@@ -3046,6 +3051,10 @@ function wait(condition) {
             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;
             }
@@ -3127,7 +3136,7 @@ function wait(condition) {
         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, _constants_js__WEBPACK_IMPORTED_MODULE_0__.LIST_TAGS);
     }
@@ -3170,12 +3179,13 @@ function wait(condition) {
     /**
      * 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
@@ -3284,16 +3294,19 @@ function wait(condition) {
         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 = [];
         let currentNode = start;
         do {
             let next = leftToRight ? 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)
@@ -3308,7 +3321,7 @@ function wait(condition) {
      * ```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
      *  }
      * });
      * ```
@@ -3388,11 +3401,17 @@ function wait(condition) {
      */ static findNotEmptyNeighbor(node, left, root) {
         return (0,_helpers_utils_utils_js__WEBPACK_IMPORTED_MODULE_14__.call)(left ? Dom.prev : Dom.next, node, (n)=>Boolean(n && (!(Dom.isText(n) || Dom.isComment(n)) || (0,_helpers_string_trim_js__WEBPACK_IMPORTED_MODULE_8__.trim)((n === null || n === void 0 ? void 0 : n.nodeValue) || '').length)), root);
     }
-    static sibling(node, left) {
+    /**
+     * 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;
         if (!start) {
@@ -3517,7 +3536,12 @@ function wait(condition) {
      */ static safeRemove(...nodes) {
         nodes.forEach((node)=>Dom.isNode(node) && node.parentNode && node.parentNode.removeChild(node));
     }
-    static safeInsertNode(range, 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;
         if (range.startContainer === range.endContainer && range.collapsed && Dom.isTag(range.startContainer, _constants_js__WEBPACK_IMPORTED_MODULE_0__.INSEPARABLE_TAGS)) {
@@ -3556,22 +3580,17 @@ function wait(condition) {
         }
     }
     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
@@ -3594,9 +3613,9 @@ function wait(condition) {
         return Dom.isNode(elm) && Dom.isTag(elm, 'span') && elm.hasAttribute('data-' + _constants_js__WEBPACK_IMPORTED_MODULE_0__.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
@@ -3655,13 +3674,29 @@ function wait(condition) {
 
 
 
-class LazyWalker extends _event_emitter_eventify_js__WEBPACK_IMPORTED_MODULE_2__.Eventify {
-    setWork(root) {
+/**
+ * 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`
+ */ class LazyWalker extends _event_emitter_eventify_js__WEBPACK_IMPORTED_MODULE_2__.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_js__WEBPACK_IMPORTED_MODULE_1__.Dom.eachGen(root, !this.options.reverse);
         this.isFinished = false;
+        this.hadAffect = false;
         this._requestStarting();
         return this;
     }
@@ -3686,10 +3721,12 @@ class LazyWalker extends _event_emitter_eventify_js__WEBPACK_IMPORTED_MODULE_2__
         }
     }
     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();
@@ -3701,7 +3738,7 @@ class LazyWalker extends _event_emitter_eventify_js__WEBPACK_IMPORTED_MODULE_2__
             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)) {
@@ -3734,7 +3771,6 @@ class LazyWalker extends _event_emitter_eventify_js__WEBPACK_IMPORTED_MODULE_2__
         this.hadAffect = false;
         this.isWorked = false;
         this.isFinished = false;
-        this.idleId = 0;
         this.__schedulerController = null;
     }
 }
@@ -10270,7 +10306,9 @@ function _async_to_generator(fn) {
 
 
 /**
- * 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
  */ function cursorInTheEdgeOfString(container, offset, start, end) {
     var _a;
@@ -10584,7 +10622,7 @@ class Selection {
     /**
      * Remove all markers
      */ removeMarkers() {
-        _dom_dom_js__WEBPACK_IMPORTED_MODULE_2__.Dom.safeRemove.apply(null, this.markers);
+        _dom_dom_js__WEBPACK_IMPORTED_MODULE_2__.Dom.safeRemove(...this.markers);
     }
     /**
      * Create marker element
@@ -10641,7 +10679,11 @@ class Selection {
             this.selectRange(range);
         }
     }
-    fakes() {
+    /**
+     * 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) {
             return [];
@@ -10667,7 +10709,10 @@ class Selection {
         this.selectRange(range);
         return result;
     }
-    restoreFakes(fakes) {
+    /**
+     * 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);
         if (!nodes.length) {
@@ -10909,7 +10954,6 @@ 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();
@@ -10922,12 +10966,10 @@ class Selection {
         if (!this.j.isEditorMode() && 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);
@@ -11040,7 +11082,8 @@ class Selection {
             if (_dom_dom_js__WEBPACK_IMPORTED_MODULE_2__.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);
             }
         }
@@ -11055,8 +11098,7 @@ 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_dom_js__WEBPACK_IMPORTED_MODULE_2__.Dom.isOrContains(parentBlock, fake, true)) {
             return null;
@@ -11397,7 +11439,11 @@ class Selection {
         }
         return currentBox.previousElementSibling;
     }
-    expandSelection() {
+    /**
+     * 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;
         }
@@ -11874,12 +11920,11 @@ if (_constants_js__WEBPACK_IMPORTED_MODULE_0__.globalDocument) {
 
 
 /**
- * Compares whether the given attributes match the element's own attributes
+ * Checks that every attribute from `attrs` is present on the element with
+ * the same value (one-directional match: extra own attributes of the element
+ * are ignored, empty `attrs` matches any element)
  * @private
  */ function isSameAttributes(elm, attrs) {
-    if (!elm.attributes.length && !(0,_helpers_size_object_size_js__WEBPACK_IMPORTED_MODULE_0__.size)(attrs)) {
-        return true;
-    }
     if (!(0,_helpers_size_object_size_js__WEBPACK_IMPORTED_MODULE_0__.size)(attrs)) {
         return true;
     }
@@ -11923,7 +11968,8 @@ function elementsEqualAttributes(elm1, elm2) {
  * @param commitStyle - style commit
  * @param elm - checked item
  * @param strict - strict mode - false - the default tag is suitable for us if it is also in the commit
- * @param strictStyle - strict style mode - true - the element has the same style keys as in the commit, but not their values
+ * @param strictStyle - strict style mode - true - the element must have the same style keys AND values
+ * as in the commit, false - matching style keys are enough
  * @private
  */ function isSuitElement(commitStyle, elm, strict, strictStyle = true) {
     var _a;
@@ -12033,6 +12079,13 @@ function unwrapList(mode, list, li, jodit, cs) {
     (0,_extract_js__WEBPACK_IMPORTED_MODULE_2__.extractSelectedPart)(list, li, jodit);
     (0,_helpers_utils_assert_js__WEBPACK_IMPORTED_MODULE_1__.assert)(_dom_dom_js__WEBPACK_IMPORTED_MODULE_0__.Dom.isHTMLElement(li.parentElement), 'Element should be inside the list');
     _dom_dom_js__WEBPACK_IMPORTED_MODULE_0__.Dom.unwrap(li.parentElement);
+    // In the REPLACE mode the content will be immediately wrapped in a `li`
+    // of the new list inside `wrapList`, so it should stay in the document.
+    // Replacing it with a fragment here would dissolve the content
+    // (with `enter: 'br'`) and the new list would never be inserted.
+    if (mode === _constants_js__WEBPACK_IMPORTED_MODULE_4__.REPLACE) {
+        return li;
+    }
     return _dom_dom_js__WEBPACK_IMPORTED_MODULE_0__.Dom.replace(li, jodit.o.enter.toLowerCase() !== 'br' ? jodit.o.enter : jodit.createInside.fragment(), jodit.createInside);
 }
 
@@ -12200,7 +12253,9 @@ function toggleClass(jodit, value, elm, mode, dry) {
 function toggleAttribute(jodit, value, elm, key, dry, mode) {
     (0,_helpers_utils_index_js__WEBPACK_IMPORTED_MODULE_7__.assert)((0,_helpers_checker_index_js__WEBPACK_IMPORTED_MODULE_3__.isString)(value) || (0,_helpers_checker_index_js__WEBPACK_IMPORTED_MODULE_3__.isNumber)(value) || (0,_helpers_checker_index_js__WEBPACK_IMPORTED_MODULE_3__.isBoolean)(value) || value == null, 'Attribute value must be a string or number or boolean or null');
     const hook = jodit.e.fire.bind(jodit.e, `${_constants_js__WEBPACK_IMPORTED_MODULE_10__._PREFIX}AfterToggleAttribute`);
-    if ((0,_helpers_utils_index_js__WEBPACK_IMPORTED_MODULE_7__.attr)(elm, key) === value) {
+    // `attr()` getter always returns a string, so a number/boolean value
+    // must be normalized, otherwise the toggle-off branch is unreachable
+    if ((0,_helpers_utils_index_js__WEBPACK_IMPORTED_MODULE_7__.attr)(elm, key) === (value == null ? value : String(value))) {
         !dry && (0,_helpers_utils_index_js__WEBPACK_IMPORTED_MODULE_7__.attr)(elm, key, null);
         mode = _constants_js__WEBPACK_IMPORTED_MODULE_10__.UNSET;
         !dry && hook(mode, elm, key, value);
@@ -12542,7 +12597,7 @@ class CommitStyle {
         if (!data) {
             return false;
         }
-        return data[key];
+        return Boolean(data[key]);
     }
     setApplied(elm, key) {
         var _a;
@@ -12557,7 +12612,7 @@ class CommitStyle {
         return this.options.element || this.defaultTag;
     }
     /**
-     * New element is blocked
+     * New element is a block element
      */ get elementIsBlock() {
         return Boolean(this.options.element && _constants_js__WEBPACK_IMPORTED_MODULE_0__.IS_BLOCK.test(this.options.element));
     }