import { __decorate, __extends } from "tslib";
// This code is largery borrowed from https://github.com/froala/vue-froala-wysiwyg.
// However some changes have been made to "inputify" the froala editor and render is compatible with modUL input-style.
import FroalaEditor from 'froala-editor';
import 'froala-editor/css/froala_editor.pkgd.min.css';
import 'froala-editor/css/froala_style.min.css';
import 'froala-editor/js/languages/fr.js';
import 'froala-editor/js/plugins.pkgd.min.js';
import $ from 'jquery';
import Component from 'vue-class-component';
import { Emit, Prop, Watch } from 'vue-property-decorator';
import { ElementQueries } from '../../../mixins/element-queries/element-queries';
import { replaceTags } from '../../../utils/clean/htmlClean';
import { ScrollToDuration } from '../../../utils/scroll-to/scroll-to';
import uuid from '../../../utils/uuid/uuid';
import { ModulVue } from '../../../utils/vue/vue';
import '../rte-internal.scss';
import boldIcon from '../svg/Froala-bold.svg';
import listsIcon from '../svg/Froala-lists.svg';
import replaceIcon from '../svg/Froala-replace.svg';
import specialCharsIcon from '../svg/Froala-special-charracters.svg';
import stylesIcon from '../svg/Froala-styles.svg';
import titleIcon from '../svg/Froala-title.svg';
import { ImageLayoutCommands } from './image-layout-commands';
import WithRender from './vue-froala.html?style=./vue-froala.scss';
// import { PopupPlugin } from './popup-plugin';
// import SubMenuPlugin from './submenu-plugin';
// Bug placeholder in the version 3.0.5.
// Bug watch 'The button "Special Characters" isn't work in mobile'  https://github.com/froala/wysiwyg-editor/issues/3650
// Bug watch "JQuery dependence isn't fully removed from Froala" https://github.com/froala/wysiwyg-editor/issues/3649
// Bug watch "Placeholder text is not aligned with the cursor in inline mode after 3.0.5" https://github.com/froala/wysiwyg-editor/issues/3628
var froalaEvents;
(function (froalaEvents) {
    froalaEvents["Blur"] = "blur";
    froalaEvents["Click"] = "click";
    froalaEvents["CommandAfter"] = "commands.after";
    froalaEvents["CommandBefore"] = "commands.before";
    froalaEvents["ContentChanged"] = "contentChanged";
    froalaEvents["Focus"] = "focus";
    froalaEvents["ImageInserted"] = "image.inserted";
    froalaEvents["ImageRemoved"] = "image.removed";
    froalaEvents["ImageResizeEnd"] = "image.resizeEnd";
    froalaEvents["Initialized"] = "initialized";
    froalaEvents["InitializationDelayed"] = "initializationDelayed";
    froalaEvents["KeyDown"] = "keydown";
    froalaEvents["KeyUp"] = "keyup";
    froalaEvents["PasteAfter"] = "paste.after";
    froalaEvents["PasteAfterCleanup"] = "paste.afterCleanup";
    froalaEvents["ShowLinkInsert"] = "popups.show.link.insert";
})(froalaEvents || (froalaEvents = {}));
var FroalaElements;
(function (FroalaElements) {
    FroalaElements["TOOLBAR"] = ".fr-toolbar";
})(FroalaElements || (FroalaElements = {}));
var FroalaBreakingPoint;
(function (FroalaBreakingPoint) {
    FroalaBreakingPoint[FroalaBreakingPoint["minDefault"] = 545] = "minDefault";
    FroalaBreakingPoint[FroalaBreakingPoint["minOneMode"] = 565] = "minOneMode";
})(FroalaBreakingPoint || (FroalaBreakingPoint = {}));
export var FroalaStatus;
(function (FroalaStatus) {
    FroalaStatus["Blurring"] = "blurring";
    FroalaStatus["Blurred"] = "blurred";
    FroalaStatus["Focused"] = "focused";
})(FroalaStatus || (FroalaStatus = {}));
export var FroalaToolbarButtons;
(function (FroalaToolbarButtons) {
    FroalaToolbarButtons[FroalaToolbarButtons["moreTextVisible"] = 6] = "moreTextVisible";
    FroalaToolbarButtons[FroalaToolbarButtons["moreTextVisibleXS"] = 0] = "moreTextVisibleXS";
    FroalaToolbarButtons[FroalaToolbarButtons["moreParagraphVisible"] = 5] = "moreParagraphVisible";
    FroalaToolbarButtons[FroalaToolbarButtons["moreParagraphVisibleXS"] = 0] = "moreParagraphVisibleXS";
    FroalaToolbarButtons[FroalaToolbarButtons["moreRichVisible"] = 3] = "moreRichVisible";
    FroalaToolbarButtons[FroalaToolbarButtons["moreRichVisibleXS"] = 3] = "moreRichVisibleXS";
    FroalaToolbarButtons[FroalaToolbarButtons["moreMiscVisible"] = 1] = "moreMiscVisible";
    FroalaToolbarButtons[FroalaToolbarButtons["moreMiscVisibleXS"] = 1] = "moreMiscVisibleXS";
})(FroalaToolbarButtons || (FroalaToolbarButtons = {}));
var ENTER_KEYCODE = 13;
var SCROLL_TO_OFFSET = -50;
var VueFroala = /** @class */ (function (_super) {
    __extends(VueFroala, _super);
    function VueFroala() {
        var _this = _super !== null && _super.apply(this, arguments) || this;
        _this.internalValue = '';
        _this.currentTag = 'div';
        _this.listeningEvents = [];
        _this.froalaEditor = undefined;
        _this.currentConfig = undefined;
        _this.defaultConfig = {
            immediateVueModelUpdate: false,
            vueIgnoreAttrs: undefined
        };
        _this.initEvents = [];
        _this.isFocused = false;
        _this.isInitialized = false;
        _this.isLoaded = false;
        _this.froalaClientWidth = 0;
        _this.isDirty = false;
        _this.status = FroalaStatus.Blurred;
        _this.isFileUploadOpen = false;
        _this.fileUploadStoreName = uuid.generate();
        _this.imageExtensions = ['jpg', 'jpeg', 'png', 'gif', 'svg', 'bmp'];
        _this.allowedExtensions = [];
        _this.mousedownTriggered = false;
        _this.mousedownInsideEditor = false;
        return _this;
    }
    VueFroala.prototype.onFullscreen = function (fullscreenWasActived) { };
    VueFroala.prototype.refreshValue = function () {
        this.htmlSet();
    };
    VueFroala.prototype.setClientWidth = function () {
        this.froalaClientWidth = this.$el.clientWidth;
    };
    Object.defineProperty(VueFroala.prototype, "isEmpty", {
        get: function () {
            return this.value.length === 0;
        },
        enumerable: false,
        configurable: true
    });
    VueFroala.prototype.addCustomIcons = function () {
        FroalaEditor.DefineIconTemplate('custom-icons', '[SVG]');
        FroalaEditor.DefineIconTemplate('custom-icons-sub-menu', '<div class="fr-sub-menu">[SVG]</div>');
        if (this.$i18n.currentLang() === 'fr') {
            FroalaEditor.DefineIcon('bold', { SVG: boldIcon, template: 'custom-icons' });
        }
        if (this.config && this.config.pluginsEnabled.includes('image')) {
            this.addImageButton();
        }
        FroalaEditor.DefineIcon('paragraphStyle', { SVG: titleIcon, template: 'custom-icons' });
        FroalaEditor.DefineIcon('moreText', { SVG: stylesIcon, template: 'custom-icons-sub-menu' });
        FroalaEditor.DefineIcon('moreParagraph', { SVG: listsIcon, template: 'custom-icons-sub-menu' });
        FroalaEditor.DefineIcon('specialCharacters', { SVG: specialCharsIcon, template: 'custom-icons' });
    };
    VueFroala.prototype.addImageButton = function () {
        FroalaEditor.RegisterCommand('insertImage', {
            title: this.$i18n.translate('m-rich-text-editor:insert-image'),
            undo: true,
            focus: true,
            showOnMobile: true,
            refreshAfterCallback: false,
            callback: function () {
                var vueFroala = this.$oel[0].parentNode.__vue__;
                vueFroala.allowedExtensions = this.imageExtensions;
                vueFroala.isFileUploadOpen = true;
                vueFroala.selectedImage = undefined;
            }
        });
        FroalaEditor.DefineIcon('imageReplace', { SVG: replaceIcon, template: 'custom-icons' });
        FroalaEditor.RegisterCommand('imageReplace', {
            title: this.$i18n.translate('m-rich-text-editor:replace-image'),
            undo: true,
            focus: true,
            showOnMobile: true,
            callback: function () {
                var vueFroala = this.$oel[0].parentNode.__vue__;
                vueFroala.allowedExtensions = this.imageExtensions;
                vueFroala.isFileUploadOpen = true;
            },
            refresh: function () {
                var vueFroala = this.$oel[0].parentNode.__vue__;
                var selectedElement = vueFroala.froalaEditor.selection.element();
                if (selectedElement.tagName === 'IMG') {
                    vueFroala.selectedImage = selectedElement;
                }
            }
        });
        ImageLayoutCommands.register(FroalaEditor);
    };
    VueFroala.prototype.filesReady = function (files) {
        this.$emit('image-ready', files[0], this.fileUploadStoreName);
    };
    VueFroala.prototype.onCloseFileUpload = function () {
        this.froalaEditor.events.focus();
    };
    VueFroala.prototype.filesAdded = function (files) {
        var _this = this;
        this.froalaEditor.opts.modulImageUploaded = true;
        this.$emit('image-added', files[0], function (file, id) {
            if (_this.selectedImage) {
                // Bug watch "JQuery dependence isn't fully removed from Froala" https://github.com/froala/angular-froala-wysiwyg/issues/324
                _this.froalaEditor.image.insert(file.url, false, { id: id }, $(_this.selectedImage)); // We need jquery for that function
                _this.selectedImage.removeAttribute('srcset');
            }
            else {
                _this.froalaEditor.image.insert(file.url, false, { id: id });
            }
        });
    };
    VueFroala.prototype.created = function () {
        document.addEventListener('mousedown', this.mousedownListener);
        document.addEventListener('mouseup', this.mouseupListener, true);
        this.currentTag = this.tag || this.currentTag;
    };
    VueFroala.prototype.mousedownListener = function (event) {
        this.mousedownTriggered = true;
        if (this.$el.contains(event.target) || document.body.querySelector('.fr-modal.fr-active')) {
            this.mousedownInsideEditor = true;
        }
        else {
            this.mousedownInsideEditor = false;
        }
    };
    VueFroala.prototype.mouseupListener = function (event) {
        if (!this.mousedownInsideEditor && !this.$el.contains(event.target) && this.isFocused
            && !this.isFileUploadOpen && !document.body.querySelector('.fr-image-resizer.fr-active')) {
            this.mousedownTriggered = false;
            this.closeEditor();
        }
    };
    VueFroala.prototype.mounted = function () {
        if (FroalaEditor !== undefined && this.config !== undefined) {
            if (FroalaEditor.LANGUAGE[this.config.language] !== undefined && this.customTranslations !== undefined) {
                Object.assign(FroalaEditor.LANGUAGE[this.config.language].translation, this.customTranslations);
            }
            this.createEditor();
        }
    };
    VueFroala.prototype.destroyed = function () {
        window.removeEventListener('resize', this.onResize);
        document.removeEventListener('mousedown', this.mousedownListener);
        document.removeEventListener('mouseup', this.mouseupListener);
    };
    VueFroala.prototype.beforeDestroy = function () {
        this.destroyEditor();
    };
    Object.defineProperty(VueFroala.prototype, "collapsed", {
        get: function () {
            return !this.isFocused && this.isEmpty;
        },
        enumerable: false,
        configurable: true
    });
    VueFroala.prototype.onResize = function () {
        this.setClientWidth();
        if (!this.isFocused) {
            this.adjusteToolbarPosition();
        }
    };
    VueFroala.prototype.createEditor = function () {
        var _a;
        var _this = this;
        if (this.isInitialized) {
            return;
        }
        this.setClientWidth();
        this.setFroalaToolbarDesktop();
        this.addCustomIcons();
        this.currentConfig = Object.assign(this.config || this.defaultConfig, {
            // we reemit each valid input events so froala can work in input-style component.
            events: (_a = {},
                _a[froalaEvents.InitializationDelayed] = function () {
                    _this.isLoaded = true;
                    _this.setReadOnly();
                    _this.htmlSet();
                    window.addEventListener('resize', _this.onResize);
                },
                _a[froalaEvents.ContentChanged] = function () {
                    _this.updateModel();
                },
                _a[froalaEvents.Focus] = function () {
                    _this.activateRichText();
                },
                _a[froalaEvents.Blur] = function () {
                    if (!_this.mousedownTriggered && !_this.isFileUploadOpen) {
                        _this.closeEditor();
                    }
                },
                _a[froalaEvents.KeyUp] = function (key) {
                    if (_this.currentConfig.immediateVueModelUpdate) {
                        _this.updateModel();
                    }
                    _this.$emit('keyup');
                },
                _a[froalaEvents.KeyDown] = function (key) {
                    _this.$emit('keydown');
                    _this.isDirty = true;
                    if (key.keyCode === ENTER_KEYCODE) {
                        _this.froalaEditor.paragraphStyle.apply('');
                    }
                },
                _a[froalaEvents.PasteAfter] = function () {
                    _this.$emit('paste');
                },
                // if we use pasteBeforeCleanup, there's an error in froala's code
                _a[froalaEvents.PasteAfterCleanup] = function (data) {
                    if (data.replace) {
                        data = replaceTags(['h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'div'], 'p', data);
                        return _this.froalaEditor.clean.html(data, ['table', 'video', 'u', 's', 'blockquote', 'button', 'input', 'img']);
                    }
                },
                _a[froalaEvents.CommandBefore] = function (cmd, param1, param2) {
                    if (cmd === 'fullscreen') {
                        var fullscreenWasActivated = !_this.froalaEditor.fullscreen.isActive();
                        if (fullscreenWasActivated) {
                            _this.froalaEditor.toolbar.hide();
                        }
                        else {
                            _this.$scrollTo.goTo(_this.$el, SCROLL_TO_OFFSET, ScrollToDuration.Instant);
                        }
                        _this.onFullscreen(fullscreenWasActivated);
                    }
                },
                _a[froalaEvents.CommandAfter] = function (cmd, param1, param2) {
                    if (cmd === 'fullscreen') {
                        if (_this.froalaEditor.fullscreen.isActive()) {
                            _this.froalaEditor.toolbar.show();
                        }
                        else {
                            _this.$scrollTo.goTo(_this.$el, SCROLL_TO_OFFSET, ScrollToDuration.Instant);
                            _this.froalaEditor.events.focus();
                        }
                    }
                },
                _a[froalaEvents.ShowLinkInsert] = function () {
                    _this.manageLinkInsert();
                },
                _a[froalaEvents.ImageRemoved] = function ($img) {
                    _this.$emit('image-removed', $img[0].dataset.id, _this.fileUploadStoreName);
                    _this.updateModel();
                },
                _a[froalaEvents.ImageInserted] = function ($img) {
                    if (_this.froalaEditor.opts.modulImageUploaded) {
                        $img[0].alt = '';
                        $img[0].classList.add(ImageLayoutCommands.DEFAULT_IMG_LAYOUT_CLASS);
                        $img[0].sizes = '100vw';
                        _this.updateModel();
                    }
                    else {
                        setTimeout(function () {
                            _this.froalaEditor.image.remove($img);
                        });
                    }
                    _this.froalaEditor.opts.modulImageUploaded = false;
                },
                _a[froalaEvents.ImageResizeEnd] = function ($img) {
                    _this.setImageSizes($img[0]);
                    _this.updateModel();
                },
                _a)
        });
        this.froalaEditor = new FroalaEditor(this.$refs.editor, this.currentConfig, function () {
            _this.isInitialized = true;
            _this.setDisabled();
            _this.manageInitialFocus();
        });
    };
    VueFroala.prototype.setImageSizes = function (img) {
        var _this = this;
        setTimeout(function () {
            var viewportWidth = Math.round(img.clientWidth / _this.froalaClientWidth * 100);
            img.sizes = viewportWidth + "vw";
        }, 0);
    };
    VueFroala.prototype.setFroalaToolbarDesktop = function () {
        if (this.froalaClientWidth < 550) {
            // toolbar for desktop devices with RTE Width with less then 550 px
            this.config.toolbarButtons.moreText.buttonsVisible = FroalaToolbarButtons.moreTextVisibleXS;
            this.config.toolbarButtons.moreParagraph.buttonsVisible = FroalaToolbarButtons.moreParagraphVisibleXS;
            this.config.toolbarButtons.moreRich.buttonsVisible = FroalaToolbarButtons.moreRichVisibleXS;
            this.config.toolbarButtons.moreMisc.buttonsVisible = FroalaToolbarButtons.moreMiscVisibleXS;
        }
        else {
            // toolbar for desktop devices with RTE Width with or more then 550 px
            this.config.toolbarButtons.moreText.buttonsVisible = FroalaToolbarButtons.moreTextVisible;
            this.config.toolbarButtons.moreParagraph.buttonsVisible = FroalaToolbarButtons.moreParagraphVisible;
            this.config.toolbarButtons.moreRich.buttonsVisible = FroalaToolbarButtons.moreRichVisible;
            this.config.toolbarButtons.moreMisc.buttonsVisible = FroalaToolbarButtons.moreMiscVisible;
        }
    };
    VueFroala.prototype.closeEditor = function () {
        this.status = FroalaStatus.Blurring;
        window.addEventListener('resize', this.onResize);
        this.$emit('blur');
        this.hideToolbar();
        this.isFocused = false;
        this.status = FroalaStatus.Blurred;
        this.isDirty = false;
        this.internalReadonly = false;
        this.isDisabled = this.disabled;
    };
    VueFroala.prototype.setDisabled = function () {
        // We have to delay the initialization of disabled until the rich text is initialized.
        // It will remain glitchy otherwise when combined with init on click.
        // See comment https://github.com/froala/angular-froala-wysiwyg/issues/75#issuecomment-310709095
        if (this.isInitialized) {
            this.isDisabled = this.disabled;
        }
    };
    Object.defineProperty(VueFroala.prototype, "isDisabled", {
        get: function () {
            return this.disabled;
        },
        set: function (value) {
            if (value) {
                this.froalaEditor.edit.off();
            }
            else {
                this.froalaEditor.edit.on();
            }
        },
        enumerable: false,
        configurable: true
    });
    VueFroala.prototype.setReadOnly = function () {
        this.internalReadonly = this.readonly;
    };
    VueFroala.prototype.simulateReadonlyBlur = function (event) {
        if (!this.$el.contains(event.target)) {
            if (this.isFocused) {
                this.froalaEditor.edit.on();
                this.froalaEditor.events.trigger('blur');
            }
            document.removeEventListener('mousedown', this.simulateReadonlyBlur, true);
        }
    };
    Object.defineProperty(VueFroala.prototype, "internalReadonly", {
        get: function () {
            return this.readonly;
        },
        set: function (value) {
            if (!this.froalaEditor) {
                return;
            }
            document.removeEventListener('mousedown', this.simulateReadonlyBlur, true);
            if (value) {
                if (this.isFocused) {
                    this.hideToolbar();
                    document.addEventListener('mousedown', this.simulateReadonlyBlur, true);
                    this.froalaEditor.edit.off();
                }
            }
            else {
                this.froalaEditor.edit.on();
            }
        },
        enumerable: false,
        configurable: true
    });
    VueFroala.prototype.editorIsAvailable = function () {
        return this.froalaEditor !== undefined && this.froalaEditor !== null && this.isInitialized;
    };
    VueFroala.prototype.manageInitialFocus = function () {
        // the editor might or might not be focused when initializing.  If it is focused, we have to emit the focus event.  Otherwise, we have to hide the toolbar.
        if (!this.froalaEditor.core.hasFocus()) {
            this.hideToolbar();
        }
        else {
            this.$emit('focus');
        }
    };
    VueFroala.prototype.manageLinkInsert = function () {
        var popup = this.froalaEditor.popups.get('link.insert')[0];
        var urlField = popup.querySelector("[name=\"href\"]");
        if (!urlField.value) {
            popup.querySelector("[name=\"target\"]").checked = true;
        }
    };
    VueFroala.prototype.onClick = function (event) {
        if (this.froalaEditor.popups) {
            event.stopPropagation();
        }
        else {
            this.$emit('click');
        }
    };
    VueFroala.prototype.hideToolbar = function () {
        if (this.editorIsAvailable()) {
            this.froalaEditor.toolbar.hide();
            this.adjusteToolbarPosition();
        }
    };
    VueFroala.prototype.showToolbar = function () {
        var toolBar = this.$el.querySelector(FroalaElements.TOOLBAR);
        if (this.editorIsAvailable() && !this.internalReadonly && toolBar) {
            this.froalaEditor.toolbar.show();
            toolBar.style.removeProperty('margin-top');
        }
    };
    VueFroala.prototype.adjusteToolbarPosition = function () {
        var toolBar = this.$el.querySelector(FroalaElements.TOOLBAR);
        if (toolBar) {
            toolBar.style.marginTop = "-" + toolBar.offsetHeight + "px";
        }
    };
    VueFroala.prototype.destroyEditor = function () {
        this.isLoaded = false;
        this.isInitialized = false;
        this.isFocused = false;
        if (this.froalaEditor) {
            this.froalaEditor.destroy();
        }
        this.listeningEvents.length = 0;
        this.froalaEditor = undefined;
        this.internalReadonly = false;
    };
    VueFroala.prototype.activateRichText = function () {
        if (!this.disabled) {
            window.removeEventListener('resize', this.onResize);
            if (this.isInitialized) {
                this.$emit('focus');
            }
            this.showToolbar();
            this.isFocused = true;
            this.status = FroalaStatus.Focused;
            this.internalReadonly = this.readonly;
        }
    };
    VueFroala.prototype.updateModel = function () {
        var returnedHtml = this.froalaEditor.html.get();
        if (this.internalValue === returnedHtml) {
            return;
        }
        var modelContent = this.removeEmptyHTML(returnedHtml);
        this.internalValue = returnedHtml;
        this.$emit('input', modelContent);
    };
    VueFroala.prototype.removeEmptyHTML = function (value) {
        var div = document.createElement('div');
        div.innerHTML = value;
        if ((div.textContent || div.innerText || '').trim().length > 0) {
            return value;
        }
        else if (value.includes('<img')) {
            return value;
        }
        return '';
    };
    VueFroala.prototype.htmlSet = function () {
        if (this.internalValue === this.value || !this.isLoaded) {
            return;
        }
        if (this.froalaEditor) {
            this.internalValue = this.value;
            this.froalaEditor.html.set(this.value || '', true);
            if (this.froalaEditor.undo) {
                // This will reset the undo stack everytime the model changes externally. Can we fix this?
                this.froalaEditor.undo.reset();
                this.froalaEditor.undo.saveStep();
            }
        }
    };
    Object.defineProperty(VueFroala.prototype, "minHeight", {
        get: function () {
            var padding = 11;
            var lineHeight = 21;
            var lineMargin = 12;
            var rowHeight = lineHeight + lineMargin;
            return this.minRows > 1 ? this.minRows * rowHeight - lineMargin + 2 * padding + 'px' : 'initial';
        },
        enumerable: false,
        configurable: true
    });
    __decorate([
        Prop({
            default: 'div'
        })
    ], VueFroala.prototype, "tag", void 0);
    __decorate([
        Prop({ default: '' })
    ], VueFroala.prototype, "value", void 0);
    __decorate([
        Prop({ default: false })
    ], VueFroala.prototype, "disabled", void 0);
    __decorate([
        Prop({ default: false })
    ], VueFroala.prototype, "readonly", void 0);
    __decorate([
        Prop()
    ], VueFroala.prototype, "config", void 0);
    __decorate([
        Prop()
    ], VueFroala.prototype, "customTranslations", void 0);
    __decorate([
        Prop({ default: 1 })
    ], VueFroala.prototype, "minRows", void 0);
    __decorate([
        Prop()
    ], VueFroala.prototype, "imageUploadCustomValidation", void 0);
    __decorate([
        Emit('fullscreen')
    ], VueFroala.prototype, "onFullscreen", null);
    __decorate([
        Watch('value')
    ], VueFroala.prototype, "refreshValue", null);
    __decorate([
        Watch('disabled')
    ], VueFroala.prototype, "setDisabled", null);
    __decorate([
        Watch('readonly')
    ], VueFroala.prototype, "setReadOnly", null);
    VueFroala = __decorate([
        WithRender,
        Component({
            mixins: [
                ElementQueries
            ],
            components: {
                FroalaEditor: FroalaEditor
            }
        })
    ], VueFroala);
    return VueFroala;
}(ModulVue));
export { VueFroala };
export default VueFroala;
//# sourceMappingURL=vue-froala.js.map