jodit 4.18.3 → 4.18.4

package/esm/plugins/resizer/config.js

@@ -4,12 +4,18 @@
  * Copyright (c) 2013-2026 Valerii Chupurnov. All rights reserved. https://xdsoft.net
  */
 import { Config } from "../../config.js";
-Config.prototype.allowResizeTags = new Set(['img', 'iframe', 'table', 'jodit']);
+Config.prototype.allowResizeTags = new Set([
+    'img',
+    'iframe',
+    'table',
+    'jodit',
+    'video'
+]);
 Config.prototype.resizer = {
     showSize: true,
     hideSizeTimeout: 1000,
     forImageChangeAttributes: true,
     min_width: 10,
     min_height: 10,
-    useAspectRatio: new Set(['img'])
+    useAspectRatio: new Set(['img', 'video'])
 };

package/esm/plugins/resizer/resizer.d.ts

@@ -26,6 +26,7 @@ export declare class resizer extends Plugin {
     private height;
     private ratio;
     private rect;
+    private layer;
     private sizeViewer;
     /** @override */
     protected afterInit(editor: IJodit): void;
@@ -33,6 +34,11 @@ export declare class resizer extends Plugin {
      * Click in the editor area
      */
     protected onEditorClick(e: MouseEvent): void;
+    /**
+     * What a click on `node` resizes: the media in it when it's a media
+     * wrapper (`jodit-media`, or one from `mediaWrappers`), or `node` itself
+     */
+    private __resizable;
     protected __afterInsertImage(image: HTMLImageElement): void;
     private addEventListeners;
     private onStartResizing;
@@ -46,6 +52,10 @@ export declare class resizer extends Plugin {
     private onClickOutside;
     private getWorkplacePosition;
     private applySize;
+    /**
+     * The framed element can go with a wrapper round it, keeping its parent
+     */
+    private get isElementInEditor();
     private onDelete;
     private __onChangeEditor;
     /**

package/esm/plugins/resizer/resizer.js

@@ -18,7 +18,7 @@ import { IS_ES_NEXT, IS_IE, KEY_ALT } from "../../core/constants.js";
 import { autobind, watch } from "../../core/decorators/index.js";
 import { Dom } from "../../core/dom/dom.js";
 import { eventEmitter, pluginSystem } from "../../core/global.js";
-import { $$, attr, css, dataBind, innerWidth, markOwner, offset } from "../../core/helpers/index.js";
+import { $$, attr, css, dataBind, getWrappedMedia, innerWidth, markOwner, offset } from "../../core/helpers/index.js";
 import { cssInline } from "../../core/helpers/utils/css.js";
 import { Plugin } from "../../core/plugin/plugin.js";
 import "./config.js";
@@ -36,6 +36,15 @@ function attrPixelSize(element, key) {
     }
     return parseFloat(value);
 }
+/**
+ * A video with no height of its own takes it from its width and its ratio,
+ * so resizing it keeps the ratio without setting a height.
+ */
+function heightFollowsWidth(element) {
+    return (Dom.isTag(element, 'video') &&
+        !attr(element, 'height') &&
+        !cssInline(element, 'height'));
+}
 /**
  * The module creates a supporting frame for resizing of the elements img and table
  */
@@ -58,6 +67,8 @@ export class resizer extends Plugin {
 				<div class="jodit-resizer__bottom-left"></div>
 				<span>100x100</span>
 			</div>`);
+        // Clips the frame to the workplace, without the frame making it scroll
+        this.layer = this.j.c.div('jodit-resizer-layer');
         this.sizeViewer = this.rect.getElementsByTagName('span')[0];
         this.pointerX = 0;
         this.pointerY = 0;
@@ -72,6 +83,10 @@ export class resizer extends Plugin {
                 if (Dom.isTag(this.element, 'img') && !this.element.complete) {
                     this.j.e.one(this.element, 'load', this.updateSize);
                 }
+                if (Dom.isTag(this.element, 'video') &&
+                    this.element.readyState < HTMLMediaElement.HAVE_METADATA) {
+                    this.j.e.one(this.element, 'loadedmetadata', this.updateSize);
+                }
             }
         };
         this.updateSize = () => {
@@ -135,14 +150,33 @@ export class resizer extends Plugin {
         let node = e.target;
         const { editor, options: { allowResizeTags } } = this.j;
         while (node && node !== editor) {
-            if (Dom.isTag(node, allowResizeTags)) {
-                this.__bind(node);
-                this.onClickElement(node);
+            const element = this.__resizable(node);
+            if (Dom.isTag(element, allowResizeTags)) {
+                this.__bind(element);
+                this.onClickElement(element);
                 return;
             }
             node = node.parentNode;
         }
     }
+    /**
+     * What a click on `node` resizes: the media in it when it's a media
+     * wrapper (`jodit-media`, or one from `mediaWrappers`), or `node` itself
+     */
+    __resizable(node) {
+        var _a;
+        const media = (_a = getWrappedMedia(this.j, node)) !== null && _a !== void 0 ? _a : (Dom.isHTMLElement(node) && attr(node, 'data-jodit_fake_wrapper')
+            ? node.firstElementChild
+            : null);
+        if (!media) {
+            return node;
+        }
+        // An embed is resized through its own wrapper
+        return Dom.isHTMLElement(media.parentNode) &&
+            attr(media.parentNode, 'data-jodit_iframe_wrapper')
+            ? media.parentNode
+            : media;
+    }
     __afterInsertImage(image) {
         if (this.j.o.resizer.forImageChangeAttributes) {
             return;
@@ -169,17 +203,15 @@ export class resizer extends Plugin {
         })
             .on(editor.ow, 'resize.resizer', this.updateSize)
             .on('resize.resizer', this.updateSize)
-            .on([editor.ow, editor.editor], 'scroll.resizer', () => {
-            if (this.isShown && !this.isResizeMode) {
-                this.hide();
-            }
-        })
+            // The frame is outside the content, so it's moved to follow the
+            // element as the content scrolls
+            .on([editor.ow, editor.editor], 'scroll.resizer', this.updateSize)
             .on(editor.ow, 'keydown.resizer', this.onKeyDown)
             .on(editor.ow, 'keyup.resizer', this.onKeyUp)
             .on(editor.ow, 'mouseup.resizer touchend.resizer', this.onClickOutside);
     }
     onStartResizing(resizeHandle, e) {
-        if (!this.element || !this.element.parentNode) {
+        if (!this.element || !this.isElementInEditor) {
             this.hide();
             return false;
         }
@@ -233,8 +265,9 @@ export class resizer extends Plugin {
             const className = this.handle.className;
             let new_w, new_h;
             const uar = this.j.o.resizer.useAspectRatio;
-            if (!this.isAltMode &&
-                (uar === true || (uar && Dom.isTag(this.element, uar)))) {
+            const keepRatio = !this.isAltMode &&
+                (uar === true || Boolean(uar && Dom.isTag(this.element, uar)));
+            if (keepRatio) {
                 if (diff_x) {
                     new_w =
                         this.width +
@@ -266,7 +299,8 @@ export class resizer extends Plugin {
                     this.applySize(this.element, 'width', '100%');
                 }
             }
-            if (new_h > this.j.o.resizer.min_height) {
+            if (new_h > this.j.o.resizer.min_height &&
+                !(keepRatio && heightFollowsWidth(this.element))) {
                 this.applySize(this.element, 'height', new_h);
             }
             this.updateSize();
@@ -312,10 +346,20 @@ export class resizer extends Plugin {
             css(element, key, value);
         }
     }
+    /**
+     * The framed element can go with a wrapper round it, keeping its parent
+     */
+    get isElementInEditor() {
+        return Boolean(this.element && this.j.editor.contains(this.element));
+    }
     onDelete(e) {
         if (!this.element) {
             return;
         }
+        if (!this.isElementInEditor) {
+            this.hide();
+            return;
+        }
         if (this.element.tagName !== 'JODIT') {
             this.j.s.select(this.element);
         }
@@ -327,7 +371,7 @@ export class resizer extends Plugin {
     }
     __onChangeEditor() {
         if (this.isShown) {
-            if (!this.element || !this.element.parentNode) {
+            if (!this.isElementInEditor) {
                 this.hide();
             }
             else {
@@ -439,9 +483,13 @@ export class resizer extends Plugin {
             return;
         }
         this.isShown = true;
+        if (this.layer.parentNode !== this.j.workplace) {
+            markOwner(this.j, this.layer);
+            Dom.append(this.j.workplace, this.layer);
+        }
         if (!this.rect.parentNode) {
             markOwner(this.j, this.rect);
-            Dom.append(this.j.workplace, this.rect);
+            Dom.append(this.layer, this.rect);
         }
         if (this.j.isFullSize) {
             css(this.rect, 'zIndex', css(this.j.container, 'zIndex').toString());
@@ -462,6 +510,7 @@ export class resizer extends Plugin {
     }
     beforeDestruct(jodit) {
         this.hide();
+        Dom.safeRemove(this.layer);
         eventEmitter.off('hideHelpers', this.hide);
         jodit.e.off(this.j.ow, '.resizer').off('.resizer');
     }

package/esm/plugins/video/config.d.ts

@@ -53,3 +53,9 @@ declare module 'jodit/config' {
         };
     }
 }
+/**
+ * The video popup's tabs: Upload, when the uploader is configured, then Link
+ * and Code. `insert` runs what a tab inserts, which by default goes in at the
+ * selection the popup was opened with.
+ */
+export declare function videoTabs(jodit: IJodit, close: () => void, insert?: (run: () => void) => void): HTMLElement;

package/esm/plugins/video/config.js

@@ -26,73 +26,85 @@ Config.prototype.video = {
     defaultHandlerSuccess: insertVideos
 };
 Icon.set('video', videoIcon);
-Config.prototype.controls.video = {
-    popup: (jodit, current, close) => {
-        const formLink = new UIForm(jodit, [
-            new UIBlock(jodit, [
-                new UIInput(jodit, {
-                    name: 'url',
-                    required: true,
-                    label: 'URL',
-                    placeholder: 'https://',
-                    validators: ['url']
-                })
-            ]),
-            new UIBlock(jodit, [
-                Button(jodit, '', 'Insert', 'primary').onAction(() => formLink.submit())
-            ])
-        ]), formCode = new UIForm(jodit, [
-            new UIBlock(jodit, [
-                new UITextArea(jodit, {
-                    name: 'code',
-                    required: true,
-                    label: 'Embed code'
-                })
-            ]),
-            new UIBlock(jodit, [
-                Button(jodit, '', 'Insert', 'primary').onAction(() => formCode.submit())
-            ])
-        ]), tabs = [], insertCode = (code) => {
-            jodit.s.restore();
-            jodit.s.insertHTML(prepareEmbedCode(jodit, code));
-            close();
-        };
+/**
+ * The video popup's tabs: Upload, when the uploader is configured, then Link
+ * and Code. `insert` runs what a tab inserts, which by default goes in at the
+ * selection the popup was opened with.
+ */
+export function videoTabs(jodit, close, insert) {
+    const run = insert !== null && insert !== void 0 ? insert : ((fn) => {
+        jodit.s.restore();
+        fn();
+    });
+    const formLink = new UIForm(jodit, [
+        new UIBlock(jodit, [
+            new UIInput(jodit, {
+                name: 'url',
+                required: true,
+                label: 'URL',
+                placeholder: 'https://',
+                validators: ['url']
+            })
+        ]),
+        new UIBlock(jodit, [
+            Button(jodit, '', 'Insert', 'primary').onAction(() => formLink.submit())
+        ])
+    ]), formCode = new UIForm(jodit, [
+        new UIBlock(jodit, [
+            new UITextArea(jodit, {
+                name: 'code',
+                required: true,
+                label: 'Embed code'
+            })
+        ]),
+        new UIBlock(jodit, [
+            Button(jodit, '', 'Insert', 'primary').onAction(() => formCode.submit())
+        ])
+    ]), tabs = [], insertCode = (code) => {
+        run(() => jodit.s.insertHTML(prepareEmbedCode(jodit, code)));
+        close();
+    };
+    if (!insert) {
         jodit.s.save();
-        const { uploader } = jodit.o;
-        // Base64 alone would put whole video files into the content
-        if (uploader.showTabInFileSelector !== false &&
-            (uploader.url || uploader.customUploadFunction)) {
-            tabs.push(UploadTab(jodit, data => {
+    }
+    const { uploader } = jodit.o;
+    // Base64 alone would put whole video files into the content
+    if (uploader.showTabInFileSelector !== false &&
+        (uploader.url || uploader.customUploadFunction)) {
+        tabs.push(UploadTab(jodit, data => {
+            run(() => {
                 var _a, _b;
-                jodit.s.restore();
-                ((_b = (_a = jodit.o.video) === null || _a === void 0 ? void 0 : _a.defaultHandlerSuccess) !== null && _b !== void 0 ? _b : insertVideos).call(jodit, data);
-            }, { label: 'Drop file', accept: 'video/*' }));
-        }
-        tabs.push({
-            icon: 'link',
-            name: 'Link',
-            content: formLink.container
-        }, {
-            icon: 'source',
-            name: 'Code',
-            content: formCode.container
-        });
-        formLink.onSubmit(data => {
-            var _a, _b, _c, _d;
-            insertCode(call((_b = (_a = jodit.o.video) === null || _a === void 0 ? void 0 : _a.parseUrlToVideoEmbed) !== null && _b !== void 0 ? _b : convertMediaUrlToVideoEmbed, data.url, {
-                width: (_c = jodit.o.video) === null || _c === void 0 ? void 0 : _c.defaultWidth,
-                height: (_d = jodit.o.video) === null || _d === void 0 ? void 0 : _d.defaultHeight
-            }));
-        });
-        formCode.onSubmit(data => {
-            insertCode(data.code);
-        });
-        const box = TabsWidget(jodit, tabs);
-        // Its tabs are sized to their labels, as the file selector's are, since
-        // "Upload" doesn't fit a third of the popup
-        box.classList.add('jodit-file-selector');
-        return box;
-    },
+                return ((_b = (_a = jodit.o.video) === null || _a === void 0 ? void 0 : _a.defaultHandlerSuccess) !== null && _b !== void 0 ? _b : insertVideos).call(jodit, data);
+            });
+        }, { label: 'Drop file', accept: 'video/*' }));
+    }
+    tabs.push({
+        icon: 'link',
+        name: 'Link',
+        content: formLink.container
+    }, {
+        icon: 'source',
+        name: 'Code',
+        content: formCode.container
+    });
+    formLink.onSubmit(data => {
+        var _a, _b, _c, _d;
+        insertCode(call((_b = (_a = jodit.o.video) === null || _a === void 0 ? void 0 : _a.parseUrlToVideoEmbed) !== null && _b !== void 0 ? _b : convertMediaUrlToVideoEmbed, data.url, {
+            width: (_c = jodit.o.video) === null || _c === void 0 ? void 0 : _c.defaultWidth,
+            height: (_d = jodit.o.video) === null || _d === void 0 ? void 0 : _d.defaultHeight
+        }));
+    });
+    formCode.onSubmit(data => {
+        insertCode(data.code);
+    });
+    const box = TabsWidget(jodit, tabs);
+    // Its tabs are sized to their labels, as the file selector's are, since
+    // "Upload" doesn't fit a third of the popup
+    box.classList.add('jodit-file-selector');
+    return box;
+}
+Config.prototype.controls.video = {
+    popup: (jodit, current, close) => videoTabs(jodit, close),
     tags: ['iframe'],
     tooltip: 'Insert youtube/vimeo video'
 };

package/esm/plugins/video-properties/interface.d.ts

@@ -0,0 +1,31 @@
+/*!
+ * 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
+ */
+/**
+ * @module plugins/video-properties
+ */
+export type EditedMedia = HTMLVideoElement | HTMLAudioElement | HTMLIFrameElement;
+export interface VideoPropertiesValues {
+    width: number | string;
+    height: number | string;
+    poster: string;
+    autoplay: boolean;
+    loop: boolean;
+    muted: boolean;
+    controls: boolean;
+}
+export interface VideoPropertiesState {
+    /**
+     * What the dialog was opened for: the media, or a wrapper round it
+     */
+    target: HTMLElement;
+    media: EditedMedia;
+    ratio: number;
+    sizeIsLocked: boolean;
+    values: VideoPropertiesValues;
+}
+export interface VideoPropertiesAPI {
+    openPosterPopup: (target: HTMLElement) => void;
+}

package/esm/plugins/video-properties/interface.js

@@ -0,0 +1,6 @@
+/*!
+ * 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
+ */
+export {};

package/esm/plugins/video-properties/readers.d.ts

@@ -0,0 +1,26 @@
+/*!
+ * 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
+ */
+/**
+ * @module plugins/video-properties
+ */
+import type { Nullable } from "../../types/index";
+import type { EditedMedia, VideoPropertiesState } from "./interface";
+/**
+ * The media `target` is, or holds as its wrapper (`jodit-media`, the resizer's
+ * `jodit` for an embed, or one from `mediaWrappers`)
+ * @private
+ */
+export declare function editedMedia(target: HTMLElement): Nullable<EditedMedia>;
+/**
+ * The size `media` is given, inline or by its attribute
+ * @private
+ */
+export declare function ownSize(media: EditedMedia, key: 'width' | 'height'): string;
+/**
+ * Read the media's values into the state
+ * @private
+ */
+export declare function readValues(state: VideoPropertiesState): void;

package/esm/plugins/video-properties/readers.js

@@ -0,0 +1,65 @@
+/*!
+ * 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
+ */
+import { Dom } from "../../core/dom/dom.js";
+import { isNumeric } from "../../core/helpers/checker/is-numeric.js";
+import { attr } from "../../core/helpers/utils/attr.js";
+import { cssInline } from "../../core/helpers/utils/css.js";
+import { normalSizeFromString } from "../image-properties/utils/utils.js";
+const mediaSelector = 'video, audio, iframe';
+/**
+ * The media `target` is, or holds as its wrapper (`jodit-media`, the resizer's
+ * `jodit` for an embed, or one from `mediaWrappers`)
+ * @private
+ */
+export function editedMedia(target) {
+    return (target.matches(mediaSelector)
+        ? target
+        : target.querySelector(mediaSelector));
+}
+/**
+ * The size `media` is given, inline or by its attribute
+ * @private
+ */
+export function ownSize(media, key) {
+    return cssInline(media, key) || attr(media, key) || '';
+}
+const toNumber = (value) => parseFloat(value.toString());
+/**
+ * Read the media's values into the state
+ * @private
+ */
+export function readValues(state) {
+    const { media, values } = state;
+    const width = ownSize(media, 'width');
+    const height = ownSize(media, 'height');
+    values.width = width ? normalSizeFromString(width) : media.offsetWidth;
+    values.height = height ? normalSizeFromString(height) : '';
+    if (Dom.isTag(media, 'video') && media.videoWidth) {
+        state.ratio = media.videoWidth / media.videoHeight;
+    }
+    else if (isNumeric(values.width) && isNumeric(values.height)) {
+        state.ratio = toNumber(values.width) / toNumber(values.height);
+    }
+    else {
+        state.ratio = media.offsetWidth / media.offsetHeight || 1;
+    }
+    // One with no height takes it from its width
+    if (!height && isNumeric(values.width)) {
+        values.height = Math.round(toNumber(values.width) / state.ratio);
+    }
+    state.sizeIsLocked =
+        isNumeric(values.width) &&
+            isNumeric(values.height) &&
+            (!height ||
+                Math.abs(toNumber(values.width) - toNumber(values.height) * state.ratio) < 1);
+    values.poster = attr(media, 'poster') || '';
+    values.autoplay = media.hasAttribute('autoplay');
+    values.loop = media.hasAttribute('loop');
+    // Autoplay's own: turning it off gives the sound back
+    values.muted = media.hasAttribute('muted') && !values.autoplay;
+    // Without Autoplay it keeps its controls, or it could never be played
+    values.controls = media.hasAttribute('controls') || !values.autoplay;
+}

package/esm/plugins/video-properties/replace.d.ts

@@ -0,0 +1,15 @@
+/*!
+ * 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
+ */
+/**
+ * @module plugins/video-properties
+ */
+import type { IJodit } from "../../types/index";
+/**
+ * Run `insert`, which inserts media at the cursor, with the cursor after
+ * `replaced`, and put what it inserts in place of `replaced`
+ * @private
+ */
+export declare function replaceMedia(j: IJodit, replaced: HTMLElement, insert: () => void): void;

package/esm/plugins/video-properties/replace.js

@@ -0,0 +1,97 @@
+/*!
+ * 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
+ */
+import { Dom } from "../../core/dom/dom.js";
+import { attr } from "../../core/helpers/utils/attr.js";
+import { css } from "../../core/helpers/utils/css.js";
+import { editedMedia, ownSize, readValues } from "./readers.js";
+import { applyValues } from "./writers.js";
+/**
+ * Give `media`, in `outer`, the classes, inline styles, size and playback
+ * settings of `old`, in `oldOuter`. It keeps its own source and poster.
+ */
+function takeOver(j, oldOuter, old, outer, media) {
+    var _a;
+    const state = {
+        target: oldOuter,
+        media: old,
+        ratio: 1,
+        sizeIsLocked: true,
+        values: {
+            width: '',
+            height: '',
+            poster: '',
+            autoplay: false,
+            loop: false,
+            muted: false,
+            controls: true
+        }
+    };
+    readValues(state);
+    const pairs = [[old, media]];
+    // A wrapper kept in the content, which holds the alignment
+    if (oldOuter !== old &&
+        outer !== media &&
+        oldOuter.nodeName === outer.nodeName) {
+        pairs.push([oldOuter, outer]);
+    }
+    pairs.forEach(([from, to]) => {
+        ['class', 'style'].forEach(name => attr(to, name, attr(from, name)));
+    });
+    // A video's size is CSS and an embed's its attributes, so the writer sizes
+    // one that's a different element
+    if (old.nodeName !== media.nodeName) {
+        css(media, { width: null, height: null });
+        if (!((_a = attr(media, 'style')) === null || _a === void 0 ? void 0 : _a.trim())) {
+            attr(media, 'style', null);
+        }
+    }
+    state.media = media;
+    state.values.poster = attr(media, 'poster') || '';
+    applyValues(j, state, Boolean(ownSize(old, 'width') || ownSize(old, 'height')));
+}
+/**
+ * Run `insert`, which inserts media at the cursor, with the cursor after
+ * `replaced`, and put what it inserts in place of `replaced`
+ * @private
+ */
+export function replaceMedia(j, replaced, insert) {
+    const inserted = [];
+    const collect = (node) => {
+        inserted.push(node);
+    };
+    j.history.snapshot.transaction(() => {
+        j.s.focus();
+        j.s.setCursorAfter(replaced);
+        j.e.on('afterInsertNode', collect);
+        try {
+            insert();
+        }
+        finally {
+            j.e.off('afterInsertNode', collect);
+        }
+        const [outer] = inserted;
+        if (!Dom.isHTMLElement(outer)) {
+            return;
+        }
+        const old = editedMedia(replaced);
+        const media = editedMedia(outer);
+        if (old && media) {
+            takeOver(j, replaced, old, outer, media);
+        }
+        // The resizer can have put an embed in its own wrapper already
+        const placed = Dom.isHTMLElement(outer.parentElement) &&
+            attr(outer.parentElement, 'data-jodit-temp')
+            ? outer.parentElement
+            : outer;
+        // Where the old one was, since media Jodit counts as blocks can be put
+        // after the paragraph
+        Dom.before(replaced, placed);
+        Dom.safeRemove(replaced);
+        j.s.setCursorAfter(placed);
+    });
+    j.synchronizeValues();
+    j.e.fire('closeAllPopups');
+}