jodit 4.12.35 → 4.12.36

package/es2021/jodit.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.36
  * Url: https://xdsoft.net/jodit/
  * License(s): MIT
  */
@@ -1810,7 +1810,7 @@ __webpack_require__.r(__webpack_exports__);
  * ```
  * @packageDocumentation
  * @module constants
- */ const APP_VERSION = "4.12.35";
+ */ const APP_VERSION = "4.12.36";
 // prettier-ignore
 const ES = "es2021";
 const IS_ES_MODERN = true;
@@ -2998,6 +2998,7 @@ function wait(condition) {
 
 
 
+const TEMP_ELEMENT_REG_EXP = new RegExp(`<([a-z]+)[^>]+${jodit_core_constants__WEBPACK_IMPORTED_MODULE_0__.TEMP_ATTR}[^>]*>(.+?)</\\1>`, 'gi');
 /**
  * Module for working with DOM
  */ class Dom {
@@ -3098,7 +3099,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){
@@ -3109,6 +3114,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?.nextSibling;
             }
@@ -3190,7 +3199,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, jodit_core_constants__WEBPACK_IMPORTED_MODULE_0__.LIST_TAGS);
     }
@@ -3236,8 +3245,10 @@ function wait(condition) {
         if (!Dom.isNode(node)) {
             return false;
         }
-        const win = node.ownerDocument?.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
@@ -3345,16 +3356,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)
@@ -3369,7 +3383,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
 	 *  }
 	 * });
 	 * ```
@@ -3448,11 +3462,17 @@ function wait(condition) {
 	 */ static findNotEmptyNeighbor(node, left, root) {
         return (0,jodit_core_helpers_utils_utils__WEBPACK_IMPORTED_MODULE_14__.call)(left ? Dom.prev : Dom.next, node, (n)=>Boolean(n && (!(Dom.isText(n) || Dom.isComment(n)) || (0,jodit_core_helpers_string_trim__WEBPACK_IMPORTED_MODULE_8__.trim)(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) {
@@ -3577,7 +3597,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, jodit_core_constants__WEBPACK_IMPORTED_MODULE_0__.INSEPARABLE_TAGS)) {
@@ -3616,22 +3641,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');
+            return tagNames.has(nameL) || tagNames.has(node.tagName.toUpperCase());
         }
-        const tags = tagNames;
-        if (nameL === tags || nameU === tags) {
-            return true;
-        }
-        return false;
+        return nameL === tagNames || node.tagName.toUpperCase() === tagNames;
     }
     /**
 	 * Marks an item as temporary
@@ -3654,9 +3674,9 @@ function wait(condition) {
         return Dom.isNode(elm) && Dom.isTag(elm, 'span') && elm.hasAttribute('data-' + jodit_core_constants__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
@@ -3717,13 +3737,29 @@ function wait(condition) {
 
 
 
-class LazyWalker extends jodit_core_event_emitter_eventify__WEBPACK_IMPORTED_MODULE_4__.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 jodit_core_event_emitter_eventify__WEBPACK_IMPORTED_MODULE_4__.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 = jodit_core_dom_dom__WEBPACK_IMPORTED_MODULE_3__.Dom.eachGen(root, !this.options.reverse);
         this.isFinished = false;
+        this.hadAffect = false;
         this._requestStarting();
         return this;
     }
@@ -3751,7 +3787,8 @@ class LazyWalker extends jodit_core_event_emitter_eventify__WEBPACK_IMPORTED_MOD
         this.isWorked = false;
         this.isFinished = true;
         this.workNodes = null;
-        this.async.cancelIdleCallback(this.idleId);
+        this.__schedulerController?.abort();
+        this.__schedulerController = null;
     }
     destruct() {
         super.destruct();
@@ -3762,7 +3799,7 @@ class LazyWalker extends jodit_core_event_emitter_eventify__WEBPACK_IMPORTED_MOD
             this.isWorked = true;
             let count = 0;
             const chunkSize = this.options.timeoutChunkSize ?? 50;
-            while(!this.isFinished && count <= chunkSize){
+            while(!this.isFinished && count < chunkSize){
                 const item = this.workNodes.next();
                 count += 1;
                 if (this.visitNode(item.value)) {
@@ -3787,7 +3824,7 @@ class LazyWalker extends jodit_core_event_emitter_eventify__WEBPACK_IMPORTED_MOD
         return this.emit('visit', nodeElm) ?? false;
     }
     constructor(async, options = {}){
-        super(), (0,_swc_helpers_define_property__WEBPACK_IMPORTED_MODULE_0__._)(this, "async", void 0), (0,_swc_helpers_define_property__WEBPACK_IMPORTED_MODULE_0__._)(this, "options", void 0), (0,_swc_helpers_define_property__WEBPACK_IMPORTED_MODULE_0__._)(this, "workNodes", void 0), (0,_swc_helpers_define_property__WEBPACK_IMPORTED_MODULE_0__._)(this, "hadAffect", void 0), (0,_swc_helpers_define_property__WEBPACK_IMPORTED_MODULE_0__._)(this, "isWorked", void 0), (0,_swc_helpers_define_property__WEBPACK_IMPORTED_MODULE_0__._)(this, "isFinished", void 0), (0,_swc_helpers_define_property__WEBPACK_IMPORTED_MODULE_0__._)(this, "idleId", void 0), (0,_swc_helpers_define_property__WEBPACK_IMPORTED_MODULE_0__._)(this, "__schedulerController", void 0), this.async = async, this.options = options, this.workNodes = null, this.hadAffect = false, this.isWorked = false, this.isFinished = false, this.idleId = 0, this.__schedulerController = null;
+        super(), (0,_swc_helpers_define_property__WEBPACK_IMPORTED_MODULE_0__._)(this, "async", void 0), (0,_swc_helpers_define_property__WEBPACK_IMPORTED_MODULE_0__._)(this, "options", void 0), (0,_swc_helpers_define_property__WEBPACK_IMPORTED_MODULE_0__._)(this, "workNodes", void 0), (0,_swc_helpers_define_property__WEBPACK_IMPORTED_MODULE_0__._)(this, "hadAffect", void 0), (0,_swc_helpers_define_property__WEBPACK_IMPORTED_MODULE_0__._)(this, "isWorked", void 0), (0,_swc_helpers_define_property__WEBPACK_IMPORTED_MODULE_0__._)(this, "isFinished", void 0), (0,_swc_helpers_define_property__WEBPACK_IMPORTED_MODULE_0__._)(this, "__schedulerController", void 0), this.async = async, this.options = options, this.workNodes = null, this.hadAffect = false, this.isWorked = false, this.isFinished = false, this.__schedulerController = null;
     }
 }
 (0,_swc_helpers_ts_decorate__WEBPACK_IMPORTED_MODULE_1__.__decorate)([
@@ -10259,7 +10296,9 @@ class Response {
 
 
 /**
- * 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) {
     const text = container.nodeValue?.length ? container.nodeValue : '';
@@ -10577,7 +10616,7 @@ class Selection {
     /**
 	 * Remove all markers
 	 */ removeMarkers() {
-        jodit_core_dom_dom__WEBPACK_IMPORTED_MODULE_4__.Dom.safeRemove.apply(null, this.markers);
+        jodit_core_dom_dom__WEBPACK_IMPORTED_MODULE_4__.Dom.safeRemove(...this.markers);
     }
     /**
 	 * Create marker element
@@ -10634,7 +10673,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 [];
@@ -10660,7 +10703,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) {
         const nodes = fakes.filter((n)=>n.isConnected);
         if (!nodes.length) {
             return;
@@ -10897,7 +10943,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();
@@ -10910,12 +10955,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);
@@ -11027,7 +11070,8 @@ class Selection {
             if (jodit_core_dom_dom__WEBPACK_IMPORTED_MODULE_4__.Dom.isEmptyTextNode(start)) {
                 nodes.push(start);
             }
-            if (start.firstChild) {
+            // `start` can be undefined for an empty root
+            if (start?.firstChild) {
                 nodes.push(start.firstChild);
             }
         }
@@ -11042,7 +11086,7 @@ class Selection {
 	 *
 	 * @returns true - the cursor is at the end(start) block, null - cursor somewhere outside
 	 */ cursorInTheEdge(start, parentBlock, fake = null) {
-        const end = !start, range = this.sel?.getRangeAt(0);
+        const end = !start, sel = this.sel, range = sel?.rangeCount ? sel.getRangeAt(0) : null;
         fake ??= this.current(false);
         if (!range || !fake || !jodit_core_dom_dom__WEBPACK_IMPORTED_MODULE_4__.Dom.isOrContains(parentBlock, fake, true)) {
             return null;
@@ -11381,7 +11425,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;
         }
@@ -11877,12 +11925,11 @@ if (jodit_core_constants__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,jodit_core_helpers_size_object_size__WEBPACK_IMPORTED_MODULE_0__.size)(attrs)) {
-        return true;
-    }
     if (!(0,jodit_core_helpers_size_object_size__WEBPACK_IMPORTED_MODULE_0__.size)(attrs)) {
         return true;
     }
@@ -11931,7 +11978,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) {
     if (!elm || !(0,_is_normal_node__WEBPACK_IMPORTED_MODULE_2__.isNormalNode)(elm)) {
@@ -12041,6 +12089,13 @@ function unwrapList(mode, list, li, jodit, cs) {
     (0,jodit_core_selection_style_api_extract__WEBPACK_IMPORTED_MODULE_2__.extractSelectedPart)(list, li, jodit);
     (0,jodit_core_helpers_utils_assert__WEBPACK_IMPORTED_MODULE_1__.assert)(jodit_core_dom_dom__WEBPACK_IMPORTED_MODULE_0__.Dom.isHTMLElement(li.parentElement), 'Element should be inside the list');
     jodit_core_dom_dom__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 === jodit_core_selection_style_constants__WEBPACK_IMPORTED_MODULE_4__.REPLACE) {
+        return li;
+    }
     return jodit_core_dom_dom__WEBPACK_IMPORTED_MODULE_0__.Dom.replace(li, jodit.o.enter.toLowerCase() !== 'br' ? jodit.o.enter : jodit.createInside.fragment(), jodit.createInside);
 }
 
@@ -12210,7 +12265,9 @@ function toggleClass(jodit, value, elm, mode, dry) {
 function toggleAttribute(jodit, value, elm, key, dry, mode) {
     (0,jodit_core_helpers_utils__WEBPACK_IMPORTED_MODULE_7__.assert)((0,jodit_core_helpers_checker__WEBPACK_IMPORTED_MODULE_3__.isString)(value) || (0,jodit_core_helpers_checker__WEBPACK_IMPORTED_MODULE_3__.isNumber)(value) || (0,jodit_core_helpers_checker__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, `${jodit_core_selection_style_constants__WEBPACK_IMPORTED_MODULE_10__._PREFIX}AfterToggleAttribute`);
-    if ((0,jodit_core_helpers_utils__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,jodit_core_helpers_utils__WEBPACK_IMPORTED_MODULE_7__.attr)(elm, key) === (value == null ? value : String(value))) {
         !dry && (0,jodit_core_helpers_utils__WEBPACK_IMPORTED_MODULE_7__.attr)(elm, key, null);
         mode = jodit_core_selection_style_constants__WEBPACK_IMPORTED_MODULE_10__.UNSET;
         !dry && hook(mode, elm, key, value);
@@ -12560,7 +12617,7 @@ class CommitStyle {
         if (!data) {
             return false;
         }
-        return data[key];
+        return Boolean(data[key]);
     }
     setApplied(elm, key) {
         const data = this.__applyMap.get(elm) ?? {};
@@ -12574,7 +12631,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 && jodit_core_constants__WEBPACK_IMPORTED_MODULE_1__.IS_BLOCK.test(this.options.element));
     }