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

package/blazorGlobalSrc/editor-manager/base/editor-manager.js

@@ -0,0 +1,339 @@
+define(["require", "exports", "@syncfusion/ej2-base", "./constant", "./../plugin/lists", "./../../selection/index", "./../plugin/dom-node", "./../plugin/formats", "./../plugin/link", "./../plugin/alignments", "./../plugin/indents", "./../plugin/image", "./../plugin/audio", "./../plugin/video", "./../plugin/table", "./../plugin/selection-exec", "./../plugin/inserthtml-exec", "./../plugin/clearformat-exec", "./../plugin/undo", "../plugin/ms-word-clean-up", "./../../common/constant", "../plugin/insert-text", "../plugin/nodecutter", "../plugin/format-painter-actions", "../plugin/emoji-picker-action", "../plugin/table-selection", "../plugin/dom-tree", "../../common/user-agent"], function (require, exports, ej2_base_1, CONSTANT, lists_1, index_1, dom_node_1, formats_1, link_1, alignments_1, indents_1, image_1, audio_1, video_1, table_1, selection_exec_1, inserthtml_exec_1, clearformat_exec_1, undo_1, ms_word_clean_up_1, EVENTS, insert_text_1, nodecutter_1, format_painter_actions_1, emoji_picker_action_1, table_selection_1, dom_tree_1, user_agent_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var EditorManager = (function () {
+        function EditorManager(options) {
+            this.clickCount = 0;
+            this.lastClickTime = 0;
+            this.currentDocument = options.document;
+            this.editableElement = options.editableElement;
+            this.nodeSelection = new index_1.NodeSelection(this.editableElement);
+            this.nodeCutter = new nodecutter_1.NodeCutter();
+            this.domNode = new dom_node_1.DOMNode(this.editableElement, this.currentDocument);
+            this.observer = new ej2_base_1.Observer(this);
+            this.listObj = new lists_1.Lists(this);
+            this.formatObj = new formats_1.Formats(this);
+            this.alignmentObj = new alignments_1.Alignments(this);
+            this.indentsObj = new indents_1.Indents(this);
+            this.linkObj = new link_1.LinkCommand(this);
+            this.imgObj = new image_1.ImageCommand(this);
+            this.audioObj = new audio_1.AudioCommand(this);
+            this.videoObj = new video_1.VideoCommand(this);
+            this.selectionObj = new selection_exec_1.SelectionBasedExec(this);
+            this.inserthtmlObj = new inserthtml_exec_1.InsertHtmlExec(this);
+            this.insertTextObj = new insert_text_1.InsertTextExec(this);
+            this.clearObj = new clearformat_exec_1.ClearFormatExec(this);
+            this.tableObj = new table_1.TableCommand(this);
+            this.undoRedoManager = new undo_1.UndoRedoManager(this, options.options);
+            this.msWordPaste = new ms_word_clean_up_1.MsWordPaste(this);
+            this.formatPainterEditor = new format_painter_actions_1.FormatPainterActions(this, options.formatPainterSettings);
+            this.emojiPickerObj = new emoji_picker_action_1.EmojiPickerAction(this);
+            this.tableCellSelection = new table_selection_1.TableSelection(this.editableElement, this.currentDocument);
+            this.userAgentData = new user_agent_1.CustomUserAgentData(ej2_base_1.Browser.userAgent, false);
+            this.wireEvents();
+            this.isDestroyed = false;
+        }
+        EditorManager.prototype.wireEvents = function () {
+            this.observer.on(EVENTS.KEY_DOWN, this.editorKeyDown, this);
+            this.observer.on(EVENTS.KEY_UP, this.editorKeyUp, this);
+            this.observer.on(EVENTS.KEY_UP, this.editorKeyUp, this);
+            this.observer.on(EVENTS.MODEL_CHANGED, this.onPropertyChanged, this);
+            this.observer.on(EVENTS.MS_WORD_CLEANUP, this.onWordPaste, this);
+            this.observer.on(EVENTS.ON_BEGIN, this.onBegin, this);
+            this.observer.on(EVENTS.MOUSE_DOWN, this.editorMouseDown, this);
+            this.observer.on(EVENTS.DESTROY, this.destroy, this);
+        };
+        EditorManager.prototype.unwireEvents = function () {
+            this.observer.off(EVENTS.KEY_DOWN, this.editorKeyDown);
+            this.observer.off(EVENTS.KEY_UP, this.editorKeyUp);
+            this.observer.off(EVENTS.KEY_UP, this.editorKeyUp);
+            this.observer.off(EVENTS.MODEL_CHANGED, this.onPropertyChanged);
+            this.observer.off(EVENTS.MS_WORD_CLEANUP, this.onWordPaste);
+            this.observer.off(EVENTS.ON_BEGIN, this.onBegin);
+            this.observer.off(EVENTS.MOUSE_DOWN, this.editorMouseDown);
+            this.observer.off(EVENTS.DESTROY, this.destroy);
+        };
+        EditorManager.prototype.onWordPaste = function (e) {
+            this.observer.notify(EVENTS.MS_WORD_CLEANUP_PLUGIN, e);
+        };
+        EditorManager.prototype.onPropertyChanged = function (props) {
+            this.observer.notify(EVENTS.MODEL_CHANGED_PLUGIN, props);
+        };
+        EditorManager.prototype.editorKeyDown = function (e) {
+            this.observer.notify(EVENTS.KEY_DOWN_HANDLER, e);
+        };
+        EditorManager.prototype.editorKeyUp = function (e) {
+            this.observer.notify(EVENTS.KEY_UP_HANDLER, e);
+        };
+        EditorManager.prototype.onBegin = function (e) {
+            this.observer.notify(EVENTS.SPACE_ACTION, e);
+        };
+        EditorManager.prototype.execCommand = function (command, value, event, callBack, text, exeValue, selector, enterAction) {
+            switch (command.toLowerCase()) {
+                case 'lists':
+                    this.observer.notify(EVENTS.LIST_TYPE, { subCommand: value, event: event, callBack: callBack,
+                        selector: selector, item: exeValue, enterAction: enterAction });
+                    break;
+                case 'formats':
+                    this.observer.notify(EVENTS.FORMAT_TYPE, { subCommand: value, event: event, callBack: callBack,
+                        selector: selector, exeValue: exeValue, enterAction: enterAction
+                    });
+                    break;
+                case 'alignments':
+                    this.observer.notify(CONSTANT.ALIGNMENT_TYPE, {
+                        subCommand: value, event: event, callBack: callBack,
+                        selector: selector, value: exeValue, enterAction: enterAction
+                    });
+                    break;
+                case 'indents':
+                    this.observer.notify(CONSTANT.INDENT_TYPE, {
+                        subCommand: value, event: event, callBack: callBack,
+                        selector: selector, enterAction: enterAction
+                    });
+                    break;
+                case 'links':
+                    this.observer.notify(CONSTANT.LINK, { command: command, value: value, item: exeValue, event: event, callBack: callBack,
+                        enterAction: enterAction });
+                    break;
+                case 'files':
+                    this.observer.notify(CONSTANT.IMAGE, {
+                        command: command, value: 'Image', item: exeValue, event: event, callBack: callBack, selector: selector
+                    });
+                    break;
+                case 'images':
+                    this.observer.notify(CONSTANT.IMAGE, {
+                        command: command, value: value, item: exeValue, event: event, callBack: callBack, selector: selector
+                    });
+                    break;
+                case 'audios':
+                    this.observer.notify(CONSTANT.AUDIO, {
+                        command: command, value: value, item: exeValue, event: event, callBack: callBack, selector: selector
+                    });
+                    break;
+                case 'videos':
+                    this.observer.notify(CONSTANT.VIDEO, {
+                        command: command, value: value, item: exeValue, event: event, callBack: callBack, selector: selector
+                    });
+                    break;
+                case 'table':
+                    switch (value.toString().toLocaleLowerCase()) {
+                        case 'createtable':
+                            this.observer.notify(CONSTANT.TABLE, { item: exeValue, event: event, callBack: callBack, enterAction: enterAction });
+                            break;
+                        case 'insertrowbefore':
+                        case 'insertrowafter':
+                            this.observer.notify(CONSTANT.INSERT_ROW, { item: exeValue, event: event, callBack: callBack });
+                            break;
+                        case 'insertcolumnleft':
+                        case 'insertcolumnright':
+                            this.observer.notify(CONSTANT.INSERT_COLUMN, { item: exeValue, event: event, callBack: callBack });
+                            break;
+                        case 'deleterow':
+                            this.observer.notify(CONSTANT.DELETEROW, { item: exeValue, event: event, callBack: callBack });
+                            break;
+                        case 'deletecolumn':
+                            this.observer.notify(CONSTANT.DELETECOLUMN, { item: exeValue, event: event, callBack: callBack });
+                            break;
+                        case 'tableremove':
+                            this.observer.notify(CONSTANT.REMOVETABLE, { item: exeValue, event: event, callBack: callBack });
+                            break;
+                        case 'tableheader':
+                            this.observer.notify(CONSTANT.TABLEHEADER, { item: exeValue, event: event, callBack: callBack });
+                            break;
+                        case 'aligntop':
+                        case 'alignmiddle':
+                        case 'alignbottom':
+                            this.observer.notify(CONSTANT.TABLE_VERTICAL_ALIGN, { item: exeValue, event: event, callBack: callBack });
+                            break;
+                        case 'merge':
+                            this.observer.notify(CONSTANT.TABLE_MERGE, { item: exeValue, event: event, callBack: callBack });
+                            break;
+                        case 'horizontalsplit':
+                            this.observer.notify(CONSTANT.TABLE_HORIZONTAL_SPLIT, { item: exeValue, event: event, callBack: callBack });
+                            break;
+                        case 'verticalsplit':
+                            this.observer.notify(CONSTANT.TABLE_VERTICAL_SPLIT, { item: exeValue, event: event, callBack: callBack });
+                            break;
+                        case 'dashed':
+                            this.observer.notify(CONSTANT.TABLE_DASHED, { item: exeValue, event: event, callBack: callBack });
+                            break;
+                        case 'alternate':
+                            this.observer.notify(CONSTANT.TABLE_ALTERNATE, { item: exeValue, event: event, callBack: callBack });
+                            break;
+                        case 'backgroundcolor':
+                            this.observer.notify(CONSTANT.TABLE_BACKGROUND_COLOR, { subCommand: value, value: exeValue, event: event, callBack: callBack });
+                            break;
+                    }
+                    break;
+                case 'font':
+                case 'style':
+                case 'effects':
+                case 'casing':
+                    this.observer.notify(CONSTANT.SELECTION_TYPE, { subCommand: value, event: event, callBack: callBack, value: text, selector: selector, enterAction: enterAction });
+                    break;
+                case 'inserthtml':
+                    this.observer.notify(CONSTANT.INSERTHTML_TYPE, { subCommand: value, callBack: callBack, value: text, enterAction: enterAction });
+                    break;
+                case 'inserttext':
+                    this.observer.notify(CONSTANT.INSERT_TEXT_TYPE, { subCommand: value, callBack: callBack, value: text });
+                    break;
+                case 'clear':
+                    this.observer.notify(CONSTANT.CLEAR_TYPE, { subCommand: value, event: event, callBack: callBack, selector: selector, enterAction: enterAction });
+                    break;
+                case 'actions':
+                    this.observer.notify(EVENTS.ACTION, { subCommand: value, event: event, callBack: callBack, selector: selector });
+                    break;
+                case 'formatpainter':
+                    this.observer.notify(EVENTS.FORMAT_PAINTER_ACTIONS, { item: exeValue, subCommand: value, event: event, callBack: callBack });
+                    break;
+                case 'emojipicker':
+                    this.observer.notify(EVENTS.EMOJI_PICKER_ACTIONS, { item: exeValue, subCommand: value, value: text,
+                        event: event, callBack: callBack });
+            }
+        };
+        EditorManager.prototype.editorMouseDown = function (e) {
+            if (e.args.detail === 3) {
+                this.tripleClickSelection(e.args);
+            }
+            if (ej2_base_1.Browser.userAgent.indexOf('Safari') !== -1) {
+                var currentTime = new Date().getTime();
+                if (currentTime - this.lastClickTime > 500) {
+                    this.clickCount = 0;
+                }
+                this.clickCount++;
+                this.lastClickTime = currentTime;
+                if (this.clickCount === 3) {
+                    this.tripleClickSelection(e.args);
+                    this.clickCount = 0;
+                }
+            }
+        };
+        EditorManager.prototype.tripleClickSelection = function (e) {
+            var range = this.nodeSelection.getRange(this.currentDocument);
+            var selection = this.nodeSelection.get(this.currentDocument);
+            var domMethods = new dom_tree_1.DOMMethods(this.editableElement);
+            if (selection.rangeCount > 0 && selection.toString() !== '') {
+                var startBlockNode = this.getParentBlockNode(range.startContainer);
+                var endBlockNode = this.getParentBlockNode(range.endContainer);
+                if (startBlockNode && endBlockNode && startBlockNode === endBlockNode) {
+                    var newRange = this.currentDocument.createRange();
+                    var startTextNode = domMethods.getFirstTextNode(startBlockNode);
+                    var endTextNode = domMethods.getLastTextNode(endBlockNode);
+                    if (startTextNode && endTextNode) {
+                        newRange.setStart(startTextNode, 0);
+                        newRange.setEnd(endTextNode, endTextNode.textContent.length);
+                        this.nodeSelection.setRange(this.currentDocument, newRange);
+                        e.preventDefault();
+                    }
+                }
+            }
+        };
+        EditorManager.prototype.getParentBlockNode = function (node) {
+            var treeWalker = this.currentDocument.createTreeWalker(this.editableElement, NodeFilter.SHOW_ELEMENT, {
+                acceptNode: function (currentNode) {
+                    var displayStyle = window.getComputedStyle(currentNode).display;
+                    if (displayStyle.indexOf('inline') < 0) {
+                        return NodeFilter.FILTER_ACCEPT;
+                    }
+                    else {
+                        return NodeFilter.FILTER_SKIP;
+                    }
+                }
+            });
+            treeWalker.currentNode = node;
+            var blockParent = treeWalker.parentNode();
+            return blockParent;
+        };
+        EditorManager.prototype.destroy = function () {
+            if (this.isDestroyed) {
+                return;
+            }
+            this.unwireEvents();
+            this.observer.notify(EVENTS.INTERNAL_DESTROY);
+            if (this.editableElement) {
+                this.editableElement = null;
+            }
+            this.currentDocument = null;
+            if (this.nodeCutter) {
+                this.nodeCutter = null;
+            }
+            if (this.domNode) {
+                this.domNode = null;
+            }
+            if (this.listObj) {
+                this.listObj = null;
+            }
+            if (this.formatObj) {
+                this.formatObj = null;
+            }
+            if (this.alignmentObj) {
+                this.alignmentObj = null;
+            }
+            if (this.indentsObj) {
+                this.indentsObj = null;
+            }
+            if (this.linkObj) {
+                this.linkObj = null;
+            }
+            if (this.imgObj) {
+                this.imgObj = null;
+            }
+            if (this.audioObj) {
+                this.audioObj = null;
+            }
+            if (this.videoObj) {
+                this.videoObj = null;
+            }
+            if (this.selectionObj) {
+                this.selectionObj = null;
+            }
+            if (this.inserthtmlObj) {
+                this.inserthtmlObj = null;
+            }
+            if (this.insertTextObj) {
+                this.insertTextObj = null;
+            }
+            if (this.clearObj) {
+                this.clearObj = null;
+            }
+            if (this.tableObj) {
+                this.tableObj = null;
+            }
+            if (this.msWordPaste) {
+                this.msWordPaste = null;
+            }
+            if (this.formatPainterEditor) {
+                this.formatPainterEditor = null;
+            }
+            if (this.emojiPickerObj) {
+                this.emojiPickerObj = null;
+            }
+            if (this.tableCellSelection) {
+                this.tableCellSelection = null;
+            }
+            this.userAgentData = null;
+            this.isDestroyed = true;
+        };
+        EditorManager.prototype.beforeSlashMenuApplyFormat = function () {
+            var currentRange = this.nodeSelection.getRange(this.currentDocument);
+            var node = this.nodeSelection.getNodeCollection(currentRange)[0];
+            var startPoint = currentRange.startOffset;
+            while (this.nodeSelection.getRange(document).toString().indexOf('/') === -1) {
+                this.nodeSelection.setSelectionText(document, node, node, startPoint, currentRange.endOffset);
+                startPoint--;
+            }
+            var slashRange = this.nodeSelection.getRange(this.currentDocument);
+            var slashNode = this.nodeCutter.GetSpliceNode(slashRange, node);
+            var previouNode = slashNode.previousSibling;
+            if (slashNode.parentElement && slashNode.parentElement.innerHTML.length === 1) {
+                slashNode.parentElement.appendChild(document.createElement('br'));
+            }
+            slashNode.parentNode.removeChild(slashNode);
+            if (previouNode) {
+                this.nodeSelection.setCursorPoint(document, previouNode, previouNode.textContent.length);
+            }
+        };
+        return EditorManager;
+    }());
+    exports.EditorManager = EditorManager;
+});

package/blazorGlobalSrc/editor-manager/base/enum.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Enum values for EditorManager
+ */
+/**
+ *
+ * @deprecated
+ * @hidden
+ * Defines the context or contexts in which styles will be copied.
+ */
+export declare type IFormatPainterContext = 'Text' | 'List' | 'Table';
+/**
+ *
+ * @deprecated
+ * @hidden
+ * Defines the action values for format painter.
+ */
+export declare type IFormatPainterActionValue = 'format-copy' | 'format-paste' | 'escape';

package/blazorGlobalSrc/editor-manager/base/enum.js

@@ -0,0 +1,4 @@
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/blazorGlobalSrc/editor-manager/base/interface.d.ts

@@ -0,0 +1,263 @@
+import { NodeSelection } from './../../selection/index';
+import { KeyboardEventArgs } from '@syncfusion/ej2-base';
+import { IHtmlFormatterCallBack, IAdvanceListItem } from '../../common/interface';
+import { IFormatPainterActionValue, IFormatPainterContext } from './enum';
+/**
+ * Specifies  Command models interfaces.
+ *
+ * @hidden
+ * @deprecated
+ */
+export interface ICommandModel {
+    /**
+     * Specifies the editor element's current document.
+     */
+    document: HTMLDocument;
+    /**
+     * Specifies the editable element.
+     */
+    editableElement: Element;
+    options?: {
+        [key: string]: number;
+    };
+    formatPainterSettings?: IFormatPainterSettings;
+}
+/**
+ * Specifies IHtmlSubCommands interfaces.
+ *
+ * @hidden
+ * @deprecated
+ */
+export interface IHtmlSubCommands {
+    /**
+     * Specifies the item
+     */
+    item?: IAdvanceListItem;
+    /**
+     * Specifies the subCommand.
+     */
+    subCommand: string;
+    /**
+     * Specifies the callBack.
+     */
+    callBack(args: IHtmlFormatterCallBack): () => void;
+    /**
+     * Specifies the callBack.
+     */
+    value?: string | Node;
+    /**
+     * Specifies the originalEvent.
+     */
+    event?: MouseEvent;
+    /**
+     * Specifies the iframe element selector.
+     */
+    selector?: string;
+    /**
+     * Specifies if the icon click is from dropdown or direct toolbarclick.
+     */
+    exeValue?: {
+        [key: string]: string;
+    };
+    enterAction?: string;
+}
+/**
+ * Specifies  IKeyboardActionArgs interfaces for command line.
+ *
+ * @hidden
+ * @deprecated
+ */
+export interface IKeyboardActionArgs extends KeyboardEvent {
+    /**
+     * action of the KeyboardEvent
+     */
+    action: string;
+}
+/**
+ * @deprecated
+ */
+export interface IHtmlItem {
+    module?: string;
+    event?: KeyboardEvent | MouseEvent;
+    selection?: NodeSelection;
+    link?: HTMLInputElement;
+    selectNode?: Node[];
+    selectParent?: Node[];
+    item: IHtmlItemArgs;
+    subCommand: string;
+    value: string;
+    selector: string;
+    callBack(args: IHtmlFormatterCallBack): () => void;
+    enterAction?: string;
+}
+/**
+ * @deprecated
+ */
+export interface IHtmlItemArgs {
+    selection?: NodeSelection;
+    selectNode?: Node[];
+    selectParent?: Node[];
+    src?: string;
+    url?: string;
+    isEmbedUrl?: string;
+    text?: string;
+    title?: string;
+    target?: string;
+    width?: {
+        minWidth?: string | number;
+        maxWidth?: string | number;
+        width?: string | number;
+    };
+    height?: {
+        minHeight?: string | number;
+        maxHeight?: string | number;
+        height?: string | number;
+    };
+    altText?: string;
+    fileName?: string;
+    rows?: number;
+    columns?: number;
+    subCommand?: string;
+    tableCell?: HTMLElement;
+    cssClass?: string;
+    insertElement?: Element;
+    captionClass?: string;
+    action?: string;
+    formatPainterAction?: IFormatPainterActionValue;
+    ariaLabel?: string;
+}
+/**
+ * @deprecated
+ */
+export interface IHtmlUndoRedoData {
+    text?: DocumentFragment;
+    range?: NodeSelection;
+}
+/**
+ * Specifies IHtmlKeyboardEvent interfaces.
+ *
+ * @hidden
+ * @deprecated
+ */
+export interface IHtmlKeyboardEvent {
+    /**
+     * Specifies the callBack.
+     */
+    callBack(args?: IHtmlFormatterCallBack): () => void;
+    /**
+     * Specifies the event.
+     */
+    event: KeyboardEventArgs;
+    /**
+     * Specifies the notifier name.
+     */
+    name?: string;
+    /**
+     * Specifies the enter key configuration.
+     */
+    enterAction?: string;
+    /**
+     * Specifies the tab key action in the Rich Text Editor content..
+     */
+    enableTabKey?: string;
+    /**
+     * Defines tag to be used when enter key is pressed.
+     */
+    enterKey?: string;
+    /**
+     * Defines tag to be used when shift enter key is pressed.
+     */
+    shiftEnterKey?: string;
+}
+/**
+ *
+ * @deprecated
+ * @hidden
+ *
+ */
+export interface IFormatPainterSettings {
+    allowedContext?: IFormatPainterContext[];
+    allowedFormats?: string;
+    deniedFormats?: string;
+}
+/**
+ *
+ * @deprecated
+ * @hidden
+ *
+ */
+export interface IFormatPainterAction {
+    formatPainterAction: IFormatPainterActionValue;
+}
+/**
+ * @private
+ * @hidden
+ *
+ */
+export interface IFormatPainterEditor {
+    destroy: Function;
+}
+/**
+ * @private
+ * @hidden
+ */
+export interface FormatPainterCollection {
+    attrs: Attr[];
+    className: string;
+    styles: CSSPropCollection[];
+    tagName: string;
+}
+/**
+ * @private
+ * @hidden
+ *
+ */
+export interface FormatPainterValue {
+    element: HTMLElement;
+    lastChild: HTMLElement;
+}
+/**
+ * @private
+ * @hidden
+ */
+export interface DeniedFormatsCollection {
+    tag: string;
+    styles: string[];
+    attributes: string[];
+    classes: string[];
+}
+/**
+ * @private
+ * @hidden
+ */
+export interface CSSPropCollection {
+    property: string;
+    value: string;
+    priority: string;
+}
+/**
+ * @private
+ * @hidden
+ */
+export interface IHTMLMouseEventArgs {
+    name: string;
+    args: MouseEvent;
+}
+/**
+ * @private
+ * @hidden
+ */
+export interface ITableSelection {
+    getBlockNodes(action?: boolean): HTMLElement[];
+    getTextNodes(): Node[];
+}
+/**
+ * @private
+ * @hidden
+ */
+export interface BeforeInputEvent extends Event {
+    data: string | null;
+    inputType: string;
+    isComposing: boolean;
+    preventDefault(): void;
+}

package/blazorGlobalSrc/editor-manager/base/interface.js

@@ -0,0 +1,4 @@
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/blazorGlobalSrc/editor-manager/base/types.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Types type for EditorManager
+ *
+ * @hidden
+ * @deprecated
+ */
+export declare type EditorExecCommand = 'Indents' | 'Lists' | 'Formats' | 'Alignments' | 'Links' | 'Images' | 'Font' | 'Style' | 'Clear' | 'Effects' | 'Casing' | 'InsertHtml' | 'InsertText' | 'Actions';

package/blazorGlobalSrc/editor-manager/base/types.js

@@ -0,0 +1,4 @@
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/blazorGlobalSrc/editor-manager/base.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Base export
+ */
+export * from './base/editor-manager';
+export * from './base/interface';
+export * from './base/constant';
+export * from './base/types';
+export * from './base/classes';

package/blazorGlobalSrc/editor-manager/base.js

@@ -0,0 +1,10 @@
+define(["require", "exports", "./base/editor-manager", "./base/constant", "./base/classes"], function (require, exports, editor_manager_1, constant_1, classes_1) {
+    "use strict";
+    function __export(m) {
+        for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+    }
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __export(editor_manager_1);
+    __export(constant_1);
+    __export(classes_1);
+});

package/blazorGlobalSrc/editor-manager/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Base export
+ */
+export * from './base';
+export * from './plugin';

package/blazorGlobalSrc/editor-manager/index.js

@@ -0,0 +1,9 @@
+define(["require", "exports", "./base", "./plugin"], function (require, exports, base_1, plugin_1) {
+    "use strict";
+    function __export(m) {
+        for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+    }
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __export(base_1);
+    __export(plugin_1);
+});