jodit-pro 4.13.1 → 4.13.2

package/es5/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
  */
@@ -2266,7 +2266,7 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Map" || n === "Set") return Array.from(n);
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
-var APP_VERSION = "4.13.1";
+var APP_VERSION = "4.13.2";
 // prettier-ignore
 var ES = "es5";
 var IS_ES_MODERN = false;
@@ -3879,6 +3879,7 @@ function _ts_values(o) {
 
 
 
+var TEMP_ELEMENT_REG_EXP = new RegExp("<([a-z]+)[^>]+".concat(_constants_js__WEBPACK_IMPORTED_MODULE_0__.TEMP_ATTR, "[^>]*>(.+?)</\\1>"), 'gi');
 /**
  * Module for working with DOM
  */ var Dom = /*#__PURE__*/ function() {
@@ -4005,7 +4006,11 @@ function _ts_values(o) {
         {
             key: "between",
             value: /**
-     * 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.
      */ function between(start, end, callback) {
                 var next = start;
                 while(next && next !== end){
@@ -4016,6 +4021,10 @@ function _ts_values(o) {
                     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;
                     }
@@ -4131,7 +4140,7 @@ function _ts_values(o) {
         {
             key: "isList",
             value: /**
-     * Check if element is a list	element UL or OL
+     * Check if element is a list element UL or OL
      */ function isList(elm) {
                 return Dom.isTag(elm, _constants_js__WEBPACK_IMPORTED_MODULE_0__.LIST_TAGS);
             }
@@ -4195,12 +4204,13 @@ function _ts_values(o) {
             value: /**
      * Check if element is document fragment
      */ function isFragment(node) {
-                var _a;
                 if (!Dom.isNode(node)) {
                     return false;
                 }
-                var 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;
             }
         },
         {
@@ -4347,7 +4357,9 @@ function _ts_values(o) {
         {
             key: "nextGen",
             value: /**
-     * 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.
      */ function nextGen(start, root) {
                 var leftToRight, withChild, stack, currentNode, next;
                 var _arguments = arguments;
@@ -4361,9 +4373,10 @@ function _ts_values(o) {
                         case 1:
                             next = leftToRight ? currentNode.nextSibling : currentNode.previousSibling;
                             while(next){
-                                stack.unshift(next);
+                                stack.push(next);
                                 next = leftToRight ? next.nextSibling : next.previousSibling;
                             }
+                            stack.reverse();
                             return [
                                 5,
                                 _ts_values(this.runInStack(start, stack, leftToRight, withChild))
@@ -4398,7 +4411,7 @@ function _ts_values(o) {
      * ```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
      *  }
      * });
      * ```
@@ -4536,7 +4549,9 @@ function _ts_values(o) {
         },
         {
             key: "sibling",
-            value: function sibling(node, left) {
+            value: /**
+     * Returns the previous (`left = true`) or next sibling of the node
+     */ function sibling(node, left) {
                 return left ? node.previousSibling : node.nextSibling;
             }
         },
@@ -4544,6 +4559,10 @@ function _ts_values(o) {
             key: "up",
             value: /**
      * 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).
      */ function up(node, condition, root) {
                 var checkRoot = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : false;
                 var start = node;
@@ -4720,7 +4739,12 @@ function _ts_values(o) {
         },
         {
             key: "safeInsertNode",
-            value: function safeInsertNode(range, node) {
+            value: /**
+     * 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.
+     */ function safeInsertNode(range, node) {
                 range.collapsed || range.deleteContents();
                 var 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)) {
@@ -4770,22 +4794,17 @@ function _ts_values(o) {
         {
             key: "isTag",
             value: function isTag(node, tagNames) {
+                if (Array.isArray(tagNames)) {
+                    throw new TypeError('Dom.isTag does not support array');
+                }
                 if (!this.isElement(node)) {
                     return false;
                 }
                 var nameL = node.tagName.toLowerCase();
-                var nameU = node.tagName.toUpperCase();
                 if (_instanceof(tagNames, Set)) {
-                    return tagNames.has(nameL) || tagNames.has(nameU);
-                }
-                if (Array.isArray(tagNames)) {
-                    throw new TypeError('Dom.isTag does not support array');
-                }
-                var 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;
             }
         },
         {
@@ -4820,9 +4839,9 @@ function _ts_values(o) {
         {
             key: "replaceTemporaryFromString",
             value: /**
-     * Replace temporary elements from string
+     * Unwrap temporary elements inside a HTML string (keeps their content)
      */ function replaceTemporaryFromString(value) {
-                return value.replace(/<([a-z]+)[^>]+data-jodit-temp[^>]+>(.+?)<\/\1>/gi, '$2');
+                return value.replace(TEMP_ELEMENT_REG_EXP, '$2');
             }
         },
         {
@@ -4980,7 +4999,16 @@ function _is_native_reflect_construct() {
 
 
 
-var LazyWalker = /*#__PURE__*/ function(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`
+ */ var LazyWalker = /*#__PURE__*/ function(Eventify) {
     "use strict";
     _inherits(LazyWalker, Eventify);
     function LazyWalker(async) {
@@ -4994,19 +5022,25 @@ var LazyWalker = /*#__PURE__*/ function(Eventify) {
         _this.hadAffect = false;
         _this.isWorked = false;
         _this.isFinished = false;
-        _this.idleId = 0;
         _this.__schedulerController = null;
         return _this;
     }
     _create_class(LazyWalker, [
         {
-            key: "setWork",
+            /**
+     * Starts a new pass over the `root` tree.
+     * If a previous pass is still running it will be stopped first.
+     */ key: "setWork",
             value: function 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;
             }
@@ -5045,10 +5079,12 @@ var LazyWalker = /*#__PURE__*/ function(Eventify) {
         {
             key: "stop",
             value: function 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;
             }
         },
         {
@@ -5066,7 +5102,7 @@ var LazyWalker = /*#__PURE__*/ function(Eventify) {
                     this.isWorked = true;
                     var count = 0;
                     var chunkSize = (_a = this.options.timeoutChunkSize) !== null && _a !== void 0 ? _a : 50;
-                    while(!this.isFinished && count <= chunkSize){
+                    while(!this.isFinished && count < chunkSize){
                         var item = this.workNodes.next();
                         count += 1;
                         if (this.visitNode(item.value)) {
@@ -13330,7 +13366,9 @@ function _ts_generator(thisArg, body) {
 
 
 /**
- * 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;
@@ -13501,6 +13539,9 @@ function _array_like_to_array(arr, len) {
 function _array_with_holes(arr) {
     if (Array.isArray(arr)) return arr;
 }
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
 function _class_call_check(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
         throw new TypeError("Cannot call a class as a function");
@@ -13520,6 +13561,9 @@ function _create_class(Constructor, protoProps, staticProps) {
     if (staticProps) _defineProperties(Constructor, staticProps);
     return Constructor;
 }
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
 function _iterable_to_array_limit(arr, i) {
     var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
     if (_i == null) return;
@@ -13547,9 +13591,15 @@ function _iterable_to_array_limit(arr, i) {
 function _non_iterable_rest() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 function _sliced_to_array(arr, i) {
     return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
 }
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
 function _type_of(obj) {
     "@swc/helpers - typeof";
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
@@ -13871,7 +13921,8 @@ var Selection = /*#__PURE__*/ function() {
      * Remove all markers
      */ key: "removeMarkers",
             value: function removeMarkers() {
-                _dom_dom_js__WEBPACK_IMPORTED_MODULE_2__.Dom.safeRemove.apply(null, this.markers);
+                var _Dom;
+                (_Dom = _dom_dom_js__WEBPACK_IMPORTED_MODULE_2__.Dom).safeRemove.apply(_Dom, _to_consumable_array(this.markers));
             }
         },
         {
@@ -13939,7 +13990,11 @@ var Selection = /*#__PURE__*/ function() {
             }
         },
         {
-            key: "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]].
+     */ key: "fakes",
             value: function fakes() {
                 var sel = this.sel;
                 if (!sel || !sel.rangeCount) {
@@ -13968,7 +14023,10 @@ var Selection = /*#__PURE__*/ function() {
             }
         },
         {
-            key: "restoreFakes",
+            /**
+     * Restores the selection previously saved with [[Select.fakes]]
+     * and removes the fake nodes (disconnected fakes are ignored).
+     */ key: "restoreFakes",
             value: function restoreFakes(fakes) {
                 var _a, _b, _c, _d;
                 var nodes = fakes.filter(function(n) {
@@ -14246,7 +14304,6 @@ var Selection = /*#__PURE__*/ function() {
                 }
                 var node = this.j.createInside.div();
                 var fragment = this.j.createInside.fragment();
-                var lastChild;
                 if (!this.isFocused() && this.j.isEditorMode()) {
                     this.focus();
                     this.restore();
@@ -14259,12 +14316,10 @@ var Selection = /*#__PURE__*/ function() {
                 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);
@@ -14385,7 +14440,8 @@ var Selection = /*#__PURE__*/ function() {
                     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);
                     }
                 }
@@ -14405,8 +14461,7 @@ var Selection = /*#__PURE__*/ function() {
             value: function cursorInTheEdge(start, parentBlock) {
                 var _this = this;
                 var fake = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : null;
-                var _a;
-                var end = !start, range = (_a = this.sel) === null || _a === void 0 ? void 0 : _a.getRangeAt(0);
+                var 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;
@@ -14902,7 +14957,11 @@ var Selection = /*#__PURE__*/ function() {
             }
         },
         {
-            key: "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>`)
+     */ key: "expandSelection",
             value: function expandSelection() {
                 var _this = this;
                 if (this.isCollapsed()) {
@@ -15414,12 +15473,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;
     }
@@ -15465,7 +15523,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) {
     var strictStyle = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : true;
@@ -15578,6 +15637,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);
 }
 
@@ -15746,7 +15812,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');
     var hook = jodit.e.fire.bind(jodit.e, "".concat(_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);
@@ -16122,7 +16190,7 @@ var CommitStyle = /*#__PURE__*/ function() {
                 if (!data) {
                     return false;
                 }
-                return data[key];
+                return Boolean(data[key]);
             }
         },
         {
@@ -16149,7 +16217,7 @@ var CommitStyle = /*#__PURE__*/ function() {
         {
             key: "elementIsBlock",
             get: /**
-     * New element is blocked
+     * New element is a block element
      */ function get() {
                 return Boolean(this.options.element && _constants_js__WEBPACK_IMPORTED_MODULE_0__.IS_BLOCK.test(this.options.element));
             }

package/es5/jodit.min.css

@@ -1,14 +1,14 @@
 /*!
  * 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
  */
 	/*!
  * 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
  */