(function webpackUniversalModuleDefinition(root, factory) {
    if (typeof exports === 'object' && typeof module === 'object')
        module.exports = factory(require("assets/quill/js/v2/quill"));
    else if (typeof define === 'function' && define.amd)
        define(["assets/quill/js/v2/quill"], factory);
    else if (typeof exports === 'object')
        exports["quillBetterTable"] = factory(require("assets/quill/js/v2/quill"));
    else
        root["quillBetterTable"] = factory(root["Quill"]);
})(window, function (__WEBPACK_EXTERNAL_MODULE__0__) {
    return /******/ (function (modules) { // webpackBootstrap
        /******/
        function hotDisposeChunk(chunkId) {
            /******/
            delete installedChunks[chunkId];
            /******/
        }

        /******/
        var parentHotUpdateCallback = window["webpackHotUpdatequillBetterTable"];
        /******/
        window["webpackHotUpdatequillBetterTable"] = // eslint-disable-next-line no-unused-vars
            /******/    function webpackHotUpdateCallback(chunkId, moreModules) {
            /******/
            hotAddUpdateChunk(chunkId, moreModules);
            /******/
            if (parentHotUpdateCallback) parentHotUpdateCallback(chunkId, moreModules);
            /******/
        };
        /******/
        /******/ 	// eslint-disable-next-line no-unused-vars
        /******/
        function hotDownloadUpdateChunk(chunkId) {
            /******/
            var script = document.createElement("script");
            /******/
            script.charset = "utf-8";
            /******/
            script.src = __webpack_require__.p + "" + chunkId + "." + hotCurrentHash + ".hot-update.js";
            /******/
            if (null) script.crossOrigin = null;
            /******/
            document.head.appendChild(script);
            /******/
        }

        /******/
        /******/ 	// eslint-disable-next-line no-unused-vars
        /******/
        function hotDownloadManifest(requestTimeout) {
            /******/
            requestTimeout = requestTimeout || 10000;
            /******/
            return new Promise(function (resolve, reject) {
                /******/
                if (typeof XMLHttpRequest === "undefined") {
                    /******/
                    return reject(new Error("No browser support"));
                    /******/
                }
                /******/
                try {
                    /******/
                    var request = new XMLHttpRequest();
                    /******/
                    var requestPath = __webpack_require__.p + "" + hotCurrentHash + ".hot-update.json";
                    /******/
                    request.open("GET", requestPath, true);
                    /******/
                    request.timeout = requestTimeout;
                    /******/
                    request.send(null);
                    /******/
                } catch (err) {
                    /******/
                    return reject(err);
                    /******/
                }
                /******/
                request.onreadystatechange = function () {
                    /******/
                    if (request.readyState !== 4) return;
                    /******/
                    if (request.status === 0) {
                        /******/ 					// timeout
                        /******/
                        reject(
                            /******/                        new Error("Manifest request to " + requestPath + " timed out.")
                            /******/);
                        /******/
                    } else if (request.status === 404) {
                        /******/ 					// no update available
                        /******/
                        resolve();
                        /******/
                    } else if (request.status !== 200 && request.status !== 304) {
                        /******/ 					// other failure
                        /******/
                        reject(new Error("Manifest request to " + requestPath + " failed."));
                        /******/
                    } else {
                        /******/ 					// success
                        /******/
                        try {
                            /******/
                            var update = JSON.parse(request.responseText);
                            /******/
                        } catch (e) {
                            /******/
                            reject(e);
                            /******/
                            return;
                            /******/
                        }
                        /******/
                        resolve(update);
                        /******/
                    }
                    /******/
                };
                /******/
            });
            /******/
        }

        /******/
        /******/
        var hotApplyOnUpdate = true;
        /******/ 	// eslint-disable-next-line no-unused-vars
        /******/
        var hotCurrentHash = "ced44c7892a78034ffe4";
        /******/
        var hotRequestTimeout = 10000;
        /******/
        var hotCurrentModuleData = {};
        /******/
        var hotCurrentChildModule;
        /******/ 	// eslint-disable-next-line no-unused-vars
        /******/
        var hotCurrentParents = [];
        /******/ 	// eslint-disable-next-line no-unused-vars
        /******/
        var hotCurrentParentsTemp = [];
        /******/
        /******/ 	// eslint-disable-next-line no-unused-vars
        /******/
        function hotCreateRequire(moduleId) {
            /******/
            var me = installedModules[moduleId];
            /******/
            if (!me) return __webpack_require__;
            /******/
            var fn = function (request) {
                /******/
                if (me.hot.active) {
                    /******/
                    if (installedModules[request]) {
                        /******/
                        if (installedModules[request].parents.indexOf(moduleId) === -1) {
                            /******/
                            installedModules[request].parents.push(moduleId);
                            /******/
                        }
                        /******/
                    } else {
                        /******/
                        hotCurrentParents = [moduleId];
                        /******/
                        hotCurrentChildModule = request;
                        /******/
                    }
                    /******/
                    if (me.children.indexOf(request) === -1) {
                        /******/
                        me.children.push(request);
                        /******/
                    }
                    /******/
                } else {
                    /******/
                    console.warn(
                        /******/                    "[HMR] unexpected require(" +
                        /******/                        request +
                        /******/                        ") from disposed module " +
                        /******/                        moduleId
                        /******/);
                    /******/
                    hotCurrentParents = [];
                    /******/
                }
                /******/
                return __webpack_require__(request);
                /******/
            };
            /******/
            var ObjectFactory = function ObjectFactory(name) {
                /******/
                return {
                    /******/                configurable: true,
                    /******/                enumerable: true,
                    /******/                get: function () {
                        /******/
                        return __webpack_require__[name];
                        /******/
                    },
                    /******/                set: function (value) {
                        /******/
                        __webpack_require__[name] = value;
                        /******/
                    }
                    /******/
                };
                /******/
            };
            /******/
            for (var name in __webpack_require__) {
                /******/
                if (
                    /******/                Object.prototype.hasOwnProperty.call(__webpack_require__, name) &&
                    /******/                name !== "e" &&
                    /******/                name !== "t"
                    /******/) {
                    /******/
                    Object.defineProperty(fn, name, ObjectFactory(name));
                    /******/
                }
                /******/
            }
            /******/
            fn.e = function (chunkId) {
                /******/
                if (hotStatus === "ready") hotSetStatus("prepare");
                /******/
                hotChunksLoading++;
                /******/
                return __webpack_require__.e(chunkId).then(finishChunkLoading, function (err) {
                    /******/
                    finishChunkLoading();
                    /******/
                    throw err;
                    /******/
                });
                /******/

                /******/
                function finishChunkLoading() {
                    /******/
                    hotChunksLoading--;
                    /******/
                    if (hotStatus === "prepare") {
                        /******/
                        if (!hotWaitingFilesMap[chunkId]) {
                            /******/
                            hotEnsureUpdateChunk(chunkId);
                            /******/
                        }
                        /******/
                        if (hotChunksLoading === 0 && hotWaitingFiles === 0) {
                            /******/
                            hotUpdateDownloaded();
                            /******/
                        }
                        /******/
                    }
                    /******/
                }

                /******/
            };
            /******/
            fn.t = function (value, mode) {
                /******/
                if (mode & 1) value = fn(value);
                /******/
                return __webpack_require__.t(value, mode & ~1);
                /******/
            };
            /******/
            return fn;
            /******/
        }

        /******/
        /******/ 	// eslint-disable-next-line no-unused-vars
        /******/
        function hotCreateModule(moduleId) {
            /******/
            var hot = {
                /******/ 			// private stuff
                /******/            _acceptedDependencies: {},
                /******/            _declinedDependencies: {},
                /******/            _selfAccepted: false,
                /******/            _selfDeclined: false,
                /******/            _disposeHandlers: [],
                /******/            _main: hotCurrentChildModule !== moduleId,
                /******/
                /******/ 			// Module API
                /******/            active: true,
                /******/            accept: function (dep, callback) {
                    /******/
                    if (dep === undefined) hot._selfAccepted = true;
                    /******/ else if (typeof dep === "function") hot._selfAccepted = dep;
                    /******/ else if (typeof dep === "object")
                        /******/                    for (var i = 0; i < dep.length; i++)
                            /******/                        hot._acceptedDependencies[dep[i]] = callback || function () {
                            };
                    /******/ else hot._acceptedDependencies[dep] = callback || function () {
                        };
                    /******/
                },
                /******/            decline: function (dep) {
                    /******/
                    if (dep === undefined) hot._selfDeclined = true;
                    /******/ else if (typeof dep === "object")
                        /******/                    for (var i = 0; i < dep.length; i++)
                            /******/                        hot._declinedDependencies[dep[i]] = true;
                    /******/ else hot._declinedDependencies[dep] = true;
                    /******/
                },
                /******/            dispose: function (callback) {
                    /******/
                    hot._disposeHandlers.push(callback);
                    /******/
                },
                /******/            addDisposeHandler: function (callback) {
                    /******/
                    hot._disposeHandlers.push(callback);
                    /******/
                },
                /******/            removeDisposeHandler: function (callback) {
                    /******/
                    var idx = hot._disposeHandlers.indexOf(callback);
                    /******/
                    if (idx >= 0) hot._disposeHandlers.splice(idx, 1);
                    /******/
                },
                /******/
                /******/ 			// Management API
                /******/            check: hotCheck,
                /******/            apply: hotApply,
                /******/            status: function (l) {
                    /******/
                    if (!l) return hotStatus;
                    /******/
                    hotStatusHandlers.push(l);
                    /******/
                },
                /******/            addStatusHandler: function (l) {
                    /******/
                    hotStatusHandlers.push(l);
                    /******/
                },
                /******/            removeStatusHandler: function (l) {
                    /******/
                    var idx = hotStatusHandlers.indexOf(l);
                    /******/
                    if (idx >= 0) hotStatusHandlers.splice(idx, 1);
                    /******/
                },
                /******/
                /******/ 			//inherit from previous dispose call
                /******/            data: hotCurrentModuleData[moduleId]
                /******/
            };
            /******/
            hotCurrentChildModule = undefined;
            /******/
            return hot;
            /******/
        }

        /******/
        /******/
        var hotStatusHandlers = [];
        /******/
        var hotStatus = "idle";
        /******/

        /******/
        function hotSetStatus(newStatus) {
            /******/
            hotStatus = newStatus;
            /******/
            for (var i = 0; i < hotStatusHandlers.length; i++)
                /******/            hotStatusHandlers[i].call(null, newStatus);
            /******/
        }

        /******/
        /******/ 	// while downloading
        /******/
        var hotWaitingFiles = 0;
        /******/
        var hotChunksLoading = 0;
        /******/
        var hotWaitingFilesMap = {};
        /******/
        var hotRequestedFilesMap = {};
        /******/
        var hotAvailableFilesMap = {};
        /******/
        var hotDeferred;
        /******/
        /******/ 	// The update info
        /******/
        var hotUpdate, hotUpdateNewHash;
        /******/

        /******/
        function toModuleId(id) {
            /******/
            var isNumber = +id + "" === id;
            /******/
            return isNumber ? +id : id;
            /******/
        }

        /******/

        /******/
        function hotCheck(apply) {
            /******/
            if (hotStatus !== "idle") {
                /******/
                throw new Error("check() is only allowed in idle status");
                /******/
            }
            /******/
            hotApplyOnUpdate = apply;
            /******/
            hotSetStatus("check");
            /******/
            return hotDownloadManifest(hotRequestTimeout).then(function (update) {
                /******/
                if (!update) {
                    /******/
                    hotSetStatus("idle");
                    /******/
                    return null;
                    /******/
                }
                /******/
                hotRequestedFilesMap = {};
                /******/
                hotWaitingFilesMap = {};
                /******/
                hotAvailableFilesMap = update.c;
                /******/
                hotUpdateNewHash = update.h;
                /******/
                /******/
                hotSetStatus("prepare");
                /******/
                var promise = new Promise(function (resolve, reject) {
                    /******/
                    hotDeferred = {
                        /******/                    resolve: resolve,
                        /******/                    reject: reject
                        /******/
                    };
                    /******/
                });
                /******/
                hotUpdate = {};
                /******/
                var chunkId = 2;
                /******/ 			// eslint-disable-next-line no-lone-blocks
                /******/
                {
                    /******/ 				/*globals chunkId */
                    /******/
                    hotEnsureUpdateChunk(chunkId);
                    /******/
                }
                /******/
                if (
                    /******/                hotStatus === "prepare" &&
                    /******/                hotChunksLoading === 0 &&
                    /******/                hotWaitingFiles === 0
                    /******/) {
                    /******/
                    hotUpdateDownloaded();
                    /******/
                }
                /******/
                return promise;
                /******/
            });
            /******/
        }

        /******/
        /******/ 	// eslint-disable-next-line no-unused-vars
        /******/
        function hotAddUpdateChunk(chunkId, moreModules) {
            /******/
            if (!hotAvailableFilesMap[chunkId] || !hotRequestedFilesMap[chunkId])
                /******/            return;
            /******/
            hotRequestedFilesMap[chunkId] = false;
            /******/
            for (var moduleId in moreModules) {
                /******/
                if (Object.prototype.hasOwnProperty.call(moreModules, moduleId)) {
                    /******/
                    hotUpdate[moduleId] = moreModules[moduleId];
                    /******/
                }
                /******/
            }
            /******/
            if (--hotWaitingFiles === 0 && hotChunksLoading === 0) {
                /******/
                hotUpdateDownloaded();
                /******/
            }
            /******/
        }

        /******/

        /******/
        function hotEnsureUpdateChunk(chunkId) {
            /******/
            if (!hotAvailableFilesMap[chunkId]) {
                /******/
                hotWaitingFilesMap[chunkId] = true;
                /******/
            } else {
                /******/
                hotRequestedFilesMap[chunkId] = true;
                /******/
                hotWaitingFiles++;
                /******/
                hotDownloadUpdateChunk(chunkId);
                /******/
            }
            /******/
        }

        /******/

        /******/
        function hotUpdateDownloaded() {
            /******/
            hotSetStatus("ready");
            /******/
            var deferred = hotDeferred;
            /******/
            hotDeferred = null;
            /******/
            if (!deferred) return;
            /******/
            if (hotApplyOnUpdate) {
                /******/ 			// Wrap deferred object in Promise to mark it as a well-handled Promise to
                /******/ 			// avoid triggering uncaught exception warning in Chrome.
                /******/ 			// See https://bugs.chromium.org/p/chromium/issues/detail?id=465666
                /******/
                Promise.resolve()
                    /******/                .then(function () {
                    /******/
                    return hotApply(hotApplyOnUpdate);
                    /******/
                })
                    /******/                .then(
                    /******/                    function (result) {
                        /******/
                        deferred.resolve(result);
                        /******/
                    },
                    /******/                    function (err) {
                        /******/
                        deferred.reject(err);
                        /******/
                    }
                    /******/);
                /******/
            } else {
                /******/
                var outdatedModules = [];
                /******/
                for (var id in hotUpdate) {
                    /******/
                    if (Object.prototype.hasOwnProperty.call(hotUpdate, id)) {
                        /******/
                        outdatedModules.push(toModuleId(id));
                        /******/
                    }
                    /******/
                }
                /******/
                deferred.resolve(outdatedModules);
                /******/
            }
            /******/
        }

        /******/

        /******/
        function hotApply(options) {
            /******/
            if (hotStatus !== "ready")
                /******/            throw new Error("apply() is only allowed in ready status");
            /******/
            options = options || {};
            /******/
            /******/
            var cb;
            /******/
            var i;
            /******/
            var j;
            /******/
            var module;
            /******/
            var moduleId;
            /******/

            /******/
            function getAffectedStuff(updateModuleId) {
                /******/
                var outdatedModules = [updateModuleId];
                /******/
                var outdatedDependencies = {};
                /******/
                /******/
                var queue = outdatedModules.map(function (id) {
                    /******/
                    return {
                        /******/                    chain: [id],
                        /******/                    id: id
                        /******/
                    };
                    /******/
                });
                /******/
                while (queue.length > 0) {
                    /******/
                    var queueItem = queue.pop();
                    /******/
                    var moduleId = queueItem.id;
                    /******/
                    var chain = queueItem.chain;
                    /******/
                    module = installedModules[moduleId];
                    /******/
                    if (!module || module.hot._selfAccepted) continue;
                    /******/
                    if (module.hot._selfDeclined) {
                        /******/
                        return {
                            /******/                        type: "self-declined",
                            /******/                        chain: chain,
                            /******/                        moduleId: moduleId
                            /******/
                        };
                        /******/
                    }
                    /******/
                    if (module.hot._main) {
                        /******/
                        return {
                            /******/                        type: "unaccepted",
                            /******/                        chain: chain,
                            /******/                        moduleId: moduleId
                            /******/
                        };
                        /******/
                    }
                    /******/
                    for (var i = 0; i < module.parents.length; i++) {
                        /******/
                        var parentId = module.parents[i];
                        /******/
                        var parent = installedModules[parentId];
                        /******/
                        if (!parent) continue;
                        /******/
                        if (parent.hot._declinedDependencies[moduleId]) {
                            /******/
                            return {
                                /******/                            type: "declined",
                                /******/                            chain: chain.concat([parentId]),
                                /******/                            moduleId: moduleId,
                                /******/                            parentId: parentId
                                /******/
                            };
                            /******/
                        }
                        /******/
                        if (outdatedModules.indexOf(parentId) !== -1) continue;
                        /******/
                        if (parent.hot._acceptedDependencies[moduleId]) {
                            /******/
                            if (!outdatedDependencies[parentId])
                                /******/                            outdatedDependencies[parentId] = [];
                            /******/
                            addAllToSet(outdatedDependencies[parentId], [moduleId]);
                            /******/
                            continue;
                            /******/
                        }
                        /******/
                        delete outdatedDependencies[parentId];
                        /******/
                        outdatedModules.push(parentId);
                        /******/
                        queue.push({
                            /******/                        chain: chain.concat([parentId]),
                            /******/                        id: parentId
                            /******/
                        });
                        /******/
                    }
                    /******/
                }
                /******/
                /******/
                return {
                    /******/                type: "accepted",
                    /******/                moduleId: updateModuleId,
                    /******/                outdatedModules: outdatedModules,
                    /******/                outdatedDependencies: outdatedDependencies
                    /******/
                };
                /******/
            }

            /******/

            /******/
            function addAllToSet(a, b) {
                /******/
                for (var i = 0; i < b.length; i++) {
                    /******/
                    var item = b[i];
                    /******/
                    if (a.indexOf(item) === -1) a.push(item);
                    /******/
                }
                /******/
            }

            /******/
            /******/ 		// at begin all updates modules are outdated
            /******/ 		// the "outdated" status can propagate to parents if they don't accept the children
            /******/
            var outdatedDependencies = {};
            /******/
            var outdatedModules = [];
            /******/
            var appliedUpdate = {};
            /******/
            /******/
            var warnUnexpectedRequire = function warnUnexpectedRequire() {
                /******/
                console.warn(
                    /******/                "[HMR] unexpected require(" + result.moduleId + ") to disposed module"
                    /******/);
                /******/
            };
            /******/
            /******/
            for (var id in hotUpdate) {
                /******/
                if (Object.prototype.hasOwnProperty.call(hotUpdate, id)) {
                    /******/
                    moduleId = toModuleId(id);
                    /******/ 				/** @type {TODO} */
                    /******/
                    var result;
                    /******/
                    if (hotUpdate[id]) {
                        /******/
                        result = getAffectedStuff(moduleId);
                        /******/
                    } else {
                        /******/
                        result = {
                            /******/                        type: "disposed",
                            /******/                        moduleId: id
                            /******/
                        };
                        /******/
                    }
                    /******/ 				/** @type {Error|false} */
                    /******/
                    var abortError = false;
                    /******/
                    var doApply = false;
                    /******/
                    var doDispose = false;
                    /******/
                    var chainInfo = "";
                    /******/
                    if (result.chain) {
                        /******/
                        chainInfo = "\nUpdate propagation: " + result.chain.join(" -> ");
                        /******/
                    }
                    /******/
                    switch (result.type) {
                        /******/
                        case "self-declined":
                            /******/
                            if (options.onDeclined) options.onDeclined(result);
                            /******/
                            if (!options.ignoreDeclined)
                                /******/                            abortError = new Error(
                                /******/                                "Aborted because of self decline: " +
                                /******/                                    result.moduleId +
                                /******/                                    chainInfo
                                /******/);
                            /******/
                            break;
                        /******/
                        case "declined":
                            /******/
                            if (options.onDeclined) options.onDeclined(result);
                            /******/
                            if (!options.ignoreDeclined)
                                /******/                            abortError = new Error(
                                /******/                                "Aborted because of declined dependency: " +
                                /******/                                    result.moduleId +
                                /******/                                    " in " +
                                /******/                                    result.parentId +
                                /******/                                    chainInfo
                                /******/);
                            /******/
                            break;
                        /******/
                        case "unaccepted":
                            /******/
                            if (options.onUnaccepted) options.onUnaccepted(result);
                            /******/
                            if (!options.ignoreUnaccepted)
                                /******/                            abortError = new Error(
                                /******/                                "Aborted because " + moduleId + " is not accepted" + chainInfo
                                /******/);
                            /******/
                            break;
                        /******/
                        case "accepted":
                            /******/
                            if (options.onAccepted) options.onAccepted(result);
                            /******/
                            doApply = true;
                            /******/
                            break;
                        /******/
                        case "disposed":
                            /******/
                            if (options.onDisposed) options.onDisposed(result);
                            /******/
                            doDispose = true;
                            /******/
                            break;
                        /******/
                        default:
                            /******/
                            throw new Error("Unexception type " + result.type);
                        /******/
                    }
                    /******/
                    if (abortError) {
                        /******/
                        hotSetStatus("abort");
                        /******/
                        return Promise.reject(abortError);
                        /******/
                    }
                    /******/
                    if (doApply) {
                        /******/
                        appliedUpdate[moduleId] = hotUpdate[moduleId];
                        /******/
                        addAllToSet(outdatedModules, result.outdatedModules);
                        /******/
                        for (moduleId in result.outdatedDependencies) {
                            /******/
                            if (
                                /******/                            Object.prototype.hasOwnProperty.call(
                                /******/                                result.outdatedDependencies,
                                /******/                                moduleId
                                /******/)
                                /******/) {
                                /******/
                                if (!outdatedDependencies[moduleId])
                                    /******/                                outdatedDependencies[moduleId] = [];
                                /******/
                                addAllToSet(
                                    /******/                                outdatedDependencies[moduleId],
                                    /******/                                result.outdatedDependencies[moduleId]
                                    /******/);
                                /******/
                            }
                            /******/
                        }
                        /******/
                    }
                    /******/
                    if (doDispose) {
                        /******/
                        addAllToSet(outdatedModules, [result.moduleId]);
                        /******/
                        appliedUpdate[moduleId] = warnUnexpectedRequire;
                        /******/
                    }
                    /******/
                }
                /******/
            }
            /******/
            /******/ 		// Store self accepted outdated modules to require them later by the module system
            /******/
            var outdatedSelfAcceptedModules = [];
            /******/
            for (i = 0; i < outdatedModules.length; i++) {
                /******/
                moduleId = outdatedModules[i];
                /******/
                if (
                    /******/                installedModules[moduleId] &&
                    /******/                installedModules[moduleId].hot._selfAccepted &&
                    /******/ 				// removed self-accepted modules should not be required
                    /******/                appliedUpdate[moduleId] !== warnUnexpectedRequire
                    /******/) {
                    /******/
                    outdatedSelfAcceptedModules.push({
                        /******/                    module: moduleId,
                        /******/                    errorHandler: installedModules[moduleId].hot._selfAccepted
                        /******/
                    });
                    /******/
                }
                /******/
            }
            /******/
            /******/ 		// Now in "dispose" phase
            /******/
            hotSetStatus("dispose");
            /******/
            Object.keys(hotAvailableFilesMap).forEach(function (chunkId) {
                /******/
                if (hotAvailableFilesMap[chunkId] === false) {
                    /******/
                    hotDisposeChunk(chunkId);
                    /******/
                }
                /******/
            });
            /******/
            /******/
            var idx;
            /******/
            var queue = outdatedModules.slice();
            /******/
            while (queue.length > 0) {
                /******/
                moduleId = queue.pop();
                /******/
                module = installedModules[moduleId];
                /******/
                if (!module) continue;
                /******/
                /******/
                var data = {};
                /******/
                /******/ 			// Call dispose handlers
                /******/
                var disposeHandlers = module.hot._disposeHandlers;
                /******/
                for (j = 0; j < disposeHandlers.length; j++) {
                    /******/
                    cb = disposeHandlers[j];
                    /******/
                    cb(data);
                    /******/
                }
                /******/
                hotCurrentModuleData[moduleId] = data;
                /******/
                /******/ 			// disable module (this disables requires from this module)
                /******/
                module.hot.active = false;
                /******/
                /******/ 			// remove module from cache
                /******/
                delete installedModules[moduleId];
                /******/
                /******/ 			// when disposing there is no need to call dispose handler
                /******/
                delete outdatedDependencies[moduleId];
                /******/
                /******/ 			// remove "parents" references from all children
                /******/
                for (j = 0; j < module.children.length; j++) {
                    /******/
                    var child = installedModules[module.children[j]];
                    /******/
                    if (!child) continue;
                    /******/
                    idx = child.parents.indexOf(moduleId);
                    /******/
                    if (idx >= 0) {
                        /******/
                        child.parents.splice(idx, 1);
                        /******/
                    }
                    /******/
                }
                /******/
            }
            /******/
            /******/ 		// remove outdated dependency from module children
            /******/
            var dependency;
            /******/
            var moduleOutdatedDependencies;
            /******/
            for (moduleId in outdatedDependencies) {
                /******/
                if (
                    /******/                Object.prototype.hasOwnProperty.call(outdatedDependencies, moduleId)
                    /******/) {
                    /******/
                    module = installedModules[moduleId];
                    /******/
                    if (module) {
                        /******/
                        moduleOutdatedDependencies = outdatedDependencies[moduleId];
                        /******/
                        for (j = 0; j < moduleOutdatedDependencies.length; j++) {
                            /******/
                            dependency = moduleOutdatedDependencies[j];
                            /******/
                            idx = module.children.indexOf(dependency);
                            /******/
                            if (idx >= 0) module.children.splice(idx, 1);
                            /******/
                        }
                        /******/
                    }
                    /******/
                }
                /******/
            }
            /******/
            /******/ 		// Now in "apply" phase
            /******/
            hotSetStatus("apply");
            /******/
            /******/
            hotCurrentHash = hotUpdateNewHash;
            /******/
            /******/ 		// insert new code
            /******/
            for (moduleId in appliedUpdate) {
                /******/
                if (Object.prototype.hasOwnProperty.call(appliedUpdate, moduleId)) {
                    /******/
                    modules[moduleId] = appliedUpdate[moduleId];
                    /******/
                }
                /******/
            }
            /******/
            /******/ 		// call accept handlers
            /******/
            var error = null;
            /******/
            for (moduleId in outdatedDependencies) {
                /******/
                if (
                    /******/                Object.prototype.hasOwnProperty.call(outdatedDependencies, moduleId)
                    /******/) {
                    /******/
                    module = installedModules[moduleId];
                    /******/
                    if (module) {
                        /******/
                        moduleOutdatedDependencies = outdatedDependencies[moduleId];
                        /******/
                        var callbacks = [];
                        /******/
                        for (i = 0; i < moduleOutdatedDependencies.length; i++) {
                            /******/
                            dependency = moduleOutdatedDependencies[i];
                            /******/
                            cb = module.hot._acceptedDependencies[dependency];
                            /******/
                            if (cb) {
                                /******/
                                if (callbacks.indexOf(cb) !== -1) continue;
                                /******/
                                callbacks.push(cb);
                                /******/
                            }
                            /******/
                        }
                        /******/
                        for (i = 0; i < callbacks.length; i++) {
                            /******/
                            cb = callbacks[i];
                            /******/
                            try {
                                /******/
                                cb(moduleOutdatedDependencies);
                                /******/
                            } catch (err) {
                                /******/
                                if (options.onErrored) {
                                    /******/
                                    options.onErrored({
                                        /******/
                                        type: "accept-errored",
                                        /******/
                                        moduleId: moduleId,
                                        /******/
                                        dependencyId: moduleOutdatedDependencies[i],
                                        /******/
                                        error: err
                                        /******/
                                    });
                                    /******/
                                }
                                /******/
                                if (!options.ignoreErrored) {
                                    /******/
                                    if (!error) error = err;
                                    /******/
                                }
                                /******/
                            }
                            /******/
                        }
                        /******/
                    }
                    /******/
                }
                /******/
            }
            /******/
            /******/ 		// Load self accepted modules
            /******/
            for (i = 0; i < outdatedSelfAcceptedModules.length; i++) {
                /******/
                var item = outdatedSelfAcceptedModules[i];
                /******/
                moduleId = item.module;
                /******/
                hotCurrentParents = [moduleId];
                /******/
                try {
                    /******/
                    __webpack_require__(moduleId);
                    /******/
                } catch (err) {
                    /******/
                    if (typeof item.errorHandler === "function") {
                        /******/
                        try {
                            /******/
                            item.errorHandler(err);
                            /******/
                        } catch (err2) {
                            /******/
                            if (options.onErrored) {
                                /******/
                                options.onErrored({
                                    /******/                                type: "self-accept-error-handler-errored",
                                    /******/                                moduleId: moduleId,
                                    /******/                                error: err2,
                                    /******/                                originalError: err
                                    /******/
                                });
                                /******/
                            }
                            /******/
                            if (!options.ignoreErrored) {
                                /******/
                                if (!error) error = err2;
                                /******/
                            }
                            /******/
                            if (!error) error = err;
                            /******/
                        }
                        /******/
                    } else {
                        /******/
                        if (options.onErrored) {
                            /******/
                            options.onErrored({
                                /******/                            type: "self-accept-errored",
                                /******/                            moduleId: moduleId,
                                /******/                            error: err
                                /******/
                            });
                            /******/
                        }
                        /******/
                        if (!options.ignoreErrored) {
                            /******/
                            if (!error) error = err;
                            /******/
                        }
                        /******/
                    }
                    /******/
                }
                /******/
            }
            /******/
            /******/ 		// handle errors in accept handlers and self accepted module load
            /******/
            if (error) {
                /******/
                hotSetStatus("fail");
                /******/
                return Promise.reject(error);
                /******/
            }
            /******/
            /******/
            hotSetStatus("idle");
            /******/
            return new Promise(function (resolve) {
                /******/
                resolve(outdatedModules);
                /******/
            });
            /******/
        }

        /******/
        /******/ 	// The module cache
        /******/
        var installedModules = {};
        /******/
        /******/ 	// The require function
        /******/
        function __webpack_require__(moduleId) {
            /******/
            /******/ 		// Check if module is in cache
            /******/
            if (installedModules[moduleId]) {
                /******/
                return installedModules[moduleId].exports;
                /******/
            }
            /******/ 		// Create a new module (and put it into the cache)
            /******/
            var module = installedModules[moduleId] = {
                /******/
                i: moduleId,
                /******/
                l: false,
                /******/
                exports: {},
                /******/
                hot: hotCreateModule(moduleId),
                /******/
                parents: (hotCurrentParentsTemp = hotCurrentParents, hotCurrentParents = [], hotCurrentParentsTemp),
                /******/
                children: []
                /******/
            };
            /******/
            /******/ 		// Execute the module function
            /******/
            modules[moduleId].call(module.exports, module, module.exports, hotCreateRequire(moduleId));
            /******/
            /******/ 		// Flag the module as loaded
            /******/
            module.l = true;
            /******/
            /******/ 		// Return the exports of the module
            /******/
            return module.exports;
            /******/
        }

        /******/
        /******/
        /******/ 	// expose the modules object (__webpack_modules__)
        /******/
        __webpack_require__.m = modules;
        /******/
        /******/ 	// expose the module cache
        /******/
        __webpack_require__.c = installedModules;
        /******/
        /******/ 	// define getter function for harmony exports
        /******/
        __webpack_require__.d = function (exports, name, getter) {
            /******/
            if (!__webpack_require__.o(exports, name)) {
                /******/
                Object.defineProperty(exports, name, {enumerable: true, get: getter});
                /******/
            }
            /******/
        };
        /******/
        /******/ 	// define __esModule on exports
        /******/
        __webpack_require__.r = function (exports) {
            /******/
            if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
                /******/
                Object.defineProperty(exports, Symbol.toStringTag, {value: 'Module'});
                /******/
            }
            /******/
            Object.defineProperty(exports, '__esModule', {value: true});
            /******/
        };
        /******/
        /******/ 	// create a fake namespace object
        /******/ 	// mode & 1: value is a module id, require it
        /******/ 	// mode & 2: merge all properties of value into the ns
        /******/ 	// mode & 4: return value when already ns object
        /******/ 	// mode & 8|1: behave like require
        /******/
        __webpack_require__.t = function (value, mode) {
            /******/
            if (mode & 1) value = __webpack_require__(value);
            /******/
            if (mode & 8) return value;
            /******/
            if ((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
            /******/
            var ns = Object.create(null);
            /******/
            __webpack_require__.r(ns);
            /******/
            Object.defineProperty(ns, 'default', {enumerable: true, value: value});
            /******/
            if (mode & 2 && typeof value != 'string') for (var key in value) __webpack_require__.d(ns, key, function (key) {
                return value[key];
            }.bind(null, key));
            /******/
            return ns;
            /******/
        };
        /******/
        /******/ 	// getDefaultExport function for compatibility with non-harmony modules
        /******/
        __webpack_require__.n = function (module) {
            /******/
            var getter = module && module.__esModule ?
                /******/            function getDefault() {
                    return module['default'];
                } :
                /******/            function getModuleExports() {
                    return module;
                };
            /******/
            __webpack_require__.d(getter, 'a', getter);
            /******/
            return getter;
            /******/
        };
        /******/
        /******/ 	// Object.prototype.hasOwnProperty.call
        /******/
        __webpack_require__.o = function (object, property) {
            return Object.prototype.hasOwnProperty.call(object, property);
        };
        /******/
        /******/ 	// __webpack_public_path__
        /******/
        __webpack_require__.p = "";
        /******/
        /******/ 	// __webpack_hash__
        /******/
        __webpack_require__.h = function () {
            return hotCurrentHash;
        };
        /******/
        /******/
        /******/ 	// Load entry module and return exports
        /******/
        return hotCreateRequire(12)(__webpack_require__.s = 12);
        /******/
    })
        /************************************************************************/
        /******/ ([
            /* 0 */
            /***/ (function (module, exports) {

                module.exports = __WEBPACK_EXTERNAL_MODULE__0__;

                /***/
            }),
            /* 1 */
            /***/ (function (module, exports) {

                module.exports = "<?xml version=\"1.0\" standalone=\"no\"?><!doctype html><svg class=icon width=20px height=20px viewBox=\"0 0 1024 1024\" version=1.1 xmlns=http://www.w3.org/2000/svg><path fill=#595959 d=\"M73.142857 336.64h526.628572v43.885714H73.142857zM73.142857 643.657143h526.628572v43.885714H73.142857zM336.457143 117.028571h43.885714v789.942858h-43.885714zM204.8 73.142857h614.4a131.657143 131.657143 0 0 1 131.657143 131.657143v614.4a131.657143 131.657143 0 0 1-131.657143 131.657143H204.8A131.657143 131.657143 0 0 1 73.142857 819.2V204.8A131.84 131.84 0 0 1 204.8 73.142857z m0 43.885714a87.771429 87.771429 0 0 0-87.771429 87.771429v614.4a87.771429 87.771429 0 0 0 87.771429 87.771429h614.4a87.771429 87.771429 0 0 0 87.771429-87.771429V204.8a87.771429 87.771429 0 0 0-87.771429-87.771429zM819.2 73.142857h-219.428571v877.714286h219.428571a131.657143 131.657143 0 0 0 131.657143-131.657143V204.8A131.84 131.84 0 0 0 819.2 73.142857z m44.068571 460.982857h-65.828571v65.828572H753.371429v-65.828572h-65.828572V490.057143h65.828572v-65.828572h44.068571v65.828572h65.828571z\"/></svg>";

                /***/
            }),
            /* 2 */
            /***/ (function (module, exports) {

                module.exports = "<?xml version=\"1.0\" standalone=\"no\"?><!doctype html><svg class=icon width=20px height=20.00px viewBox=\"0 0 1024 1024\" version=1.1 xmlns=http://www.w3.org/2000/svg><path fill=#595959 d=\"M380.342857 336.457143h526.811429v43.885714H380.342857z m0 307.2h526.811429v43.885714H380.342857zM643.657143 117.028571h43.885714v789.942858h-43.885714zM204.8 73.142857h614.582857A131.474286 131.474286 0 0 1 950.857143 204.8v614.4a131.657143 131.657143 0 0 1-131.657143 131.657143H204.8A131.657143 131.657143 0 0 1 73.142857 819.2V204.8A131.657143 131.657143 0 0 1 204.8 73.142857z m0 43.885714a87.588571 87.588571 0 0 0-87.588571 87.771429v614.4a87.588571 87.588571 0 0 0 87.588571 87.771429h614.582857a87.771429 87.771429 0 0 0 87.771429-87.771429V204.8a87.771429 87.771429 0 0 0-87.771429-87.771429zM204.8 73.142857A131.657143 131.657143 0 0 0 73.142857 204.8v614.4a131.657143 131.657143 0 0 0 131.657143 131.657143h219.428571V73.142857z m131.84 460.8h-65.828571v65.828572h-43.885715v-65.828572h-65.828571v-43.885714h65.828571v-65.828572h43.885715v65.828572h65.828571z\"/></svg>";

                /***/
            }),
            /* 3 */
            /***/ (function (module, exports) {

                module.exports = "<?xml version=\"1.0\" standalone=\"no\"?><!doctype html><svg class=icon width=20px height=20.00px viewBox=\"0 0 1024 1024\" version=1.1 xmlns=http://www.w3.org/2000/svg><path fill=#595959 d=\"M73.142857 599.771429h877.714286v43.885714H73.142857zM336.457143 380.342857h43.885714v526.628572h-43.885714z m307.2 0h43.885714v526.628572h-43.885714zM204.8 73.142857h614.4a131.657143 131.657143 0 0 1 131.657143 131.657143v614.4a131.657143 131.657143 0 0 1-131.657143 131.657143H204.8A131.657143 131.657143 0 0 1 73.142857 819.2V204.8A131.657143 131.657143 0 0 1 204.8 73.142857z m0 43.885714a87.771429 87.771429 0 0 0-87.771429 87.771429v614.4a87.588571 87.588571 0 0 0 87.771429 87.771429h614.4a87.588571 87.588571 0 0 0 87.771429-87.771429V204.8a87.771429 87.771429 0 0 0-87.771429-87.771429zM819.2 73.142857H204.8A131.657143 131.657143 0 0 0 73.142857 204.8v219.428571h877.714286v-219.428571A131.657143 131.657143 0 0 0 819.2 73.142857z m-219.428571 197.485714h-65.828572v65.828572h-43.885714v-65.828572h-65.828572v-43.885714h65.828572V160.914286h43.885714v65.828571h65.828572z\"/></svg>";

                /***/
            }),
            /* 4 */
            /***/ (function (module, exports) {

                module.exports = "<?xml version=\"1.0\" standalone=\"no\"?><!doctype html><svg class=icon width=20px height=20.00px viewBox=\"0 0 1024 1024\" version=1.1 xmlns=http://www.w3.org/2000/svg><path fill=#595959 d=\"M204.8 73.142857h614.4a131.657143 131.657143 0 0 1 131.657143 131.657143v614.4a131.657143 131.657143 0 0 1-131.657143 131.657143H204.8A131.657143 131.657143 0 0 1 73.142857 819.2V204.8A131.84 131.84 0 0 1 204.8 73.142857z m0 43.885714a87.771429 87.771429 0 0 0-87.771429 87.771429v614.4a87.771429 87.771429 0 0 0 87.771429 87.771429h614.4a87.771429 87.771429 0 0 0 87.771429-87.771429V204.8a87.771429 87.771429 0 0 0-87.771429-87.771429zM73.142857 336.457143h877.714286v44.068571H73.142857zM336.64 117.028571h43.885714v526.628572h-43.885714z m307.017143 0h44.068571v526.628572H643.657143zM73.142857 599.771429v219.428571a131.657143 131.657143 0 0 0 131.657143 131.657143h614.4a131.657143 131.657143 0 0 0 131.657143-131.657143v-219.428571z m526.628572 197.485714h-65.645715v65.828571H490.057143v-65.828571h-65.828572v-43.885714h65.828572v-65.828572h44.068571v65.828572h65.645715z\"/></svg>";

                /***/
            }),
            /* 5 */
            /***/ (function (module, exports) {

                module.exports = "<?xml version=\"1.0\" standalone=\"no\"?><!doctype html><svg class=icon width=20px height=20.00px viewBox=\"0 0 1024 1024\" version=1.1 xmlns=http://www.w3.org/2000/svg><path fill=#595959 d=\"M925.99596 99.038384c-25.470707-25.6-60.121212-39.822222-96.323233-39.822222H194.19798c-36.072727 0-70.723232 14.351515-96.323233 39.822222-25.6 25.6-39.822222 60.121212-39.822222 96.323232v635.474748c0 36.072727 14.351515 70.723232 39.822222 96.323232C123.474747 952.759596 158.125253 967.111111 194.19798 967.111111h635.474747c36.072727 0 70.723232-14.351515 96.323233-39.951515 25.6-25.6 39.951515-60.121212 39.951515-96.323232V195.361616c0-36.072727-14.351515-70.723232-39.951515-96.323232z m-277.850505 5.559596v226.909091H375.725253V104.59798h272.420202zM103.434343 195.361616c0-24.048485 9.567677-47.191919 26.634344-64.129293 17.066667-17.066667 40.080808-26.634343 64.129293-26.634343h136.145454v226.909091H103.434343V195.361616z m90.763637 726.367677c-24.048485 0-47.191919-9.567677-64.129293-26.634344-17.066667-17.066667-26.634343-40.080808-26.634344-64.129292V649.309091h226.909091v272.420202H194.19798z m181.527273 0V649.309091h272.290909v272.420202H375.725253z m544.711111-90.892929c0 24.048485-9.567677 47.191919-26.634344 64.129293-17.066667 17.066667-40.080808 26.634343-64.129293 26.634343H693.527273V649.309091h226.909091v181.527273zM693.527273 331.507071V104.59798h136.145454c24.048485 0 47.191919 9.567677 64.129293 26.634343 17.066667 17.066667 26.634343 40.080808 26.634344 64.129293v136.145455H693.527273z\"/></svg>";

                /***/
            }),
            /* 6 */
            /***/ (function (module, exports) {

                module.exports = "<?xml version=\"1.0\" standalone=\"no\"?><!doctype html><svg class=icon width=20px height=20.00px viewBox=\"0 0 1024 1024\" version=1.1 xmlns=http://www.w3.org/2000/svg><path fill=#595959 d=\"M336.457143 73.142857h43.885714v877.714286h-43.885714z m307.382857 0h43.702857v877.714286h-43.702857z m-438.857143 0h614.4A131.657143 131.657143 0 0 1 950.857143 204.8v614.4a131.474286 131.474286 0 0 1-131.474286 131.657143h-614.4A131.657143 131.657143 0 0 1 73.142857 819.2V204.8A131.84 131.84 0 0 1 204.982857 73.142857z m0 43.885714a87.588571 87.588571 0 0 0-87.771428 87.771429v614.4a87.588571 87.588571 0 0 0 87.771428 87.771429h614.4a87.771429 87.771429 0 0 0 87.771429-87.771429V204.8a87.771429 87.771429 0 0 0-87.771429-87.771429zM73.142857 336.457143h877.714286v307.2H73.142857z m292.571429 43.885714v219.428572h292.571428v-219.428572z\"/></svg>";

                /***/
            }),
            /* 7 */
            /***/ (function (module, exports) {

                module.exports = "<?xml version=\"1.0\" standalone=\"no\"?><!doctype html><svg class=icon width=20px height=20.00px viewBox=\"0 0 1024 1024\" version=1.1 xmlns=http://www.w3.org/2000/svg><path fill=#595959 d=\"M925.996 99.038c-25.47-25.6-60.121-39.822-96.323-39.822H194.198c-75.12 0.13-136.016 61.026-136.145 136.146v635.345c0 36.073 14.351 70.723 39.822 96.323 25.6 25.73 60.25 40.081 96.323 40.081h635.475c36.072 0 70.723-14.351 96.323-39.951 25.6-25.6 39.951-60.122 39.951-96.324V195.362c0-36.073-14.351-70.724-39.951-96.324z m-365.77 494.287L512 545.228l-48.226 48.097-32.194-31.935 48.355-48.226-48.226-48.097 32.194-32.194L512 480.97l48.097-48.097 32.194 32.194-48.097 48.097 48.226 48.226-32.194 31.935zM103.434 195.362c0-24.049 9.568-47.192 26.635-64.13 17.066-17.066 40.08-26.634 64.129-26.634h136.145v226.91H103.434V195.361z m0 181.656h226.91V649.31h-226.91V377.02z m90.764 544.84c-24.049 0-47.192-9.567-64.13-26.634-17.066-17.066-26.634-40.08-26.634-64.258V694.69h226.91v227.168H194.197z m726.238-90.763c0 24.048-9.438 47.192-26.505 64.259-17.066 17.066-40.21 26.634-64.258 26.505H693.527V694.69h226.91v136.404z m0-181.786H693.527V377.02h226.91v272.29zM693.527 331.507V104.598h136.146c24.048 0 47.192 9.438 64.258 26.505 17.067 17.067 26.635 40.21 26.505 64.259v136.145H693.527z\"/></svg>";

                /***/
            }),
            /* 8 */
            /***/ (function (module, exports) {

                module.exports = "<?xml version=\"1.0\" standalone=\"no\"?><!doctype html><svg class=icon width=20px height=20.00px viewBox=\"0 0 1024 1024\" version=1.1 xmlns=http://www.w3.org/2000/svg><path fill=#595959 d=\"M925.99596 99.038384c-25.470707-25.6-60.121212-39.822222-96.323233-39.822222H194.19798c-36.072727 0-70.723232 14.351515-96.323233 39.822222-25.6 25.6-39.822222 60.121212-39.822222 96.323232v635.474748c0 36.072727 14.351515 70.723232 39.822222 96.323232C123.474747 952.759596 158.125253 967.111111 194.19798 967.111111h635.474747c36.072727 0 70.723232-14.351515 96.323233-39.951515 25.6-25.6 39.951515-60.121212 39.951515-96.323232V195.361616c0-36.072727-14.351515-70.723232-39.951515-96.323232z m-550.270707 5.559596h272.290909v227.167677H375.725253V104.59798z m56.242424 360.468687l31.935353-32.19394 48.09697 48.226263 48.09697-48.226263 32.193939 32.19394-48.09697 48.096969 48.226263 48.226263-32.193939 31.935354-48.226263-48.09697-48.226263 48.09697-31.935353-31.935354 48.226262-48.226263-48.096969-48.096969zM103.434343 195.361616c0-24.048485 9.567677-47.191919 26.634344-64.129293 17.066667-17.066667 40.080808-26.634343 64.129293-26.634343h136.145454v227.167677H103.434343V195.361616z m817.002021 635.733333c0 24.048485-9.567677 47.191919-26.634344 64.258586-17.066667 17.066667-40.080808 26.634343-64.129293 26.634344H194.19798c-24.048485 0-47.191919-9.567677-64.258586-26.634344C112.872727 878.157576 103.434343 855.014141 103.434343 830.836364V694.690909h226.909091v226.909091h45.381819V694.690909h272.290909v226.909091h45.381818V694.690909h226.909091v136.40404z m0-499.329292H693.527273V104.59798h136.145454c24.048485 0 47.191919 9.567677 64.129293 26.634343 17.066667 17.066667 26.634343 40.080808 26.634344 64.129293v136.404041z\"/></svg>";

                /***/
            }),
            /* 9 */
            /***/ (function (module, exports) {

                module.exports = "<?xml version=\"1.0\" standalone=\"no\"?><!doctype html><svg class=icon width=20px height=20.00px viewBox=\"0 0 1024 1024\" version=1.1 xmlns=http://www.w3.org/2000/svg><path fill=#595959 d=\"M764.42168889 830.5152c0 30.23530667-24.61013333 54.84430222-54.84316444 54.84430222H314.42147555c-30.23416889 0-54.84316445-24.61013333-54.84316444-54.84430222V248.32796445h504.84337778v582.18723555zM369.26577778 149.89084445c0-6.32832 4.92202667-11.25034667 11.25034667-11.25034667H644.18702222c6.32832 0 11.25034667 4.92202667 11.25034667 11.25034667v33.04675555H369.26577778V149.89084445z m559.68768 33.04675555H720.82773333V149.89084445c0-42.1888-34.45191111-76.64071111-76.64071111-76.64071112H380.51612445c-42.1888 0-76.64071111 34.45191111-76.64071112 76.64071112v33.04675555h-208.82773333c-18.28181333 0-33.04789333 14.76608-33.04789333 33.04675555s14.76608 33.04675555 33.04675555 33.04675556h98.43825778v581.48408889c0 66.79779555 54.14001778 120.93781333 120.93667555 120.93781333h395.1570489c66.79665778 0 120.93667555-54.14001778 120.93667555-120.93781333V248.32796445h98.43825778c18.28067555 0 33.04675555-14.76494222 33.04675555-33.04675556s-14.76608-32.34360889-33.04675555-32.34360889zM512 786.21923555c18.28181333 0 33.04675555-14.76608 33.04675555-33.04789333v-351.56195555c0-18.28181333-14.76494222-33.04675555-33.04675555-33.04675556s-33.04675555 14.76494222-33.04675555 33.04675556v351.56195555c0 18.28181333 14.76494222 33.04789333 33.04675555 33.04789333m-153.98456889 0c18.28181333 0 33.04675555-14.76608 33.04675556-33.04789333v-351.56195555c0-18.28181333-14.76494222-33.04675555-33.04675556-33.04675556s-33.04675555 14.76494222-33.04675556 33.04675556v351.56195555c0.70314667 18.28181333 15.46922667 33.04789333 33.04675556 33.04789333m307.96913778 0c18.28067555 0 33.04675555-14.76608 33.04675556-33.04789333v-351.56195555c0-18.28181333-14.76608-33.04675555-33.04675556-33.04675556s-33.04675555 14.76494222-33.04675556 33.04675556v351.56195555c0 18.28181333 14.76494222 33.04789333 33.04675556 33.04789333\"/></svg>";

                /***/
            }),
            /* 10 */
            /***/ (function (module, __webpack_exports__, __webpack_require__) {

                "use strict";
                __webpack_require__.r(__webpack_exports__);

// EXTERNAL MODULE: external {"commonjs":"quill","commonjs2":"quill","amd":"quill","root":"Quill"}
                var external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_ = __webpack_require__(0);
                var external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default = /*#__PURE__*/__webpack_require__.n(external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_);

// CONCATENATED MODULE: ./src/utils/index.js
                function css(domNode, rules) {
                    if (typeof rules === 'object') {
                        for (let prop in rules) {
                            domNode.style[prop] = rules[prop];
                        }
                    }
                }

                /**
                 * getRelativeRect
                 * @param  {Object} targetRect  rect data for target element
                 * @param  {Element} container  container element
                 * @return {Object}             an object with rect data
                 */

                function getRelativeRect(targetRect, container) {
                    let containerRect = container.getBoundingClientRect();
                    return {
                        x: targetRect.x - containerRect.x - container.scrollLeft,
                        y: targetRect.y - containerRect.y - container.scrollTop,
                        x1: targetRect.x - containerRect.x - container.scrollLeft + targetRect.width,
                        y1: targetRect.y - containerRect.y - container.scrollTop + targetRect.height,
                        width: targetRect.width,
                        height: targetRect.height
                    };
                }

                /**
                 * _omit
                 * @param  {Object} obj         target Object
                 * @param  {Array} uselessKeys  keys of removed properties
                 * @return {Object}             new Object without useless properties
                 */

                function _omit(obj, uselessKeys) {
                    return obj && Object.keys(obj).reduce((acc, key) => {
                        return uselessKeys.includes(key) ? acc : Object.assign({}, acc, {
                            [key]: obj[key]
                        });
                    }, {});
                }

                /**
                 * getEventComposedPath
                 *  compatibility fixed for Event.path/Event.composedPath
                 *  Event.path is only for chrome/opera
                 *  Event.composedPath is for Safari, FF
                 *  Neither for Micro Edge
                 * @param {Event} evt
                 * @return {Array} an array of event.path
                 */

                function getEventComposedPath(evt) {
                    let path; // chrome, opera, safari, firefox

                    path = evt.path || evt.composedPath && evt.composedPath(); // other: edge

                    if (path == undefined && evt.target) {
                        path = [];
                        let target = evt.target;
                        path.push(target);

                        while (target && target.parentNode) {
                            target = target.parentNode;
                            path.push(target);
                        }
                    }

                    return path;
                }

                function convertToHex(rgb) {
                    var reg = /^#([0-9a-fA-f]{3}|[0-9a-fA-f]{6})$/; // if rgb

                    if (/^(rgb|RGB)/.test(rgb)) {
                        var color = rgb.toString().match(/\d+/g);
                        var hex = "#";

                        for (var i = 0; i < 3; i++) {
                            hex += ("0" + Number(color[i]).toString(16)).slice(-2);
                        }

                        return hex;
                    } else if (reg.test(rgb)) {
                        var aNum = rgb.replace(/#/, "").split("");

                        if (aNum.length === 6) {
                            return rgb;
                        } else if (aNum.length === 3) {
                            var numHex = "#";

                            for (var i = 0; i < aNum.length; i += 1) {
                                numHex += aNum[i] + aNum[i];
                            }

                            return numHex;
                        }
                    }

                    return rgb;
                }

// CONCATENATED MODULE: ./src/modules/table-column-tool.js


                const COL_TOOL_HEIGHT = 12;
                const COL_TOOL_CELL_HEIGHT = 12;
                const ROW_TOOL_WIDTH = 12;
                const CELL_MIN_WIDTH = 50;
                const PRIMARY_COLOR = '#35A7ED';

                class table_column_tool_TableColumnTool {
                    constructor(table, quill, options) {
                        if (!table) return null;
                        this.table = table;
                        this.quill = quill;
                        this.options = options;
                        this.domNode = null;
                        this.initColTool();
                    }

                    initColTool() {
                        const parent = this.quill.root.parentNode;
                        const tableRect = this.table.getBoundingClientRect();
                        const containerRect = parent.getBoundingClientRect();
                        const tableViewRect = this.table.parentNode.getBoundingClientRect();
                        this.domNode = document.createElement('div');
                        this.domNode.classList.add('qlbt-col-tool');
                        this.updateToolCells();
                        parent.appendChild(this.domNode);
                        css(this.domNode, {
                            width: "".concat(tableViewRect.width, "px"),
                            height: "".concat(COL_TOOL_HEIGHT, "px"),
                            left: "".concat(tableViewRect.left - containerRect.left + parent.scrollLeft, "px"),
                            top: "".concat(tableViewRect.top - containerRect.top + parent.scrollTop - COL_TOOL_HEIGHT - 5, "px")
                        });
                    }

                    createToolCell() {
                        const toolCell = document.createElement('div');
                        toolCell.classList.add('qlbt-col-tool-cell');
                        const resizeHolder = document.createElement('div');
                        resizeHolder.classList.add('qlbt-col-tool-cell-holder');
                        css(toolCell, {
                            'height': "".concat(COL_TOOL_CELL_HEIGHT, "px")
                        });
                        toolCell.appendChild(resizeHolder);
                        return toolCell;
                    }

                    updateToolCells() {
                        const tableContainer = external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.find(this.table);
                        const CellsInFirstRow = tableContainer.children.tail.children.head.children;
                        const tableCols = tableContainer.colGroup().children;
                        const cellsNumber = computeCellsNumber(CellsInFirstRow);
                        let existCells = Array.from(this.domNode.querySelectorAll('.qlbt-col-tool-cell'));

                        for (let index = 0; index < Math.max(cellsNumber, existCells.length); index++) {
                            let col = tableCols.at(index);
                            let colWidth = col && parseInt(col.formats()[col.statics.blotName].width, 10); // if cell already exist

                            let toolCell = null;

                            if (!existCells[index]) {
                                toolCell = this.createToolCell();
                                this.domNode.appendChild(toolCell);
                                this.addColCellHolderHandler(toolCell); // set tool cell min-width

                                css(toolCell, {
                                    'min-width': "".concat(colWidth, "px")
                                });
                            } else if (existCells[index] && index >= cellsNumber) {
                                existCells[index].remove();
                            } else {
                                toolCell = existCells[index]; // set tool cell min-width

                                css(toolCell, {
                                    'min-width': "".concat(colWidth, "px")
                                });
                            }
                        }
                    }

                    destroy() {
                        this.domNode.remove();
                        return null;
                    }

                    addColCellHolderHandler(cell) {
                        const tableContainer = external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.find(this.table);
                        const $holder = cell.querySelector(".qlbt-col-tool-cell-holder");
                        let dragging = false;
                        let x0 = 0;
                        let x = 0;
                        let delta = 0;
                        let width0 = 0; // helpLine relation varrible

                        let tableRect = {};
                        let cellRect = {};
                        let $helpLine = null;

                        const handleDrag = e => {
                            e.preventDefault();

                            if (dragging) {
                                x = e.clientX;

                                if (width0 + x - x0 >= CELL_MIN_WIDTH) {
                                    delta = x - x0;
                                } else {
                                    delta = CELL_MIN_WIDTH - width0;
                                }

                                css($helpLine, {
                                    'left': "".concat(cellRect.left + cellRect.width - 1 + delta, "px")
                                });
                            }
                        };

                        const handleMouseup = e => {
                            e.preventDefault();
                            const existCells = Array.from(this.domNode.querySelectorAll('.qlbt-col-tool-cell'));
                            const colIndex = existCells.indexOf(cell);
                            const colBlot = tableContainer.colGroup().children.at(colIndex);

                            if (dragging) {
                                colBlot.format('width', width0 + delta);
                                css(cell, {
                                    'min-width': "".concat(width0 + delta, "px")
                                });
                                x0 = 0;
                                x = 0;
                                delta = 0;
                                width0 = 0;
                                dragging = false;
                                $holder.classList.remove('dragging');
                            }

                            document.removeEventListener('mousemove', handleDrag, false);
                            document.removeEventListener('mouseup', handleMouseup, false);
                            tableRect = {};
                            cellRect = {};
                            $helpLine.remove();
                            $helpLine = null;
                            tableContainer.updateTableWidth();
                            const tableSelection = this.quill.getModule('better-table').tableSelection;
                            tableSelection && tableSelection.clearSelection();
                        };

                        const handleMousedown = e => {
                            document.addEventListener('mousemove', handleDrag, false);
                            document.addEventListener('mouseup', handleMouseup, false);
                            tableRect = this.table.getBoundingClientRect();
                            cellRect = cell.getBoundingClientRect();
                            $helpLine = document.createElement('div');
                            css($helpLine, {
                                position: 'fixed',
                                top: "".concat(cellRect.top, "px"),
                                left: "".concat(cellRect.left + cellRect.width - 1, "px"),
                                zIndex: '100',
                                height: "".concat(tableRect.height + COL_TOOL_HEIGHT + 4, "px"),
                                width: '1px',
                                backgroundColor: PRIMARY_COLOR
                            });
                            document.body.appendChild($helpLine);
                            dragging = true;
                            x0 = e.clientX;
                            width0 = cellRect.width;
                            $holder.classList.add('dragging');
                        };

                        $holder.addEventListener('mousedown', handleMousedown, false);
                    }

                    colToolCells() {
                        return Array.from(this.domNode.querySelectorAll('.qlbt-col-tool-cell'));
                    }

                }

                function computeCellsNumber(CellsInFirstRow) {
                    return CellsInFirstRow.reduce((sum, cell) => {
                        const cellColspan = cell.formats().colspan;
                        sum = sum + parseInt(cellColspan, 10);
                        return sum;
                    }, 0);
                }

// CONCATENATED MODULE: ./src/formats/header.js


                const Block = external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.import("blots/block");

                class header_Header extends Block {
                    static create(value) {
                        if (typeof value === 'string') {
                            value = {
                                value
                            };
                        }

                        const node = super.create(value.value);
                        CELL_IDENTITY_KEYS.forEach(key => {
                            if (value[key]) node.setAttribute("data-".concat(key), value[key]);
                        });
                        CELL_ATTRIBUTES.forEach(key => {
                            if (value[key]) node.setAttribute("data-".concat(key), value[key]);
                        });
                        return node;
                    }

                    static formats(domNode) {
                        const formats = {};
                        formats.value = this.tagName.indexOf(domNode.tagName) + 1;
                        return CELL_ATTRIBUTES.concat(CELL_IDENTITY_KEYS).reduce((formats, attribute) => {
                            if (domNode.hasAttribute("data-".concat(attribute))) {
                                formats[attribute] = domNode.getAttribute("data-".concat(attribute)) || undefined;
                            }

                            return formats;
                        }, formats);
                    }

                    format(name, value) {
                        const {
                            row,
                            cell,
                            rowspan,
                            colspan
                        } = header_Header.formats(this.domNode);

                        if (name === header_Header.blotName) {
                            if (value) {
                                super.format(name, {
                                    value,
                                    row,
                                    cell,
                                    rowspan,
                                    colspan
                                });
                            } else {
                                if (row) {
                                    this.replaceWith(TableCellLine.blotName, {
                                        row,
                                        cell,
                                        rowspan,
                                        colspan
                                    });
                                } else {
                                    super.format(name, value);
                                }
                            }
                        } else {
                            super.format(name, value);
                        }
                    }

                    optimize(context) {
                        const {
                            row,
                            rowspan,
                            colspan
                        } = header_Header.formats(this.domNode);

                        if (row && !(this.parent instanceof TableCell)) {
                            this.wrap(TableCell.blotName, {
                                row,
                                colspan,
                                rowspan
                            });
                        } // ShadowBlot optimize


                        this.enforceAllowedChildren();

                        if (this.uiNode != null && this.uiNode !== this.domNode.firstChild) {
                            this.domNode.insertBefore(this.uiNode, this.domNode.firstChild);
                        }

                        if (this.children.length === 0) {
                            if (this.statics.defaultChild != null) {
                                const child = this.scroll.create(this.statics.defaultChild.blotName);
                                this.appendChild(child); // TODO double check if necessary
                                // child.optimize(context);
                            } else {
                                this.remove();
                            }
                        } // Block optimize


                        this.cache = {};
                    }

                }

                header_Header.blotName = 'header';
                header_Header.tagName = ['H1', 'H2', 'H3', 'H4', 'H5', 'H6'];
                /* harmony default export */
                var header = (header_Header);
// CONCATENATED MODULE: ./src/formats/table.js


                const Break = external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.import("blots/break");
                const table_Block = external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.import("blots/block");
                const Container = external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.import("blots/container");
                const COL_ATTRIBUTES = ["width"];
                const COL_DEFAULT = {
                    width: 100
                };
                const CELL_IDENTITY_KEYS = ["row", "cell"];
                const CELL_ATTRIBUTES = ["rowspan", "colspan"];
                const CELL_DEFAULT = {
                    rowspan: 1,
                    colspan: 1
                };
                const ERROR_LIMIT = 5;

                class TableCellLine extends table_Block {
                    static create(value) {
                        const node = super.create(value);
                        CELL_IDENTITY_KEYS.forEach(key => {
                            let identityMaker = key === 'row' ? table_rowId : table_cellId;
                            node.setAttribute("data-".concat(key), value[key] || identityMaker());
                        });
                        CELL_ATTRIBUTES.forEach(attrName => {
                            node.setAttribute("data-".concat(attrName), value[attrName] || CELL_DEFAULT[attrName]);
                        });

                        if (value['cell-bg']) {
                            node.setAttribute('data-cell-bg', value['cell-bg']);
                        }

                        return node;
                    }

                    static formats(domNode) {
                        const formats = {};
                        return CELL_ATTRIBUTES.concat(CELL_IDENTITY_KEYS).concat(['cell-bg']).reduce((formats, attribute) => {
                            if (domNode.hasAttribute("data-".concat(attribute))) {
                                formats[attribute] = domNode.getAttribute("data-".concat(attribute)) || undefined;
                            }

                            return formats;
                        }, formats);
                    }

                    format(name, value) {
                        if (CELL_ATTRIBUTES.concat(CELL_IDENTITY_KEYS).indexOf(name) > -1) {
                            if (value) {
                                this.domNode.setAttribute("data-".concat(name), value);
                            } else {
                                this.domNode.removeAttribute("data-".concat(name));
                            }
                        } else if (name === 'cell-bg') {
                            if (value) {
                                this.domNode.setAttribute('data-cell-bg', value);
                            } else {
                                this.domNode.removeAttribute('data-cell-bg');
                            }
                        } else if (name === 'header') {
                            if (!value) return;
                            const {
                                row,
                                cell,
                                rowspan,
                                colspan
                            } = TableCellLine.formats(this.domNode);
                            super.format(name, {
                                value,
                                row,
                                cell,
                                rowspan,
                                colspan
                            });
                        } else {
                            super.format(name, value);
                        }
                    }

                    optimize(context) {
                        // cover shadowBlot's wrap call, pass params parentBlot initialize
                        // needed
                        const rowId = this.domNode.getAttribute('data-row');
                        const rowspan = this.domNode.getAttribute('data-rowspan');
                        const colspan = this.domNode.getAttribute('data-colspan');
                        const cellBg = this.domNode.getAttribute('data-cell-bg');

                        if (this.statics.requiredContainer && !(this.parent instanceof this.statics.requiredContainer)) {
                            this.wrap(this.statics.requiredContainer.blotName, {
                                row: rowId,
                                colspan,
                                rowspan,
                                'cell-bg': cellBg
                            });
                        }

                        super.optimize(context);
                    }

                    tableCell() {
                        return this.parent;
                    }

                }

                TableCellLine.blotName = "table-cell-line";
                TableCellLine.className = "qlbt-cell-line";
                TableCellLine.tagName = "P";

                class TableCell extends Container {
                    checkMerge() {
                        if (super.checkMerge() && this.next.children.head != null) {
                            const thisHead = this.children.head.formats()[this.children.head.statics.blotName];
                            const thisTail = this.children.tail.formats()[this.children.tail.statics.blotName];
                            const nextHead = this.next.children.head.formats()[this.next.children.head.statics.blotName];
                            const nextTail = this.next.children.tail.formats()[this.next.children.tail.statics.blotName];
                            return thisHead.cell === thisTail.cell && thisHead.cell === nextHead.cell && thisHead.cell === nextTail.cell;
                        }

                        return false;
                    }

                    static create(value) {
                        const node = super.create(value);
                        node.setAttribute("data-row", value.row);
                        CELL_ATTRIBUTES.forEach(attrName => {
                            if (value[attrName]) {
                                node.setAttribute(attrName, value[attrName]);
                            }
                        });

                        if (value['cell-bg']) {
                            node.setAttribute('data-cell-bg', value['cell-bg']);
                            node.style.backgroundColor = value['cell-bg'];
                        }

                        return node;
                    }

                    static formats(domNode) {
                        const formats = {};

                        if (domNode.hasAttribute("data-row")) {
                            formats["row"] = domNode.getAttribute("data-row");
                        }

                        if (domNode.hasAttribute("data-cell-bg")) {
                            formats["cell-bg"] = domNode.getAttribute("data-cell-bg");
                        }

                        return CELL_ATTRIBUTES.reduce((formats, attribute) => {
                            if (domNode.hasAttribute(attribute)) {
                                formats[attribute] = domNode.getAttribute(attribute);
                            }

                            return formats;
                        }, formats);
                    }

                    cellOffset() {
                        if (this.parent) {
                            return this.parent.children.indexOf(this);
                        }

                        return -1;
                    }

                    formats() {
                        const formats = {};

                        if (this.domNode.hasAttribute("data-row")) {
                            formats["row"] = this.domNode.getAttribute("data-row");
                        }

                        if (this.domNode.hasAttribute("data-cell-bg")) {
                            formats["cell-bg"] = this.domNode.getAttribute("data-cell-bg");
                        }

                        return CELL_ATTRIBUTES.reduce((formats, attribute) => {
                            if (this.domNode.hasAttribute(attribute)) {
                                formats[attribute] = this.domNode.getAttribute(attribute);
                            }

                            return formats;
                        }, formats);
                    }

                    toggleAttribute(name, value) {
                        if (value) {
                            this.domNode.setAttribute(name, value);
                        } else {
                            this.domNode.removeAttribute(name);
                        }
                    }

                    formatChildren(name, value) {
                        this.children.forEach(child => {
                            child.format(name, value);
                        });
                    }

                    format(name, value) {
                        if (CELL_ATTRIBUTES.indexOf(name) > -1) {
                            this.toggleAttribute(name, value);
                            this.formatChildren(name, value);
                        } else if (['row'].indexOf(name) > -1) {
                            this.toggleAttribute("data-".concat(name), value);
                            this.formatChildren(name, value);
                        } else if (name === 'cell-bg') {
                            this.toggleAttribute('data-cell-bg', value);
                            this.formatChildren(name, value);

                            if (value) {
                                this.domNode.style.backgroundColor = value;
                            } else {
                                this.domNode.style.backgroundColor = 'initial';
                            }
                        } else {
                            super.format(name, value);
                        }
                    }

                    optimize(context) {
                        const rowId = this.domNode.getAttribute("data-row");

                        if (this.statics.requiredContainer && !(this.parent instanceof this.statics.requiredContainer)) {
                            this.wrap(this.statics.requiredContainer.blotName, {
                                row: rowId
                            });
                        }

                        super.optimize(context);
                    }

                    row() {
                        return this.parent;
                    }

                    rowOffset() {
                        if (this.row()) {
                            return this.row().rowOffset();
                        }

                        return -1;
                    }

                    table() {
                        return this.row() && this.row().table();
                    }

                }

                TableCell.blotName = "table";
                TableCell.tagName = "TD";

                class TableRow extends Container {
                    checkMerge() {
                        if (super.checkMerge() && this.next.children.head != null) {
                            const thisHead = this.children.head.formats();
                            const thisTail = this.children.tail.formats();
                            const nextHead = this.next.children.head.formats();
                            const nextTail = this.next.children.tail.formats();
                            return thisHead.row === thisTail.row && thisHead.row === nextHead.row && thisHead.row === nextTail.row;
                        }

                        return false;
                    }

                    static create(value) {
                        const node = super.create(value);
                        node.setAttribute("data-row", value.row);
                        return node;
                    }

                    formats() {
                        return ["row"].reduce((formats, attrName) => {
                            if (this.domNode.hasAttribute("data-".concat(attrName))) {
                                formats[attrName] = this.domNode.getAttribute("data-".concat(attrName));
                            }

                            return formats;
                        }, {});
                    }

                    optimize(context) {
                        // optimize function of ShadowBlot
                        if (this.statics.requiredContainer && !(this.parent instanceof this.statics.requiredContainer)) {
                            this.wrap(this.statics.requiredContainer.blotName);
                        } // optimize function of ParentBlot
                        // note: modified this optimize function because
                        // TableRow should not be removed when the length of its children was 0


                        this.enforceAllowedChildren();

                        if (this.uiNode != null && this.uiNode !== this.domNode.firstChild) {
                            this.domNode.insertBefore(this.uiNode, this.domNode.firstChild);
                        } // optimize function of ContainerBlot


                        if (this.children.length > 0 && this.next != null && this.checkMerge()) {
                            this.next.moveChildren(this);
                            this.next.remove();
                        }
                    }

                    rowOffset() {
                        if (this.parent) {
                            return this.parent.children.indexOf(this);
                        }

                        return -1;
                    }

                    table() {
                        return this.parent && this.parent.parent;
                    }

                }

                TableRow.blotName = "table-row";
                TableRow.tagName = "TR";

                class TableBody extends Container {
                }

                TableBody.blotName = "table-body";
                TableBody.tagName = "TBODY";

                class TableCol extends table_Block {
                    static create(value) {
                        let node = super.create(value);
                        COL_ATTRIBUTES.forEach(attrName => {
                            node.setAttribute("".concat(attrName), value[attrName] || COL_DEFAULT[attrName]);
                        });
                        return node;
                    }

                    static formats(domNode) {
                        return COL_ATTRIBUTES.reduce((formats, attribute) => {
                            if (domNode.hasAttribute("".concat(attribute))) {
                                formats[attribute] = domNode.getAttribute("".concat(attribute)) || undefined;
                            }

                            return formats;
                        }, {});
                    }

                    format(name, value) {
                        if (COL_ATTRIBUTES.indexOf(name) > -1) {
                            this.domNode.setAttribute("".concat(name), value || COL_DEFAULT[name]);
                        } else {
                            super.format(name, value);
                        }
                    }

                    html() {
                        return this.domNode.outerHTML;
                    }

                }

                TableCol.blotName = "table-col";
                TableCol.tagName = "col";

                class TableColGroup extends Container {
                }

                TableColGroup.blotName = "table-col-group";
                TableColGroup.tagName = "colgroup";

                class table_TableContainer extends Container {
                    static create() {
                        let node = super.create();
                        return node;
                    }

                    constructor(scroll, domNode) {
                        super(scroll, domNode);
                        this.updateTableWidth();
                    }

                    updateTableWidth() {
                        setTimeout(() => {
                            const colGroup = this.colGroup();
                            if (!colGroup) return;
                            const tableWidth = colGroup.children.reduce((sumWidth, col) => {
                                sumWidth = sumWidth + parseInt(col.formats()[TableCol.blotName].width, 10);
                                return sumWidth;
                            }, 0);
                            this.domNode.style.width = "".concat(tableWidth, "px");
                        }, 0);
                    }

                    cells(column) {
                        return this.rows().map(row => row.children.at(column));
                    }

                    colGroup() {
                        return this.children.head;
                    }

                    deleteColumns(compareRect) {
                        let delIndexes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
                        let editorWrapper = arguments.length > 2 ? arguments[2] : undefined;
                        const [body] = this.descendants(TableBody);
                        if (body == null || body.children.head == null) return;
                        const tableCells = this.descendants(TableCell);
                        const removedCells = [];
                        const modifiedCells = [];
                        tableCells.forEach(cell => {
                            const cellRect = getRelativeRect(cell.domNode.getBoundingClientRect(), editorWrapper);

                            if (cellRect.x + ERROR_LIMIT > compareRect.x && cellRect.x1 - ERROR_LIMIT < compareRect.x1) {
                                removedCells.push(cell);
                            } else if (cellRect.x < compareRect.x + ERROR_LIMIT && cellRect.x1 > compareRect.x1 - ERROR_LIMIT) {
                                modifiedCells.push(cell);
                            }
                        });

                        if (removedCells.length === tableCells.length) {
                            this.tableDestroy();
                            return true;
                        } // remove the matches column tool cell


                        delIndexes.forEach(delIndex => {
                            this.colGroup().children.at(delIndexes[0]).remove();
                        });
                        removedCells.forEach(cell => {
                            cell.remove();
                        });
                        modifiedCells.forEach(cell => {
                            const cellColspan = parseInt(cell.formats().colspan, 10);
                            const cellWidth = parseInt(cell.formats().width, 10);
                            cell.format('colspan', cellColspan - delIndexes.length);
                        });
                        this.updateTableWidth();
                    }

                    deleteRow(compareRect, editorWrapper) {
                        const [body] = this.descendants(TableBody);
                        if (body == null || body.children.head == null) return;
                        const tableCells = this.descendants(TableCell);
                        const tableRows = this.descendants(TableRow);
                        const removedCells = []; // cells to be removed

                        const modifiedCells = []; // cells to be modified

                        const fallCells = []; // cells to fall into next row
                        // compute rows to remove
                        // bugfix: #21 There will be a empty tr left if delete the last row of a table

                        const removedRows = tableRows.filter(row => {
                            const rowRect = getRelativeRect(row.domNode.getBoundingClientRect(), editorWrapper);
                            return rowRect.y > compareRect.y - ERROR_LIMIT && rowRect.y1 < compareRect.y1 + ERROR_LIMIT;
                        });
                        tableCells.forEach(cell => {
                            const cellRect = getRelativeRect(cell.domNode.getBoundingClientRect(), editorWrapper);

                            if (cellRect.y > compareRect.y - ERROR_LIMIT && cellRect.y1 < compareRect.y1 + ERROR_LIMIT) {
                                removedCells.push(cell);
                            } else if (cellRect.y < compareRect.y + ERROR_LIMIT && cellRect.y1 > compareRect.y1 - ERROR_LIMIT) {
                                modifiedCells.push(cell);

                                if (Math.abs(cellRect.y - compareRect.y) < ERROR_LIMIT) {
                                    fallCells.push(cell);
                                }
                            }
                        });

                        if (removedCells.length === tableCells.length) {
                            this.tableDestroy();
                            return;
                        } // compute length of removed rows


                        const removedRowsLength = this.rows().reduce((sum, row) => {
                            let rowRect = getRelativeRect(row.domNode.getBoundingClientRect(), editorWrapper);

                            if (rowRect.y > compareRect.y - ERROR_LIMIT && rowRect.y1 < compareRect.y1 + ERROR_LIMIT) {
                                sum += 1;
                            }

                            return sum;
                        }, 0); // it must excute before the table layout changed with other operation

                        fallCells.forEach(cell => {
                            const cellRect = getRelativeRect(cell.domNode.getBoundingClientRect(), editorWrapper);
                            const nextRow = cell.parent.next;
                            const cellsInNextRow = nextRow.children;
                            const refCell = cellsInNextRow.reduce((ref, compareCell) => {
                                const compareRect = getRelativeRect(compareCell.domNode.getBoundingClientRect(), editorWrapper);

                                if (Math.abs(cellRect.x1 - compareRect.x) < ERROR_LIMIT) {
                                    ref = compareCell;
                                }

                                return ref;
                            }, null);
                            nextRow.insertBefore(cell, refCell);
                            cell.format('row', nextRow.formats().row);
                        });
                        removedCells.forEach(cell => {
                            cell.remove();
                        });
                        modifiedCells.forEach(cell => {
                            const cellRowspan = parseInt(cell.formats().rowspan, 10);
                            cell.format("rowspan", cellRowspan - removedRowsLength);
                        }); // remove selected rows

                        removedRows.forEach(row => row.remove());
                    }

                    tableDestroy() {
                        const quill = external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.find(this.scroll.domNode.parentNode);
                        const tableModule = quill.getModule("better-table");
                        this.remove();
                        tableModule.hideTableTools();
                        quill.update(external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.sources.USER);
                    }

                    insertCell(tableRow, ref) {
                        const id = table_cellId();
                        const rId = tableRow.formats().row;
                        const tableCell = this.scroll.create(TableCell.blotName, Object.assign({}, CELL_DEFAULT, {
                            row: rId
                        }));
                        const cellLine = this.scroll.create(TableCellLine.blotName, {
                            row: rId,
                            cell: id
                        });
                        tableCell.appendChild(cellLine);

                        if (ref) {
                            tableRow.insertBefore(tableCell, ref);
                        } else {
                            tableRow.appendChild(tableCell);
                        }
                    }

                    insertColumn(compareRect, colIndex) {
                        let isRight = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
                        let editorWrapper = arguments.length > 3 ? arguments[3] : undefined;
                        const [body] = this.descendants(TableBody);
                        const [tableColGroup] = this.descendants(TableColGroup);
                        const tableCols = this.descendants(TableCol);
                        let addAsideCells = [];
                        let modifiedCells = [];
                        let affectedCells = [];
                        if (body == null || body.children.head == null) return;
                        const tableCells = this.descendants(TableCell);
                        tableCells.forEach(cell => {
                            const cellRect = getRelativeRect(cell.domNode.getBoundingClientRect(), editorWrapper);

                            if (isRight) {
                                if (Math.abs(cellRect.x1 - compareRect.x1) < ERROR_LIMIT) {
                                    // the right of selected boundary equal to the right of table cell,
                                    // add a new table cell right aside this table cell
                                    addAsideCells.push(cell);
                                } else if (compareRect.x1 - cellRect.x > ERROR_LIMIT && compareRect.x1 - cellRect.x1 < -ERROR_LIMIT) {
                                    // the right of selected boundary is inside this table cell
                                    // colspan of this table cell will increase 1
                                    modifiedCells.push(cell);
                                }
                            } else {
                                if (Math.abs(cellRect.x - compareRect.x) < ERROR_LIMIT) {
                                    // left of selected boundary equal to left of table cell,
                                    // add a new table cell left aside this table cell
                                    addAsideCells.push(cell);
                                } else if (compareRect.x - cellRect.x > ERROR_LIMIT && compareRect.x - cellRect.x1 < -ERROR_LIMIT) {
                                    // the left of selected boundary is inside this table cell
                                    // colspan of this table cell will increase 1
                                    modifiedCells.push(cell);
                                }
                            }
                        });
                        addAsideCells.forEach(cell => {
                            const ref = isRight ? cell.next : cell;
                            const id = table_cellId();
                            const tableRow = cell.parent;
                            const rId = tableRow.formats().row;
                            const cellFormats = cell.formats();
                            const tableCell = this.scroll.create(TableCell.blotName, Object.assign({}, CELL_DEFAULT, {
                                row: rId,
                                rowspan: cellFormats.rowspan
                            }));
                            const cellLine = this.scroll.create(TableCellLine.blotName, {
                                row: rId,
                                cell: id,
                                rowspan: cellFormats.rowspan
                            });
                            tableCell.appendChild(cellLine);

                            if (ref) {
                                tableRow.insertBefore(tableCell, ref);
                            } else {
                                tableRow.appendChild(tableCell);
                            }

                            affectedCells.push(tableCell);
                        }); // insert new tableCol

                        const tableCol = this.scroll.create(TableCol.blotName, true);
                        let colRef = isRight ? tableCols[colIndex].next : tableCols[colIndex];

                        if (colRef) {
                            tableColGroup.insertBefore(tableCol, colRef);
                        } else {
                            tableColGroup.appendChild(tableCol);
                        }

                        modifiedCells.forEach(cell => {
                            const cellColspan = cell.formats().colspan;
                            cell.format('colspan', parseInt(cellColspan, 10) + 1);
                            affectedCells.push(cell);
                        });
                        affectedCells.sort((cellA, cellB) => {
                            let y1 = cellA.domNode.getBoundingClientRect().y;
                            let y2 = cellB.domNode.getBoundingClientRect().y;
                            return y1 - y2;
                        });
                        this.updateTableWidth();
                        return affectedCells;
                    }

                    insertRow(compareRect, isDown, editorWrapper) {
                        const [body] = this.descendants(TableBody);
                        if (body == null || body.children.head == null) return;
                        const tableCells = this.descendants(TableCell);
                        const rId = table_rowId();
                        const newRow = this.scroll.create(TableRow.blotName, {
                            row: rId
                        });
                        let addBelowCells = [];
                        let modifiedCells = [];
                        let affectedCells = [];
                        tableCells.forEach(cell => {
                            const cellRect = getRelativeRect(cell.domNode.getBoundingClientRect(), editorWrapper);

                            if (isDown) {
                                if (Math.abs(cellRect.y1 - compareRect.y1) < ERROR_LIMIT) {
                                    addBelowCells.push(cell);
                                } else if (compareRect.y1 - cellRect.y > ERROR_LIMIT && compareRect.y1 - cellRect.y1 < -ERROR_LIMIT) {
                                    modifiedCells.push(cell);
                                }
                            } else {
                                if (Math.abs(cellRect.y - compareRect.y) < ERROR_LIMIT) {
                                    addBelowCells.push(cell);
                                } else if (compareRect.y - cellRect.y > ERROR_LIMIT && compareRect.y - cellRect.y1 < -ERROR_LIMIT) {
                                    modifiedCells.push(cell);
                                }
                            }
                        }); // ordered table cells with rect.x, fix error for inserting
                        // new table cell in complicated table with wrong order.

                        const sortFunc = (cellA, cellB) => {
                            let x1 = cellA.domNode.getBoundingClientRect().x;
                            let x2 = cellB.domNode.getBoundingClientRect().x;
                            return x1 - x2;
                        };

                        addBelowCells.sort(sortFunc);
                        addBelowCells.forEach(cell => {
                            const cId = table_cellId();
                            const cellFormats = cell.formats();
                            const tableCell = this.scroll.create(TableCell.blotName, Object.assign({}, CELL_DEFAULT, {
                                row: rId,
                                colspan: cellFormats.colspan
                            }));
                            const cellLine = this.scroll.create(TableCellLine.blotName, {
                                row: rId,
                                cell: cId,
                                colspan: cellFormats.colspan
                            });
                            const empty = this.scroll.create(Break.blotName);
                            cellLine.appendChild(empty);
                            tableCell.appendChild(cellLine);
                            newRow.appendChild(tableCell);
                            affectedCells.push(tableCell);
                        });
                        modifiedCells.forEach(cell => {
                            const cellRowspan = parseInt(cell.formats().rowspan, 10);
                            cell.format("rowspan", cellRowspan + 1);
                            affectedCells.push(cell);
                        });
                        const refRow = this.rows().find(row => {
                            let rowRect = getRelativeRect(row.domNode.getBoundingClientRect(), editorWrapper);

                            if (isDown) {
                                return Math.abs(rowRect.y - compareRect.y - compareRect.height) < ERROR_LIMIT;
                            } else {
                                return Math.abs(rowRect.y - compareRect.y) < ERROR_LIMIT;
                            }
                        });
                        body.insertBefore(newRow, refRow); // reordering affectedCells

                        affectedCells.sort(sortFunc);
                        return affectedCells;
                    }

                    mergeCells(compareRect, mergingCells, rowspan, colspan, editorWrapper) {
                        const mergedCell = mergingCells.reduce((result, tableCell, index) => {
                            if (index !== 0) {
                                result && tableCell.moveChildren(result);
                                tableCell.remove();
                            } else {
                                tableCell.format('colspan', colspan);
                                tableCell.format('rowspan', rowspan);
                                result = tableCell;
                            }

                            return result;
                        }, null);
                        let rowId = mergedCell.domNode.getAttribute('data-row');
                        let cellId = mergedCell.children.head.domNode.getAttribute('data-cell');
                        mergedCell.children.forEach(cellLine => {
                            cellLine.format('cell', cellId);
                            cellLine.format('row', rowId);
                            cellLine.format('colspan', colspan);
                            cellLine.format('rowspan', rowspan);
                        });
                        return mergedCell;
                    }

                    unmergeCells(unmergingCells, editorWrapper) {
                        let cellFormats = {};
                        let cellRowspan = 1;
                        let cellColspan = 1;
                        unmergingCells.forEach(tableCell => {
                            cellFormats = tableCell.formats();
                            cellRowspan = cellFormats.rowspan;
                            cellColspan = cellFormats.colspan;

                            if (cellColspan > 1) {
                                let ref = tableCell.next;
                                let row = tableCell.row();
                                tableCell.format('colspan', 1);

                                for (let i = cellColspan; i > 1; i--) {
                                    this.insertCell(row, ref);
                                }
                            }

                            if (cellRowspan > 1) {
                                let i = cellRowspan;
                                let nextRow = tableCell.row().next;

                                while (i > 1) {
                                    let refInNextRow = nextRow.children.reduce((result, cell) => {
                                        let compareRect = getRelativeRect(tableCell.domNode.getBoundingClientRect(), editorWrapper);
                                        let cellRect = getRelativeRect(cell.domNode.getBoundingClientRect(), editorWrapper);

                                        if (Math.abs(compareRect.x1 - cellRect.x) < ERROR_LIMIT) {
                                            result = cell;
                                        }

                                        return result;
                                    }, null);

                                    for (let i = cellColspan; i > 0; i--) {
                                        this.insertCell(nextRow, refInNextRow);
                                    }

                                    i -= 1;
                                    nextRow = nextRow.next;
                                }

                                tableCell.format('rowspan', 1);
                            }
                        });
                    }

                    rows() {
                        const body = this.children.tail;
                        if (body == null) return [];
                        return body.children.map(row => row);
                    }

                }

                table_TableContainer.blotName = "table-container";
                table_TableContainer.className = "quill-better-table";
                table_TableContainer.tagName = "TABLE";

                class table_TableViewWrapper extends Container {
                    constructor(scroll, domNode) {
                        super(scroll, domNode);
                        const quill = external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.find(scroll.domNode.parentNode);
                        domNode.addEventListener('scroll', e => {
                            const tableModule = quill.getModule('better-table');

                            if (tableModule.columnTool) {
                                tableModule.columnTool.domNode.scrollLeft = e.target.scrollLeft;
                            }

                            if (tableModule.tableSelection && tableModule.tableSelection.selectedTds.length > 0) {
                                tableModule.tableSelection.repositionHelpLines();
                            }
                        }, false);
                    }

                    table() {
                        return this.children.head;
                    }

                }

                table_TableViewWrapper.blotName = "table-view";
                table_TableViewWrapper.className = "quill-better-table-wrapper";
                table_TableViewWrapper.tagName = "DIV";
                table_TableViewWrapper.allowedChildren = [table_TableContainer];
                table_TableContainer.requiredContainer = table_TableViewWrapper;
                table_TableContainer.allowedChildren = [TableBody, TableColGroup];
                TableBody.requiredContainer = table_TableContainer;
                TableBody.allowedChildren = [TableRow];
                TableRow.requiredContainer = TableBody;
                TableRow.allowedChildren = [TableCell];
                TableCell.requiredContainer = TableRow;
                TableCell.allowedChildren = [TableCellLine, header];
                TableCellLine.requiredContainer = TableCell;
                TableColGroup.allowedChildren = [TableCol];
                TableColGroup.requiredContainer = table_TableContainer;
                TableCol.requiredContainer = TableColGroup;

                function table_rowId() {
                    const id = Math.random().toString(36).slice(2, 6);
                    return "row-".concat(id);
                }

                function table_cellId() {
                    const id = Math.random().toString(36).slice(2, 6);
                    return "cell-".concat(id);
                }


// CONCATENATED MODULE: ./src/modules/table-selection.js


                const table_selection_PRIMARY_COLOR = '#0589f3';
                const LINE_POSITIONS = ['left', 'right', 'top', 'bottom'];
                const table_selection_ERROR_LIMIT = 2;

                class table_selection_TableSelection {
                    constructor(table, quill, options) {
                        if (!table) return null;
                        this.table = table;
                        this.quill = quill;
                        this.options = options;
                        this.boundary = {}; // params for selected square

                        this.selectedTds = []; // array for selected table-cells

                        this.dragging = false;
                        this.selectingHandler = this.mouseDownHandler.bind(this);
                        this.clearSelectionHandler = this.clearSelection.bind(this);
                        this.helpLinesInitial();
                        this.quill.root.addEventListener('mousedown', this.selectingHandler, false);
                        this.quill.on('text-change', this.clearSelectionHandler);
                    }

                    helpLinesInitial() {
                        let parent = this.quill.root.parentNode;
                        LINE_POSITIONS.forEach(direction => {
                            this[direction] = document.createElement('div');
                            this[direction].classList.add('qlbt-selection-line');
                            this[direction].classList.add('qlbt-selection-line-' + direction);
                            css(this[direction], {
                                position: 'absolute',
                                display: 'none',
                                'background-color': table_selection_PRIMARY_COLOR
                            });
                            parent.appendChild(this[direction]);
                        });
                    }

                    mouseDownHandler(e) {
                        if (e.button !== 0 || !e.target.closest(".quill-better-table")) return;
                        this.quill.root.addEventListener('mousemove', mouseMoveHandler, false);
                        this.quill.root.addEventListener('mouseup', mouseUpHandler, false);
                        const self = this;
                        const startTd = e.target.closest('td[data-row]');
                        const startTdRect = getRelativeRect(startTd.getBoundingClientRect(), this.quill.root.parentNode);
                        this.dragging = true;
                        this.boundary = computeBoundaryFromRects(startTdRect, startTdRect);
                        this.correctBoundary();
                        this.selectedTds = this.computeSelectedTds();
                        this.repositionHelpLines();

                        function mouseMoveHandler(e) {
                            if (e.button !== 0 || !e.target.closest(".quill-better-table")) return;
                            const endTd = e.target.closest('td[data-row]');
                            const endTdRect = getRelativeRect(endTd.getBoundingClientRect(), self.quill.root.parentNode);
                            self.boundary = computeBoundaryFromRects(startTdRect, endTdRect);
                            self.correctBoundary();
                            self.selectedTds = self.computeSelectedTds();
                            self.repositionHelpLines(); // avoid select text in multiple table-cell

                            if (startTd !== endTd) {
                                self.quill.blur();
                            }
                        }

                        function mouseUpHandler(e) {
                            self.quill.root.removeEventListener('mousemove', mouseMoveHandler, false);
                            self.quill.root.removeEventListener('mouseup', mouseUpHandler, false);
                            self.dragging = false;
                        }
                    }

                    correctBoundary() {
                        const tableContainer = external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.find(this.table);
                        const tableCells = tableContainer.descendants(TableCell);
                        tableCells.forEach(tableCell => {
                            let {
                                x,
                                y,
                                width,
                                height
                            } = getRelativeRect(tableCell.domNode.getBoundingClientRect(), this.quill.root.parentNode);
                            let isCellIntersected = (x + table_selection_ERROR_LIMIT >= this.boundary.x && x + table_selection_ERROR_LIMIT <= this.boundary.x1 || x - table_selection_ERROR_LIMIT + width >= this.boundary.x && x - table_selection_ERROR_LIMIT + width <= this.boundary.x1) && (y + table_selection_ERROR_LIMIT >= this.boundary.y && y + table_selection_ERROR_LIMIT <= this.boundary.y1 || y - table_selection_ERROR_LIMIT + height >= this.boundary.y && y - table_selection_ERROR_LIMIT + height <= this.boundary.y1);

                            if (isCellIntersected) {
                                this.boundary = computeBoundaryFromRects(this.boundary, {
                                    x,
                                    y,
                                    width,
                                    height
                                });
                            }
                        });
                    }

                    computeSelectedTds() {
                        const tableContainer = external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.find(this.table);
                        const tableCells = tableContainer.descendants(TableCell);
                        return tableCells.reduce((selectedCells, tableCell) => {
                            let {
                                x,
                                y,
                                width,
                                height
                            } = getRelativeRect(tableCell.domNode.getBoundingClientRect(), this.quill.root.parentNode);
                            let isCellIncluded = x + table_selection_ERROR_LIMIT >= this.boundary.x && x - table_selection_ERROR_LIMIT + width <= this.boundary.x1 && y + table_selection_ERROR_LIMIT >= this.boundary.y && y - table_selection_ERROR_LIMIT + height <= this.boundary.y1;

                            if (isCellIncluded) {
                                selectedCells.push(tableCell);
                            }

                            return selectedCells;
                        }, []);
                    }

                    repositionHelpLines() {
                        const tableViewScrollLeft = this.table.parentNode.scrollLeft;
                        css(this.left, {
                            display: 'block',
                            left: "".concat(this.boundary.x - tableViewScrollLeft - 1, "px"),
                            top: "".concat(this.boundary.y, "px"),
                            height: "".concat(this.boundary.height + 1, "px"),
                            width: '1px'
                        });
                        css(this.right, {
                            display: 'block',
                            left: "".concat(this.boundary.x1 - tableViewScrollLeft, "px"),
                            top: "".concat(this.boundary.y, "px"),
                            height: "".concat(this.boundary.height + 1, "px"),
                            width: '1px'
                        });
                        css(this.top, {
                            display: 'block',
                            left: "".concat(this.boundary.x - 1 - tableViewScrollLeft, "px"),
                            top: "".concat(this.boundary.y, "px"),
                            width: "".concat(this.boundary.width + 1, "px"),
                            height: '1px'
                        });
                        css(this.bottom, {
                            display: 'block',
                            left: "".concat(this.boundary.x - 1 - tableViewScrollLeft, "px"),
                            top: "".concat(this.boundary.y1 + 1, "px"),
                            width: "".concat(this.boundary.width + 1, "px"),
                            height: '1px'
                        });
                    } // based on selectedTds compute positions of help lines
                    // It is useful when selectedTds are not changed


                    refreshHelpLinesPosition() {
                        const startRect = getRelativeRect(this.selectedTds[0].domNode.getBoundingClientRect(), this.quill.root.parentNode);
                        const endRect = getRelativeRect(this.selectedTds[this.selectedTds.length - 1].domNode.getBoundingClientRect(), this.quill.root.parentNode);
                        this.boundary = computeBoundaryFromRects(startRect, endRect);
                        this.repositionHelpLines();
                    }

                    destroy() {
                        LINE_POSITIONS.forEach(direction => {
                            this[direction].remove();
                            this[direction] = null;
                        });
                        this.quill.root.removeEventListener('mousedown', this.selectingHandler, false);
                        this.quill.off('text-change', this.clearSelectionHandler);
                        return null;
                    }

                    setSelection(startRect, endRect) {
                        this.boundary = computeBoundaryFromRects(getRelativeRect(startRect, this.quill.root.parentNode), getRelativeRect(endRect, this.quill.root.parentNode));
                        this.correctBoundary();
                        this.selectedTds = this.computeSelectedTds();
                        this.repositionHelpLines();
                    }

                    clearSelection() {
                        this.boundary = {};
                        this.selectedTds = [];
                        LINE_POSITIONS.forEach(direction => {
                            this[direction] && css(this[direction], {
                                display: 'none'
                            });
                        });
                    }

                }

                function computeBoundaryFromRects(startRect, endRect) {
                    let x = Math.min(startRect.x, endRect.x, startRect.x + startRect.width - 1, endRect.x + endRect.width - 1);
                    let x1 = Math.max(startRect.x, endRect.x, startRect.x + startRect.width - 1, endRect.x + endRect.width - 1);
                    let y = Math.min(startRect.y, endRect.y, startRect.y + startRect.height - 1, endRect.y + endRect.height - 1);
                    let y1 = Math.max(startRect.y, endRect.y, startRect.y + startRect.height - 1, endRect.y + endRect.height - 1);
                    let width = x1 - x;
                    let height = y1 - y;
                    return {
                        x,
                        x1,
                        y,
                        y1,
                        width,
                        height
                    };
                }

// EXTERNAL MODULE: ./src/assets/icons/icon_operation_1.svg
                var icon_operation_1 = __webpack_require__(1);
                var icon_operation_1_default = /*#__PURE__*/__webpack_require__.n(icon_operation_1);

// EXTERNAL MODULE: ./src/assets/icons/icon_operation_2.svg
                var icon_operation_2 = __webpack_require__(2);
                var icon_operation_2_default = /*#__PURE__*/__webpack_require__.n(icon_operation_2);

// EXTERNAL MODULE: ./src/assets/icons/icon_operation_3.svg
                var icon_operation_3 = __webpack_require__(3);
                var icon_operation_3_default = /*#__PURE__*/__webpack_require__.n(icon_operation_3);

// EXTERNAL MODULE: ./src/assets/icons/icon_operation_4.svg
                var icon_operation_4 = __webpack_require__(4);
                var icon_operation_4_default = /*#__PURE__*/__webpack_require__.n(icon_operation_4);

// EXTERNAL MODULE: ./src/assets/icons/icon_operation_5.svg
                var icon_operation_5 = __webpack_require__(5);
                var icon_operation_5_default = /*#__PURE__*/__webpack_require__.n(icon_operation_5);

// EXTERNAL MODULE: ./src/assets/icons/icon_operation_6.svg
                var icon_operation_6 = __webpack_require__(6);
                var icon_operation_6_default = /*#__PURE__*/__webpack_require__.n(icon_operation_6);

// EXTERNAL MODULE: ./src/assets/icons/icon_operation_7.svg
                var icon_operation_7 = __webpack_require__(7);
                var icon_operation_7_default = /*#__PURE__*/__webpack_require__.n(icon_operation_7);

// EXTERNAL MODULE: ./src/assets/icons/icon_operation_8.svg
                var icon_operation_8 = __webpack_require__(8);
                var icon_operation_8_default = /*#__PURE__*/__webpack_require__.n(icon_operation_8);

// EXTERNAL MODULE: ./src/assets/icons/icon_operation_9.svg
                var icon_operation_9 = __webpack_require__(9);
                var icon_operation_9_default = /*#__PURE__*/__webpack_require__.n(icon_operation_9);

// CONCATENATED MODULE: ./src/modules/table-operation-menu.js

                // svg icons


                const MENU_MIN_HEIHGT = 150;
                const MENU_WIDTH = 200;
                const table_operation_menu_ERROR_LIMIT = 5;
                const DEFAULT_CELL_COLORS = ['white', 'red', 'yellow', 'blue'];
                const DEFAULT_COLOR_SUBTITLE = 'Background Colors';
                const MENU_ITEMS_DEFAULT = {
                    insertColumnRight: {
                        text: 'Insert column right',
                        iconSrc: icon_operation_1_default.a,

                        handler() {
                            const tableContainer = external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.find(this.table);
                            let colIndex = getColToolCellIndexByBoundary(this.columnToolCells, this.boundary, (cellRect, boundary) => {
                                return Math.abs(cellRect.x + cellRect.width - boundary.x1) <= table_operation_menu_ERROR_LIMIT;
                            }, this.quill.root.parentNode);
                            const newColumn = tableContainer.insertColumn(this.boundary, colIndex, true, this.quill.root.parentNode);
                            this.tableColumnTool.updateToolCells();
                            this.quill.update(external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.sources.USER);
                            this.quill.setSelection(this.quill.getIndex(newColumn[0]), 0, external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.sources.SILENT);
                            this.tableSelection.setSelection(newColumn[0].domNode.getBoundingClientRect(), newColumn[0].domNode.getBoundingClientRect());
                        }

                    },
                    insertColumnLeft: {
                        text: 'Insert column left',
                        iconSrc: icon_operation_2_default.a,

                        handler() {
                            const tableContainer = external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.find(this.table);
                            let colIndex = getColToolCellIndexByBoundary(this.columnToolCells, this.boundary, (cellRect, boundary) => {
                                return Math.abs(cellRect.x - boundary.x) <= table_operation_menu_ERROR_LIMIT;
                            }, this.quill.root.parentNode);
                            const newColumn = tableContainer.insertColumn(this.boundary, colIndex, false, this.quill.root.parentNode);
                            this.tableColumnTool.updateToolCells();
                            this.quill.update(external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.sources.USER);
                            this.quill.setSelection(this.quill.getIndex(newColumn[0]), 0, external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.sources.SILENT);
                            this.tableSelection.setSelection(newColumn[0].domNode.getBoundingClientRect(), newColumn[0].domNode.getBoundingClientRect());
                        }

                    },
                    insertRowUp: {
                        text: 'Insert row up',
                        iconSrc: icon_operation_3_default.a,

                        handler() {
                            const tableContainer = external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.find(this.table);
                            const affectedCells = tableContainer.insertRow(this.boundary, false, this.quill.root.parentNode);
                            this.quill.update(external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.sources.USER);
                            this.quill.setSelection(this.quill.getIndex(affectedCells[0]), 0, external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.sources.SILENT);
                            this.tableSelection.setSelection(affectedCells[0].domNode.getBoundingClientRect(), affectedCells[0].domNode.getBoundingClientRect());
                        }

                    },
                    insertRowDown: {
                        text: 'Insert row down',
                        iconSrc: icon_operation_4_default.a,

                        handler() {
                            const tableContainer = external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.find(this.table);
                            const affectedCells = tableContainer.insertRow(this.boundary, true, this.quill.root.parentNode);
                            this.quill.update(external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.sources.USER);
                            this.quill.setSelection(this.quill.getIndex(affectedCells[0]), 0, external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.sources.SILENT);
                            this.tableSelection.setSelection(affectedCells[0].domNode.getBoundingClientRect(), affectedCells[0].domNode.getBoundingClientRect());
                        }

                    },
                    mergeCells: {
                        text: 'Merge selected cells',
                        iconSrc: icon_operation_5_default.a,

                        handler() {
                            const tableContainer = external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.find(this.table); // compute merged Cell rowspan, equal to length of selected rows

                            const rowspan = tableContainer.rows().reduce((sum, row) => {
                                let rowRect = getRelativeRect(row.domNode.getBoundingClientRect(), this.quill.root.parentNode);

                                if (rowRect.y > this.boundary.y - table_operation_menu_ERROR_LIMIT && rowRect.y + rowRect.height < this.boundary.y + this.boundary.height + table_operation_menu_ERROR_LIMIT) {
                                    sum += 1;
                                }

                                return sum;
                            }, 0); // compute merged cell colspan, equal to length of selected cols

                            const colspan = this.columnToolCells.reduce((sum, cell) => {
                                let cellRect = getRelativeRect(cell.getBoundingClientRect(), this.quill.root.parentNode);

                                if (cellRect.x > this.boundary.x - table_operation_menu_ERROR_LIMIT && cellRect.x + cellRect.width < this.boundary.x + this.boundary.width + table_operation_menu_ERROR_LIMIT) {
                                    sum += 1;
                                }

                                return sum;
                            }, 0);
                            const mergedCell = tableContainer.mergeCells(this.boundary, this.selectedTds, rowspan, colspan, this.quill.root.parentNode);
                            this.quill.update(external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.sources.USER);
                            this.tableSelection.setSelection(mergedCell.domNode.getBoundingClientRect(), mergedCell.domNode.getBoundingClientRect());
                        }

                    },
                    unmergeCells: {
                        text: 'Unmerge cells',
                        iconSrc: icon_operation_6_default.a,

                        handler() {
                            const tableContainer = external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.find(this.table);
                            tableContainer.unmergeCells(this.selectedTds, this.quill.root.parentNode);
                            this.quill.update(external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.sources.USER);
                            this.tableSelection.clearSelection();
                        }

                    },
                    deleteColumn: {
                        text: 'Delete selected columns',
                        iconSrc: icon_operation_7_default.a,

                        handler() {
                            const tableContainer = external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.find(this.table);
                            let colIndexes = getColToolCellIndexesByBoundary(this.columnToolCells, this.boundary, (cellRect, boundary) => {
                                return cellRect.x + table_operation_menu_ERROR_LIMIT > boundary.x && cellRect.x + cellRect.width - table_operation_menu_ERROR_LIMIT < boundary.x1;
                            }, this.quill.root.parentNode);
                            let isDeleteTable = tableContainer.deleteColumns(this.boundary, colIndexes, this.quill.root.parentNode);

                            if (!isDeleteTable) {
                                this.tableColumnTool.updateToolCells();
                                this.quill.update(external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.sources.USER);
                                this.tableSelection.clearSelection();
                            }
                        }

                    },
                    deleteRow: {
                        text: 'Delete selected rows',
                        iconSrc: icon_operation_8_default.a,

                        handler() {
                            const tableContainer = external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.find(this.table);
                            tableContainer.deleteRow(this.boundary, this.quill.root.parentNode);
                            this.quill.update(external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.sources.USER);
                            this.tableSelection.clearSelection();
                        }

                    },
                    deleteTable: {
                        text: 'Delete table',
                        iconSrc: icon_operation_9_default.a,

                        handler() {
                            const betterTableModule = this.quill.getModule('better-table');
                            const tableContainer = external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.find(this.table);
                            betterTableModule.hideTableTools();
                            tableContainer.remove();
                            this.quill.update(external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.sources.USER);
                        }

                    }
                };

                class table_operation_menu_TableOperationMenu {
                    constructor(params, quill, options) {
                        const betterTableModule = quill.getModule('better-table');
                        this.tableSelection = betterTableModule.tableSelection;
                        this.table = params.table;
                        this.quill = quill;
                        this.options = options;
                        this.menuItems = Object.assign({}, MENU_ITEMS_DEFAULT, options.items);
                        this.tableColumnTool = betterTableModule.columnTool;
                        this.boundary = this.tableSelection.boundary;
                        this.selectedTds = this.tableSelection.selectedTds;
                        this.destroyHandler = this.destroy.bind(this);
                        this.columnToolCells = this.tableColumnTool.colToolCells();
                        this.colorSubTitle = options.color && options.color.text ? options.color.text : DEFAULT_COLOR_SUBTITLE;
                        this.cellColors = options.color && options.color.colors ? options.color.colors : DEFAULT_CELL_COLORS;
                        this.menuInitial(params);
                        this.mount();
                        document.addEventListener("click", this.destroyHandler, false);
                    }

                    mount() {
                        document.body.appendChild(this.domNode);
                    }

                    destroy() {
                        this.domNode.remove();
                        document.removeEventListener("click", this.destroyHandler, false);
                        return null;
                    }

                    menuInitial(_ref) {
                        let {
                            table,
                            left,
                            top
                        } = _ref;
                        this.domNode = document.createElement('div');
                        this.domNode.classList.add('qlbt-operation-menu');
                        css(this.domNode, {
                            position: 'absolute',
                            left: "".concat(left, "px"),
                            top: "".concat(top, "px"),
                            'min-height': "".concat(MENU_MIN_HEIHGT, "px"),
                            width: "".concat(MENU_WIDTH, "px")
                        });

                        for (let name in this.menuItems) {
                            if (this.menuItems[name]) {
                                this.domNode.appendChild(this.menuItemCreator(Object.assign({}, MENU_ITEMS_DEFAULT[name], this.menuItems[name])));

                                if (['insertRowDown', 'unmergeCells'].indexOf(name) > -1) {
                                    this.domNode.appendChild(dividingCreator());
                                }
                            }
                        } // if colors option is false, disabled bg color


                        if (this.options.color && this.options.color !== false) {
                            this.domNode.appendChild(dividingCreator());
                            this.domNode.appendChild(subTitleCreator(this.colorSubTitle));
                            this.domNode.appendChild(this.colorsItemCreator(this.cellColors));
                        } // create dividing line


                        function dividingCreator() {
                            const dividing = document.createElement('div');
                            dividing.classList.add('qlbt-operation-menu-dividing');
                            return dividing;
                        } // create subtitle for menu


                        function subTitleCreator(title) {
                            const subTitle = document.createElement('div');
                            subTitle.classList.add('qlbt-operation-menu-subtitle');
                            subTitle.innerText = title;
                            return subTitle;
                        }
                    }

                    colorsItemCreator(colors) {
                        const self = this;
                        const node = document.createElement('div');
                        node.classList.add('qlbt-operation-color-picker');
                        colors.forEach(color => {
                            let colorBox = colorBoxCreator(color);
                            node.appendChild(colorBox);
                        });

                        function colorBoxCreator(color) {
                            const box = document.createElement('div');
                            box.classList.add('qlbt-operation-color-picker-item');
                            box.setAttribute('data-color', color);
                            box.style.backgroundColor = color;
                            box.addEventListener('click', function () {
                                const selectedTds = self.tableSelection.selectedTds;

                                if (selectedTds && selectedTds.length > 0) {
                                    selectedTds.forEach(tableCell => {
                                        tableCell.format('cell-bg', color);
                                    });
                                }
                            }, false);
                            return box;
                        }

                        return node;
                    }

                    menuItemCreator(_ref2) {
                        let {
                            text,
                            iconSrc,
                            handler
                        } = _ref2;
                        const node = document.createElement('div');
                        node.classList.add('qlbt-operation-menu-item');
                        const iconSpan = document.createElement('span');
                        iconSpan.classList.add('qlbt-operation-menu-icon');
                        iconSpan.innerHTML = iconSrc;
                        const textSpan = document.createElement('span');
                        textSpan.classList.add('qlbt-operation-menu-text');
                        textSpan.innerText = text;
                        node.appendChild(iconSpan);
                        node.appendChild(textSpan);
                        node.addEventListener('click', handler.bind(this), false);
                        return node;
                    }

                }

                function getColToolCellIndexByBoundary(cells, boundary, conditionFn, container) {
                    return cells.reduce((findIndex, cell) => {
                        let cellRect = getRelativeRect(cell.getBoundingClientRect(), container);

                        if (conditionFn(cellRect, boundary)) {
                            findIndex = cells.indexOf(cell);
                        }

                        return findIndex;
                    }, false);
                }

                function getColToolCellIndexesByBoundary(cells, boundary, conditionFn, container) {
                    return cells.reduce((findIndexes, cell) => {
                        let cellRect = getRelativeRect(cell.getBoundingClientRect(), container);

                        if (conditionFn(cellRect, boundary)) {
                            findIndexes.push(cells.indexOf(cell));
                        }

                        return findIndexes;
                    }, []);
                }

// CONCATENATED MODULE: ./src/utils/node-matchers.js


                const Delta = external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.import('delta'); // rebuild delta

                function matchTableCell(node, delta, scroll) {
                    const row = node.parentNode;
                    const table = row.parentNode.tagName === 'TABLE' ? row.parentNode : row.parentNode.parentNode;
                    const rows = Array.from(table.querySelectorAll('tr'));
                    const cells = Array.from(row.querySelectorAll('td'));
                    const rowId = rows.indexOf(row) + 1;
                    const cellId = cells.indexOf(node) + 1;
                    const colspan = node.getAttribute('colspan') || false;
                    const rowspan = node.getAttribute('rowspan') || false;
                    const cellBg = node.getAttribute('data-cell-bg') || node.style.backgroundColor; // The td from external table has no 'data-cell-bg'
                    // bugfix: empty table cells copied from other place will be removed unexpectedly

                    if (delta.length() === 0) {
                        delta = new Delta().insert('\n', {
                            'table-cell-line': {
                                row: rowId,
                                cell: cellId,
                                rowspan,
                                colspan
                            }
                        });
                        return delta;
                    }

                    delta = delta.reduce((newDelta, op) => {
                        if (op.insert && typeof op.insert === 'string') {
                            const lines = [];
                            let insertStr = op.insert;
                            let start = 0;

                            for (let i = 0; i < op.insert.length; i++) {
                                if (insertStr.charAt(i) === '\n') {
                                    if (i === 0) {
                                        lines.push('\n');
                                    } else {
                                        lines.push(insertStr.substring(start, i));
                                        lines.push('\n');
                                    }

                                    start = i + 1;
                                }
                            }

                            const tailStr = insertStr.substring(start);
                            if (tailStr) lines.push(tailStr);
                            lines.forEach(text => {
                                text === '\n' ? newDelta.insert('\n', op.attributes) : newDelta.insert(text, _omit(op.attributes, ['table', 'table-cell-line']));
                            });
                        } else {
                            newDelta.insert(op.insert, op.attributes);
                        }

                        return newDelta;
                    }, new Delta());
                    return delta.reduce((newDelta, op) => {
                        if (op.insert && typeof op.insert === 'string' && op.insert.startsWith('\n')) {
                            newDelta.insert(op.insert, Object.assign({}, Object.assign({}, {
                                row: rowId
                            }, op.attributes.table), {
                                'table-cell-line': {
                                    row: rowId,
                                    cell: cellId,
                                    rowspan,
                                    colspan,
                                    'cell-bg': cellBg
                                }
                            }, _omit(op.attributes, ['table'])));
                        } else {
                            // bugfix: remove background attr from the delta of table cell
                            //         to prevent unexcepted background attr append.
                            if (op.attributes && op.attributes.background && op.attributes.background === convertToHex(cellBg)) {
                                newDelta.insert(op.insert, Object.assign({}, _omit(op.attributes, ['table', 'table-cell-line', 'background'])));
                            } else {
                                newDelta.insert(op.insert, Object.assign({}, _omit(op.attributes, ['table', 'table-cell-line'])));
                            }
                        }

                        return newDelta;
                    }, new Delta());
                } // replace th tag with td tag

                function matchTableHeader(node, delta, scroll) {
                    const row = node.parentNode;
                    const table = row.parentNode.tagName === 'TABLE' ? row.parentNode : row.parentNode.parentNode;
                    const rows = Array.from(table.querySelectorAll('tr'));
                    const cells = Array.from(row.querySelectorAll('th'));
                    const rowId = rows.indexOf(row) + 1;
                    const cellId = cells.indexOf(node) + 1;
                    const colspan = node.getAttribute('colspan') || false;
                    const rowspan = node.getAttribute('rowspan') || false; // bugfix: empty table cells copied from other place will be removed unexpectedly

                    if (delta.length() === 0) {
                        delta = new Delta().insert('\n', {
                            'table-cell-line': {
                                row: rowId,
                                cell: cellId,
                                rowspan,
                                colspan
                            }
                        });
                        return delta;
                    }

                    delta = delta.reduce((newDelta, op) => {
                        if (op.insert && typeof op.insert === 'string') {
                            const lines = [];
                            let insertStr = op.insert;
                            let start = 0;

                            for (let i = 0; i < op.insert.length; i++) {
                                if (insertStr.charAt(i) === '\n') {
                                    if (i === 0) {
                                        lines.push('\n');
                                    } else {
                                        lines.push(insertStr.substring(start, i));
                                        lines.push('\n');
                                    }

                                    start = i + 1;
                                }
                            }

                            const tailStr = insertStr.substring(start);
                            if (tailStr) lines.push(tailStr); // bugfix: no '\n' in op.insert, push a '\n' to lines

                            if (lines.indexOf('\n') < 0) {
                                lines.push('\n');
                            }

                            lines.forEach(text => {
                                text === '\n' ? newDelta.insert('\n', {
                                    'table-cell-line': {
                                        row: rowId,
                                        cell: cellId,
                                        rowspan,
                                        colspan
                                    }
                                }) : newDelta.insert(text, op.attributes);
                            });
                        } else {
                            newDelta.insert(op.insert, op.attributes);
                        }

                        return newDelta;
                    }, new Delta());
                    return delta.reduce((newDelta, op) => {
                        if (op.insert && typeof op.insert === 'string' && op.insert.startsWith('\n')) {
                            newDelta.insert(op.insert, Object.assign({}, {
                                'table-cell-line': {
                                    row: rowId,
                                    cell: cellId,
                                    rowspan,
                                    colspan
                                }
                            }));
                        } else {
                            newDelta.insert(op.insert, Object.assign({}, _omit(op.attributes, ['table', 'table-cell-line'])));
                        }

                        return newDelta;
                    }, new Delta());
                } // supplement colgroup and col

                function matchTable(node, delta, scroll) {
                    let newColDelta = new Delta();
                    const topRow = node.querySelector('tr'); // bugfix: empty table will return empty delta

                    if (topRow === null) return newColDelta;
                    const cellsInTopRow = Array.from(topRow.querySelectorAll('td')).concat(Array.from(topRow.querySelectorAll('th')));
                    const maxCellsNumber = cellsInTopRow.reduce((sum, cell) => {
                        const cellColspan = cell.getAttribute('colspan') || 1;
                        sum = sum + parseInt(cellColspan, 10);
                        return sum;
                    }, 0);
                    const colsNumber = node.querySelectorAll('col').length; // issue #2
                    // bugfix: the table copied from Excel had some default col tags missing
                    //         add missing col tags

                    if (colsNumber === maxCellsNumber) {
                        return delta;
                    } else {
                        for (let i = 0; i < maxCellsNumber - colsNumber; i++) {
                            newColDelta.insert('\n', {
                                'table-col': true
                            });
                        }

                        if (colsNumber === 0) return newColDelta.concat(delta);
                        let lastNumber = 0;
                        return delta.reduce((finalDelta, op) => {
                            finalDelta.insert(op.insert, op.attributes);

                            if (op.attributes && op.attributes['table-col']) {
                                lastNumber += op.insert.length;

                                if (lastNumber === colsNumber) {
                                    finalDelta = finalDelta.concat(newColDelta);
                                }
                            }

                            return finalDelta;
                        }, new Delta());
                    }
                }

// CONCATENATED MODULE: ./src/quill-better-table.js


                // import table node matchers


                const Module = external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.import('core/module');
                const quill_better_table_Delta = external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.import('delta');


                class quill_better_table_BetterTable extends Module {
                    static register() {
                        external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.register(TableCol, true);
                        external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.register(TableColGroup, true);
                        external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.register(TableCellLine, true);
                        external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.register(TableCell, true);
                        external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.register(TableRow, true);
                        external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.register(TableBody, true);
                        external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.register(table_TableContainer, true);
                        external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.register(table_TableViewWrapper, true);
                        external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.register(table_TableViewWrapper, true); // register customized Header，overwriting quill built-in Header
                        // Quill.register('formats/header', Header, true);
                    }

                    constructor(quill, options) {
                        super(quill, options); // handle click on quill-better-table

                        this.quill.root.addEventListener('click', evt => {
                            // bugfix: evt.path is undefined in Safari, FF, Micro Edge
                            const path = getEventComposedPath(evt);
                            if (!path || path.length <= 0) return;
                            const tableNode = path.filter(node => {
                                return node.tagName && node.tagName.toUpperCase() === 'TABLE' && node.classList.contains('quill-better-table');
                            })[0];

                            if (tableNode) {
                                // current table clicked
                                if (this.table === tableNode) return; // other table clicked

                                if (this.table) this.hideTableTools();
                                this.showTableTools(tableNode, quill, options);
                            } else if (this.table) {
                                // other clicked
                                this.hideTableTools();
                            }
                        }, false); // handle right click on quill-better-table

                        this.quill.root.addEventListener('contextmenu', evt => {
                            if (!this.table) return true;
                            evt.preventDefault(); // bugfix: evt.path is undefined in Safari, FF, Micro Edge

                            const path = getEventComposedPath(evt);
                            if (!path || path.length <= 0) return;
                            const tableNode = path.filter(node => {
                                return node.tagName && node.tagName.toUpperCase() === 'TABLE' && node.classList.contains('quill-better-table');
                            })[0];
                            const rowNode = path.filter(node => {
                                return node.tagName && node.tagName.toUpperCase() === 'TR' && node.getAttribute('data-row');
                            })[0];
                            const cellNode = path.filter(node => {
                                return node.tagName && node.tagName.toUpperCase() === 'TD' && node.getAttribute('data-row');
                            })[0];
                            let isTargetCellSelected = this.tableSelection.selectedTds.map(tableCell => tableCell.domNode).includes(cellNode);

                            if (this.tableSelection.selectedTds.length <= 0 || !isTargetCellSelected) {
                                this.tableSelection.setSelection(cellNode.getBoundingClientRect(), cellNode.getBoundingClientRect());
                            }

                            if (this.tableOperationMenu) this.tableOperationMenu = this.tableOperationMenu.destroy();

                            if (tableNode) {
                                this.tableOperationMenu = new table_operation_menu_TableOperationMenu({
                                    table: tableNode,
                                    row: rowNode,
                                    cell: cellNode,
                                    left: evt.pageX,
                                    top: evt.pageY
                                }, quill, options.operationMenu);
                            }
                        }, false); // add keyboard binding：Backspace
                        // prevent user hits backspace to delete table cell

                        const KeyBoard = quill.getModule('keyboard');
                        quill.keyboard.addBinding({
                            key: 'Backspace'
                        }, {}, function (range, context) {
                            if (range.index === 0 || this.quill.getLength() <= 1) return true;
                            const [line] = this.quill.getLine(range.index);

                            if (context.offset === 0) {
                                const [prev] = this.quill.getLine(range.index - 1);

                                if (prev != null) {
                                    if (prev.statics.blotName === 'table-cell-line' && line.statics.blotName !== 'table-cell-line') return false;
                                }
                            }

                            return true;
                        }); // since only one matched bindings callback will excute.
                        // expected my binding callback excute first
                        // I changed the order of binding callbacks

                        let thisBinding = quill.keyboard.bindings['Backspace'].pop();
                        quill.keyboard.bindings['Backspace'].splice(0, 1, thisBinding); // add Matchers to match and render quill-better-table for initialization
                        // or pasting

                        quill.clipboard.addMatcher('td', matchTableCell);
                        quill.clipboard.addMatcher('th', matchTableHeader);
                        quill.clipboard.addMatcher('table', matchTable); // quill.clipboard.addMatcher('h1, h2, h3, h4, h5, h6', matchHeader)
                        // remove matcher for tr tag

                        quill.clipboard.matchers = quill.clipboard.matchers.filter(matcher => {
                            return matcher[0] !== 'tr';
                        });
                    }

                    getTable() {
                        let range = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.quill.getSelection();
                        if (range == null) return [null, null, null, -1];
                        const [cellLine, offset] = this.quill.getLine(range.index);

                        if (cellLine == null || cellLine.statics.blotName !== TableCellLine.blotName) {
                            return [null, null, null, -1];
                        }

                        const cell = cellLine.tableCell();
                        const row = cell.row();
                        const table = row.table();
                        return [table, row, cell, offset];
                    }

                    insertTable(rows, columns) {
                        const range = this.quill.getSelection(true);
                        if (range == null) return;
                        let currentBlot = this.quill.getLeaf(range.index)[0];
                        let delta = new quill_better_table_Delta().retain(range.index);

                        if (isInTableCell(currentBlot)) {
                            console.warn("Can not insert table into a table cell.");
                            return;
                        }

                        delta.insert('\n'); // insert table column

                        delta = new Array(columns).fill('\n').reduce((memo, text) => {
                            memo.insert(text, {
                                'table-col': true
                            });
                            return memo;
                        }, delta); // insert table cell line with empty line

                        delta = new Array(rows).fill(0).reduce(memo => {
                            let tableRowId = table_rowId();
                            return new Array(columns).fill('\n').reduce((memo, text) => {
                                memo.insert(text, {
                                    'table-cell-line': {
                                        row: tableRowId,
                                        cell: table_cellId()
                                    }
                                });
                                return memo;
                            }, memo);
                        }, delta);
                        this.quill.updateContents(delta, external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.sources.USER);
                        this.quill.setSelection(range.index + columns + 1, external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.sources.API);
                    }

                    showTableTools(table, quill, options) {
                        this.table = table;
                        this.columnTool = new table_column_tool_TableColumnTool(table, quill, options);
                        this.tableSelection = new table_selection_TableSelection(table, quill, options);
                    }

                    hideTableTools() {
                        this.columnTool && this.columnTool.destroy();
                        this.tableSelection && this.tableSelection.destroy();
                        this.tableOperationMenu && this.tableOperationMenu.destroy();
                        this.columnTool = null;
                        this.tableSelection = null;
                        this.tableOperationMenu = null;
                        this.table = null;
                    }

                }
                
                quill_better_table_BetterTable.keyboardBindings = {
                    'table-cell-line backspace': {
                        key: 'Backspace',
                        format: ['table-cell-line'],
                        collapsed: true,
                        offset: 0,

                        handler(range, context) {
                            const [line, offset] = this.quill.getLine(range.index);

                            if (!line.prev || line.prev.statics.blotName !== 'table-cell-line') {
                                return false;
                            }

                            return true;
                        }

                    },
                    'table-cell-line delete': {
                        key: 'Delete',
                        format: ['table-cell-line'],
                        collapsed: true,
                        suffix: /^$/,

                        handler() {
                        }

                    },
                    'table-cell-line enter': {
                        key: 'Enter',
                        shiftKey: null,
                        format: ['table-cell-line'],

                        handler(range, context) {
                            // bugfix: a unexpected new line inserted when user compositionend with hitting Enter
                            if (this.quill.selection && this.quill.selection.composing) return;
                            const Scope = external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.imports.parchment.Scope;

                            if (range.length > 0) {
                                this.quill.scroll.deleteAt(range.index, range.length); // So we do not trigger text-change
                            }

                            const lineFormats = Object.keys(context.format).reduce((formats, format) => {
                                if (this.quill.scroll.query(format, Scope.BLOCK) && !Array.isArray(context.format[format])) {
                                    formats[format] = context.format[format];
                                }

                                return formats;
                            }, {}); // insert new cellLine with lineFormats

                            this.quill.insertText(range.index, '\n', lineFormats['table-cell-line'], external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.sources.USER); // Earlier scroll.deleteAt might have messed up our selection,
                            // so insertText's built in selection preservation is not reliable

                            this.quill.setSelection(range.index + 1, external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.sources.SILENT);
                            this.quill.focus();
                            Object.keys(context.format).forEach(name => {
                                if (lineFormats[name] != null) return;
                                if (Array.isArray(context.format[name])) return;
                                if (name === 'link') return;
                                this.quill.format(name, context.format[name], external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.sources.USER);
                            });
                        }

                    },
                    'table-cell-line up': makeTableArrowHandler(true),
                    'table-cell-line down': makeTableArrowHandler(false),
                    'down-to-table': {
                        key: 'ArrowDown',
                        collapsed: true,

                        handler(range, context) {
                            const target = context.line.next;

                            if (target && target.statics.blotName === 'table-view') {
                                const targetCell = target.table().rows()[0].children.head;
                                const targetLine = targetCell.children.head;
                                this.quill.setSelection(targetLine.offset(this.quill.scroll), 0, external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.sources.USER);
                                return false;
                            }

                            return true;
                        }

                    },
                    'up-to-table': {
                        key: 'ArrowUp',
                        collapsed: true,

                        handler(range, context) {
                            const target = context.line.prev;

                            if (target && target.statics.blotName === 'table-view') {
                                const rows = target.table().rows();
                                const targetCell = rows[rows.length - 1].children.head;
                                const targetLine = targetCell.children.head;
                                this.quill.setSelection(targetLine.offset(this.quill.scroll), 0, external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.sources.USER);
                                return false;
                            }

                            return true;
                        }

                    }
                };
                // console.log('loading Quill Better Table...')
                Quill.register({'modules/better-table':quill_better_table_BetterTable}, true);

                function makeTableArrowHandler(up) {
                    return {
                        key: up ? 'ArrowUp' : 'ArrowDown',
                        collapsed: true,
                        format: ['table-cell-line'],

                        handler(range, context) {
                            // TODO move to table module
                            const key = up ? 'prev' : 'next';
                            const targetLine = context.line[key];
                            if (targetLine != null) return true;
                            const cell = context.line.parent;
                            const targetRow = cell.parent[key];

                            if (targetRow != null && targetRow.statics.blotName === 'table-row') {
                                let targetCell = targetRow.children.head;
                                let totalColspanOfTargetCell = parseInt(targetCell.formats()['colspan'], 10);
                                let cur = cell;
                                let totalColspanOfCur = parseInt(cur.formats()['colspan'], 10); // get targetCell above current cell depends on colspan

                                while (cur.prev != null) {
                                    cur = cur.prev;
                                    totalColspanOfCur += parseInt(cur.formats()['colspan'], 10);
                                }

                                while (targetCell.next != null && totalColspanOfTargetCell < totalColspanOfCur) {
                                    targetCell = targetCell.next;
                                    totalColspanOfTargetCell += parseInt(targetCell.formats()['colspan'], 10);
                                }

                                const index = targetCell.offset(this.quill.scroll);
                                this.quill.setSelection(index, 0, external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.sources.USER);
                            } else {
                                const targetLine = cell.table().parent[key];

                                if (targetLine != null) {
                                    if (up) {
                                        this.quill.setSelection(targetLine.offset(this.quill.scroll) + targetLine.length() - 1, 0, external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.sources.USER);
                                    } else {
                                        this.quill.setSelection(targetLine.offset(this.quill.scroll), 0, external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.sources.USER);
                                    }
                                }
                            }

                            return false;
                        }

                    };
                }

                function isTableCell(blot) {
                    return blot.statics.blotName === TableCell.blotName;
                }

                function isInTableCell(current) {
                    return current && current.parent ? isTableCell(current.parent) ? true : isInTableCell(current.parent) : false;
                }

                /* harmony default export */
                var quill_better_table = __webpack_exports__["default"] = (quill_better_table_BetterTable);

                /***/
            }),
            /* 11 */,
            /* 12 */
            /***/ (function (module, exports, __webpack_require__) {

                module.exports = __webpack_require__(10);


                /***/
            })
            /******/])["default"];
});