jodit 4.14.2 → 4.14.3

package/esm/core/selection/style/api/extract.js

@@ -5,7 +5,6 @@
  */
 import { Dom } from "../../../dom/dom.js";
 import { isMarker } from "../../../helpers/checker/is-marker.js";
-import { trim } from "../../../helpers/string/trim.js";
 import { call } from "../../../helpers/utils/utils.js";
 /**
  * If the selection area is inside an element that matches the commit (suitable relative),
@@ -44,8 +43,7 @@ export function extractSelectedPart(wrapper, font, jodit) {
  */
 function extractAndMove(wrapper, range, left) {
     const fragment = range.extractContents();
-    if ((!fragment.textContent || !trim(fragment.textContent).length) &&
-        fragment.firstChild) {
+    if (Dom.isEmpty(fragment) && fragment.firstChild) {
         Dom.unwrap(fragment.firstChild);
     }
     if (wrapper.parentNode) {

package/esm/core/selection/style/api/is-same-attributes.js

@@ -20,13 +20,16 @@ export function isSameAttributes(elm, attrs) {
     }
     assert(attrs, 'Attrs must be a non-empty object');
     return Object.keys(attrs).every(key => {
+        var _a;
         if (key === 'class' || key === 'className') {
-            return elm.classList.contains(attrs[key]);
+            const classes = (_a = String(attrs[key]).match(/[^\t\n\f\r ]+/g)) !== null && _a !== void 0 ? _a : [];
+            return classes.every(name => elm.classList.contains(name));
         }
         if (key === 'style') {
             return hasSameStyle(elm, attrs[key]);
         }
-        return attr(elm, key) === attrs[key];
+        const value = attrs[key];
+        return attr(elm, key) === (value == null ? value : String(value));
     });
 }
 export function elementsEqualAttributes(elm1, elm2) {

package/esm/core/selection/style/api/toggle-attributes.js

@@ -29,7 +29,7 @@ export function toggleAttributes(commitStyle, elm, jodit, mode, dry = false) {
             const value = attributes[key];
             switch (key) {
                 case 'style': {
-                    mode = toggleStyle(commitStyle, jodit, value, elm, dry, mode);
+                    mode = toggleStyle(jodit, value, elm, dry, mode);
                     break;
                 }
                 case 'className':
@@ -41,9 +41,13 @@ export function toggleAttributes(commitStyle, elm, jodit, mode, dry = false) {
             }
         });
     }
-    return mode;
+    // Cleanup belongs to the complete attribute transaction. Removing a
+    // wrapper between CSS rules would apply the remaining rules to a detached node.
+    return !dry && (attributes === null || attributes === void 0 ? void 0 : attributes.style)
+        ? removeExtraStyleAttribute(commitStyle, elm, mode)
+        : mode;
 }
-function toggleStyle(commitStyle, jodit, style, elm, dry, mode) {
+function toggleStyle(jodit, style, elm, dry, mode) {
     assert(isPlainObject(style) && size(style), 'Style must be an object');
     Object.keys(style).forEach((rule) => {
         const inlineValue = cssInline(elm, rule);
@@ -51,6 +55,15 @@ function toggleStyle(commitStyle, jodit, style, elm, dry, mode) {
         if (inlineValue === '' && newValue == null) {
             return;
         }
+        if (newValue == null || newValue === '') {
+            if (inlineValue) {
+                !dry && css(elm, rule, null);
+                // An explicit reset changes a style; it is not a toggle of
+                // the owning element (notably when resetting list-style-type).
+                mode = CHANGE;
+            }
+            return;
+        }
         if (getNativeCSSValue(jodit, elm, rule) ===
             normalizeCssValue(rule, newValue)) {
             if (!inlineValue) {
@@ -58,34 +71,37 @@ function toggleStyle(commitStyle, jodit, style, elm, dry, mode) {
             }
             !dry && css(elm, rule, null);
             mode = UNSET;
-            mode = removeExtraStyleAttribute(commitStyle, elm, mode);
             return;
         }
         mode = CHANGE;
         if (!dry) {
             css(elm, rule, newValue);
-            mode = removeExtraStyleAttribute(commitStyle, elm, mode);
         }
     });
     return mode;
 }
 function toggleClass(jodit, value, elm, mode, dry) {
+    var _a;
     assert(isString(value), 'Class name must be a string');
+    const classes = (_a = value.match(/[^\t\n\f\r ]+/g)) !== null && _a !== void 0 ? _a : [];
+    if (!classes.length) {
+        return mode;
+    }
     const hook = jodit.e.fire.bind(jodit.e, `${_PREFIX}AfterToggleAttribute`);
-    if (elm.classList.contains(value.toString())) {
+    if (classes.every(name => elm.classList.contains(name))) {
         mode = UNSET;
         if (!dry) {
-            elm.classList.remove(value);
+            elm.classList.remove(...classes);
             if (elm.classList.length === 0) {
                 attr(elm, 'class', null);
-                hook(mode, elm, 'class', null);
             }
+            hook(mode, elm, 'class', attr(elm, 'class'));
         }
     }
     else {
         mode = CHANGE;
         if (!dry) {
-            elm.classList.add(value);
+            elm.classList.add(...classes);
             hook(mode, elm, 'class', value);
         }
     }
@@ -116,7 +132,8 @@ function toggleAttribute(jodit, value, elm, key, dry, mode) {
 function removeExtraStyleAttribute(commitStyle, elm, mode) {
     if (!attr(elm, 'style')) {
         attr(elm, 'style', null);
-        if (elm.tagName.toLowerCase() === commitStyle.defaultTag) {
+        if (!elm.attributes.length &&
+            elm.tagName.toLowerCase() === commitStyle.defaultTag) {
             Dom.unwrap(elm);
             mode = UNWRAP;
         }

package/esm/core/selection/style/api/unwrap-children.js

@@ -6,7 +6,7 @@
 import { Dom } from "../../../dom/dom.js";
 import { attr, css } from "../../../helpers/utils/index.js";
 import { hasSameStyleKeys } from "./has-same-style.js";
-import { isSameStyleChild, isSuitElement } from "./is-suit-element.js";
+import { isSuitElement } from "./is-suit-element.js";
 /**
  * Unwrap all suit elements inside
  * @private
@@ -17,42 +17,48 @@ export function unwrapChildren(style, font) {
     const needChangeStyle = [];
     let firstElementSuit;
     const cssStyle = (_a = style.options.attributes) === null || _a === void 0 ? void 0 : _a.style;
-    if (font.firstChild) {
-        const gen = Dom.eachGen(font);
-        let item = gen.next();
-        while (!item.done) {
-            const elm = item.value;
-            if (isSuitElement(style, elm, true) &&
-                (!cssStyle || hasSameStyleKeys(elm, cssStyle))) {
-                if (firstElementSuit === undefined) {
-                    firstElementSuit = true;
-                }
+    const styleKeys = Object.keys(cssStyle !== null && cssStyle !== void 0 ? cssStyle : {});
+    const clearedStyle = {};
+    styleKeys.forEach(key => {
+        clearedStyle[key] = null;
+    });
+    const clearStyle = (elm) => {
+        css(elm, clearedStyle);
+        if (!attr(elm, 'style')) {
+            attr(elm, 'style', null);
+        }
+        if (!elm.attributes.length && Dom.isTag(elm, style.element)) {
+            needUnwrap.push(elm);
+        }
+    };
+    for (const elm of Dom.eachGen(font)) {
+        if (!Dom.isContentEditable(elm, font)) {
+            continue;
+        }
+        if (isSuitElement(style, elm, true) &&
+            (!cssStyle || hasSameStyleKeys(elm, cssStyle))) {
+            if (firstElementSuit === undefined) {
+                firstElementSuit = true;
+            }
+            if (cssStyle) {
+                needChangeStyle.push(() => clearStyle(elm));
+            }
+            else {
                 needUnwrap.push(elm);
             }
-            else if (cssStyle && isSameStyleChild(style, elm)) {
-                if (firstElementSuit === undefined) {
-                    firstElementSuit = false;
-                }
-                needChangeStyle.push(() => {
-                    css(elm, Object.keys(cssStyle).reduce((acc, key) => {
-                        acc[key] = null;
-                        return acc;
-                    }, {}));
-                    if (!attr(elm, 'style')) {
-                        attr(elm, 'style', null);
-                    }
-                    if (!attr(elm, 'style') &&
-                        elm.nodeName.toLowerCase() === style.element) {
-                        needUnwrap.push(elm);
-                    }
-                });
+        }
+        else if (cssStyle &&
+            Dom.isHTMLElement(elm) &&
+            styleKeys.some(key => css(elm, key, true) !== '')) {
+            if (firstElementSuit === undefined) {
+                firstElementSuit = false;
             }
-            else if (!Dom.isEmptyTextNode(elm)) {
-                if (firstElementSuit === undefined) {
-                    firstElementSuit = false;
-                }
+            needChangeStyle.push(() => clearStyle(elm));
+        }
+        else if (!Dom.isEmptyTextNode(elm)) {
+            if (firstElementSuit === undefined) {
+                firstElementSuit = false;
             }
-            item = gen.next();
         }
     }
     needChangeStyle.forEach(clb => clb());

package/esm/core/selection/style/apply-style.js

@@ -10,33 +10,31 @@ import { states, transactions } from "./transactions.js";
 export function ApplyStyle(jodit, cs) {
     var _a;
     const { s: sel, editor } = jodit;
-    // sel.save();
     (_a = editor.firstChild) === null || _a === void 0 ? void 0 : _a.normalize(); // FF fix for test "commandsTest - Exec command "bold"
     const fakes = sel.fakes();
-    const gen = jodit.s.wrapInTagGen(fakes);
-    let font = gen.next();
-    if (font.done) {
-        return;
-    }
-    let state = {
-        collapsed: sel.isCollapsed(),
-        mode: INITIAL,
-        element: font.value,
-        next: states.START,
-        jodit,
-        style: cs
-    };
-    while (font && !font.done) {
-        const machine = new FiniteStateMachine(states.START, transactions);
-        state.element = font.value;
-        // machine.disableSilent();
-        while (machine.getState() !== states.END) {
-            // console.log(machine.getState(), state);
-            state = machine.dispatch('exec', state);
+    const collapsed = sel.isCollapsed();
+    let mode = INITIAL;
+    try {
+        // for...of closes the generator on an exception, releasing every
+        // temporary wrapper before the selection is restored in finally.
+        for (const font of sel.wrapInTagGen(fakes)) {
+            let state = {
+                collapsed,
+                mode,
+                element: font,
+                next: states.START,
+                jodit,
+                style: cs
+            };
+            const machine = new FiniteStateMachine(states.START, transactions);
+            while (!jodit.isInDestruct && machine.getState() !== states.END) {
+                state = machine.dispatch('exec', state);
+            }
+            // The first selected fragment determines how later fragments toggle.
+            mode = state.mode;
         }
-        // console.log('-------------------');
-        font = gen.next();
     }
-    // sel.restore();
-    sel.restoreFakes(fakes);
+    finally {
+        sel.restoreFakes(fakes);
+    }
 }

package/esm/core/selection/style/commit-style.js

@@ -68,6 +68,9 @@ export class CommitStyle {
             });
             this.__applyMap = new WeakMap();
         }
+        if (jodit.isInDestruct) {
+            return;
+        }
         jodit.synchronizeValues();
         jodit.e.fire('afterCommitStyle', this);
     }

package/esm/core/selection/style/transactions.js

@@ -25,7 +25,8 @@ export const transactions = {
     [states.START]: {
         exec(value) {
             const { element, jodit, style, mode, collapsed } = value;
-            if (isInsideInvisibleElement(element, jodit.editor) ||
+            if (!Dom.isContentEditable(element, jodit.editor) ||
+                isInsideInvisibleElement(element, jodit.editor) ||
                 (!collapsed && Dom.isEmptyContent(element))) {
                 return { ...value, next: states.END };
             }

package/esm/langs/az.d.ts

@@ -0,0 +1,223 @@
+declare const _exports: {
+    'Type something': string;
+    Advanced: string;
+    'About Jodit': string;
+    'Jodit Editor': string;
+    "Jodit User's Guide": string;
+    'contains detailed help for using': string;
+    'For information about the license, please go to our website:': string;
+    'Buy full version': string;
+    'Copyright \u00A9 XDSoft.net - Chupurnov Valeriy. All rights reserved.': string;
+    Anchor: string;
+    'Open in new tab': string;
+    'Open in fullsize': string;
+    'Clear Formatting': string;
+    'Fill color or set the text color': string;
+    Redo: string;
+    Undo: string;
+    Bold: string;
+    Italic: string;
+    'Insert Unordered List': string;
+    'Insert Ordered List': string;
+    'Align Center': string;
+    'Align Justify': string;
+    'Align Left': string;
+    'Align Right': string;
+    'Insert Horizontal Line': string;
+    'Insert Image': string;
+    'Insert file': string;
+    'Insert youtube/vimeo video': string;
+    'Insert link': string;
+    'Font size': string;
+    'Font family': string;
+    'Line height': string;
+    Spellcheck: string;
+    'Speech Recognize': string;
+    newline: string;
+    'Insert format block': string;
+    Normal: string;
+    'Heading 1': string;
+    'Heading 2': string;
+    'Heading 3': string;
+    'Heading 4': string;
+    Quote: string;
+    Code: string;
+    Insert: string;
+    'Insert table': string;
+    'Decrease Indent': string;
+    'Increase Indent': string;
+    'Select Special Character': string;
+    'Insert Special Character': string;
+    'Paint format': string;
+    'Change mode': string;
+    Margins: string;
+    top: string;
+    right: string;
+    bottom: string;
+    left: string;
+    Styles: string;
+    Classes: string;
+    Align: string;
+    Right: string;
+    Center: string;
+    Left: string;
+    '--Not Set--': string;
+    Src: string;
+    Title: string;
+    Alternative: string;
+    Link: string;
+    'Open link in new tab': string;
+    Image: string;
+    file: string;
+    'Image properties': string;
+    Cancel: string;
+    Ok: string;
+    'Your code is similar to HTML. Keep as HTML?': string;
+    'Paste as HTML': string;
+    Keep: string;
+    Clean: string;
+    'Insert as Text': string;
+    'Word Paste Detected': string;
+    'The pasted content is coming from a Microsoft Word/Excel document. Do you want to keep the format or clean it up?': string;
+    'Insert only Text': string;
+    'File Browser': string;
+    'Error on load list': string;
+    'Error on load folders': string;
+    'Are you sure?': string;
+    'Enter Directory name': string;
+    'Create directory': string;
+    'type name': string;
+    'type dir name': string;
+    'Drop image': string;
+    'Drop file': string;
+    'or click': string;
+    'Alternative text': string;
+    Browse: string;
+    Upload: string;
+    Background: string;
+    Text: string;
+    Top: string;
+    Middle: string;
+    Bottom: string;
+    'Insert column before': string;
+    'Insert column after': string;
+    'Insert row above': string;
+    'Insert row below': string;
+    'Delete table': string;
+    'Delete row': string;
+    'Delete column': string;
+    'Empty cell': string;
+    Delete: string;
+    'Strike through': string;
+    Underline: string;
+    Break: string;
+    'Search for': string;
+    'Replace with': string;
+    Replace: string;
+    Edit: string;
+    'Vertical align': string;
+    'Horizontal align': string;
+    Filter: string;
+    'Sort by changed': string;
+    'Sort by name': string;
+    'Sort by size': string;
+    'Add folder': string;
+    'Split vertical': string;
+    'Split horizontal': string;
+    Split: string;
+    Merge: string;
+    'Add column': string;
+    'Add row': string;
+    Border: string;
+    'Embed code': string;
+    Update: string;
+    superscript: string;
+    subscript: string;
+    'Cut selection': string;
+    Paste: string;
+    'Choose Content to Paste': string;
+    'Chars: %d': string;
+    'Words: %d': string;
+    All: string;
+    'Select %s': string;
+    'Select all': string;
+    source: string;
+    bold: string;
+    italic: string;
+    brush: string;
+    link: string;
+    undo: string;
+    redo: string;
+    table: string;
+    image: string;
+    eraser: string;
+    paragraph: string;
+    fontsize: string;
+    video: string;
+    font: string;
+    about: string;
+    print: string;
+    underline: string;
+    strikethrough: string;
+    indent: string;
+    outdent: string;
+    fullsize: string;
+    shrink: string;
+    hr: string;
+    ul: string;
+    ol: string;
+    'Lower Alpha': string;
+    'Upper Alpha': string;
+    'Lower Roman': string;
+    'Upper Roman': string;
+    'Lower Greek': string;
+    cut: string;
+    selectall: string;
+    'Open link': string;
+    'Edit link': string;
+    'No follow': string;
+    Unlink: string;
+    Eye: string;
+    pencil: string;
+    ' URL': string;
+    Reset: string;
+    Save: string;
+    'Save as ...': string;
+    Resize: string;
+    Crop: string;
+    Width: string;
+    Height: string;
+    'Keep Aspect Ratio': string;
+    Yes: string;
+    No: string;
+    Remove: string;
+    Select: string;
+    'You can only edit your own images. Download this image on the host?': string;
+    'The image has been successfully uploaded to the host!': string;
+    palette: string;
+    'There are no files': string;
+    Rename: string;
+    'Enter new name': string;
+    preview: string;
+    download: string;
+    'Paste from clipboard': string;
+    "Your browser doesn't support direct access to the clipboard.": string;
+    'Copy selection': string;
+    copy: string;
+    'Border radius': string;
+    'Show all': string;
+    Apply: string;
+    'Please fill out this field': string;
+    'Please enter a web address': string;
+    Default: string;
+    Circle: string;
+    Dot: string;
+    Quadrate: string;
+    Find: string;
+    'Find Previous': string;
+    'Find Next': string;
+    'Insert className': string;
+    'Press Alt for custom resizing': string;
+    'License: %s': string;
+};
+export = _exports;