text: (function webpackUniversalModuleDefinition(root, factory) {
  	if(typeof exports === 'object' && typeof module === 'object')
  		module.exports = factory(require("quill"));
  	else if(typeof define === 'function' && define.amd)
  		define(["quill"], factory);
  	else if(typeof exports === 'object')
  		exports["quillBetterTable"] = factory(require("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 = "1b0e2a34d0e3d2fc104c";
  /******/ 	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,
  /******/ 			_selfInvalidated: 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);
  /******/ 			},
  /******/ 			invalidate: function() {
  /******/ 				this._selfInvalidated = true;
  /******/ 				switch (hotStatus) {
  /******/ 					case "idle":
  /******/ 						hotUpdate = {};
  /******/ 						hotUpdate[moduleId] = modules[moduleId];
  /******/ 						hotSetStatus("ready");
  /******/ 						break;
  /******/ 					case "ready":
  /******/ 						hotApplyInvalidatedModule(moduleId);
  /******/ 						break;
  /******/ 					case "prepare":
  /******/ 					case "check":
  /******/ 					case "dispose":
  /******/ 					case "apply":
  /******/ 						(hotQueuedInvalidatedModules =
  /******/ 							hotQueuedInvalidatedModules || []).push(moduleId);
  /******/ 						break;
  /******/ 					default:
  /******/ 						// ignore requests in error states
  /******/ 						break;
  /******/ 				}
  /******/ 			},
  /******/
  /******/ 			// 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, hotQueuedInvalidatedModules;
  /******/
  /******/ 	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(hotApplyInvalidatedModules() ? "ready" : "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
  /******/ 			{
  /******/ 				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 || {};
  /******/ 		return hotApplyInternal(options);
  /******/ 	}
  /******/
  /******/ 	function hotApplyInternal(options) {
  /******/ 		hotApplyInvalidatedModules();
  /******/
  /******/ 		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 && !module.hot._selfInvalidated)
  /******/ 				)
  /******/ 					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 &&
  /******/ 				// when called invalidate self-accepting is not possible
  /******/ 				!installedModules[moduleId].hot._selfInvalidated
  /******/ 			) {
  /******/ 				outdatedSelfAcceptedModules.push({
  /******/ 					module: moduleId,
  /******/ 					parents: installedModules[moduleId].parents.slice(),
  /******/ 					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");
  /******/
  /******/ 		if (hotUpdateNewHash !== undefined) {
  /******/ 			hotCurrentHash = hotUpdateNewHash;
  /******/ 			hotUpdateNewHash = undefined;
  /******/ 		}
  /******/ 		hotUpdate = undefined;
  /******/
  /******/ 		// 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 = item.parents;
  /******/ 			hotCurrentChildModule = 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);
  /******/ 		}
  /******/
  /******/ 		if (hotQueuedInvalidatedModules) {
  /******/ 			return hotApplyInternal(options).then(function(list) {
  /******/ 				outdatedModules.forEach(function(moduleId) {
  /******/ 					if (list.indexOf(moduleId) < 0) list.push(moduleId);
  /******/ 				});
  /******/ 				return list;
  /******/ 			});
  /******/ 		}
  /******/
  /******/ 		hotSetStatus("idle");
  /******/ 		return new Promise(function(resolve) {
  /******/ 			resolve(outdatedModules);
  /******/ 		});
  /******/ 	}
  /******/
  /******/ 	function hotApplyInvalidatedModules() {
  /******/ 		if (hotQueuedInvalidatedModules) {
  /******/ 			if (!hotUpdate) hotUpdate = {};
  /******/ 			hotQueuedInvalidatedModules.forEach(hotApplyInvalidatedModule);
  /******/ 			hotQueuedInvalidatedModules = undefined;
  /******/ 			return true;
  /******/ 		}
  /******/ 	}
  /******/
  /******/ 	function hotApplyInvalidatedModule(moduleId) {
  /******/ 		if (!Object.prototype.hasOwnProperty.call(hotUpdate, moduleId))
  /******/ 			hotUpdate[moduleId] = modules[moduleId];
  /******/ 	}
  /******/
  /******/ 	// 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(13)(__webpack_require__.s = 13);
  /******/ })
  /************************************************************************/
  /******/ ([
  /* 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, exports, __webpack_require__) {
  
  "use strict";
  
  
  var hasOwn = Object.prototype.hasOwnProperty;
  var toStr = Object.prototype.toString;
  var defineProperty = Object.defineProperty;
  var gOPD = Object.getOwnPropertyDescriptor;
  
  var isArray = function isArray(arr) {
  	if (typeof Array.isArray === 'function') {
  		return Array.isArray(arr);
  	}
  
  	return toStr.call(arr) === '[object Array]';
  };
  
  var isPlainObject = function isPlainObject(obj) {
  	if (!obj || toStr.call(obj) !== '[object Object]') {
  		return false;
  	}
  
  	var hasOwnConstructor = hasOwn.call(obj, 'constructor');
  	var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');
  	// Not own constructor property must be Object
  	if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {
  		return false;
  	}
  
  	// Own properties are enumerated firstly, so to speed up,
  	// if last one is own, then all properties are own.
  	var key;
  	for (key in obj) { /**/ }
  
  	return typeof key === 'undefined' || hasOwn.call(obj, key);
  };
  
  // If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target
  var setProperty = function setProperty(target, options) {
  	if (defineProperty && options.name === '__proto__') {
  		defineProperty(target, options.name, {
  			enumerable: true,
  			configurable: true,
  			value: options.newValue,
  			writable: true
  		});
  	} else {
  		target[options.name] = options.newValue;
  	}
  };
  
  // Return undefined instead of __proto__ if '__proto__' is not an own property
  var getProperty = function getProperty(obj, name) {
  	if (name === '__proto__') {
  		if (!hasOwn.call(obj, name)) {
  			return void 0;
  		} else if (gOPD) {
  			// In early versions of node, obj['__proto__'] is buggy when obj has
  			// __proto__ as an own property. Object.getOwnPropertyDescriptor() works.
  			return gOPD(obj, name).value;
  		}
  	}
  
  	return obj[name];
  };
  
  module.exports = function extend() {
  	var options, name, src, copy, copyIsArray, clone;
  	var target = arguments[0];
  	var i = 1;
  	var length = arguments.length;
  	var deep = false;
  
  	// Handle a deep copy situation
  	if (typeof target === 'boolean') {
  		deep = target;
  		target = arguments[1] || {};
  		// skip the boolean and the target
  		i = 2;
  	}
  	if (target == null || (typeof target !== 'object' && typeof target !== 'function')) {
  		target = {};
  	}
  
  	for (; i < length; ++i) {
  		options = arguments[i];
  		// Only deal with non-null/undefined values
  		if (options != null) {
  			// Extend the base object
  			for (name in options) {
  				src = getProperty(target, name);
  				copy = getProperty(options, name);
  
  				// Prevent never-ending loop
  				if (target !== copy) {
  					// Recurse if we're merging plain objects or arrays
  					if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {
  						if (copyIsArray) {
  							copyIsArray = false;
  							clone = src && isArray(src) ? src : [];
  						} else {
  							clone = src && isPlainObject(src) ? src : {};
  						}
  
  						// Never move original objects, clone them
  						setProperty(target, { name: name, newValue: extend(deep, clone, copy) });
  
  					// Don't bring in undefined values
  					} else if (typeof copy !== 'undefined') {
  						setProperty(target, { name: name, newValue: copy });
  					}
  				}
  			}
  		}
  	}
  
  	// Return the modified object
  	return target;
  };
  
  
  /***/ }),
  /* 11 */
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  // ESM COMPAT FLAG
  __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, delIndexes = [], editorWrapper) {
      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, isRight = true, editorWrapper) {
      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({
      table,
      left,
      top
    }) {
      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({
      text,
      iconSrc,
      handler
    }) {
      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/ui/table-picker.js
  
  const Picker = external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.import('ui/picker');
  
  class TablePicker extends Picker {
    constructor(select, label) {
      super(select);
      this.label.innerHTML = label;
      this.container.classList.add('ql-table-picker');
    }
  
    buildItem(option) {
      const item = super.buildItem(option);
      item.addEventListener('mouseover', () => {
        let value = item.getAttribute('data-value').split('x');
        let row = parseInt(value[1]);
        let column = parseInt(value[0]);
        let items = Array.from(this.container.querySelectorAll('.ql-picker-item'));
        let lastItem = this.container.querySelector('.ql-picker-item:last-child');
        value = lastItem.getAttribute('data-value').split('x'); // let rows = parseInt(value[1]);
  
        let cols = parseInt(value[0]);
        items.forEach(i => {
          i.classList.remove('hover');
        });
  
        for (let r = 0; r < row; r++) {
          items.slice(r * cols, r * cols + column).forEach(i => {
            i.classList.add('hover');
          });
        }
      });
      return item;
    }
  
    selectItem(item, trigger = false) {
      super.selectItem(item, trigger);
      if (item == null) return;
      item.classList.remove('ql-selected');
  
      if (item.label) {
        item.label.removeAttribute('data-value');
        item.label.removeAttribute('data-label');
      }
  
      Array.from(this.container.querySelectorAll('.hover')).forEach(item => {
        item.classList.remove('hover');
      });
    }
  
  }
  
  /* harmony default export */ var table_picker = (TablePicker);
  // EXTERNAL MODULE: ./node_modules/extend/index.js
  var extend = __webpack_require__(10);
  var extend_default = /*#__PURE__*/__webpack_require__.n(extend);
  
  // CONCATENATED MODULE: ./src/themes/better-table-snow.js
  
  
  
  const SnowTheme = external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.import('themes/snow');
  
  class better_table_snow_BetterTableSnowTheme extends SnowTheme {
    constructor(quill, options) {
      super(quill, options);
    }
  
    buildPickers(selects, icons) {
      selects = Array.from(selects);
      let pickers = selects.map((select, index, selects) => {
        if (select.classList.contains('ql-better-table')) {
          selects.splice(index, 1);
  
          if (select.querySelector('option') == null) {
            for (let r = 1; r <= 8; r++) {
              for (let c = 1; c <= 10; c++) {
                const option = document.createElement('option');
                option.setAttribute('value', c + 'x' + r);
                select.appendChild(option);
              }
            }
          }
  
          return new table_picker(select, icons.table);
        }
      });
      super.buildPickers(selects, icons);
      this.pickers = extend_default()([], this.pickers, pickers);
    }
  
  }
  
  /* harmony default export */ var better_table_snow = (better_table_snow_BetterTableSnowTheme);
  // 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);
  
      external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.register('themes/better-table-snow', better_table_snow, true);
      external_commonjs_quill_commonjs2_quill_amd_quill_root_Quill_default.a.register('ui/table-picker', table_picker, 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';
      });
      const toolbar = quill.getModule('toolbar');
      const input = toolbar.container.querySelector('select.ql-better-table');
  
      if (toolbar && input) {
        toolbar.addHandler('better-table', this.insertTable);
        toolbar.attach(input);
      }
    }
  
    getTable(range = 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) {
      if (!columns) {
        if (rows.match(/^\d+x\d+$/)) {
          let tmp = rows.split('x');
          columns = parseInt(tmp[0]);
          rows = parseInt(tmp[1]);
        } else {
          return;
        }
      }
  
      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);
        return !(!line.prev || line.prev.statics.blotName !== 'table-cell-line');
      }
  
    },
    '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;
      }
  
    }
  };
  
  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);
  
  /***/ }),
  /* 12 */,
  /* 13 */
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports = __webpack_require__(11);
  
  
  /***/ })
  /******/ ])["default"];
  });