jodit-pro 4.17.1 → 4.17.3

package/es2015/jodit.js

@@ -1,7 +1,7 @@
 /*!
  * jodit-pro - PRO Version of Jodit Editor
  * Author: Chupurnov Valerii <chupurnov@gmail.com>
- * Version: v4.17.1
+ * Version: v4.17.3
  * Url: https://xdsoft.net/jodit/pro/
  * License(s): SEE LICENSE IN LICENSE.md
  */
@@ -1791,7 +1791,7 @@ __webpack_require__.r(__webpack_exports__);
  * ```
  * @packageDocumentation
  * @module constants
- */ const APP_VERSION = "4.17.1";
+ */ const APP_VERSION = "4.17.3";
 // prettier-ignore
 const ES = "es2015";
 const IS_ES_MODERN = true;
@@ -6070,6 +6070,21 @@ function isSmuggledForeignHtml(elm) {
             _dom_dom_js__WEBPACK_IMPORTED_MODULE_0__.Dom.safeRemove(elm);
         }
     }
+    // `<noscript>` is parsed as markup in a document with scripting off (the
+    // inert document the value is sanitized in) and as raw text in one with
+    // scripting on (the live editor). The same serialized bytes therefore
+    // describe two different trees, and markup hidden as inert text in the
+    // first comes alive as elements in the second. The element has no use in
+    // editor content, so it goes, together with everything it carried.
+    const noscript = [];
+    _dom_dom_js__WEBPACK_IMPORTED_MODULE_0__.Dom.each(box, (node)=>{
+        if (_dom_dom_js__WEBPACK_IMPORTED_MODULE_0__.Dom.isElement(node) && node.nodeName === 'NOSCRIPT') {
+            noscript.push(node);
+        }
+    });
+    for (const elm of noscript){
+        _dom_dom_js__WEBPACK_IMPORTED_MODULE_0__.Dom.safeRemove(elm);
+    }
     const removeEvents = (_a = options.removeEventAttributes) !== null && _a !== void 0 ? _a : options.removeOnError;
     // Single synchronous traversal of the subtree. Besides removing event
     // handlers and `javascript:` links, `sanitizeHTMLElement` neutralises
@@ -10542,20 +10557,83 @@ function _async_to_generator(fn) {
 }
 
 
+/***/ }),
+
+/***/ 79505:
+/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   composedRanges: function() { return /* binding */ composedRanges; }
+/* harmony export */ });
+/* harmony import */ var _helpers_checker_index_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(27613);
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * 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
+ */ 
+function isInside(node, shadowRoot) {
+    return node === shadowRoot || shadowRoot.contains(node);
+}
+function usable(ranges, shadowRoot) {
+    return Array.isArray(ranges) && ranges.length > 0 && ranges.every((range)=>isInside(range.startContainer, shadowRoot));
+}
+/**
+ * Ranges of a selection that lies inside the given shadow tree.
+ *
+ * `window.getSelection()` stops at the shadow boundary and reports the host
+ * instead of the node the caret is really in. `getComposedRanges` is the
+ * standard way to ask past that boundary.
+ *
+ * @returns `null` when the browser has no `getComposedRanges`, or when neither
+ * call shape returned ranges that point inside the shadow tree — in which case
+ * there is nothing better to offer than the plain window selection.
+ */ function composedRanges(selection, shadowRoot) {
+    const getComposedRanges = selection.getComposedRanges;
+    if (!(0,_helpers_checker_index_js__WEBPACK_IMPORTED_MODULE_0__.isFunction)(getComposedRanges)) {
+        return null;
+    }
+    for (const args of [
+        [
+            {
+                shadowRoots: [
+                    shadowRoot
+                ]
+            }
+        ],
+        [
+            shadowRoot
+        ]
+    ]){
+        let ranges;
+        try {
+            ranges = getComposedRanges.apply(selection, args);
+        } catch (_a) {
+            continue;
+        }
+        if (usable(ranges, shadowRoot)) {
+            return ranges;
+        }
+    }
+    return null;
+}
+
+
 /***/ }),
 
 /***/ 45124:
 /***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   composedRanges: function() { return /* reexport safe */ _composed_ranges_js__WEBPACK_IMPORTED_MODULE_2__.composedRanges; },
 /* harmony export */   cursorInTheEdgeOfString: function() { return /* binding */ cursorInTheEdgeOfString; },
 /* harmony export */   findCorrectCurrentNode: function() { return /* binding */ findCorrectCurrentNode; },
-/* harmony export */   moveNodeInsideStart: function() { return /* reexport safe */ _move_node_inside_start_js__WEBPACK_IMPORTED_MODULE_2__.moveNodeInsideStart; }
+/* harmony export */   moveNodeInsideStart: function() { return /* reexport safe */ _move_node_inside_start_js__WEBPACK_IMPORTED_MODULE_3__.moveNodeInsideStart; }
 /* harmony export */ });
 /* harmony import */ var _constants_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(82758);
 /* harmony import */ var _dom_dom_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(2748);
-/* harmony import */ var _move_node_inside_start_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(26716);
-/* harmony import */ var _move_the_node_along_the_edge_outward_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(43463);
+/* harmony import */ var _composed_ranges_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(79505);
+/* harmony import */ var _move_node_inside_start_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(26716);
+/* harmony import */ var _move_the_node_along_the_edge_outward_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(43463);
 /*!
  * Jodit Editor (https://xdsoft.net/jodit/)
  * Released under MIT see LICENSE.txt in the project root for license information.
@@ -10566,6 +10644,7 @@ function _async_to_generator(fn) {
 
 
 
+
 /**
  * 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
@@ -10789,11 +10868,87 @@ class Selection {
     /**
      * Return current selection object
      */ get sel() {
-        if (this.j.o.shadowRoot && (0,_helpers_checker_index_js__WEBPACK_IMPORTED_MODULE_4__.isFunction)(this.j.o.shadowRoot.getSelection)) {
-            return this.j.o.shadowRoot.getSelection();
+        const { shadowRoot } = this.j.o;
+        if (shadowRoot) {
+            if ((0,_helpers_checker_index_js__WEBPACK_IMPORTED_MODULE_4__.isFunction)(shadowRoot.getSelection)) {
+                return shadowRoot.getSelection();
+            }
+            const composed = this.__composedSelection(shadowRoot);
+            if (composed) {
+                return composed;
+            }
         }
         return this.win.getSelection();
     }
+    /**
+     * Selection of a shadow tree in a browser without `ShadowRoot.getSelection`.
+     *
+     * `ShadowRoot.getSelection()` is a non-standard method that WebKit never
+     * implemented, and `window.getSelection()` stops at the shadow boundary: for
+     * a caret inside the shadow tree it reports the host, or the document
+     * itself. Everything downstream then works on the wrong tree, which is why
+     * Backspace used to throw `HierarchyRequestError` and Enter did nothing when
+     * the editor lived in a shadow root in Safari.
+     *
+     * The standard replacement is `Selection.getComposedRanges()`, which does
+     * reach into a shadow tree it is given. It hands back `StaticRange`s, and
+     * the editor mutates ranges constantly, so they are turned into live ones.
+     *
+     * Reads are answered from those ranges; everything else, including the
+     * writes (`addRange`, `removeAllRanges`, `setBaseAndExtent`), goes to the
+     * real selection, which does accept nodes inside a shadow tree. Reading is
+     * the only side the browser blocks.
+     *
+     * @returns `null` when the browser offers neither API, so the caller falls
+     * back to the plain window selection.
+     */ __composedSelection(shadowRoot) {
+        const selection = this.win.getSelection();
+        if (!selection) {
+            return null;
+        }
+        // Firefox has no `ShadowRoot.getSelection` either, but its window
+        // selection does see into a shadow tree. Where the plain selection
+        // already points at the right node there is nothing to work around, and
+        // taking it over would change behaviour that works today.
+        const { anchorNode } = selection;
+        if (anchorNode && _dom_dom_js__WEBPACK_IMPORTED_MODULE_2__.Dom.isOrContains(shadowRoot, anchorNode)) {
+            return null;
+        }
+        const ranges = (0,_helpers_index_js__WEBPACK_IMPORTED_MODULE_9__.composedRanges)(selection, shadowRoot);
+        if (!ranges) {
+            return null;
+        }
+        const live = ranges.map((staticRange)=>{
+            const range = this.createRange();
+            range.setStart(staticRange.startContainer, staticRange.startOffset);
+            range.setEnd(staticRange.endContainer, staticRange.endOffset);
+            return range;
+        });
+        const first = live[0];
+        const overrides = {
+            rangeCount: live.length,
+            getRangeAt: (index)=>live[index],
+            isCollapsed: live.every((range)=>range.collapsed),
+            // Without these the editor asks the window selection where the
+            // caret is, is told "outside the editable area", and resets the
+            // caret to the start of it — which is the focus loss that shows up
+            // right after a successful Backspace.
+            anchorNode: first ? first.startContainer : null,
+            anchorOffset: first ? first.startOffset : 0,
+            focusNode: first ? first.endContainer : null,
+            focusOffset: first ? first.endOffset : 0,
+            toString: ()=>live.map((range)=>range.toString()).join('')
+        };
+        return new Proxy(selection, {
+            get (target, property) {
+                if ((0,_helpers_checker_index_js__WEBPACK_IMPORTED_MODULE_4__.isString)(property) && property in overrides) {
+                    return overrides[property];
+                }
+                const value = Reflect.get(target, property, target);
+                return (0,_helpers_checker_index_js__WEBPACK_IMPORTED_MODULE_4__.isFunction)(value) ? value.bind(target) : value;
+            }
+        });
+    }
     /**
      * Return first selected range or create new
      */ get range() {
@@ -18295,6 +18450,11 @@ let Jodit = Jodit_1 = class Jodit extends _modules_index_js__WEBPACK_IMPORTED_MO
         }
         if (this.editor) {
             this.editor.innerHTML = data.value;
+            // Fired synchronously, before any task can run: the value was
+            // sanitized in an inert document and re-parsed here with scripting
+            // on, and the two parsers do not always agree. Listeners get to
+            // look at the tree that actually exists.
+            this.e.fire('afterSetNativeEditorValue');
         }
     }
     /**
@@ -35476,6 +35636,15 @@ class cleanHtml extends _core_plugin_plugin_js__WEBPACK_IMPORTED_MODULE_5__.Plug
             return false;
         }
     }
+    /**
+     * The value was sanitized in an inert document and has just been re-parsed
+     * into the live editor with scripting on. Where the two parsers disagree
+     * (`<noscript>`, raw-text elements), markup that was inert text a moment
+     * ago is a real element now, so the live tree is sanitized once more, in
+     * the same call stack, before any handler it might carry can fire.
+     */ onAfterSetNativeEditorValue() {
+        ;(0,_core_helpers_html_safe_html_js__WEBPACK_IMPORTED_MODULE_4__.safeHTML)(this.j.editor, this.j.o.cleanHTML);
+    }
     /**
      * Event handler when manually assigning a value to the HTML editor.
      */ onBeforeSetNativeEditorValue(data) {
@@ -35605,6 +35774,9 @@ __decorate([
 __decorate([
     (0,_core_decorators_index_js__WEBPACK_IMPORTED_MODULE_0__.watch)(':beforeCommand')
 ], cleanHtml.prototype, "beforeCommand", null);
+__decorate([
+    (0,_core_decorators_index_js__WEBPACK_IMPORTED_MODULE_0__.watch)(':afterSetNativeEditorValue')
+], cleanHtml.prototype, "onAfterSetNativeEditorValue", null);
 __decorate([
     (0,_core_decorators_index_js__WEBPACK_IMPORTED_MODULE_0__.watch)(':beforeSetNativeEditorValue')
 ], cleanHtml.prototype, "onBeforeSetNativeEditorValue", null);