@syncfusion/ej2-richtexteditor 29.2.4-738301 → 29.2.4-760237

package/blazorGlobalSrc/rich-text-editor/actions/resize.js

@@ -0,0 +1,188 @@
+define(["require", "exports", "@syncfusion/ej2-base", "../base/constant", "../base/classes"], function (require, exports, ej2_base_1, events, classes) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var Resize = (function () {
+        function Resize(parent) {
+            this.parent = parent;
+            this.addEventListener();
+            this.isDestroyed = false;
+            this.isResizing = false;
+            this.iframeMouseUpBoundFn = this.iframeMouseUp.bind(this);
+        }
+        Resize.prototype.addEventListener = function () {
+            if (this.parent.isDestroyed) {
+                return;
+            }
+            this.parent.on(events.initialEnd, this.renderResizable, this);
+            this.parent.on(events.destroy, this.destroy, this);
+        };
+        Resize.prototype.renderResizable = function () {
+            var _this = this;
+            var enableRtlClass = (this.parent.enableRtl) ? classes.CLS_RTE_RES_WEST : classes.CLS_RTE_RES_EAST;
+            this.resizer = this.parent.createElement('div', {
+                id: this.parent.getID() + '-resizable', className: 'e-icons'
+                    + ' ' + classes.CLS_RTE_RES_HANDLE + ' ' + enableRtlClass
+            });
+            this.parent.element.classList.add(classes.CLS_RTE_RES_CNT);
+            this.parent.rootContainer.appendChild(this.resizer);
+            this.parent.rootContainer.classList.add('e-resize-enabled');
+            if (this.parent.iframeSettings.enable) {
+                this.parent.inputElement.classList.add('e-resize-enabled');
+                this.parent.contentModule.getDocument().addEventListener('mouseup', this.iframeMouseUpBoundFn);
+            }
+            this.iframeElement = this.parent.contentModule.getDocument().querySelectorAll('iframe');
+            if (!ej2_base_1.isNullOrUndefined(this.iframeElement)) {
+                this.iframeElement.forEach(function (iframe) {
+                    ej2_base_1.EventHandler.add(iframe, 'load', _this.onIFrameLoad, _this);
+                });
+            }
+            this.touchStartEvent = (ej2_base_1.Browser.info.name === 'msie') ? 'pointerdown' : 'touchstart';
+            ej2_base_1.EventHandler.add(this.resizer, 'mousedown', this.resizeStart, this);
+            ej2_base_1.EventHandler.add(this.resizer, this.touchStartEvent, this.resizeStart, this);
+        };
+        Resize.prototype.onIFrameLoad = function (e) {
+            var iframe = e.target;
+            if (iframe.nodeName === 'IFRAME' && iframe.contentDocument) {
+                ej2_base_1.EventHandler.add(iframe.contentDocument, 'mouseup', this.stopResize, this);
+            }
+        };
+        Resize.prototype.removeMouseUpEventListener = function (iframe) {
+            if (iframe.contentDocument) {
+                ej2_base_1.EventHandler.remove(iframe.contentDocument, 'mouseup', this.stopResize);
+            }
+        };
+        Resize.prototype.resizeStart = function (e) {
+            var _this = this;
+            this.isResizing = false;
+            if (e.cancelable) {
+                e.preventDefault();
+            }
+            this.wireResizeEvents();
+            this.parent.notify(events.resizeInitialized, {});
+            var args = { event: e, requestType: 'editor' };
+            this.parent.trigger(events.resizeStart, args, function (resizeStartArgs) {
+                if (resizeStartArgs.cancel) {
+                    _this.unwireResizeEvents();
+                }
+            });
+        };
+        Resize.prototype.performResize = function (e) {
+            var _this = this;
+            this.isResizing = true;
+            var args = { event: e, requestType: 'editor' };
+            this.parent.trigger(events.onResize, args, function (resizingArgs) {
+                if (resizingArgs.cancel) {
+                    _this.unwireResizeEvents();
+                }
+            });
+            var boundRect = this.parent.element.getBoundingClientRect();
+            if (this.isMouseEvent(e)) {
+                this.parent.element.style.height = e.clientY - boundRect.top + 'px';
+                this.parent.element.style.width = (!this.parent.enableRtl) ? e.clientX - boundRect.left + 'px' :
+                    boundRect.right - e.clientX + 'px';
+                if (this.parent.toolbarModule) {
+                    var toolBarEle = this.parent.toolbarModule.getToolbarElement();
+                    if (!ej2_base_1.isNullOrUndefined(toolBarEle) && !ej2_base_1.isNullOrUndefined(toolBarEle.parentElement)) {
+                        if (toolBarEle.parentElement.classList.contains(classes.CLS_TB_FLOAT) && this.parent.toolbarSettings.enableFloating &&
+                            this.parent.getToolbar() && !this.parent.inlineMode.enable) {
+                            var contentPanel = this.parent.contentModule.getPanel();
+                            var contentPanelWidth = contentPanel.getBoundingClientRect().width;
+                            toolBarEle.style.width = contentPanelWidth + 'px';
+                        }
+                    }
+                }
+            }
+            else {
+                var eventType = ej2_base_1.Browser.info.name !== 'msie' ? e.touches[0] : e;
+                this.parent.element.style.height = eventType.clientY - boundRect.top + 'px';
+                this.parent.element.style.width = (!this.parent.enableRtl) ? eventType.clientX - boundRect.left + 'px' : boundRect.right - eventType.clientX + 'px';
+            }
+            var rteContent = this.parent.element.querySelector('#' + this.parent.getID() + '_source-view');
+            if (!ej2_base_1.isNullOrUndefined(rteContent)) {
+                rteContent.style.height = this.parent.element.style.height;
+            }
+            this.parent.refreshUI();
+        };
+        Resize.prototype.stopResize = function (e) {
+            this.isResizing = false;
+            this.parent.refreshUI();
+            this.unwireResizeEvents();
+            var args = { event: e, requestType: 'editor' };
+            this.parent.trigger(events.resizeStop, args);
+        };
+        Resize.prototype.getEventType = function (e) {
+            return (e.indexOf('mouse') > -1) ? 'mouse' : 'touch';
+        };
+        Resize.prototype.isMouseEvent = function (e) {
+            var isMouse = false;
+            if (this.getEventType(e.type) === 'mouse' || (!ej2_base_1.isNullOrUndefined(e.pointerType) &&
+                this.getEventType(e.pointerType) === 'mouse')) {
+                isMouse = true;
+            }
+            return isMouse;
+        };
+        Resize.prototype.wireResizeEvents = function () {
+            ej2_base_1.EventHandler.add(document, 'mousemove', this.performResize, this);
+            ej2_base_1.EventHandler.add(document, 'mouseup', this.stopResize, this);
+            this.touchMoveEvent = (ej2_base_1.Browser.info.name === 'msie') ? 'pointermove' : 'touchmove';
+            this.touchEndEvent = (ej2_base_1.Browser.info.name === 'msie') ? 'pointerup' : 'touchend';
+            ej2_base_1.EventHandler.add(document, this.touchMoveEvent, this.performResize, this);
+            ej2_base_1.EventHandler.add(document, this.touchEndEvent, this.stopResize, this);
+        };
+        Resize.prototype.unwireResizeEvents = function () {
+            ej2_base_1.EventHandler.remove(document, 'mousemove', this.performResize);
+            ej2_base_1.EventHandler.remove(document, 'mouseup', this.stopResize);
+            ej2_base_1.EventHandler.remove(document, this.touchMoveEvent, this.performResize);
+            ej2_base_1.EventHandler.remove(document, this.touchEndEvent, this.stopResize);
+        };
+        Resize.prototype.destroy = function () {
+            if (this.isDestroyed) {
+                return;
+            }
+            this.removeEventListener();
+            if (this.resizer) {
+                ej2_base_1.detach(this.resizer);
+                this.resizer = null;
+            }
+            this.isDestroyed = true;
+        };
+        Resize.prototype.removeEventListener = function () {
+            var _this = this;
+            this.parent.off(events.initialEnd, this.renderResizable);
+            this.parent.element.classList.remove(classes.CLS_RTE_RES_CNT);
+            if (this.parent && this.parent.rootContainer && this.parent.rootContainer.classList.contains('e-resize-enabled')) {
+                this.parent.rootContainer.classList.remove('e-resize-enabled');
+            }
+            if (this.parent.iframeSettings.enable && !ej2_base_1.isNullOrUndefined(this.parent.inputElement)) {
+                this.parent.inputElement.classList.remove('e-resize-enabled');
+                this.parent.contentModule.getDocument().removeEventListener('mouseup', this.iframeMouseUpBoundFn);
+            }
+            if (!ej2_base_1.isNullOrUndefined(this.iframeElement)) {
+                this.iframeElement.forEach(function (iframe) {
+                    _this.removeMouseUpEventListener(iframe);
+                    ej2_base_1.EventHandler.remove(iframe, 'load', _this.onIFrameLoad);
+                });
+            }
+            if (this.resizer) {
+                ej2_base_1.EventHandler.remove(this.resizer, 'mousedown', this.resizeStart);
+                ej2_base_1.EventHandler.remove(this.resizer, this.touchStartEvent, this.resizeStart);
+                ej2_base_1.detach(this.resizer);
+            }
+            this.parent.off(events.destroy, this.destroy);
+            this.iframeMouseUpBoundFn = null;
+        };
+        Resize.prototype.iframeMouseUp = function (e) {
+            if (this.isResizing) {
+                this.stopResize(e);
+            }
+            else {
+                return;
+            }
+        };
+        Resize.prototype.getModuleName = function () {
+            return 'resize';
+        };
+        return Resize;
+    }());
+    exports.Resize = Resize;
+});

package/blazorGlobalSrc/rich-text-editor/actions/sanitize-helper.d.ts

@@ -0,0 +1,11 @@
+import { BeforeSanitizeHtmlArgs, SanitizeRemoveAttrs, IRichTextEditor } from '../base/interface';
+export declare class SanitizeHtmlHelper {
+    removeAttrs: SanitizeRemoveAttrs[];
+    removeTags: string[];
+    wrapElement: HTMLElement;
+    initialize(value: string, parent?: IRichTextEditor): string;
+    serializeValue(item: BeforeSanitizeHtmlArgs, value: string): string;
+    private removeXssTags;
+    private removeJsEvents;
+    private removeXssAttrs;
+}

package/blazorGlobalSrc/rich-text-editor/actions/sanitize-helper.js

@@ -0,0 +1,168 @@
+define(["require", "exports", "@syncfusion/ej2-base"], function (require, exports, ej2_base_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var removeTags = [
+        'script',
+        'iframe[src]',
+        'link[href*="javascript:"]',
+        'object[type="text/x-scriptlet"]',
+        'object[data^="data:text/html;base64"]',
+        'img[src^="data:text/html;base64"]',
+        '[src^="javascript:"]',
+        '[dynsrc^="javascript:"]',
+        '[lowsrc^="javascript:"]',
+        '[type^="application/x-shockwave-flash"]'
+    ];
+    var removeAttrs = [
+        { attribute: 'href', selector: '[href*="javascript:"]' },
+        { attribute: 'background', selector: '[background^="javascript:"]' },
+        { attribute: 'style', selector: '[style*="javascript:"]' },
+        { attribute: 'style', selector: '[style*="expression("]' },
+        { attribute: 'href', selector: 'a[href^="data:text/html;base64"]' }
+    ];
+    var jsEvents = ['onchange',
+        'onclick',
+        'onmouseover',
+        'onmouseout',
+        'onkeydown',
+        'onload',
+        'onerror',
+        'onblur',
+        'onfocus',
+        'onbeforeload',
+        'onbeforeunload',
+        'onkeyup',
+        'onsubmit',
+        'onafterprint',
+        'onbeforeonload',
+        'onbeforeprint',
+        'onblur',
+        'oncanplay',
+        'oncanplaythrough',
+        'onchange',
+        'onclick',
+        'oncontextmenu',
+        'ondblclick',
+        'ondrag',
+        'ondragend',
+        'ondragenter',
+        'ondragleave',
+        'ondragover',
+        'ondragstart',
+        'ondrop',
+        'ondurationchange',
+        'onemptied',
+        'onended',
+        'onerror',
+        'onerror',
+        'onfocus',
+        'onformchange',
+        'onforminput',
+        'onhaschange',
+        'oninput',
+        'oninvalid',
+        'onkeydown',
+        'onkeypress',
+        'onkeyup',
+        'onload',
+        'onloadeddata',
+        'onloadedmetadata',
+        'onloadstart',
+        'onmessage',
+        'onmousedown',
+        'onmousemove',
+        'onmouseout',
+        'onmouseover',
+        'onmouseup',
+        'onmousewheel',
+        'onoffline',
+        'onoine',
+        'ononline',
+        'onpagehide',
+        'onpageshow',
+        'onpause',
+        'onplay',
+        'onplaying',
+        'onpopstate',
+        'onprogress',
+        'onratechange',
+        'onreadystatechange',
+        'onredo',
+        'onresize',
+        'onscroll',
+        'onseeked',
+        'onseeking',
+        'onselect',
+        'onstalled',
+        'onstorage',
+        'onsubmit',
+        'onsuspend',
+        'ontimeupdate',
+        'onundo',
+        'onunload',
+        'onvolumechange',
+        'onwaiting',
+        'onmouseenter',
+        'onmouseleave',
+        'onmousewheel',
+        'onstart',
+        'onpropertychange'
+    ];
+    var SanitizeHtmlHelper = (function () {
+        function SanitizeHtmlHelper() {
+        }
+        SanitizeHtmlHelper.prototype.initialize = function (value, parent) {
+            var item = {
+                selectors: {
+                    tags: removeTags,
+                    attributes: removeAttrs
+                },
+                helper: null
+            };
+            parent.trigger('beforeSanitizeHtml', item);
+            if (item.helper) {
+                value = item.helper(value);
+            }
+            if (!item.cancel) {
+                value = this.serializeValue(item, value);
+            }
+            return value;
+        };
+        SanitizeHtmlHelper.prototype.serializeValue = function (item, value) {
+            this.removeAttrs = item.selectors.attributes;
+            this.removeTags = item.selectors.tags;
+            this.wrapElement = document.createElement('div');
+            this.wrapElement.innerHTML = value;
+            this.removeXssTags();
+            this.removeJsEvents();
+            this.removeXssAttrs();
+            return this.wrapElement.innerHTML;
+        };
+        SanitizeHtmlHelper.prototype.removeXssTags = function () {
+            var elements = this.wrapElement.querySelectorAll(this.removeTags.join(','));
+            for (var i = 0; i < elements.length; i++) {
+                ej2_base_1.detach(elements[i]);
+            }
+        };
+        SanitizeHtmlHelper.prototype.removeJsEvents = function () {
+            var elements = this.wrapElement.querySelectorAll('[' + jsEvents.join('],[') + ']');
+            for (var i = 0; i < elements.length; i++) {
+                for (var j = 0; j < jsEvents.length; j++) {
+                    if (elements[i].hasAttribute(jsEvents[j])) {
+                        elements[i].removeAttribute(jsEvents[j]);
+                    }
+                }
+            }
+        };
+        SanitizeHtmlHelper.prototype.removeXssAttrs = function () {
+            for (var i = 0; i < this.removeAttrs.length; i++) {
+                var elements = this.wrapElement.querySelectorAll(this.removeAttrs[i].selector);
+                for (var j = 0; j < elements.length; j++) {
+                    elements[j].removeAttribute(this.removeAttrs[i].attribute);
+                }
+            }
+        };
+        return SanitizeHtmlHelper;
+    }());
+    exports.SanitizeHtmlHelper = SanitizeHtmlHelper;
+});

package/blazorGlobalSrc/rich-text-editor/actions/toolbar-action.d.ts

@@ -0,0 +1,18 @@
+import { IRichTextEditor } from '../base/interface';
+/**
+ * `ToolbarAction` module is used to toolbar click action
+ */
+export declare class ToolbarAction {
+    /**
+     *
+     * @hidden
+     * @private
+     */
+    parent: IRichTextEditor;
+    constructor(parent?: IRichTextEditor);
+    private addEventListener;
+    private toolbarClick;
+    private dropDownSelect;
+    private renderSelection;
+    private removeEventListener;
+}

package/blazorGlobalSrc/rich-text-editor/actions/toolbar-action.js

@@ -0,0 +1,76 @@
+define(["require", "exports", "@syncfusion/ej2-base", "../base/constant"], function (require, exports, ej2_base_1, events) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var ToolbarAction = (function () {
+        function ToolbarAction(parent) {
+            this.parent = parent;
+            this.addEventListener();
+        }
+        ToolbarAction.prototype.addEventListener = function () {
+            this.parent.on(events.toolbarClick, this.toolbarClick, this);
+            this.parent.on(events.dropDownSelect, this.dropDownSelect, this);
+            this.parent.on(events.colorPickerChanged, this.renderSelection, this);
+            this.parent.on(events.destroy, this.removeEventListener, this);
+        };
+        ToolbarAction.prototype.toolbarClick = function (args) {
+            if (this.parent.userAgentData.isSafari() && this.parent.formatter.editorManager.nodeSelection &&
+                !this.parent.inputElement.contains(this.parent.getRange().startContainer)) {
+                this.parent.notify(events.selectionRestore, {});
+            }
+            if (ej2_base_1.isNullOrUndefined(args.item)) {
+                return;
+            }
+            if (!ej2_base_1.isNullOrUndefined(args.item.controlParent)) {
+                var activeEle = args.item.controlParent
+                    .activeEle;
+                if (activeEle) {
+                    activeEle.tabIndex = -1;
+                }
+            }
+            if (args.item.command === 'NumberFormatList' || args.item.command === 'BulletFormatList') {
+                if (args.originalEvent.target.classList.contains('e-order-list') || args.originalEvent.target.classList.contains('e-unorder-list')) {
+                    args.item.command = 'Lists';
+                    args.item.subCommand = args.item.subCommand === 'NumberFormatList' ? 'OL' : 'UL';
+                }
+            }
+            if (args.item.command === 'Lists') {
+                if (args.originalEvent.target.classList.contains('e-caret') &&
+                    (args.originalEvent.target.parentElement.classList.contains('e-rte-bulletformatlist-dropdown') || args.originalEvent.target.parentElement.classList.contains('e-rte-numberformatlist-dropdown'))) {
+                    return;
+                }
+            }
+            this.parent.notify(events.htmlToolbarClick, args);
+            this.parent.notify(events.markdownToolbarClick, args);
+        };
+        ToolbarAction.prototype.dropDownSelect = function (e) {
+            this.parent.notify(events.selectionRestore, {});
+            if (!(document.body.contains(document.body.querySelector('.e-rte-quick-toolbar'))
+                && e.item && (e.item.command === 'Images' || e.item.command === 'Audios' || e.item.command === 'Videos' ||
+                e.item.command === 'VideoLayoutOption' || e.item.command === 'Display' || e.item.command === 'Table'))) {
+                var value = e.item.controlParent && this.parent.quickToolbarModule && this.parent.quickToolbarModule.tableQTBar
+                    && this.parent.quickToolbarModule.tableQTBar.element.contains(e.item.controlParent.element) ? 'Table' : null;
+                if (e.item.command === 'Lists') {
+                    var listItem = { listStyle: e.item.value, listImage: e.item.listImage, type: e.item.subCommand };
+                    this.parent.formatter.process(this.parent, e, e.originalEvent, listItem);
+                }
+                else {
+                    this.parent.formatter.process(this.parent, e, e.originalEvent, value);
+                }
+            }
+            this.parent.notify(events.selectionSave, {});
+        };
+        ToolbarAction.prototype.renderSelection = function (args) {
+            this.parent.notify(events.selectionRestore, {});
+            this.parent.formatter.process(this.parent, args, args.originalEvent, null);
+            this.parent.notify(events.selectionSave, {});
+        };
+        ToolbarAction.prototype.removeEventListener = function () {
+            this.parent.off(events.toolbarClick, this.toolbarClick);
+            this.parent.off(events.dropDownSelect, this.dropDownSelect);
+            this.parent.off(events.colorPickerChanged, this.renderSelection);
+            this.parent.off(events.destroy, this.removeEventListener);
+        };
+        return ToolbarAction;
+    }());
+    exports.ToolbarAction = ToolbarAction;
+});

package/blazorGlobalSrc/rich-text-editor/actions/toolbar.d.ts

@@ -0,0 +1,185 @@
+import { Toolbar as tool } from '@syncfusion/ej2-navigations';
+import { IRichTextEditor } from '../base/interface';
+import { IUpdateItemsModel } from '../base/interface';
+import { ServiceLocator } from '../services/service-locator';
+import { RendererFactory } from '../services/renderer-factory';
+import { BaseToolbar } from './base-toolbar';
+import { DropDownButtons } from './dropdown-buttons';
+import { RichTextEditorModel } from '../base/rich-text-editor-model';
+import { ColorPickerInput } from './color-picker';
+/**
+ * `Toolbar` module is used to handle Toolbar actions.
+ */
+export declare class Toolbar {
+    isDestroyed: boolean;
+    toolbarObj: tool;
+    private editPanel;
+    private isToolbar;
+    private editableElement;
+    private tbItems;
+    baseToolbar: BaseToolbar;
+    private tbElement;
+    private tbWrapper;
+    protected parent: IRichTextEditor;
+    protected locator: ServiceLocator;
+    private isTransformChild;
+    private contentRenderer;
+    dropDownModule: DropDownButtons;
+    colorPickerModule: ColorPickerInput;
+    private toolbarActionModule;
+    protected renderFactory: RendererFactory;
+    private keyBoardModule;
+    private tools;
+    constructor(parent?: IRichTextEditor, serviceLocator?: ServiceLocator);
+    private initializeInstance;
+    private toolbarBindEvent;
+    private toolBarKeyDown;
+    private createToolbarElement;
+    private getToolbarMode;
+    private checkToolbarResponsive;
+    private checkIsTransformChild;
+    private toggleFloatClass;
+    private renderToolbar;
+    /**
+     * addFixedTBarClass method
+     *
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    addFixedTBarClass(): void;
+    /**
+     * removeFixedTBarClass method
+     *
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    removeFixedTBarClass(): void;
+    private showFixedTBar;
+    private hideFixedTBar;
+    /**
+     * updateItem method
+     *
+     * @param {IUpdateItemsModel} args - specifies the arguments.
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    updateItem(args: IUpdateItemsModel): void;
+    private updateToolbarStatus;
+    private fullScreen;
+    private hideScreen;
+    /**
+     * getBaseToolbar method
+     *
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    getBaseToolbar(): BaseToolbar;
+    /**
+     * addTBarItem method
+     *
+     * @param {IUpdateItemsModel} args - specifies the arguments.
+     * @param {number} index - specifies the index value.
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    addTBarItem(args: IUpdateItemsModel, index: number): void;
+    /**
+     * enableTBarItems method
+     *
+     * @param {BaseToolbar} baseToolbar - specifies the toolbar.
+     * @param {string} items - specifies the string value.
+     * @param {boolean} isEnable - specifies the boolean value.
+     * @param {boolean} muteToolbarUpdate - specifies the toolbar.
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    enableTBarItems(baseToolbar: BaseToolbar, items: string | string[], isEnable: boolean, muteToolbarUpdate?: boolean): void;
+    /**
+     * removeTBarItems method
+     *
+     * @param {string} items - specifies the string value.
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    removeTBarItems(items: string | string[]): void;
+    /**
+     * getExpandTBarPopHeight method
+     *
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    getExpandTBarPopHeight(): number;
+    /**
+     * getToolbarHeight method
+     *
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    getToolbarHeight(): number;
+    /**
+     * getToolbarElement method
+     *
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    getToolbarElement(): Element;
+    /**
+     * refreshToolbarOverflow method
+     *
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    refreshToolbarOverflow(): void;
+    private isToolbarDestroyed;
+    private destroyToolbar;
+    /**
+     * Destroys the ToolBar.
+     *
+     * @function destroy
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    destroy(): void;
+    private mouseDownHandler;
+    private focusChangeHandler;
+    private dropDownBeforeOpenHandler;
+    private tbFocusHandler;
+    protected wireEvents(): void;
+    protected unWireEvents(): void;
+    protected addEventListener(): void;
+    protected removeEventListener(): void;
+    private setCssClass;
+    private onRefresh;
+    /**
+     * Called internally if any of the property value changed.
+     *
+     * @param {RichTextEditorModel} e - specifies the string value
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    protected onPropertyChanged(e: {
+        [key: string]: RichTextEditorModel;
+    }): void;
+    private refreshToolbar;
+    /**
+     * For internal use only - Get the module name.
+     *
+     * @returns {void}
+     * @hidden
+     */
+    private getModuleName;
+    private renderColorPicker;
+}