@mnykj/wangeditoroptimize-table-module 1.0.0

package/dist/index.esm.js

@@ -0,0 +1,3389 @@
+import { i18nAddResources, DomEditor, t, canRemoveEmptyLineAboveBlock, resolveElemPath, insertEmptyLineAboveAtPath, removeEmptyLineAboveTopLevelBlock } from '@mnykj/wangeditoroptimize-core';
+import { Editor, Transforms, Path, Node, Point, Range, Element, Text } from 'slate';
+import { jsx, h } from 'snabbdom';
+import isEqual from 'lodash.isequal';
+import throttle from 'lodash.throttle';
+import $, { append, on, focus, attr, val, html as html$1, dataset, addClass, removeClass, children, each, find } from 'dom7';
+import 'nanoid';
+
+var enResources = {
+  tableModule: {
+    deleteCol: 'Delete column',
+    deleteRow: 'Delete row',
+    deleteTable: 'Delete table',
+    widthAuto: 'Width auto',
+    insertCol: 'Insert column',
+    insertRow: 'Insert row',
+    insertTable: 'Insert table',
+    header: 'Header'
+  }
+};
+
+var zhResources = {
+  tableModule: {
+    deleteCol: '删除列',
+    deleteRow: '删除行',
+    deleteTable: '删除表格',
+    widthAuto: '宽度自适应',
+    insertCol: '插入列',
+    insertRow: '插入行',
+    insertTable: '插入表格',
+    header: '表头'
+  }
+};
+
+i18nAddResources('en', enResources);
+i18nAddResources('zh-CN', zhResources);
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function createCommonjsModule(fn) {
+  var module = { exports: {} };
+	return fn(module, module.exports), module.exports;
+}
+
+var check = function (it) {
+  return it && it.Math == Math && it;
+};
+
+// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
+var global$1 =
+  // eslint-disable-next-line es/no-global-this -- safe
+  check(typeof globalThis == 'object' && globalThis) ||
+  check(typeof window == 'object' && window) ||
+  // eslint-disable-next-line no-restricted-globals -- safe
+  check(typeof self == 'object' && self) ||
+  check(typeof commonjsGlobal == 'object' && commonjsGlobal) ||
+  // eslint-disable-next-line no-new-func -- fallback
+  (function () { return this; })() || Function('return this')();
+
+var fails = function (exec) {
+  try {
+    return !!exec();
+  } catch (error) {
+    return true;
+  }
+};
+
+// Detect IE8's incomplete defineProperty implementation
+var descriptors = !fails(function () {
+  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;
+});
+
+var call$2 = Function.prototype.call;
+
+var functionCall = call$2.bind ? call$2.bind(call$2) : function () {
+  return call$2.apply(call$2, arguments);
+};
+
+var $propertyIsEnumerable = {}.propertyIsEnumerable;
+// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+var getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
+
+// Nashorn ~ JDK8 bug
+var NASHORN_BUG = getOwnPropertyDescriptor$1 && !$propertyIsEnumerable.call({ 1: 2 }, 1);
+
+// `Object.prototype.propertyIsEnumerable` method implementation
+// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
+var f$4 = NASHORN_BUG ? function propertyIsEnumerable(V) {
+  var descriptor = getOwnPropertyDescriptor$1(this, V);
+  return !!descriptor && descriptor.enumerable;
+} : $propertyIsEnumerable;
+
+var objectPropertyIsEnumerable = {
+	f: f$4
+};
+
+var createPropertyDescriptor = function (bitmap, value) {
+  return {
+    enumerable: !(bitmap & 1),
+    configurable: !(bitmap & 2),
+    writable: !(bitmap & 4),
+    value: value
+  };
+};
+
+var FunctionPrototype$2 = Function.prototype;
+var bind$2 = FunctionPrototype$2.bind;
+var call$1 = FunctionPrototype$2.call;
+var callBind = bind$2 && bind$2.bind(call$1);
+
+var functionUncurryThis = bind$2 ? function (fn) {
+  return fn && callBind(call$1, fn);
+} : function (fn) {
+  return fn && function () {
+    return call$1.apply(fn, arguments);
+  };
+};
+
+var toString$2 = functionUncurryThis({}.toString);
+var stringSlice$5 = functionUncurryThis(''.slice);
+
+var classofRaw = function (it) {
+  return stringSlice$5(toString$2(it), 8, -1);
+};
+
+var Object$4 = global$1.Object;
+var split = functionUncurryThis(''.split);
+
+// fallback for non-array-like ES3 and non-enumerable old V8 strings
+var indexedObject = fails(function () {
+  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
+  // eslint-disable-next-line no-prototype-builtins -- safe
+  return !Object$4('z').propertyIsEnumerable(0);
+}) ? function (it) {
+  return classofRaw(it) == 'String' ? split(it, '') : Object$4(it);
+} : Object$4;
+
+var TypeError$9 = global$1.TypeError;
+
+// `RequireObjectCoercible` abstract operation
+// https://tc39.es/ecma262/#sec-requireobjectcoercible
+var requireObjectCoercible = function (it) {
+  if (it == undefined) throw TypeError$9("Can't call method on " + it);
+  return it;
+};
+
+// toObject with fallback for non-array-like ES3 strings
+
+
+
+var toIndexedObject = function (it) {
+  return indexedObject(requireObjectCoercible(it));
+};
+
+// `IsCallable` abstract operation
+// https://tc39.es/ecma262/#sec-iscallable
+var isCallable = function (argument) {
+  return typeof argument == 'function';
+};
+
+var isObject = function (it) {
+  return typeof it == 'object' ? it !== null : isCallable(it);
+};
+
+var aFunction = function (argument) {
+  return isCallable(argument) ? argument : undefined;
+};
+
+var getBuiltIn = function (namespace, method) {
+  return arguments.length < 2 ? aFunction(global$1[namespace]) : global$1[namespace] && global$1[namespace][method];
+};
+
+var objectIsPrototypeOf = functionUncurryThis({}.isPrototypeOf);
+
+var engineUserAgent = getBuiltIn('navigator', 'userAgent') || '';
+
+var process = global$1.process;
+var Deno = global$1.Deno;
+var versions = process && process.versions || Deno && Deno.version;
+var v8 = versions && versions.v8;
+var match, version;
+
+if (v8) {
+  match = v8.split('.');
+  // in old Chrome, versions of V8 isn't V8 = Chrome / 10
+  // but their correct versions are not interesting for us
+  version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
+}
+
+// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
+// so check `userAgent` even if `.v8` exists, but 0
+if (!version && engineUserAgent) {
+  match = engineUserAgent.match(/Edge\/(\d+)/);
+  if (!match || match[1] >= 74) {
+    match = engineUserAgent.match(/Chrome\/(\d+)/);
+    if (match) version = +match[1];
+  }
+}
+
+var engineV8Version = version;
+
+/* eslint-disable es/no-symbol -- required for testing */
+
+// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
+var nativeSymbol = !!Object.getOwnPropertySymbols && !fails(function () {
+  var symbol = Symbol();
+  // Chrome 38 Symbol has incorrect toString conversion
+  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
+  return !String(symbol) || !(Object(symbol) instanceof Symbol) ||
+    // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
+    !Symbol.sham && engineV8Version && engineV8Version < 41;
+});
+
+/* eslint-disable es/no-symbol -- required for testing */
+
+var useSymbolAsUid = nativeSymbol
+  && !Symbol.sham
+  && typeof Symbol.iterator == 'symbol';
+
+var Object$3 = global$1.Object;
+
+var isSymbol = useSymbolAsUid ? function (it) {
+  return typeof it == 'symbol';
+} : function (it) {
+  var $Symbol = getBuiltIn('Symbol');
+  return isCallable($Symbol) && objectIsPrototypeOf($Symbol.prototype, Object$3(it));
+};
+
+var String$3 = global$1.String;
+
+var tryToString = function (argument) {
+  try {
+    return String$3(argument);
+  } catch (error) {
+    return 'Object';
+  }
+};
+
+var TypeError$8 = global$1.TypeError;
+
+// `Assert: IsCallable(argument) is true`
+var aCallable = function (argument) {
+  if (isCallable(argument)) return argument;
+  throw TypeError$8(tryToString(argument) + ' is not a function');
+};
+
+// `GetMethod` abstract operation
+// https://tc39.es/ecma262/#sec-getmethod
+var getMethod = function (V, P) {
+  var func = V[P];
+  return func == null ? undefined : aCallable(func);
+};
+
+var TypeError$7 = global$1.TypeError;
+
+// `OrdinaryToPrimitive` abstract operation
+// https://tc39.es/ecma262/#sec-ordinarytoprimitive
+var ordinaryToPrimitive = function (input, pref) {
+  var fn, val;
+  if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = functionCall(fn, input))) return val;
+  if (isCallable(fn = input.valueOf) && !isObject(val = functionCall(fn, input))) return val;
+  if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = functionCall(fn, input))) return val;
+  throw TypeError$7("Can't convert object to primitive value");
+};
+
+// eslint-disable-next-line es/no-object-defineproperty -- safe
+var defineProperty = Object.defineProperty;
+
+var setGlobal = function (key, value) {
+  try {
+    defineProperty(global$1, key, { value: value, configurable: true, writable: true });
+  } catch (error) {
+    global$1[key] = value;
+  } return value;
+};
+
+var SHARED = '__core-js_shared__';
+var store$1 = global$1[SHARED] || setGlobal(SHARED, {});
+
+var sharedStore = store$1;
+
+var shared = createCommonjsModule(function (module) {
+(module.exports = function (key, value) {
+  return sharedStore[key] || (sharedStore[key] = value !== undefined ? value : {});
+})('versions', []).push({
+  version: '3.19.3',
+  mode: 'global',
+  copyright: '© 2021 Denis Pushkarev (zloirock.ru)'
+});
+});
+
+var Object$2 = global$1.Object;
+
+// `ToObject` abstract operation
+// https://tc39.es/ecma262/#sec-toobject
+var toObject = function (argument) {
+  return Object$2(requireObjectCoercible(argument));
+};
+
+var hasOwnProperty = functionUncurryThis({}.hasOwnProperty);
+
+// `HasOwnProperty` abstract operation
+// https://tc39.es/ecma262/#sec-hasownproperty
+var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
+  return hasOwnProperty(toObject(it), key);
+};
+
+var id = 0;
+var postfix = Math.random();
+var toString$1 = functionUncurryThis(1.0.toString);
+
+var uid = function (key) {
+  return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$1(++id + postfix, 36);
+};
+
+var WellKnownSymbolsStore = shared('wks');
+var Symbol$1 = global$1.Symbol;
+var symbolFor = Symbol$1 && Symbol$1['for'];
+var createWellKnownSymbol = useSymbolAsUid ? Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid;
+
+var wellKnownSymbol = function (name) {
+  if (!hasOwnProperty_1(WellKnownSymbolsStore, name) || !(nativeSymbol || typeof WellKnownSymbolsStore[name] == 'string')) {
+    var description = 'Symbol.' + name;
+    if (nativeSymbol && hasOwnProperty_1(Symbol$1, name)) {
+      WellKnownSymbolsStore[name] = Symbol$1[name];
+    } else if (useSymbolAsUid && symbolFor) {
+      WellKnownSymbolsStore[name] = symbolFor(description);
+    } else {
+      WellKnownSymbolsStore[name] = createWellKnownSymbol(description);
+    }
+  } return WellKnownSymbolsStore[name];
+};
+
+var TypeError$6 = global$1.TypeError;
+var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
+
+// `ToPrimitive` abstract operation
+// https://tc39.es/ecma262/#sec-toprimitive
+var toPrimitive = function (input, pref) {
+  if (!isObject(input) || isSymbol(input)) return input;
+  var exoticToPrim = getMethod(input, TO_PRIMITIVE);
+  var result;
+  if (exoticToPrim) {
+    if (pref === undefined) pref = 'default';
+    result = functionCall(exoticToPrim, input, pref);
+    if (!isObject(result) || isSymbol(result)) return result;
+    throw TypeError$6("Can't convert object to primitive value");
+  }
+  if (pref === undefined) pref = 'number';
+  return ordinaryToPrimitive(input, pref);
+};
+
+// `ToPropertyKey` abstract operation
+// https://tc39.es/ecma262/#sec-topropertykey
+var toPropertyKey = function (argument) {
+  var key = toPrimitive(argument, 'string');
+  return isSymbol(key) ? key : key + '';
+};
+
+var document$1 = global$1.document;
+// typeof document.createElement is 'object' in old IE
+var EXISTS$1 = isObject(document$1) && isObject(document$1.createElement);
+
+var documentCreateElement = function (it) {
+  return EXISTS$1 ? document$1.createElement(it) : {};
+};
+
+// Thank's IE8 for his funny defineProperty
+var ie8DomDefine = !descriptors && !fails(function () {
+  // eslint-disable-next-line es/no-object-defineproperty -- requied for testing
+  return Object.defineProperty(documentCreateElement('div'), 'a', {
+    get: function () { return 7; }
+  }).a != 7;
+});
+
+// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+
+// `Object.getOwnPropertyDescriptor` method
+// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
+var f$3 = descriptors ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
+  O = toIndexedObject(O);
+  P = toPropertyKey(P);
+  if (ie8DomDefine) try {
+    return $getOwnPropertyDescriptor(O, P);
+  } catch (error) { /* empty */ }
+  if (hasOwnProperty_1(O, P)) return createPropertyDescriptor(!functionCall(objectPropertyIsEnumerable.f, O, P), O[P]);
+};
+
+var objectGetOwnPropertyDescriptor = {
+	f: f$3
+};
+
+var String$2 = global$1.String;
+var TypeError$5 = global$1.TypeError;
+
+// `Assert: Type(argument) is Object`
+var anObject = function (argument) {
+  if (isObject(argument)) return argument;
+  throw TypeError$5(String$2(argument) + ' is not an object');
+};
+
+var TypeError$4 = global$1.TypeError;
+// eslint-disable-next-line es/no-object-defineproperty -- safe
+var $defineProperty = Object.defineProperty;
+
+// `Object.defineProperty` method
+// https://tc39.es/ecma262/#sec-object.defineproperty
+var f$2 = descriptors ? $defineProperty : function defineProperty(O, P, Attributes) {
+  anObject(O);
+  P = toPropertyKey(P);
+  anObject(Attributes);
+  if (ie8DomDefine) try {
+    return $defineProperty(O, P, Attributes);
+  } catch (error) { /* empty */ }
+  if ('get' in Attributes || 'set' in Attributes) throw TypeError$4('Accessors not supported');
+  if ('value' in Attributes) O[P] = Attributes.value;
+  return O;
+};
+
+var objectDefineProperty = {
+	f: f$2
+};
+
+var createNonEnumerableProperty = descriptors ? function (object, key, value) {
+  return objectDefineProperty.f(object, key, createPropertyDescriptor(1, value));
+} : function (object, key, value) {
+  object[key] = value;
+  return object;
+};
+
+var functionToString = functionUncurryThis(Function.toString);
+
+// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
+if (!isCallable(sharedStore.inspectSource)) {
+  sharedStore.inspectSource = function (it) {
+    return functionToString(it);
+  };
+}
+
+var inspectSource = sharedStore.inspectSource;
+
+var WeakMap$1 = global$1.WeakMap;
+
+var nativeWeakMap = isCallable(WeakMap$1) && /native code/.test(inspectSource(WeakMap$1));
+
+var keys = shared('keys');
+
+var sharedKey = function (key) {
+  return keys[key] || (keys[key] = uid(key));
+};
+
+var hiddenKeys$1 = {};
+
+var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
+var TypeError$3 = global$1.TypeError;
+var WeakMap = global$1.WeakMap;
+var set, get, has;
+
+var enforce = function (it) {
+  return has(it) ? get(it) : set(it, {});
+};
+
+var getterFor = function (TYPE) {
+  return function (it) {
+    var state;
+    if (!isObject(it) || (state = get(it)).type !== TYPE) {
+      throw TypeError$3('Incompatible receiver, ' + TYPE + ' required');
+    } return state;
+  };
+};
+
+if (nativeWeakMap || sharedStore.state) {
+  var store = sharedStore.state || (sharedStore.state = new WeakMap());
+  var wmget = functionUncurryThis(store.get);
+  var wmhas = functionUncurryThis(store.has);
+  var wmset = functionUncurryThis(store.set);
+  set = function (it, metadata) {
+    if (wmhas(store, it)) throw new TypeError$3(OBJECT_ALREADY_INITIALIZED);
+    metadata.facade = it;
+    wmset(store, it, metadata);
+    return metadata;
+  };
+  get = function (it) {
+    return wmget(store, it) || {};
+  };
+  has = function (it) {
+    return wmhas(store, it);
+  };
+} else {
+  var STATE = sharedKey('state');
+  hiddenKeys$1[STATE] = true;
+  set = function (it, metadata) {
+    if (hasOwnProperty_1(it, STATE)) throw new TypeError$3(OBJECT_ALREADY_INITIALIZED);
+    metadata.facade = it;
+    createNonEnumerableProperty(it, STATE, metadata);
+    return metadata;
+  };
+  get = function (it) {
+    return hasOwnProperty_1(it, STATE) ? it[STATE] : {};
+  };
+  has = function (it) {
+    return hasOwnProperty_1(it, STATE);
+  };
+}
+
+var internalState = {
+  set: set,
+  get: get,
+  has: has,
+  enforce: enforce,
+  getterFor: getterFor
+};
+
+var FunctionPrototype$1 = Function.prototype;
+// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+var getDescriptor = descriptors && Object.getOwnPropertyDescriptor;
+
+var EXISTS = hasOwnProperty_1(FunctionPrototype$1, 'name');
+// additional protection from minified / mangled / dropped function names
+var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
+var CONFIGURABLE = EXISTS && (!descriptors || (descriptors && getDescriptor(FunctionPrototype$1, 'name').configurable));
+
+var functionName = {
+  EXISTS: EXISTS,
+  PROPER: PROPER,
+  CONFIGURABLE: CONFIGURABLE
+};
+
+var redefine = createCommonjsModule(function (module) {
+var CONFIGURABLE_FUNCTION_NAME = functionName.CONFIGURABLE;
+
+var getInternalState = internalState.get;
+var enforceInternalState = internalState.enforce;
+var TEMPLATE = String(String).split('String');
+
+(module.exports = function (O, key, value, options) {
+  var unsafe = options ? !!options.unsafe : false;
+  var simple = options ? !!options.enumerable : false;
+  var noTargetGet = options ? !!options.noTargetGet : false;
+  var name = options && options.name !== undefined ? options.name : key;
+  var state;
+  if (isCallable(value)) {
+    if (String(name).slice(0, 7) === 'Symbol(') {
+      name = '[' + String(name).replace(/^Symbol\(([^)]*)\)/, '$1') + ']';
+    }
+    if (!hasOwnProperty_1(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
+      createNonEnumerableProperty(value, 'name', name);
+    }
+    state = enforceInternalState(value);
+    if (!state.source) {
+      state.source = TEMPLATE.join(typeof name == 'string' ? name : '');
+    }
+  }
+  if (O === global$1) {
+    if (simple) O[key] = value;
+    else setGlobal(key, value);
+    return;
+  } else if (!unsafe) {
+    delete O[key];
+  } else if (!noTargetGet && O[key]) {
+    simple = true;
+  }
+  if (simple) O[key] = value;
+  else createNonEnumerableProperty(O, key, value);
+// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
+})(Function.prototype, 'toString', function toString() {
+  return isCallable(this) && getInternalState(this).source || inspectSource(this);
+});
+});
+
+var ceil = Math.ceil;
+var floor$1 = Math.floor;
+
+// `ToIntegerOrInfinity` abstract operation
+// https://tc39.es/ecma262/#sec-tointegerorinfinity
+var toIntegerOrInfinity = function (argument) {
+  var number = +argument;
+  // eslint-disable-next-line no-self-compare -- safe
+  return number !== number || number === 0 ? 0 : (number > 0 ? floor$1 : ceil)(number);
+};
+
+var max$3 = Math.max;
+var min$3 = Math.min;
+
+// Helper for a popular repeating case of the spec:
+// Let integer be ? ToInteger(index).
+// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
+var toAbsoluteIndex = function (index, length) {
+  var integer = toIntegerOrInfinity(index);
+  return integer < 0 ? max$3(integer + length, 0) : min$3(integer, length);
+};
+
+var min$2 = Math.min;
+
+// `ToLength` abstract operation
+// https://tc39.es/ecma262/#sec-tolength
+var toLength = function (argument) {
+  return argument > 0 ? min$2(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
+};
+
+// `LengthOfArrayLike` abstract operation
+// https://tc39.es/ecma262/#sec-lengthofarraylike
+var lengthOfArrayLike = function (obj) {
+  return toLength(obj.length);
+};
+
+// `Array.prototype.{ indexOf, includes }` methods implementation
+var createMethod$3 = function (IS_INCLUDES) {
+  return function ($this, el, fromIndex) {
+    var O = toIndexedObject($this);
+    var length = lengthOfArrayLike(O);
+    var index = toAbsoluteIndex(fromIndex, length);
+    var value;
+    // Array#includes uses SameValueZero equality algorithm
+    // eslint-disable-next-line no-self-compare -- NaN check
+    if (IS_INCLUDES && el != el) while (length > index) {
+      value = O[index++];
+      // eslint-disable-next-line no-self-compare -- NaN check
+      if (value != value) return true;
+    // Array#indexOf ignores holes, Array#includes - not
+    } else for (;length > index; index++) {
+      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
+    } return !IS_INCLUDES && -1;
+  };
+};
+
+var arrayIncludes = {
+  // `Array.prototype.includes` method
+  // https://tc39.es/ecma262/#sec-array.prototype.includes
+  includes: createMethod$3(true),
+  // `Array.prototype.indexOf` method
+  // https://tc39.es/ecma262/#sec-array.prototype.indexof
+  indexOf: createMethod$3(false)
+};
+
+var indexOf$1 = arrayIncludes.indexOf;
+
+
+var push$3 = functionUncurryThis([].push);
+
+var objectKeysInternal = function (object, names) {
+  var O = toIndexedObject(object);
+  var i = 0;
+  var result = [];
+  var key;
+  for (key in O) !hasOwnProperty_1(hiddenKeys$1, key) && hasOwnProperty_1(O, key) && push$3(result, key);
+  // Don't enum bug & hidden keys
+  while (names.length > i) if (hasOwnProperty_1(O, key = names[i++])) {
+    ~indexOf$1(result, key) || push$3(result, key);
+  }
+  return result;
+};
+
+// IE8- don't enum bug keys
+var enumBugKeys = [
+  'constructor',
+  'hasOwnProperty',
+  'isPrototypeOf',
+  'propertyIsEnumerable',
+  'toLocaleString',
+  'toString',
+  'valueOf'
+];
+
+var hiddenKeys = enumBugKeys.concat('length', 'prototype');
+
+// `Object.getOwnPropertyNames` method
+// https://tc39.es/ecma262/#sec-object.getownpropertynames
+// eslint-disable-next-line es/no-object-getownpropertynames -- safe
+var f$1 = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
+  return objectKeysInternal(O, hiddenKeys);
+};
+
+var objectGetOwnPropertyNames = {
+	f: f$1
+};
+
+// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
+var f = Object.getOwnPropertySymbols;
+
+var objectGetOwnPropertySymbols = {
+	f: f
+};
+
+var concat$1 = functionUncurryThis([].concat);
+
+// all object keys, includes non-enumerable and symbols
+var ownKeys = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
+  var keys = objectGetOwnPropertyNames.f(anObject(it));
+  var getOwnPropertySymbols = objectGetOwnPropertySymbols.f;
+  return getOwnPropertySymbols ? concat$1(keys, getOwnPropertySymbols(it)) : keys;
+};
+
+var copyConstructorProperties = function (target, source) {
+  var keys = ownKeys(source);
+  var defineProperty = objectDefineProperty.f;
+  var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    if (!hasOwnProperty_1(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));
+  }
+};
+
+var replacement = /#|\.prototype\./;
+
+var isForced = function (feature, detection) {
+  var value = data[normalize(feature)];
+  return value == POLYFILL ? true
+    : value == NATIVE ? false
+    : isCallable(detection) ? fails(detection)
+    : !!detection;
+};
+
+var normalize = isForced.normalize = function (string) {
+  return String(string).replace(replacement, '.').toLowerCase();
+};
+
+var data = isForced.data = {};
+var NATIVE = isForced.NATIVE = 'N';
+var POLYFILL = isForced.POLYFILL = 'P';
+
+var isForced_1 = isForced;
+
+var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
+
+
+
+
+
+
+/*
+  options.target      - name of the target object
+  options.global      - target is the global object
+  options.stat        - export as static methods of target
+  options.proto       - export as prototype methods of target
+  options.real        - real prototype method for the `pure` version
+  options.forced      - export even if the native feature is available
+  options.bind        - bind methods to the target, required for the `pure` version
+  options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version
+  options.unsafe      - use the simple assignment of property instead of delete + defineProperty
+  options.sham        - add a flag to not completely full polyfills
+  options.enumerable  - export as enumerable property
+  options.noTargetGet - prevent calling a getter on target
+  options.name        - the .name of the function if it does not match the key
+*/
+var _export = function (options, source) {
+  var TARGET = options.target;
+  var GLOBAL = options.global;
+  var STATIC = options.stat;
+  var FORCED, target, key, targetProperty, sourceProperty, descriptor;
+  if (GLOBAL) {
+    target = global$1;
+  } else if (STATIC) {
+    target = global$1[TARGET] || setGlobal(TARGET, {});
+  } else {
+    target = (global$1[TARGET] || {}).prototype;
+  }
+  if (target) for (key in source) {
+    sourceProperty = source[key];
+    if (options.noTargetGet) {
+      descriptor = getOwnPropertyDescriptor(target, key);
+      targetProperty = descriptor && descriptor.value;
+    } else targetProperty = target[key];
+    FORCED = isForced_1(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
+    // contained in target
+    if (!FORCED && targetProperty !== undefined) {
+      if (typeof sourceProperty == typeof targetProperty) continue;
+      copyConstructorProperties(sourceProperty, targetProperty);
+    }
+    // add a flag to not completely full polyfills
+    if (options.sham || (targetProperty && targetProperty.sham)) {
+      createNonEnumerableProperty(sourceProperty, 'sham', true);
+    }
+    // extend global
+    redefine(target, key, sourceProperty, options);
+  }
+};
+
+var TO_STRING_TAG$1 = wellKnownSymbol('toStringTag');
+var test = {};
+
+test[TO_STRING_TAG$1] = 'z';
+
+var toStringTagSupport = String(test) === '[object z]';
+
+var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+var Object$1 = global$1.Object;
+
+// ES3 wrong here
+var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';
+
+// fallback for IE11 Script Access Denied error
+var tryGet = function (it, key) {
+  try {
+    return it[key];
+  } catch (error) { /* empty */ }
+};
+
+// getting tag from ES6+ `Object.prototype.toString`
+var classof = toStringTagSupport ? classofRaw : function (it) {
+  var O, tag, result;
+  return it === undefined ? 'Undefined' : it === null ? 'Null'
+    // @@toStringTag case
+    : typeof (tag = tryGet(O = Object$1(it), TO_STRING_TAG)) == 'string' ? tag
+    // builtinTag case
+    : CORRECT_ARGUMENTS ? classofRaw(O)
+    // ES3 arguments fallback
+    : (result = classofRaw(O)) == 'Object' && isCallable(O.callee) ? 'Arguments' : result;
+};
+
+var String$1 = global$1.String;
+
+var toString = function (argument) {
+  if (classof(argument) === 'Symbol') throw TypeError('Cannot convert a Symbol value to a string');
+  return String$1(argument);
+};
+
+var quot = /"/g;
+var replace$3 = functionUncurryThis(''.replace);
+
+// `CreateHTML` abstract operation
+// https://tc39.es/ecma262/#sec-createhtml
+var createHtml = function (string, tag, attribute, value) {
+  var S = toString(requireObjectCoercible(string));
+  var p1 = '<' + tag;
+  if (attribute !== '') p1 += ' ' + attribute + '="' + replace$3(toString(value), quot, '&quot;') + '"';
+  return p1 + '>' + S + '</' + tag + '>';
+};
+
+// check the existence of a method, lowercase
+// of a tag and escaping quotes in arguments
+var stringHtmlForced = function (METHOD_NAME) {
+  return fails(function () {
+    var test = ''[METHOD_NAME]('"');
+    return test !== test.toLowerCase() || test.split('"').length > 3;
+  });
+};
+
+// `String.prototype.anchor` method
+// https://tc39.es/ecma262/#sec-string.prototype.anchor
+_export({ target: 'String', proto: true, forced: stringHtmlForced('anchor') }, {
+  anchor: function anchor(name) {
+    return createHtml(this, 'a', 'name', name);
+  }
+});
+
+// `RegExp.prototype.flags` getter implementation
+// https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
+var regexpFlags = function () {
+  var that = anObject(this);
+  var result = '';
+  if (that.global) result += 'g';
+  if (that.ignoreCase) result += 'i';
+  if (that.multiline) result += 'm';
+  if (that.dotAll) result += 's';
+  if (that.unicode) result += 'u';
+  if (that.sticky) result += 'y';
+  return result;
+};
+
+// babel-minify and Closure Compiler transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError
+var $RegExp$2 = global$1.RegExp;
+
+var UNSUPPORTED_Y$2 = fails(function () {
+  var re = $RegExp$2('a', 'y');
+  re.lastIndex = 2;
+  return re.exec('abcd') != null;
+});
+
+// UC Browser bug
+// https://github.com/zloirock/core-js/issues/1008
+var MISSED_STICKY = UNSUPPORTED_Y$2 || fails(function () {
+  return !$RegExp$2('a', 'y').sticky;
+});
+
+var BROKEN_CARET = UNSUPPORTED_Y$2 || fails(function () {
+  // https://bugzilla.mozilla.org/show_bug.cgi?id=773687
+  var re = $RegExp$2('^r', 'gy');
+  re.lastIndex = 2;
+  return re.exec('str') != null;
+});
+
+var regexpStickyHelpers = {
+  BROKEN_CARET: BROKEN_CARET,
+  MISSED_STICKY: MISSED_STICKY,
+  UNSUPPORTED_Y: UNSUPPORTED_Y$2
+};
+
+// `Object.keys` method
+// https://tc39.es/ecma262/#sec-object.keys
+// eslint-disable-next-line es/no-object-keys -- safe
+var objectKeys = Object.keys || function keys(O) {
+  return objectKeysInternal(O, enumBugKeys);
+};
+
+// `Object.defineProperties` method
+// https://tc39.es/ecma262/#sec-object.defineproperties
+// eslint-disable-next-line es/no-object-defineproperties -- safe
+var objectDefineProperties = descriptors ? Object.defineProperties : function defineProperties(O, Properties) {
+  anObject(O);
+  var props = toIndexedObject(Properties);
+  var keys = objectKeys(Properties);
+  var length = keys.length;
+  var index = 0;
+  var key;
+  while (length > index) objectDefineProperty.f(O, key = keys[index++], props[key]);
+  return O;
+};
+
+var html = getBuiltIn('document', 'documentElement');
+
+/* global ActiveXObject -- old IE, WSH */
+
+var GT = '>';
+var LT = '<';
+var PROTOTYPE = 'prototype';
+var SCRIPT = 'script';
+var IE_PROTO = sharedKey('IE_PROTO');
+
+var EmptyConstructor = function () { /* empty */ };
+
+var scriptTag = function (content) {
+  return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
+};
+
+// Create object with fake `null` prototype: use ActiveX Object with cleared prototype
+var NullProtoObjectViaActiveX = function (activeXDocument) {
+  activeXDocument.write(scriptTag(''));
+  activeXDocument.close();
+  var temp = activeXDocument.parentWindow.Object;
+  activeXDocument = null; // avoid memory leak
+  return temp;
+};
+
+// Create object with fake `null` prototype: use iframe Object with cleared prototype
+var NullProtoObjectViaIFrame = function () {
+  // Thrash, waste and sodomy: IE GC bug
+  var iframe = documentCreateElement('iframe');
+  var JS = 'java' + SCRIPT + ':';
+  var iframeDocument;
+  iframe.style.display = 'none';
+  html.appendChild(iframe);
+  // https://github.com/zloirock/core-js/issues/475
+  iframe.src = String(JS);
+  iframeDocument = iframe.contentWindow.document;
+  iframeDocument.open();
+  iframeDocument.write(scriptTag('document.F=Object'));
+  iframeDocument.close();
+  return iframeDocument.F;
+};
+
+// Check for document.domain and active x support
+// No need to use active x approach when document.domain is not set
+// see https://github.com/es-shims/es5-shim/issues/150
+// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
+// avoid IE GC bug
+var activeXDocument;
+var NullProtoObject = function () {
+  try {
+    activeXDocument = new ActiveXObject('htmlfile');
+  } catch (error) { /* ignore */ }
+  NullProtoObject = typeof document != 'undefined'
+    ? document.domain && activeXDocument
+      ? NullProtoObjectViaActiveX(activeXDocument) // old IE
+      : NullProtoObjectViaIFrame()
+    : NullProtoObjectViaActiveX(activeXDocument); // WSH
+  var length = enumBugKeys.length;
+  while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
+  return NullProtoObject();
+};
+
+hiddenKeys$1[IE_PROTO] = true;
+
+// `Object.create` method
+// https://tc39.es/ecma262/#sec-object.create
+var objectCreate = Object.create || function create(O, Properties) {
+  var result;
+  if (O !== null) {
+    EmptyConstructor[PROTOTYPE] = anObject(O);
+    result = new EmptyConstructor();
+    EmptyConstructor[PROTOTYPE] = null;
+    // add "__proto__" for Object.getPrototypeOf polyfill
+    result[IE_PROTO] = O;
+  } else result = NullProtoObject();
+  return Properties === undefined ? result : objectDefineProperties(result, Properties);
+};
+
+// babel-minify and Closure Compiler transpiles RegExp('.', 's') -> /./s and it causes SyntaxError
+var $RegExp$1 = global$1.RegExp;
+
+var regexpUnsupportedDotAll = fails(function () {
+  var re = $RegExp$1('.', 's');
+  return !(re.dotAll && re.exec('\n') && re.flags === 's');
+});
+
+// babel-minify and Closure Compiler transpiles RegExp('(?<a>b)', 'g') -> /(?<a>b)/g and it causes SyntaxError
+var $RegExp = global$1.RegExp;
+
+var regexpUnsupportedNcg = fails(function () {
+  var re = $RegExp('(?<a>b)', 'g');
+  return re.exec('b').groups.a !== 'b' ||
+    'b'.replace(re, '$<a>c') !== 'bc';
+});
+
+/* eslint-disable regexp/no-empty-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */
+/* eslint-disable regexp/no-useless-quantifier -- testing */
+
+
+
+
+
+
+
+var getInternalState = internalState.get;
+
+
+
+var nativeReplace = shared('native-string-replace', String.prototype.replace);
+var nativeExec = RegExp.prototype.exec;
+var patchedExec = nativeExec;
+var charAt$3 = functionUncurryThis(''.charAt);
+var indexOf = functionUncurryThis(''.indexOf);
+var replace$2 = functionUncurryThis(''.replace);
+var stringSlice$4 = functionUncurryThis(''.slice);
+
+var UPDATES_LAST_INDEX_WRONG = (function () {
+  var re1 = /a/;
+  var re2 = /b*/g;
+  functionCall(nativeExec, re1, 'a');
+  functionCall(nativeExec, re2, 'a');
+  return re1.lastIndex !== 0 || re2.lastIndex !== 0;
+})();
+
+var UNSUPPORTED_Y$1 = regexpStickyHelpers.BROKEN_CARET;
+
+// nonparticipating capturing group, copied from es5-shim's String#split patch.
+var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined;
+
+var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y$1 || regexpUnsupportedDotAll || regexpUnsupportedNcg;
+
+if (PATCH) {
+  patchedExec = function exec(string) {
+    var re = this;
+    var state = getInternalState(re);
+    var str = toString(string);
+    var raw = state.raw;
+    var result, reCopy, lastIndex, match, i, object, group;
+
+    if (raw) {
+      raw.lastIndex = re.lastIndex;
+      result = functionCall(patchedExec, raw, str);
+      re.lastIndex = raw.lastIndex;
+      return result;
+    }
+
+    var groups = state.groups;
+    var sticky = UNSUPPORTED_Y$1 && re.sticky;
+    var flags = functionCall(regexpFlags, re);
+    var source = re.source;
+    var charsAdded = 0;
+    var strCopy = str;
+
+    if (sticky) {
+      flags = replace$2(flags, 'y', '');
+      if (indexOf(flags, 'g') === -1) {
+        flags += 'g';
+      }
+
+      strCopy = stringSlice$4(str, re.lastIndex);
+      // Support anchored sticky behavior.
+      if (re.lastIndex > 0 && (!re.multiline || re.multiline && charAt$3(str, re.lastIndex - 1) !== '\n')) {
+        source = '(?: ' + source + ')';
+        strCopy = ' ' + strCopy;
+        charsAdded++;
+      }
+      // ^(? + rx + ) is needed, in combination with some str slicing, to
+      // simulate the 'y' flag.
+      reCopy = new RegExp('^(?:' + source + ')', flags);
+    }
+
+    if (NPCG_INCLUDED) {
+      reCopy = new RegExp('^' + source + '$(?!\\s)', flags);
+    }
+    if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex;
+
+    match = functionCall(nativeExec, sticky ? reCopy : re, strCopy);
+
+    if (sticky) {
+      if (match) {
+        match.input = stringSlice$4(match.input, charsAdded);
+        match[0] = stringSlice$4(match[0], charsAdded);
+        match.index = re.lastIndex;
+        re.lastIndex += match[0].length;
+      } else re.lastIndex = 0;
+    } else if (UPDATES_LAST_INDEX_WRONG && match) {
+      re.lastIndex = re.global ? match.index + match[0].length : lastIndex;
+    }
+    if (NPCG_INCLUDED && match && match.length > 1) {
+      // Fix browsers whose `exec` methods don't consistently return `undefined`
+      // for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/
+      functionCall(nativeReplace, match[0], reCopy, function () {
+        for (i = 1; i < arguments.length - 2; i++) {
+          if (arguments[i] === undefined) match[i] = undefined;
+        }
+      });
+    }
+
+    if (match && groups) {
+      match.groups = object = objectCreate(null);
+      for (i = 0; i < groups.length; i++) {
+        group = groups[i];
+        object[group[0]] = match[group[1]];
+      }
+    }
+
+    return match;
+  };
+}
+
+var regexpExec = patchedExec;
+
+// `RegExp.prototype.exec` method
+// https://tc39.es/ecma262/#sec-regexp.prototype.exec
+_export({ target: 'RegExp', proto: true, forced: /./.exec !== regexpExec }, {
+  exec: regexpExec
+});
+
+// `IsArray` abstract operation
+// https://tc39.es/ecma262/#sec-isarray
+// eslint-disable-next-line es/no-array-isarray -- safe
+var isArray = Array.isArray || function isArray(argument) {
+  return classofRaw(argument) == 'Array';
+};
+
+var noop = function () { /* empty */ };
+var empty = [];
+var construct = getBuiltIn('Reflect', 'construct');
+var constructorRegExp = /^\s*(?:class|function)\b/;
+var exec$1 = functionUncurryThis(constructorRegExp.exec);
+var INCORRECT_TO_STRING = !constructorRegExp.exec(noop);
+
+var isConstructorModern = function (argument) {
+  if (!isCallable(argument)) return false;
+  try {
+    construct(noop, empty, argument);
+    return true;
+  } catch (error) {
+    return false;
+  }
+};
+
+var isConstructorLegacy = function (argument) {
+  if (!isCallable(argument)) return false;
+  switch (classof(argument)) {
+    case 'AsyncFunction':
+    case 'GeneratorFunction':
+    case 'AsyncGeneratorFunction': return false;
+    // we can't check .prototype since constructors produced by .bind haven't it
+  } return INCORRECT_TO_STRING || !!exec$1(constructorRegExp, inspectSource(argument));
+};
+
+// `IsConstructor` abstract operation
+// https://tc39.es/ecma262/#sec-isconstructor
+var isConstructor = !construct || fails(function () {
+  var called;
+  return isConstructorModern(isConstructorModern.call)
+    || !isConstructorModern(Object)
+    || !isConstructorModern(function () { called = true; })
+    || called;
+}) ? isConstructorLegacy : isConstructorModern;
+
+var createProperty = function (object, key, value) {
+  var propertyKey = toPropertyKey(key);
+  if (propertyKey in object) objectDefineProperty.f(object, propertyKey, createPropertyDescriptor(0, value));
+  else object[propertyKey] = value;
+};
+
+var SPECIES$4 = wellKnownSymbol('species');
+
+var arrayMethodHasSpeciesSupport = function (METHOD_NAME) {
+  // We can't use this feature detection in V8 since it causes
+  // deoptimization and serious performance degradation
+  // https://github.com/zloirock/core-js/issues/677
+  return engineV8Version >= 51 || !fails(function () {
+    var array = [];
+    var constructor = array.constructor = {};
+    constructor[SPECIES$4] = function () {
+      return { foo: 1 };
+    };
+    return array[METHOD_NAME](Boolean).foo !== 1;
+  });
+};
+
+var arraySlice = functionUncurryThis([].slice);
+
+var HAS_SPECIES_SUPPORT$2 = arrayMethodHasSpeciesSupport('slice');
+
+var SPECIES$3 = wellKnownSymbol('species');
+var Array$3 = global$1.Array;
+var max$2 = Math.max;
+
+// `Array.prototype.slice` method
+// https://tc39.es/ecma262/#sec-array.prototype.slice
+// fallback for not array-like ES3 strings and DOM objects
+_export({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT$2 }, {
+  slice: function slice(start, end) {
+    var O = toIndexedObject(this);
+    var length = lengthOfArrayLike(O);
+    var k = toAbsoluteIndex(start, length);
+    var fin = toAbsoluteIndex(end === undefined ? length : end, length);
+    // inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible
+    var Constructor, result, n;
+    if (isArray(O)) {
+      Constructor = O.constructor;
+      // cross-realm fallback
+      if (isConstructor(Constructor) && (Constructor === Array$3 || isArray(Constructor.prototype))) {
+        Constructor = undefined;
+      } else if (isObject(Constructor)) {
+        Constructor = Constructor[SPECIES$3];
+        if (Constructor === null) Constructor = undefined;
+      }
+      if (Constructor === Array$3 || Constructor === undefined) {
+        return arraySlice(O, k, fin);
+      }
+    }
+    result = new (Constructor === undefined ? Array$3 : Constructor)(max$2(fin - k, 0));
+    for (n = 0; k < fin; k++, n++) if (k in O) createProperty(result, n, O[k]);
+    result.length = n;
+    return result;
+  }
+});
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+}
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+function deleteHandler(newEditor) {
+  var selection = newEditor.selection;
+  if (selection == null) return false;
+  var _a = __read(Editor.nodes(newEditor, {
+    match: function match(n) {
+      return DomEditor.checkNodeType(n, 'table-cell');
+    }
+  }), 1),
+      cellNodeEntry = _a[0];
+  if (cellNodeEntry) {
+    var _b = __read(cellNodeEntry, 2),
+        cellPath = _b[1];
+    var start = Editor.start(newEditor, cellPath);
+    if (Point.equals(selection.anchor, start)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isTableLocation(editor, location) {
+  var e_1, _a;
+  var tables = Editor.nodes(editor, {
+    at: location,
+    match: function match(n) {
+      var type = DomEditor.getNodeType(n);
+      return type === 'table';
+    }
+  });
+  var hasTable = false;
+  try {
+    for (var tables_1 = __values(tables), tables_1_1 = tables_1.next(); !tables_1_1.done; tables_1_1 = tables_1.next()) {
+      var table = tables_1_1.value;
+      hasTable = true;
+    }
+  } catch (e_1_1) {
+    e_1 = {
+      error: e_1_1
+    };
+  } finally {
+    try {
+      if (tables_1_1 && !tables_1_1.done && (_a = tables_1.return)) _a.call(tables_1);
+    } finally {
+      if (e_1) throw e_1.error;
+    }
+  }
+  return hasTable;
+}
+function withTable(editor) {
+  var insertBreak = editor.insertBreak,
+      deleteBackward = editor.deleteBackward,
+      deleteForward = editor.deleteForward,
+      normalizeNode = editor.normalizeNode,
+      insertData = editor.insertData,
+      handleTab = editor.handleTab,
+      selectAll = editor.selectAll;
+  var newEditor = editor;
+  newEditor.insertBreak = function () {
+    var selectedNode = DomEditor.getSelectedNodeByType(newEditor, 'table');
+    if (selectedNode != null) {
+      newEditor.insertText('\n');
+      return;
+    }
+    insertBreak();
+  };
+  newEditor.deleteBackward = function (unit) {
+    var res = deleteHandler(newEditor);
+    if (res) return;
+    var selection = newEditor.selection;
+    if (selection) {
+      var before = Editor.before(newEditor, selection);
+      if (before) {
+        var isTableOnBeforeLocation = isTableLocation(newEditor, before);
+        var isTableOnCurSelection = isTableLocation(newEditor, selection);
+        if (isTableOnBeforeLocation && !isTableOnCurSelection) {
+          return;
+        }
+      }
+    }
+    deleteBackward(unit);
+  };
+  newEditor.handleTab = function () {
+    var _a;
+    var selectedNode = DomEditor.getSelectedNodeByType(newEditor, 'table');
+    if (selectedNode) {
+      var above = Editor.above(editor);
+      if (DomEditor.checkNodeType(above[0], 'table-cell')) {
+        Transforms.select(editor, above[1]);
+      }
+      var next = Editor.next(editor);
+      if (next) {
+        if (next[0] && next[0].text) {
+          next = (_a = Editor.above(editor, {
+            at: next[1]
+          })) !== null && _a !== void 0 ? _a : next;
+        }
+        Transforms.select(editor, next[1]);
+      } else {
+        var topLevelNodes = newEditor.children || [];
+        var topLevelNodesLength = topLevelNodes.length;
+        if (DomEditor.checkNodeType(topLevelNodes[topLevelNodesLength - 1], 'table')) {
+          var p = DomEditor.genEmptyParagraph();
+          Transforms.insertNodes(newEditor, p, {
+            at: [topLevelNodesLength]
+          });
+          newEditor.handleTab();
+        }
+      }
+      return;
+    }
+    handleTab();
+  };
+  newEditor.deleteForward = function (unit) {
+    var res = deleteHandler(newEditor);
+    if (res) return;
+    deleteForward(unit);
+  };
+  newEditor.normalizeNode = function (_a) {
+    var _b = __read(_a, 2),
+        node = _b[0],
+        path = _b[1];
+    var type = DomEditor.getNodeType(node);
+    if (type !== 'table') {
+      return normalizeNode([node, path]);
+    }
+    var isLast = DomEditor.isLastNode(newEditor, node);
+    if (isLast) {
+      var p = DomEditor.genEmptyParagraph();
+      Transforms.insertNodes(newEditor, p, {
+        at: [path[0] + 1]
+      });
+    }
+  };
+  newEditor.insertData = function (data) {
+    var tableNode = DomEditor.getSelectedNodeByType(newEditor, 'table');
+    if (tableNode == null) {
+      insertData(data);
+      return;
+    }
+    var text = data.getData('text/plain');
+    if (text === '\n' || /<img[^>]+>/.test(data.getData('text/html'))) {
+      insertData(data);
+      return;
+    }
+    Editor.insertText(newEditor, text);
+  };
+  newEditor.selectAll = function () {
+    var selection = newEditor.selection;
+    if (selection == null) {
+      selectAll();
+      return;
+    }
+    var cell = DomEditor.getSelectedNodeByType(newEditor, 'table-cell');
+    if (cell == null) {
+      selectAll();
+      return;
+    }
+    var anchor = selection.anchor,
+        focus = selection.focus;
+    if (!Path.equals(anchor.path.slice(0, 3), focus.path.slice(0, 3))) {
+      selectAll();
+      return;
+    }
+    var text = Node.string(cell);
+    var textLength = text.length;
+    if (textLength === 0) {
+      selectAll();
+      return;
+    }
+    var path = DomEditor.findPath(newEditor, cell);
+    var start = Editor.start(newEditor, path);
+    var end = Editor.end(newEditor, path);
+    var newSelection = {
+      anchor: start,
+      focus: end
+    };
+    newEditor.select(newSelection);
+  };
+  return newEditor;
+}
+
+var arrayMethodIsStrict = function (METHOD_NAME, argument) {
+  var method = [][METHOD_NAME];
+  return !!method && fails(function () {
+    // eslint-disable-next-line no-useless-call,no-throw-literal -- required for testing
+    method.call(null, argument || function () { throw 1; }, 1);
+  });
+};
+
+var un$Join = functionUncurryThis([].join);
+
+var ES3_STRINGS = indexedObject != Object;
+var STRICT_METHOD$1 = arrayMethodIsStrict('join', ',');
+
+// `Array.prototype.join` method
+// https://tc39.es/ecma262/#sec-array.prototype.join
+_export({ target: 'Array', proto: true, forced: ES3_STRINGS || !STRICT_METHOD$1 }, {
+  join: function join(separator) {
+    return un$Join(toIndexedObject(this), separator === undefined ? ',' : separator);
+  }
+});
+
+var bind$1 = functionUncurryThis(functionUncurryThis.bind);
+
+// optional / simple context binding
+var functionBindContext = function (fn, that) {
+  aCallable(fn);
+  return that === undefined ? fn : bind$1 ? bind$1(fn, that) : function (/* ...args */) {
+    return fn.apply(that, arguments);
+  };
+};
+
+var SPECIES$2 = wellKnownSymbol('species');
+var Array$2 = global$1.Array;
+
+// a part of `ArraySpeciesCreate` abstract operation
+// https://tc39.es/ecma262/#sec-arrayspeciescreate
+var arraySpeciesConstructor = function (originalArray) {
+  var C;
+  if (isArray(originalArray)) {
+    C = originalArray.constructor;
+    // cross-realm fallback
+    if (isConstructor(C) && (C === Array$2 || isArray(C.prototype))) C = undefined;
+    else if (isObject(C)) {
+      C = C[SPECIES$2];
+      if (C === null) C = undefined;
+    }
+  } return C === undefined ? Array$2 : C;
+};
+
+// `ArraySpeciesCreate` abstract operation
+// https://tc39.es/ecma262/#sec-arrayspeciescreate
+var arraySpeciesCreate = function (originalArray, length) {
+  return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);
+};
+
+var push$2 = functionUncurryThis([].push);
+
+// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation
+var createMethod$2 = function (TYPE) {
+  var IS_MAP = TYPE == 1;
+  var IS_FILTER = TYPE == 2;
+  var IS_SOME = TYPE == 3;
+  var IS_EVERY = TYPE == 4;
+  var IS_FIND_INDEX = TYPE == 6;
+  var IS_FILTER_REJECT = TYPE == 7;
+  var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
+  return function ($this, callbackfn, that, specificCreate) {
+    var O = toObject($this);
+    var self = indexedObject(O);
+    var boundFunction = functionBindContext(callbackfn, that);
+    var length = lengthOfArrayLike(self);
+    var index = 0;
+    var create = specificCreate || arraySpeciesCreate;
+    var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;
+    var value, result;
+    for (;length > index; index++) if (NO_HOLES || index in self) {
+      value = self[index];
+      result = boundFunction(value, index, O);
+      if (TYPE) {
+        if (IS_MAP) target[index] = result; // map
+        else if (result) switch (TYPE) {
+          case 3: return true;              // some
+          case 5: return value;             // find
+          case 6: return index;             // findIndex
+          case 2: push$2(target, value);      // filter
+        } else switch (TYPE) {
+          case 4: return false;             // every
+          case 7: push$2(target, value);      // filterReject
+        }
+      }
+    }
+    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;
+  };
+};
+
+var arrayIteration = {
+  // `Array.prototype.forEach` method
+  // https://tc39.es/ecma262/#sec-array.prototype.foreach
+  forEach: createMethod$2(0),
+  // `Array.prototype.map` method
+  // https://tc39.es/ecma262/#sec-array.prototype.map
+  map: createMethod$2(1),
+  // `Array.prototype.filter` method
+  // https://tc39.es/ecma262/#sec-array.prototype.filter
+  filter: createMethod$2(2),
+  // `Array.prototype.some` method
+  // https://tc39.es/ecma262/#sec-array.prototype.some
+  some: createMethod$2(3),
+  // `Array.prototype.every` method
+  // https://tc39.es/ecma262/#sec-array.prototype.every
+  every: createMethod$2(4),
+  // `Array.prototype.find` method
+  // https://tc39.es/ecma262/#sec-array.prototype.find
+  find: createMethod$2(5),
+  // `Array.prototype.findIndex` method
+  // https://tc39.es/ecma262/#sec-array.prototype.findIndex
+  findIndex: createMethod$2(6),
+  // `Array.prototype.filterReject` method
+  // https://github.com/tc39/proposal-array-filtering
+  filterReject: createMethod$2(7)
+};
+
+var $filter = arrayIteration.filter;
+
+
+var HAS_SPECIES_SUPPORT$1 = arrayMethodHasSpeciesSupport('filter');
+
+// `Array.prototype.filter` method
+// https://tc39.es/ecma262/#sec-array.prototype.filter
+// with adding support of @@species
+_export({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT$1 }, {
+  filter: function filter(callbackfn /* , thisArg */) {
+    return $filter(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
+  }
+});
+
+// `Object.prototype.toString` method implementation
+// https://tc39.es/ecma262/#sec-object.prototype.tostring
+var objectToString = toStringTagSupport ? {}.toString : function toString() {
+  return '[object ' + classof(this) + ']';
+};
+
+// `Object.prototype.toString` method
+// https://tc39.es/ecma262/#sec-object.prototype.tostring
+if (!toStringTagSupport) {
+  redefine(Object.prototype, 'toString', objectToString, { unsafe: true });
+}
+
+var $map = arrayIteration.map;
+
+
+var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('map');
+
+// `Array.prototype.map` method
+// https://tc39.es/ecma262/#sec-array.prototype.map
+// with adding support of @@species
+_export({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {
+  map: function map(callbackfn /* , thisArg */) {
+    return $map(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
+  }
+});
+
+function getFirstRowCells(tableNode) {
+  var rows = tableNode.children || [];
+  if (rows.length === 0) return [];
+  var firstRow = rows[0] || {};
+  var cells = firstRow.children || [];
+  return cells;
+}
+function isTableWithHeader(tableNode) {
+  var firstRowCells = getFirstRowCells(tableNode);
+  return firstRowCells.every(function (cell) {
+    return !!cell.isHeader;
+  });
+}
+function isCellInFirstRow(editor, cellNode) {
+  var rowNode = DomEditor.getParentNode(editor, cellNode);
+  if (rowNode == null) return false;
+  var tableNode = DomEditor.getParentNode(editor, rowNode);
+  if (tableNode == null) return false;
+  var firstRowCells = getFirstRowCells(tableNode);
+  return firstRowCells.some(function (c) {
+    return c === cellNode;
+  });
+}
+
+var TABLE_SVG = '<svg viewBox="0 0 1024 1024"><path d="M0 64v896h1024V64H0z m384 576v-192h256v192h-256z m256 64v192h-256v-192h256z m0-512v192h-256V192h256zM320 192v192H64V192h256z m-256 256h256v192H64v-192z m640 0h256v192h-256v-192z m0-64V192h256v192h-256zM64 704h256v192H64v-192z m640 192v-192h256v192h-256z"></path></svg>';
+var TRASH_SVG = '<svg viewBox="0 0 1024 1024"><path d="M826.8032 356.5312c-19.328 0-36.3776 15.6928-36.3776 35.0464v524.2624c0 19.328-16 34.56-35.328 34.56H264.9344c-19.328 0-35.5072-15.3088-35.5072-34.56V390.0416c0-19.328-14.1568-35.0464-33.5104-35.0464s-33.5104 15.6928-33.5104 35.0464V915.712c0 57.9328 44.6208 108.288 102.528 108.288H755.2c57.9328 0 108.0832-50.4576 108.0832-108.288V391.4752c-0.1024-19.2512-17.1264-34.944-36.48-34.944z" p-id="9577"></path><path d="M437.1712 775.7568V390.6048c0-19.328-14.1568-35.0464-33.5104-35.0464s-33.5104 15.616-33.5104 35.0464v385.152c0 19.328 14.1568 35.0464 33.5104 35.0464s33.5104-15.7184 33.5104-35.0464zM649.7024 775.7568V390.6048c0-19.328-17.0496-35.0464-36.3776-35.0464s-36.3776 15.616-36.3776 35.0464v385.152c0 19.328 17.0496 35.0464 36.3776 35.0464s36.3776-15.7184 36.3776-35.0464zM965.0432 217.0368h-174.6176V145.5104c0-57.9328-47.2064-101.76-104.6528-101.76h-350.976c-57.8304 0-105.3952 43.8528-105.3952 101.76v71.5264H54.784c-19.4304 0-35.0464 14.1568-35.0464 33.5104 0 19.328 15.616 33.5104 35.0464 33.5104h910.3616c19.328 0 35.0464-14.1568 35.0464-33.5104 0-19.3536-15.6928-33.5104-35.1488-33.5104z m-247.3728 0H297.3952V145.5104c0-19.328 18.2016-34.7648 37.4272-34.7648h350.976c19.1488 0 31.872 15.1296 31.872 34.7648v71.5264z"></path></svg>';
+var ADD_ROW_SVG = '<svg viewBox="0 0 1048 1024"><path d="M707.7888 521.0112h-147.456v-147.456H488.2432v147.456h-147.456v68.8128h147.456v147.456h72.0896v-147.456h147.456zM0 917.504V0h1048.576v917.504H0zM327.68 65.536H65.536v196.608H327.68V65.536z m327.68 0H393.216v196.608h262.144V65.536z m327.68 0h-262.144v196.608h262.144V65.536z m0 258.8672H65.536v462.0288H983.04V324.4032z"></path></svg>';
+var DEL_ROW_SVG = '<svg viewBox="0 0 1048 1024"><path d="M907.6736 586.5472L747.1104 425.984l163.84-163.84-78.6432-78.6432-163.84 163.84L507.904 186.7776 429.2608 262.144l163.84 163.84-167.1168 167.1168 78.6432 78.6432 167.1168-167.1168 160.5632 160.5632 75.3664-78.6432zM0 917.504V0h1048.576v917.504H0z m983.04-327.68h-22.9376l-65.536-65.536H983.04V327.68h-91.7504l65.536-65.536h26.2144V65.536H65.536v196.608h317.8496l65.536 65.536H65.536v196.608h380.1088l-65.536 65.536H65.536v196.608H983.04v-196.608z"></path></svg>';
+var ADD_COL_SVG = '<svg viewBox="0 0 1048 1024"><path d="M327.68 193.3312v186.7776H140.9024v91.7504H327.68v186.7776h88.4736V471.8592h190.0544V380.1088H416.1536V193.3312zM0 917.504V0h1048.576v917.504H0zM655.36 65.536H65.536v720.896H655.36V65.536z m327.68 0h-262.144v196.608h262.144V65.536z m0 262.144h-262.144v196.608h262.144V327.68z m0 262.144h-262.144v196.608h262.144v-196.608z"></path></svg>';
+var DEL_COL_SVG = '<svg viewBox="0 0 1048 1024"><path d="M327.68 510.976L393.216 445.44v-13.1072L327.68 366.7968V510.976z m327.68-78.4384l65.536-65.536V507.904L655.36 442.368v-9.8304z m393.216 484.9664V0H0v917.504h1048.576z m-65.536-131.072h-262.144v-52.4288l-13.1072 13.1072-52.4288-52.4288v91.7504H393.216v-91.7504l-52.4288 52.4288-13.1072-13.1072v52.4288H65.536V65.536H327.68v121.2416l36.0448-36.0448 29.4912 29.4912V62.2592h262.144V180.224l49.152-49.152 16.384 16.384V62.2592h262.144V786.432z m-294.912-108.1344l-160.5632-160.5632-167.1168 167.1168-78.6432-78.6432 167.1168-167.1168L288.3584 278.528l78.6432-78.6432 160.5632 160.5632 163.84-163.84 78.6432 78.6432-163.84 163.84 160.5632 160.5632-78.6432 78.6432z"></path></svg>';
+var TABLE_HEADER_SVG = '<svg viewBox="0 0 1024 1024"><path d="M704 128l-64 0L384 128 320 128 0 128l0 256 0 64 0 192 0 64 0 256 320 0 64 0 256 0 64 0 320 0 0-256 0-64L1024 448 1024 384 1024 128 704 128zM640 640 384 640 384 448l256 0L640 640zM64 448l256 0 0 192L64 640 64 448zM320 896 64 896l0-192 256 0L320 896zM640 896 384 896l0-192 256 0L640 896zM960 896l-256 0 0-192 256 0L960 896zM960 640l-256 0L704 448l256 0L960 640z"></path></svg>';
+var FULL_WIDTH_SVG = '<svg viewBox="0 0 1228 1024"><path d="M862.514337 563.200461H404.581995v121.753478a13.311987 13.311987 0 0 1-6.655993 11.468789 10.23999 10.23999 0 0 1-12.083188-1.433599l-204.799795-179.199821a13.721586 13.721586 0 0 1 0-20.479979l204.799795-179.302221a10.23999 10.23999 0 0 1 12.185588-1.535998 13.209587 13.209587 0 0 1 6.553593 11.673588v115.097485h457.932342V319.693504a11.571188 11.571188 0 0 1 18.841582-10.239989l204.799795 179.19982a13.721586 13.721586 0 0 1 0 20.47998l-204.799795 179.199821a10.23999 10.23999 0 0 1-12.185588 1.535998 13.311987 13.311987 0 0 1-6.655994-11.571188V563.200461zM136.499064 14.951409v993.893406a15.257585 15.257585 0 0 1-15.155185 15.052785H15.155185A15.155185 15.155185 0 0 1 0 1008.844815V14.951409a15.257585 15.257585 0 0 1 15.155185-15.052785h106.086294a15.155185 15.155185 0 0 1 15.257585 15.155185zM1228.798771 14.951409v993.893406a15.257585 15.257585 0 0 1-15.155185 15.052785h-106.188693a15.155185 15.155185 0 0 1-15.155185-15.052785V14.951409a15.257585 15.257585 0 0 1 15.155185-15.052785h106.086293A15.155185 15.155185 0 0 1 1228.798771 15.053809z"></path></svg>';
+
+var InsertRow =
+function () {
+  function InsertRow() {
+    this.title = t('tableModule.insertRow');
+    this.iconSvg = ADD_ROW_SVG;
+    this.tag = 'button';
+  }
+  InsertRow.prototype.getValue = function (editor) {
+    return '';
+  };
+  InsertRow.prototype.isActive = function (editor) {
+    return false;
+  };
+  InsertRow.prototype.isDisabled = function (editor) {
+    var selection = editor.selection;
+    if (selection == null) return true;
+    if (!Range.isCollapsed(selection)) return true;
+    var tableNode = DomEditor.getSelectedNodeByType(editor, 'table');
+    if (tableNode == null) {
+      return true;
+    }
+    return false;
+  };
+  InsertRow.prototype.exec = function (editor, value) {
+    if (this.isDisabled(editor)) return;
+    var _a = __read(Editor.nodes(editor, {
+      match: function match(n) {
+        return DomEditor.checkNodeType(n, 'table-cell');
+      },
+      universal: true
+    }), 1),
+        cellEntry = _a[0];
+    var _b = __read(cellEntry, 2),
+        cellNode = _b[0],
+        cellPath = _b[1];
+    var rowNode = DomEditor.getParentNode(editor, cellNode);
+    var cellsLength = (rowNode === null || rowNode === void 0 ? void 0 : rowNode.children.length) || 0;
+    if (cellsLength === 0) return;
+    var newRow = {
+      type: 'table-row',
+      children: []
+    };
+    for (var i = 0; i < cellsLength; i++) {
+      var cell = {
+        type: 'table-cell',
+        children: [{
+          text: ''
+        }]
+      };
+      newRow.children.push(cell);
+    }
+    var rowPath = Path.parent(cellPath);
+    var newRowPath = Path.next(rowPath);
+    Transforms.insertNodes(editor, newRow, {
+      at: newRowPath
+    });
+  };
+  return InsertRow;
+}();
+
+var DeleteRow =
+function () {
+  function DeleteRow() {
+    this.title = t('tableModule.deleteRow');
+    this.iconSvg = DEL_ROW_SVG;
+    this.tag = 'button';
+  }
+  DeleteRow.prototype.getValue = function (editor) {
+    return '';
+  };
+  DeleteRow.prototype.isActive = function (editor) {
+    return false;
+  };
+  DeleteRow.prototype.isDisabled = function (editor) {
+    var selection = editor.selection;
+    if (selection == null) return true;
+    if (!Range.isCollapsed(selection)) return true;
+    var rowNode = DomEditor.getSelectedNodeByType(editor, 'table-row');
+    if (rowNode == null) {
+      return true;
+    }
+    return false;
+  };
+  DeleteRow.prototype.exec = function (editor, value) {
+    if (this.isDisabled(editor)) return;
+    var _a = __read(Editor.nodes(editor, {
+      match: function match(n) {
+        return DomEditor.checkNodeType(n, 'table-row');
+      },
+      universal: true
+    }), 1),
+        rowEntry = _a[0];
+    var _b = __read(rowEntry, 2),
+        rowNode = _b[0],
+        rowPath = _b[1];
+    var tableNode = DomEditor.getParentNode(editor, rowNode);
+    var rowsLength = (tableNode === null || tableNode === void 0 ? void 0 : tableNode.children.length) || 0;
+    if (rowsLength <= 1) {
+      Transforms.removeNodes(editor, {
+        mode: 'highest'
+      });
+      return;
+    }
+    Transforms.removeNodes(editor, {
+      at: rowPath
+    });
+  };
+  return DeleteRow;
+}();
+
+// iterable DOM collections
+// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods
+var domIterables = {
+  CSSRuleList: 0,
+  CSSStyleDeclaration: 0,
+  CSSValueList: 0,
+  ClientRectList: 0,
+  DOMRectList: 0,
+  DOMStringList: 0,
+  DOMTokenList: 1,
+  DataTransferItemList: 0,
+  FileList: 0,
+  HTMLAllCollection: 0,
+  HTMLCollection: 0,
+  HTMLFormElement: 0,
+  HTMLSelectElement: 0,
+  MediaList: 0,
+  MimeTypeArray: 0,
+  NamedNodeMap: 0,
+  NodeList: 1,
+  PaintRequestList: 0,
+  Plugin: 0,
+  PluginArray: 0,
+  SVGLengthList: 0,
+  SVGNumberList: 0,
+  SVGPathSegList: 0,
+  SVGPointList: 0,
+  SVGStringList: 0,
+  SVGTransformList: 0,
+  SourceBufferList: 0,
+  StyleSheetList: 0,
+  TextTrackCueList: 0,
+  TextTrackList: 0,
+  TouchList: 0
+};
+
+// in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList`
+
+
+var classList = documentCreateElement('span').classList;
+var DOMTokenListPrototype = classList && classList.constructor && classList.constructor.prototype;
+
+var domTokenListPrototype = DOMTokenListPrototype === Object.prototype ? undefined : DOMTokenListPrototype;
+
+var $forEach = arrayIteration.forEach;
+
+
+var STRICT_METHOD = arrayMethodIsStrict('forEach');
+
+// `Array.prototype.forEach` method implementation
+// https://tc39.es/ecma262/#sec-array.prototype.foreach
+var arrayForEach = !STRICT_METHOD ? function forEach(callbackfn /* , thisArg */) {
+  return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
+// eslint-disable-next-line es/no-array-prototype-foreach -- safe
+} : [].forEach;
+
+var handlePrototype = function (CollectionPrototype) {
+  // some Chrome versions have non-configurable methods on DOMTokenList
+  if (CollectionPrototype && CollectionPrototype.forEach !== arrayForEach) try {
+    createNonEnumerableProperty(CollectionPrototype, 'forEach', arrayForEach);
+  } catch (error) {
+    CollectionPrototype.forEach = arrayForEach;
+  }
+};
+
+for (var COLLECTION_NAME in domIterables) {
+  if (domIterables[COLLECTION_NAME]) {
+    handlePrototype(global$1[COLLECTION_NAME] && global$1[COLLECTION_NAME].prototype);
+  }
+}
+
+handlePrototype(domTokenListPrototype);
+
+var InsertCol =
+function () {
+  function InsertCol() {
+    this.title = t('tableModule.insertCol');
+    this.iconSvg = ADD_COL_SVG;
+    this.tag = 'button';
+  }
+  InsertCol.prototype.getValue = function (editor) {
+    return '';
+  };
+  InsertCol.prototype.isActive = function (editor) {
+    return false;
+  };
+  InsertCol.prototype.isDisabled = function (editor) {
+    var selection = editor.selection;
+    if (selection == null) return true;
+    if (!Range.isCollapsed(selection)) return true;
+    var tableNode = DomEditor.getSelectedNodeByType(editor, 'table');
+    if (tableNode == null) {
+      return true;
+    }
+    return false;
+  };
+  InsertCol.prototype.exec = function (editor, value) {
+    if (this.isDisabled(editor)) return;
+    var _a = __read(Editor.nodes(editor, {
+      match: function match(n) {
+        return DomEditor.checkNodeType(n, 'table-cell');
+      },
+      universal: true
+    }), 1),
+        cellEntry = _a[0];
+    var _b = __read(cellEntry, 2),
+        selectedCellNode = _b[0],
+        selectedCellPath = _b[1];
+    var rowNode = DomEditor.getParentNode(editor, selectedCellNode);
+    if (rowNode == null) return;
+    var tableNode = DomEditor.getParentNode(editor, rowNode);
+    if (tableNode == null) return;
+    var rows = tableNode.children || [];
+    rows.forEach(function (row, rowIndex) {
+      if (!Element.isElement(row)) return;
+      var cells = row.children || [];
+      cells.forEach(function (cell) {
+        var path = DomEditor.findPath(editor, cell);
+        if (path.length === selectedCellPath.length && isEqual(path.slice(-1), selectedCellPath.slice(-1))
+        ) {
+          var newCell = {
+            type: 'table-cell',
+            children: [{
+              text: ''
+            }]
+          };
+          if (rowIndex === 0 && isTableWithHeader(tableNode)) {
+            newCell.isHeader = true;
+          }
+          Transforms.insertNodes(editor, newCell, {
+            at: path
+          });
+        }
+      });
+    });
+  };
+  return InsertCol;
+}();
+
+var DeleteCol =
+function () {
+  function DeleteCol() {
+    this.title = t('tableModule.deleteCol');
+    this.iconSvg = DEL_COL_SVG;
+    this.tag = 'button';
+  }
+  DeleteCol.prototype.getValue = function (editor) {
+    return '';
+  };
+  DeleteCol.prototype.isActive = function (editor) {
+    return false;
+  };
+  DeleteCol.prototype.isDisabled = function (editor) {
+    var selection = editor.selection;
+    if (selection == null) return true;
+    if (!Range.isCollapsed(selection)) return true;
+    var cellNode = DomEditor.getSelectedNodeByType(editor, 'table-cell');
+    if (cellNode == null) {
+      return true;
+    }
+    return false;
+  };
+  DeleteCol.prototype.exec = function (editor, value) {
+    if (this.isDisabled(editor)) return;
+    var _a = __read(Editor.nodes(editor, {
+      match: function match(n) {
+        return DomEditor.checkNodeType(n, 'table-cell');
+      },
+      universal: true
+    }), 1),
+        cellEntry = _a[0];
+    var _b = __read(cellEntry, 2),
+        selectedCellNode = _b[0],
+        selectedCellPath = _b[1];
+    var rowNode = DomEditor.getParentNode(editor, selectedCellNode);
+    var colLength = (rowNode === null || rowNode === void 0 ? void 0 : rowNode.children.length) || 0;
+    if (!rowNode || colLength <= 1) {
+      Transforms.removeNodes(editor, {
+        mode: 'highest'
+      });
+      return;
+    }
+    var tableNode = DomEditor.getParentNode(editor, rowNode);
+    if (tableNode == null) return;
+    var rows = tableNode.children || [];
+    rows.forEach(function (row) {
+      if (!Element.isElement(row)) return;
+      var cells = row.children || [];
+      cells.forEach(function (cell) {
+        var path = DomEditor.findPath(editor, cell);
+        if (path.length === selectedCellPath.length && isEqual(path.slice(-1), selectedCellPath.slice(-1))
+        ) {
+          Transforms.removeNodes(editor, {
+            at: path
+          });
+        }
+      });
+    });
+  };
+  return DeleteCol;
+}();
+
+var DeleteTable =
+function () {
+  function DeleteTable() {
+    this.title = t('tableModule.deleteTable');
+    this.iconSvg = TRASH_SVG;
+    this.tag = 'button';
+  }
+  DeleteTable.prototype.getValue = function (editor) {
+    return '';
+  };
+  DeleteTable.prototype.isActive = function (editor) {
+    return false;
+  };
+  DeleteTable.prototype.isDisabled = function (editor) {
+    if (editor.selection == null) return true;
+    var tableNode = DomEditor.getSelectedNodeByType(editor, 'table');
+    if (tableNode == null) {
+      return true;
+    }
+    return false;
+  };
+  DeleteTable.prototype.exec = function (editor, value) {
+    if (this.isDisabled(editor)) return;
+    Transforms.removeNodes(editor, {
+      mode: 'highest'
+    });
+  };
+  return DeleteTable;
+}();
+
+var TableHeader =
+function () {
+  function TableHeader() {
+    this.title = t('tableModule.header');
+    this.iconSvg = TABLE_HEADER_SVG;
+    this.tag = 'button';
+  }
+  TableHeader.prototype.getValue = function (editor) {
+    var tableNode = DomEditor.getSelectedNodeByType(editor, 'table');
+    if (tableNode == null) return false;
+    return isTableWithHeader(tableNode);
+  };
+  TableHeader.prototype.isActive = function (editor) {
+    return !!this.getValue(editor);
+  };
+  TableHeader.prototype.isDisabled = function (editor) {
+    var selection = editor.selection;
+    if (selection == null) return true;
+    if (!Range.isCollapsed(selection)) return true;
+    var tableNode = DomEditor.getSelectedNodeByType(editor, 'table');
+    if (tableNode == null) {
+      return true;
+    }
+    return false;
+  };
+  TableHeader.prototype.exec = function (editor, value) {
+    if (this.isDisabled(editor)) return;
+    var newValue = value ? false : true;
+    var tableNode = DomEditor.getSelectedNodeByType(editor, 'table');
+    if (tableNode == null) return;
+    var firstRowCells = getFirstRowCells(tableNode);
+    firstRowCells.forEach(function (cell) {
+      return Transforms.setNodes(editor, {
+        isHeader: newValue
+      }, {
+        at: DomEditor.findPath(editor, cell)
+      });
+    });
+  };
+  return TableHeader;
+}();
+
+var TableFullWidth =
+function () {
+  function TableFullWidth() {
+    this.title = t('tableModule.widthAuto');
+    this.iconSvg = FULL_WIDTH_SVG;
+    this.tag = 'button';
+  }
+  TableFullWidth.prototype.getValue = function (editor) {
+    var tableNode = DomEditor.getSelectedNodeByType(editor, 'table');
+    if (tableNode == null) return false;
+    return tableNode.width === '100%';
+  };
+  TableFullWidth.prototype.isActive = function (editor) {
+    return !!this.getValue(editor);
+  };
+  TableFullWidth.prototype.isDisabled = function (editor) {
+    var selection = editor.selection;
+    if (selection == null) return true;
+    if (!Range.isCollapsed(selection)) return true;
+    var tableNode = DomEditor.getSelectedNodeByType(editor, 'table');
+    if (tableNode == null) {
+      return true;
+    }
+    return false;
+  };
+  TableFullWidth.prototype.exec = function (editor, value) {
+    if (this.isDisabled(editor)) return;
+    var props = {
+      width: value ? 'auto' : '100%'
+    };
+    Transforms.setNodes(editor, props, {
+      mode: 'highest'
+    });
+  };
+  return TableFullWidth;
+}();
+
+var ICON_ENTER = '<svg viewBox="0 0 1255 1024"><path d="M1095.111111 731.477333h-625.777778V1024L0 658.318222 469.333333 292.408889v292.636444h625.777778V0h156.444445v731.477333z"></path></svg>';
+var ICON_CANCEL_ENTER = '<svg viewBox="0 0 1024 1024"><path d="M436 680H124v-56h312l-124-124 42-42 220 220-220 220-42-42 124-124z"></path><path d="M198 128l64-64 628 628-64 64z"></path></svg>';
+function makeBtn(action, title, iconSvg, opts) {
+  if (opts === void 0) {
+    opts = {};
+  }
+  var _a = opts.disabled,
+      disabled = _a === void 0 ? false : _a,
+      _b = opts.active,
+      active = _b === void 0 ? false : _b;
+  var cls = ['mdg-table-btn', disabled ? 'is-disabled' : '', active ? 'is-active' : ''].filter(Boolean).join(' ');
+  return h('button', {
+    attrs: __assign({
+      type: 'button',
+      class: cls,
+      title: title,
+      'data-table-action': action
+    }, disabled ? {
+      disabled: 'disabled'
+    } : {}),
+    props: {
+      contentEditable: false,
+      disabled: disabled
+    },
+    hook: {
+      insert: function insert(vnode) {
+        var el = vnode.elm;
+        if (el) el.innerHTML = iconSvg;
+      },
+      postpatch: function postpatch(_o, vnode) {
+        var el = vnode.elm;
+        if (el && el.innerHTML !== iconSvg) el.innerHTML = iconSvg;
+      }
+    }
+  });
+}
+function getContentEditable(editor, tableElem) {
+  if (editor.isDisabled()) return false;
+  var selection = editor.selection;
+  if (selection == null) return true;
+  if (Range.isCollapsed(selection)) return true;
+  var anchor = selection.anchor,
+      focus = selection.focus;
+  var tablePath = DomEditor.findPath(editor, tableElem);
+  var tableStart = Editor.start(editor, tablePath);
+  var tableEnd = Editor.end(editor, tablePath);
+  var isAnchorInTable = Point.compare(anchor, tableEnd) <= 0 && Point.compare(anchor, tableStart) >= 0;
+  var isFocusInTable = Point.compare(focus, tableEnd) <= 0 && Point.compare(focus, tableStart) >= 0;
+  if (isAnchorInTable && isFocusInTable) {
+    if (Path.equals(anchor.path.slice(0, 3), focus.path.slice(0, 3))) {
+      return true;
+    }
+  }
+  return false;
+}
+function isTableHeaderOn(tableElem) {
+  var _a, _b;
+  var row = (_b = (_a = tableElem) === null || _a === void 0 ? void 0 : _a.children) === null || _b === void 0 ? void 0 : _b[0];
+  var cells = Array.isArray(row === null || row === void 0 ? void 0 : row.children) ? row.children : [];
+  return cells.length > 0 && cells.every(function (c) {
+    return !!(c === null || c === void 0 ? void 0 : c.isHeader);
+  });
+}
+function isTableFullWidthOn(tableElem) {
+  var _a;
+  return String(((_a = tableElem) === null || _a === void 0 ? void 0 : _a.width) || '') === '100%';
+}
+function ensureSelectionInTable(editor, tableElem) {
+  try {
+    var path = resolveElemPath(editor, tableElem);
+    if (!(path === null || path === void 0 ? void 0 : path.length)) return false;
+    var selected = DomEditor.getSelectedNodeByType(editor, 'table');
+    if (selected) {
+      try {
+        var selPath = DomEditor.findPath(editor, selected);
+        if ((selPath === null || selPath === void 0 ? void 0 : selPath[0]) === path[0]) return true;
+      } catch (_) {
+      }
+    }
+    var cellStart = Editor.start(editor, __spreadArray(__spreadArray([], __read(path)), [0, 0]));
+    editor.select(cellStart);
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+function runMenu(editor, MenuClass) {
+  var menu = new MenuClass();
+  if (typeof menu.isDisabled === 'function' && menu.isDisabled(editor)) return;
+  menu.exec(editor, '');
+}
+function handleTableToolbarAction(editor, tableElem, action) {
+  if (!editor || editor.isDestroyed || editor.isDisabled()) return;
+  var path = resolveElemPath(editor, tableElem);
+  if (!(path === null || path === void 0 ? void 0 : path.length)) return;
+  if (action === 'enter') {
+    insertEmptyLineAboveAtPath(editor, path);
+    return;
+  }
+  if (action === 'cancel-enter') {
+    removeEmptyLineAboveTopLevelBlock(editor, path);
+    return;
+  }
+  if (!ensureSelectionInTable(editor, tableElem)) return;
+  try {
+    switch (action) {
+      case 'header':
+        runMenu(editor, TableHeader);
+        break;
+      case 'full-width':
+        runMenu(editor, TableFullWidth);
+        break;
+      case 'insert-row':
+        runMenu(editor, InsertRow);
+        break;
+      case 'delete-row':
+        runMenu(editor, DeleteRow);
+        break;
+      case 'insert-col':
+        runMenu(editor, InsertCol);
+        break;
+      case 'delete-col':
+        runMenu(editor, DeleteCol);
+        break;
+      case 'remove':
+        runMenu(editor, DeleteTable);
+        break;
+      default:
+        break;
+    }
+  } catch (err) {
+    console.warn('[wangeditor] table toolbar action failed', action, err);
+  }
+}
+function renderTable(elemNode, children, editor) {
+  var editable = getContentEditable(editor, elemNode);
+  var _a = elemNode.width,
+      width = _a === void 0 ? 'auto' : _a;
+  var selected = DomEditor.isNodeSelected(editor, elemNode);
+  var firstRowCells = getFirstRowCells(elemNode);
+  var kids = children == null ? [] : Array.isArray(children) ? children : [children];
+  var tableOn = {
+    mousedown: function mousedown(e) {
+      var _a, _b, _c;
+      var target = e.target;
+      if ((_a = target === null || target === void 0 ? void 0 : target.closest) === null || _a === void 0 ? void 0 : _a.call(target, '[data-mdg-table-toolbar]')) return;
+      if ((target === null || target === void 0 ? void 0 : target.tagName) === 'DIV') e.preventDefault();
+      if (editor.isDisabled()) return;
+      try {
+        var tablePath = DomEditor.findPath(editor, elemNode);
+        var tableStart = Editor.start(editor, tablePath);
+        var selection = editor.selection;
+        if (selection == null || ((_c = (_b = selection.anchor) === null || _b === void 0 ? void 0 : _b.path) === null || _c === void 0 ? void 0 : _c[0]) !== tablePath[0]) {
+          editor.select(tableStart);
+        }
+      } catch (_) {
+      }
+    }
+  };
+  var tableInner = jsx("table", {
+    width: width,
+    contentEditable: editable
+  }, jsx("colgroup", null, firstRowCells.map(function (cell) {
+    var _a = cell.width,
+        colWidth = _a === void 0 ? 'auto' : _a;
+    return jsx("col", {
+      width: colWidth
+    });
+  })), jsx("tbody", null, kids));
+  if (editor.isDisabled()) {
+    return h('div', {
+      attrs: {
+        class: 'mdg-table-wrap'
+      }
+    }, [h('div', {
+      attrs: {
+        class: 'table-container',
+        'data-selected': selected ? 'true' : 'false'
+      },
+      on: tableOn
+    }, [tableInner])]);
+  }
+  var canCancelEnter = false;
+  try {
+    var path = DomEditor.findPath(editor, elemNode);
+    canCancelEnter = canRemoveEmptyLineAboveBlock(editor, path);
+  } catch (_) {
+    canCancelEnter = false;
+  }
+  var headerOn = isTableHeaderOn(elemNode);
+  var fullWidthOn = isTableFullWidthOn(elemNode);
+  var toolbar = h('div', {
+    attrs: {
+      class: 'mdg-table-toolbar',
+      contenteditable: 'false',
+      'data-mdg-table-toolbar': '1'
+    },
+    props: {
+      contentEditable: false
+    },
+    on: {
+      mousedown: function mousedown(e) {
+        e.preventDefault();
+        e.stopPropagation();
+      },
+      click: function click(e) {
+        var _a, _b, _c;
+        e.preventDefault();
+        e.stopPropagation();
+        var t = e.target;
+        var btn = (_a = t === null || t === void 0 ? void 0 : t.closest) === null || _a === void 0 ? void 0 : _a.call(t, 'button[data-table-action]');
+        var action = (_b = btn === null || btn === void 0 ? void 0 : btn.getAttribute) === null || _b === void 0 ? void 0 : _b.call(btn, 'data-table-action');
+        if (!action || ((_c = btn === null || btn === void 0 ? void 0 : btn.classList) === null || _c === void 0 ? void 0 : _c.contains('is-disabled'))) return;
+        handleTableToolbarAction(editor, elemNode, action);
+      }
+    }
+  }, [makeBtn('enter', '回车（上方空行）', ICON_ENTER), makeBtn('cancel-enter', '取消回车', ICON_CANCEL_ENTER, {
+    disabled: !canCancelEnter
+  }), makeBtn('header', '表头', TABLE_HEADER_SVG, {
+    active: headerOn
+  }), makeBtn('full-width', '宽度自适应', FULL_WIDTH_SVG, {
+    active: fullWidthOn
+  }), makeBtn('insert-row', '插入行', ADD_ROW_SVG), makeBtn('delete-row', '删除行', DEL_ROW_SVG), makeBtn('insert-col', '插入列', ADD_COL_SVG), makeBtn('delete-col', '删除列', DEL_COL_SVG), makeBtn('remove', '删除表格', TRASH_SVG)]);
+  return h('div', {
+    attrs: {
+      class: 'mdg-table-wrap'
+    }
+  }, [h('div', {
+    attrs: {
+      class: 'table-container mdg-table-with-toolbar',
+      'data-selected': selected ? 'true' : 'false'
+    },
+    on: tableOn
+  }, [toolbar, tableInner])]);
+}
+
+function renderTableRow(elemNode, children, editor) {
+  var vnode = jsx("tr", null, children);
+  return vnode;
+}
+
+var PROPER_FUNCTION_NAME$1 = functionName.PROPER;
+
+
+
+
+
+
+
+var TO_STRING = 'toString';
+var RegExpPrototype$1 = RegExp.prototype;
+var n$ToString = RegExpPrototype$1[TO_STRING];
+var getFlags = functionUncurryThis(regexpFlags);
+
+var NOT_GENERIC = fails(function () { return n$ToString.call({ source: 'a', flags: 'b' }) != '/a/b'; });
+// FF44- RegExp#toString has a wrong name
+var INCORRECT_NAME = PROPER_FUNCTION_NAME$1 && n$ToString.name != TO_STRING;
+
+// `RegExp.prototype.toString` method
+// https://tc39.es/ecma262/#sec-regexp.prototype.tostring
+if (NOT_GENERIC || INCORRECT_NAME) {
+  redefine(RegExp.prototype, TO_STRING, function toString$1() {
+    var R = anObject(this);
+    var p = toString(R.source);
+    var rf = R.flags;
+    var f = toString(rf === undefined && objectIsPrototypeOf(RegExpPrototype$1, R) && !('flags' in RegExpPrototype$1) ? getFlags(R) : rf);
+    return '/' + p + '/' + f;
+  }, { unsafe: true });
+}
+
+var UNSCOPABLES = wellKnownSymbol('unscopables');
+var ArrayPrototype = Array.prototype;
+
+// Array.prototype[@@unscopables]
+// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
+if (ArrayPrototype[UNSCOPABLES] == undefined) {
+  objectDefineProperty.f(ArrayPrototype, UNSCOPABLES, {
+    configurable: true,
+    value: objectCreate(null)
+  });
+}
+
+// add a key to Array.prototype[@@unscopables]
+var addToUnscopables = function (key) {
+  ArrayPrototype[UNSCOPABLES][key] = true;
+};
+
+var $find = arrayIteration.find;
+
+
+var FIND = 'find';
+var SKIPS_HOLES = true;
+
+// Shouldn't skip holes
+if (FIND in []) Array(1)[FIND](function () { SKIPS_HOLES = false; });
+
+// `Array.prototype.find` method
+// https://tc39.es/ecma262/#sec-array.prototype.find
+_export({ target: 'Array', proto: true, forced: SKIPS_HOLES }, {
+  find: function find(callbackfn /* , that = undefined */) {
+    return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
+  }
+});
+
+// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
+addToUnscopables(FIND);
+
+var FunctionPrototype = Function.prototype;
+var apply = FunctionPrototype.apply;
+var bind = FunctionPrototype.bind;
+var call = FunctionPrototype.call;
+
+// eslint-disable-next-line es/no-reflect -- safe
+var functionApply = typeof Reflect == 'object' && Reflect.apply || (bind ? call.bind(apply) : function () {
+  return call.apply(apply, arguments);
+});
+
+// TODO: Remove from `core-js@4` since it's moved to entry points
+
+
+
+
+
+
+
+
+var SPECIES$1 = wellKnownSymbol('species');
+var RegExpPrototype = RegExp.prototype;
+
+var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) {
+  var SYMBOL = wellKnownSymbol(KEY);
+
+  var DELEGATES_TO_SYMBOL = !fails(function () {
+    // String methods call symbol-named RegEp methods
+    var O = {};
+    O[SYMBOL] = function () { return 7; };
+    return ''[KEY](O) != 7;
+  });
+
+  var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails(function () {
+    // Symbol-named RegExp methods call .exec
+    var execCalled = false;
+    var re = /a/;
+
+    if (KEY === 'split') {
+      // We can't use real regex here since it causes deoptimization
+      // and serious performance degradation in V8
+      // https://github.com/zloirock/core-js/issues/306
+      re = {};
+      // RegExp[@@split] doesn't call the regex's exec method, but first creates
+      // a new one. We need to return the patched regex when creating the new one.
+      re.constructor = {};
+      re.constructor[SPECIES$1] = function () { return re; };
+      re.flags = '';
+      re[SYMBOL] = /./[SYMBOL];
+    }
+
+    re.exec = function () { execCalled = true; return null; };
+
+    re[SYMBOL]('');
+    return !execCalled;
+  });
+
+  if (
+    !DELEGATES_TO_SYMBOL ||
+    !DELEGATES_TO_EXEC ||
+    FORCED
+  ) {
+    var uncurriedNativeRegExpMethod = functionUncurryThis(/./[SYMBOL]);
+    var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) {
+      var uncurriedNativeMethod = functionUncurryThis(nativeMethod);
+      var $exec = regexp.exec;
+      if ($exec === regexpExec || $exec === RegExpPrototype.exec) {
+        if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
+          // The native String method already delegates to @@method (this
+          // polyfilled function), leasing to infinite recursion.
+          // We avoid it by directly calling the native @@method method.
+          return { done: true, value: uncurriedNativeRegExpMethod(regexp, str, arg2) };
+        }
+        return { done: true, value: uncurriedNativeMethod(str, regexp, arg2) };
+      }
+      return { done: false };
+    });
+
+    redefine(String.prototype, KEY, methods[0]);
+    redefine(RegExpPrototype, SYMBOL, methods[1]);
+  }
+
+  if (SHAM) createNonEnumerableProperty(RegExpPrototype[SYMBOL], 'sham', true);
+};
+
+var MATCH = wellKnownSymbol('match');
+
+// `IsRegExp` abstract operation
+// https://tc39.es/ecma262/#sec-isregexp
+var isRegexp = function (it) {
+  var isRegExp;
+  return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : classofRaw(it) == 'RegExp');
+};
+
+var TypeError$2 = global$1.TypeError;
+
+// `Assert: IsConstructor(argument) is true`
+var aConstructor = function (argument) {
+  if (isConstructor(argument)) return argument;
+  throw TypeError$2(tryToString(argument) + ' is not a constructor');
+};
+
+var SPECIES = wellKnownSymbol('species');
+
+// `SpeciesConstructor` abstract operation
+// https://tc39.es/ecma262/#sec-speciesconstructor
+var speciesConstructor = function (O, defaultConstructor) {
+  var C = anObject(O).constructor;
+  var S;
+  return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? defaultConstructor : aConstructor(S);
+};
+
+var charAt$2 = functionUncurryThis(''.charAt);
+var charCodeAt = functionUncurryThis(''.charCodeAt);
+var stringSlice$3 = functionUncurryThis(''.slice);
+
+var createMethod$1 = function (CONVERT_TO_STRING) {
+  return function ($this, pos) {
+    var S = toString(requireObjectCoercible($this));
+    var position = toIntegerOrInfinity(pos);
+    var size = S.length;
+    var first, second;
+    if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;
+    first = charCodeAt(S, position);
+    return first < 0xD800 || first > 0xDBFF || position + 1 === size
+      || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF
+        ? CONVERT_TO_STRING
+          ? charAt$2(S, position)
+          : first
+        : CONVERT_TO_STRING
+          ? stringSlice$3(S, position, position + 2)
+          : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
+  };
+};
+
+var stringMultibyte = {
+  // `String.prototype.codePointAt` method
+  // https://tc39.es/ecma262/#sec-string.prototype.codepointat
+  codeAt: createMethod$1(false),
+  // `String.prototype.at` method
+  // https://github.com/mathiasbynens/String.prototype.at
+  charAt: createMethod$1(true)
+};
+
+var charAt$1 = stringMultibyte.charAt;
+
+// `AdvanceStringIndex` abstract operation
+// https://tc39.es/ecma262/#sec-advancestringindex
+var advanceStringIndex = function (S, index, unicode) {
+  return index + (unicode ? charAt$1(S, index).length : 1);
+};
+
+var Array$1 = global$1.Array;
+var max$1 = Math.max;
+
+var arraySliceSimple = function (O, start, end) {
+  var length = lengthOfArrayLike(O);
+  var k = toAbsoluteIndex(start, length);
+  var fin = toAbsoluteIndex(end === undefined ? length : end, length);
+  var result = Array$1(max$1(fin - k, 0));
+  for (var n = 0; k < fin; k++, n++) createProperty(result, n, O[k]);
+  result.length = n;
+  return result;
+};
+
+var TypeError$1 = global$1.TypeError;
+
+// `RegExpExec` abstract operation
+// https://tc39.es/ecma262/#sec-regexpexec
+var regexpExecAbstract = function (R, S) {
+  var exec = R.exec;
+  if (isCallable(exec)) {
+    var result = functionCall(exec, R, S);
+    if (result !== null) anObject(result);
+    return result;
+  }
+  if (classofRaw(R) === 'RegExp') return functionCall(regexpExec, R, S);
+  throw TypeError$1('RegExp#exec called on incompatible receiver');
+};
+
+var UNSUPPORTED_Y = regexpStickyHelpers.UNSUPPORTED_Y;
+var MAX_UINT32 = 0xFFFFFFFF;
+var min$1 = Math.min;
+var $push = [].push;
+var exec = functionUncurryThis(/./.exec);
+var push$1 = functionUncurryThis($push);
+var stringSlice$2 = functionUncurryThis(''.slice);
+
+// Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec
+// Weex JS has frozen built-in prototypes, so use try / catch wrapper
+var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = !fails(function () {
+  // eslint-disable-next-line regexp/no-empty-group -- required for testing
+  var re = /(?:)/;
+  var originalExec = re.exec;
+  re.exec = function () { return originalExec.apply(this, arguments); };
+  var result = 'ab'.split(re);
+  return result.length !== 2 || result[0] !== 'a' || result[1] !== 'b';
+});
+
+// @@split logic
+fixRegexpWellKnownSymbolLogic('split', function (SPLIT, nativeSplit, maybeCallNative) {
+  var internalSplit;
+  if (
+    'abbc'.split(/(b)*/)[1] == 'c' ||
+    // eslint-disable-next-line regexp/no-empty-group -- required for testing
+    'test'.split(/(?:)/, -1).length != 4 ||
+    'ab'.split(/(?:ab)*/).length != 2 ||
+    '.'.split(/(.?)(.?)/).length != 4 ||
+    // eslint-disable-next-line regexp/no-empty-capturing-group, regexp/no-empty-group -- required for testing
+    '.'.split(/()()/).length > 1 ||
+    ''.split(/.?/).length
+  ) {
+    // based on es5-shim implementation, need to rework it
+    internalSplit = function (separator, limit) {
+      var string = toString(requireObjectCoercible(this));
+      var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;
+      if (lim === 0) return [];
+      if (separator === undefined) return [string];
+      // If `separator` is not a regex, use native split
+      if (!isRegexp(separator)) {
+        return functionCall(nativeSplit, string, separator, lim);
+      }
+      var output = [];
+      var flags = (separator.ignoreCase ? 'i' : '') +
+                  (separator.multiline ? 'm' : '') +
+                  (separator.unicode ? 'u' : '') +
+                  (separator.sticky ? 'y' : '');
+      var lastLastIndex = 0;
+      // Make `global` and avoid `lastIndex` issues by working with a copy
+      var separatorCopy = new RegExp(separator.source, flags + 'g');
+      var match, lastIndex, lastLength;
+      while (match = functionCall(regexpExec, separatorCopy, string)) {
+        lastIndex = separatorCopy.lastIndex;
+        if (lastIndex > lastLastIndex) {
+          push$1(output, stringSlice$2(string, lastLastIndex, match.index));
+          if (match.length > 1 && match.index < string.length) functionApply($push, output, arraySliceSimple(match, 1));
+          lastLength = match[0].length;
+          lastLastIndex = lastIndex;
+          if (output.length >= lim) break;
+        }
+        if (separatorCopy.lastIndex === match.index) separatorCopy.lastIndex++; // Avoid an infinite loop
+      }
+      if (lastLastIndex === string.length) {
+        if (lastLength || !exec(separatorCopy, '')) push$1(output, '');
+      } else push$1(output, stringSlice$2(string, lastLastIndex));
+      return output.length > lim ? arraySliceSimple(output, 0, lim) : output;
+    };
+  // Chakra, V8
+  } else if ('0'.split(undefined, 0).length) {
+    internalSplit = function (separator, limit) {
+      return separator === undefined && limit === 0 ? [] : functionCall(nativeSplit, this, separator, limit);
+    };
+  } else internalSplit = nativeSplit;
+
+  return [
+    // `String.prototype.split` method
+    // https://tc39.es/ecma262/#sec-string.prototype.split
+    function split(separator, limit) {
+      var O = requireObjectCoercible(this);
+      var splitter = separator == undefined ? undefined : getMethod(separator, SPLIT);
+      return splitter
+        ? functionCall(splitter, separator, O, limit)
+        : functionCall(internalSplit, toString(O), separator, limit);
+    },
+    // `RegExp.prototype[@@split]` method
+    // https://tc39.es/ecma262/#sec-regexp.prototype-@@split
+    //
+    // NOTE: This cannot be properly polyfilled in engines that don't support
+    // the 'y' flag.
+    function (string, limit) {
+      var rx = anObject(this);
+      var S = toString(string);
+      var res = maybeCallNative(internalSplit, rx, S, limit, internalSplit !== nativeSplit);
+
+      if (res.done) return res.value;
+
+      var C = speciesConstructor(rx, RegExp);
+
+      var unicodeMatching = rx.unicode;
+      var flags = (rx.ignoreCase ? 'i' : '') +
+                  (rx.multiline ? 'm' : '') +
+                  (rx.unicode ? 'u' : '') +
+                  (UNSUPPORTED_Y ? 'g' : 'y');
+
+      // ^(? + rx + ) is needed, in combination with some S slicing, to
+      // simulate the 'y' flag.
+      var splitter = new C(UNSUPPORTED_Y ? '^(?:' + rx.source + ')' : rx, flags);
+      var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;
+      if (lim === 0) return [];
+      if (S.length === 0) return regexpExecAbstract(splitter, S) === null ? [S] : [];
+      var p = 0;
+      var q = 0;
+      var A = [];
+      while (q < S.length) {
+        splitter.lastIndex = UNSUPPORTED_Y ? 0 : q;
+        var z = regexpExecAbstract(splitter, UNSUPPORTED_Y ? stringSlice$2(S, q) : S);
+        var e;
+        if (
+          z === null ||
+          (e = min$1(toLength(splitter.lastIndex + (UNSUPPORTED_Y ? q : 0)), S.length)) === p
+        ) {
+          q = advanceStringIndex(S, q, unicodeMatching);
+        } else {
+          push$1(A, stringSlice$2(S, p, q));
+          if (A.length === lim) return A;
+          for (var i = 1; i <= z.length - 1; i++) {
+            push$1(A, z[i]);
+            if (A.length === lim) return A;
+          }
+          q = p = e;
+        }
+      }
+      push$1(A, stringSlice$2(S, p));
+      return A;
+    }
+  ];
+}, !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC, UNSUPPORTED_Y);
+
+// a string of all valid unicode whitespaces
+var whitespaces = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002' +
+  '\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF';
+
+var replace$1 = functionUncurryThis(''.replace);
+var whitespace = '[' + whitespaces + ']';
+var ltrim = RegExp('^' + whitespace + whitespace + '*');
+var rtrim = RegExp(whitespace + whitespace + '*$');
+
+// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation
+var createMethod = function (TYPE) {
+  return function ($this) {
+    var string = toString(requireObjectCoercible($this));
+    if (TYPE & 1) string = replace$1(string, ltrim, '');
+    if (TYPE & 2) string = replace$1(string, rtrim, '');
+    return string;
+  };
+};
+
+var stringTrim = {
+  // `String.prototype.{ trimLeft, trimStart }` methods
+  // https://tc39.es/ecma262/#sec-string.prototype.trimstart
+  start: createMethod(1),
+  // `String.prototype.{ trimRight, trimEnd }` methods
+  // https://tc39.es/ecma262/#sec-string.prototype.trimend
+  end: createMethod(2),
+  // `String.prototype.trim` method
+  // https://tc39.es/ecma262/#sec-string.prototype.trim
+  trim: createMethod(3)
+};
+
+var PROPER_FUNCTION_NAME = functionName.PROPER;
+
+
+
+var non = '\u200B\u0085\u180E';
+
+// check that a method works with the correct list
+// of whitespaces and has a correct name
+var stringTrimForced = function (METHOD_NAME) {
+  return fails(function () {
+    return !!whitespaces[METHOD_NAME]()
+      || non[METHOD_NAME]() !== non
+      || (PROPER_FUNCTION_NAME && whitespaces[METHOD_NAME].name !== METHOD_NAME);
+  });
+};
+
+var $trim = stringTrim.trim;
+
+
+// `String.prototype.trim` method
+// https://tc39.es/ecma262/#sec-string.prototype.trim
+_export({ target: 'String', proto: true, forced: stringTrimForced('trim') }, {
+  trim: function trim() {
+    return $trim(this);
+  }
+});
+
+// `globalThis` object
+// https://tc39.es/ecma262/#sec-globalthis
+_export({ global: true }, {
+  globalThis: global$1
+});
+
+if (append) $.fn.append = append;
+if (on) $.fn.on = on;
+if (focus) $.fn.focus = focus;
+if (attr) $.fn.attr = attr;
+if (val) $.fn.val = val;
+if (html$1) $.fn.html = html$1;
+if (dataset) $.fn.dataset = dataset;
+if (addClass) $.fn.addClass = addClass;
+if (removeClass) $.fn.removeClass = removeClass;
+if (children) $.fn.children = children;
+if (each) $.fn.each = each;
+if (find) $.fn.find = find;
+function getTagName($elem) {
+  if ($elem.length) return $elem[0].tagName.toLowerCase();
+  return '';
+}
+function getStyleValue($elem, styleKey) {
+  var res = '';
+  var styleStr = $elem.attr('style') || '';
+  var styleArr = styleStr.split(';');
+  var length = styleArr.length;
+  for (var i = 0; i < length; i++) {
+    var styleItemStr = styleArr[i];
+    if (styleItemStr) {
+      var arr = styleItemStr.split(':');
+      if (arr[0].trim() === styleKey) {
+        res = arr[1].trim();
+      }
+    }
+  }
+  return res;
+}
+
+var isMouseDownForResize = false;
+var clientXWhenMouseDown = 0;
+var cellWidthWhenMouseDown = 0;
+var cellPathWhenMouseDown = null;
+var editorWhenMouseDown = null;
+var $body = $('body');
+function onMouseDown(event) {
+  var elem = event.target;
+  if (elem.tagName !== 'TH' && elem.tagName !== 'TD') return;
+  if (elem.style.cursor !== 'col-resize') return;
+  elem.style.cursor = 'auto';
+  event.preventDefault();
+  isMouseDownForResize = true;
+  var clientX = event.clientX;
+  clientXWhenMouseDown = clientX;
+  var width = elem.getBoundingClientRect().width;
+  cellWidthWhenMouseDown = width;
+  $body.on('mousemove', onMouseMove);
+  $body.on('mouseup', onMouseUp);
+}
+$body.on('mousedown', onMouseDown);
+function onMouseUp(event) {
+  isMouseDownForResize = false;
+  editorWhenMouseDown = null;
+  cellPathWhenMouseDown = null;
+  $body.off('mousemove', onMouseMove);
+  $body.off('mouseup', onMouseUp);
+}
+var onMouseMove = throttle(function (event) {
+  if (!isMouseDownForResize) return;
+  if (editorWhenMouseDown == null || cellPathWhenMouseDown == null) return;
+  event.preventDefault();
+  var clientX = event.clientX;
+  var newWith = cellWidthWhenMouseDown + (clientX - clientXWhenMouseDown);
+  newWith = Math.floor(newWith * 100) / 100;
+  if (newWith < 30) newWith = 30;
+  Transforms.setNodes(editorWhenMouseDown, {
+    width: newWith.toString()
+  }, {
+    at: cellPathWhenMouseDown
+  });
+}, 100);
+function renderTableCell(cellNode, children, editor) {
+  var isFirstRow = isCellInFirstRow(editor, cellNode);
+  var _a = cellNode,
+      _b = _a.colSpan,
+      colSpan = _b === void 0 ? 1 : _b,
+      _c = _a.rowSpan,
+      rowSpan = _c === void 0 ? 1 : _c,
+      _d = _a.isHeader,
+      isHeader = _d === void 0 ? false : _d;
+  if (!isFirstRow) {
+    return jsx("td", {
+      colSpan: colSpan,
+      rowSpan: rowSpan
+    }, children);
+  }
+  var Tag = isHeader ? 'th' : 'td';
+  var vnode = jsx(Tag, {
+    colSpan: colSpan,
+    rowSpan: rowSpan,
+    style: {
+      borderRightWidth: '3px'
+    },
+    on: {
+      mousemove: throttle(function (event) {
+        var elem = this.elm;
+        if (elem == null) return;
+        var _a = elem.getBoundingClientRect(),
+            left = _a.left,
+            width = _a.width,
+            top = _a.top,
+            height = _a.height;
+        var clientX = event.clientX,
+            clientY = event.clientY;
+        if (isMouseDownForResize) return;
+        var matchX = clientX > left + width - 5 && clientX < left + width;
+        var matchY = clientY > top && clientY < top + height;
+        if (matchX && matchY) {
+          elem.style.cursor = 'col-resize';
+          editorWhenMouseDown = editor;
+          cellPathWhenMouseDown = DomEditor.findPath(editor, cellNode);
+        } else {
+          if (!isMouseDownForResize) {
+            elem.style.cursor = 'auto';
+            editorWhenMouseDown = null;
+            cellPathWhenMouseDown = null;
+          }
+        }
+      }, 100)
+    }
+  }, children);
+  return vnode;
+}
+
+var renderTableConf = {
+  type: 'table',
+  renderElem: renderTable
+};
+var renderTableRowConf = {
+  type: 'table-row',
+  renderElem: renderTableRow
+};
+var renderTableCellConf = {
+  type: 'table-cell',
+  renderElem: renderTableCell
+};
+
+function tableToHtml(elemNode, childrenHtml) {
+  var _a = elemNode.width,
+      width = _a === void 0 ? 'auto' : _a;
+  return "<table style=\"width: " + width + ";\"><tbody>" + childrenHtml + "</tbody></table>";
+}
+function tableRowToHtml(elem, childrenHtml) {
+  return "<tr>" + childrenHtml + "</tr>";
+}
+function tableCellToHtml(cellNode, childrenHtml) {
+  var _a = cellNode,
+      _b = _a.colSpan,
+      colSpan = _b === void 0 ? 1 : _b,
+      _c = _a.rowSpan,
+      rowSpan = _c === void 0 ? 1 : _c,
+      _d = _a.isHeader,
+      isHeader = _d === void 0 ? false : _d,
+      _e = _a.width,
+      width = _e === void 0 ? 'auto' : _e;
+  var tag = isHeader ? 'th' : 'td';
+  return "<" + tag + " colSpan=\"" + colSpan + "\" rowSpan=\"" + rowSpan + "\" width=\"" + width + "\">" + childrenHtml + "</" + tag + ">";
+}
+var tableToHtmlConf = {
+  type: 'table',
+  elemToHtml: tableToHtml
+};
+var tableRowToHtmlConf = {
+  type: 'table-row',
+  elemToHtml: tableRowToHtml
+};
+var tableCellToHtmlConf = {
+  type: 'table-cell',
+  elemToHtml: tableCellToHtml
+};
+
+function preParse(tableElem) {
+  var $table = $(tableElem);
+  var tagName = getTagName($table);
+  if (tagName !== 'table') return tableElem;
+  var $tbody = $table.find('tbody');
+  if ($tbody.length === 0) return tableElem;
+  var $tr = $table.find('tr');
+  $table.append($tr);
+  $tbody.remove();
+  return $table[0];
+}
+var preParseTableHtmlConf = {
+  selector: 'table',
+  preParseHtml: preParse
+};
+
+var floor = Math.floor;
+var charAt = functionUncurryThis(''.charAt);
+var replace = functionUncurryThis(''.replace);
+var stringSlice$1 = functionUncurryThis(''.slice);
+var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d{1,2}|<[^>]*>)/g;
+var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d{1,2})/g;
+
+// `GetSubstitution` abstract operation
+// https://tc39.es/ecma262/#sec-getsubstitution
+var getSubstitution = function (matched, str, position, captures, namedCaptures, replacement) {
+  var tailPos = position + matched.length;
+  var m = captures.length;
+  var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED;
+  if (namedCaptures !== undefined) {
+    namedCaptures = toObject(namedCaptures);
+    symbols = SUBSTITUTION_SYMBOLS;
+  }
+  return replace(replacement, symbols, function (match, ch) {
+    var capture;
+    switch (charAt(ch, 0)) {
+      case '$': return '$';
+      case '&': return matched;
+      case '`': return stringSlice$1(str, 0, position);
+      case "'": return stringSlice$1(str, tailPos);
+      case '<':
+        capture = namedCaptures[stringSlice$1(ch, 1, -1)];
+        break;
+      default: // \d\d?
+        var n = +ch;
+        if (n === 0) return match;
+        if (n > m) {
+          var f = floor(n / 10);
+          if (f === 0) return match;
+          if (f <= m) return captures[f - 1] === undefined ? charAt(ch, 1) : captures[f - 1] + charAt(ch, 1);
+          return match;
+        }
+        capture = captures[n - 1];
+    }
+    return capture === undefined ? '' : capture;
+  });
+};
+
+var REPLACE = wellKnownSymbol('replace');
+var max = Math.max;
+var min = Math.min;
+var concat = functionUncurryThis([].concat);
+var push = functionUncurryThis([].push);
+var stringIndexOf = functionUncurryThis(''.indexOf);
+var stringSlice = functionUncurryThis(''.slice);
+
+var maybeToString = function (it) {
+  return it === undefined ? it : String(it);
+};
+
+// IE <= 11 replaces $0 with the whole match, as if it was $&
+// https://stackoverflow.com/questions/6024666/getting-ie-to-replace-a-regex-with-the-literal-string-0
+var REPLACE_KEEPS_$0 = (function () {
+  // eslint-disable-next-line regexp/prefer-escape-replacement-dollar-char -- required for testing
+  return 'a'.replace(/./, '$0') === '$0';
+})();
+
+// Safari <= 13.0.3(?) substitutes nth capture where n>m with an empty string
+var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = (function () {
+  if (/./[REPLACE]) {
+    return /./[REPLACE]('a', '$0') === '';
+  }
+  return false;
+})();
+
+var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {
+  var re = /./;
+  re.exec = function () {
+    var result = [];
+    result.groups = { a: '7' };
+    return result;
+  };
+  // eslint-disable-next-line regexp/no-useless-dollar-replacements -- false positive
+  return ''.replace(re, '$<a>') !== '7';
+});
+
+// @@replace logic
+fixRegexpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNative) {
+  var UNSAFE_SUBSTITUTE = REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE ? '$' : '$0';
+
+  return [
+    // `String.prototype.replace` method
+    // https://tc39.es/ecma262/#sec-string.prototype.replace
+    function replace(searchValue, replaceValue) {
+      var O = requireObjectCoercible(this);
+      var replacer = searchValue == undefined ? undefined : getMethod(searchValue, REPLACE);
+      return replacer
+        ? functionCall(replacer, searchValue, O, replaceValue)
+        : functionCall(nativeReplace, toString(O), searchValue, replaceValue);
+    },
+    // `RegExp.prototype[@@replace]` method
+    // https://tc39.es/ecma262/#sec-regexp.prototype-@@replace
+    function (string, replaceValue) {
+      var rx = anObject(this);
+      var S = toString(string);
+
+      if (
+        typeof replaceValue == 'string' &&
+        stringIndexOf(replaceValue, UNSAFE_SUBSTITUTE) === -1 &&
+        stringIndexOf(replaceValue, '$<') === -1
+      ) {
+        var res = maybeCallNative(nativeReplace, rx, S, replaceValue);
+        if (res.done) return res.value;
+      }
+
+      var functionalReplace = isCallable(replaceValue);
+      if (!functionalReplace) replaceValue = toString(replaceValue);
+
+      var global = rx.global;
+      if (global) {
+        var fullUnicode = rx.unicode;
+        rx.lastIndex = 0;
+      }
+      var results = [];
+      while (true) {
+        var result = regexpExecAbstract(rx, S);
+        if (result === null) break;
+
+        push(results, result);
+        if (!global) break;
+
+        var matchStr = toString(result[0]);
+        if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);
+      }
+
+      var accumulatedResult = '';
+      var nextSourcePosition = 0;
+      for (var i = 0; i < results.length; i++) {
+        result = results[i];
+
+        var matched = toString(result[0]);
+        var position = max(min(toIntegerOrInfinity(result.index), S.length), 0);
+        var captures = [];
+        // NOTE: This is equivalent to
+        //   captures = result.slice(1).map(maybeToString)
+        // but for some reason `nativeSlice.call(result, 1, result.length)` (called in
+        // the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and
+        // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.
+        for (var j = 1; j < result.length; j++) push(captures, maybeToString(result[j]));
+        var namedCaptures = result.groups;
+        if (functionalReplace) {
+          var replacerArgs = concat([matched], captures, position, S);
+          if (namedCaptures !== undefined) push(replacerArgs, namedCaptures);
+          var replacement = toString(functionApply(replaceValue, undefined, replacerArgs));
+        } else {
+          replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);
+        }
+        if (position >= nextSourcePosition) {
+          accumulatedResult += stringSlice(S, nextSourcePosition, position) + replacement;
+          nextSourcePosition = position + matched.length;
+        }
+      }
+      return accumulatedResult + stringSlice(S, nextSourcePosition);
+    }
+  ];
+}, !REPLACE_SUPPORTS_NAMED_GROUPS || !REPLACE_KEEPS_$0 || REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE);
+
+function parseCellHtml(elem, children, editor) {
+  var $elem = $(elem);
+  children = children.filter(function (child) {
+    if (Text.isText(child)) return true;
+    if (editor.isInline(child)) return true;
+    return false;
+  });
+  if (children.length === 0) {
+    children = [{
+      text: $elem.text().replace(/\s+/gm, ' ')
+    }];
+  }
+  var colSpan = parseInt($elem.attr('colSpan') || '1');
+  var rowSpan = parseInt($elem.attr('rowSpan') || '1');
+  var width = $elem.attr('width') || 'auto';
+  return {
+    type: 'table-cell',
+    isHeader: getTagName($elem) === 'th',
+    colSpan: colSpan,
+    rowSpan: rowSpan,
+    width: width,
+    children: children
+  };
+}
+var parseCellHtmlConf = {
+  selector: 'td:not([data-w-e-type]),th:not([data-w-e-type])',
+  parseElemHtml: parseCellHtml
+};
+function parseRowHtml(elem, children, editor) {
+  return {
+    type: 'table-row',
+    children: children.filter(function (child) {
+      return DomEditor.getNodeType(child) === 'table-cell';
+    })
+  };
+}
+var parseRowHtmlConf = {
+  selector: 'tr:not([data-w-e-type])',
+  parseElemHtml: parseRowHtml
+};
+function parseTableHtml(elem, children, editor) {
+  var $elem = $(elem);
+  var width = 'auto';
+  if (getStyleValue($elem, 'width') === '100%') width = '100%';
+  if ($elem.attr('width') === '100%') width = '100%';
+  return {
+    type: 'table',
+    width: width,
+    children: children.filter(function (child) {
+      return DomEditor.getNodeType(child) === 'table-row';
+    })
+  };
+}
+var parseTableHtmlConf = {
+  selector: 'table:not([data-w-e-type])',
+  parseElemHtml: parseTableHtml
+};
+
+function genTableNode(rowNum, colNum) {
+  var rows = [];
+  for (var i = 0; i < rowNum; i++) {
+    var cells = [];
+    for (var j = 0; j < colNum; j++) {
+      var cellNode = {
+        type: 'table-cell',
+        children: [{
+          text: ''
+        }]
+      };
+      if (i === 0) {
+        cellNode.isHeader = true;
+      }
+      cells.push(cellNode);
+    }
+    rows.push({
+      type: 'table-row',
+      children: cells
+    });
+  }
+  return {
+    type: 'table',
+    width: 'auto',
+    children: rows
+  };
+}
+var InsertTable =
+function () {
+  function InsertTable() {
+    this.title = t('tableModule.insertTable');
+    this.iconSvg = TABLE_SVG;
+    this.tag = 'button';
+    this.showDropPanel = true;
+    this.$content = null;
+  }
+  InsertTable.prototype.getValue = function (editor) {
+    return '';
+  };
+  InsertTable.prototype.isActive = function (editor) {
+    return false;
+  };
+  InsertTable.prototype.exec = function (editor, value) {
+  };
+  InsertTable.prototype.isDisabled = function (editor) {
+    var selection = editor.selection;
+    if (selection == null) return true;
+    if (!Range.isCollapsed(selection)) return true;
+    var selectedElems = DomEditor.getSelectedElems(editor);
+    var hasVoidOrPreOrTable = selectedElems.some(function (elem) {
+      var type = DomEditor.getNodeType(elem);
+      if (type === 'pre') return true;
+      if (type === 'table') return true;
+      if (type === 'list-item') return true;
+      if (editor.isVoid(elem)) return true;
+      return false;
+    });
+    if (hasVoidOrPreOrTable) return true;
+    return false;
+  };
+  InsertTable.prototype.getPanelContentElem = function (editor) {
+    var _this = this;
+    if (this.$content) return this.$content[0];
+    var $content = $('<div class="w-e-panel-content-table"></div>');
+    var $info = $('<span>0 &times; 0</span>');
+    var $table = $('<table></table>');
+    for (var i = 0; i < 10; i++) {
+      var $tr = $('<tr></tr>');
+      for (var j = 0; j < 10; j++) {
+        var $td = $('<td></td>');
+        $td.attr('data-x', j.toString());
+        $td.attr('data-y', i.toString());
+        $tr.append($td);
+        $td.on('mouseenter', function (e) {
+          var target = e.target;
+          if (target == null) return;
+          var $focusTd = $(target);
+          var _a = $focusTd.dataset(),
+              focusX = _a.x,
+              focusY = _a.y;
+          $info[0].innerHTML = focusX + 1 + " &times; " + (focusY + 1);
+          $table.children().each(function (tr) {
+            $(tr).children().each(function (td) {
+              var $td = $(td);
+              var _a = $td.dataset(),
+                  x = _a.x,
+                  y = _a.y;
+              if (x <= focusX && y <= focusY) {
+                $td.addClass('active');
+              } else {
+                $td.removeClass('active');
+              }
+            });
+          });
+        });
+        $td.on('click', function (e) {
+          e.preventDefault();
+          var target = e.target;
+          if (target == null) return;
+          var $td = $(target);
+          var _a = $td.dataset(),
+              x = _a.x,
+              y = _a.y;
+          _this.insertTable(editor, y + 1, x + 1);
+        });
+      }
+      $table.append($tr);
+    }
+    $content.append($table);
+    $content.append($info);
+    this.$content = $content;
+    return $content[0];
+  };
+  InsertTable.prototype.insertTable = function (editor, rowNumStr, colNumStr) {
+    var rowNum = parseInt(rowNumStr, 10);
+    var colNum = parseInt(colNumStr, 10);
+    if (!rowNum || !colNum) return;
+    if (rowNum <= 0 || colNum <= 0) return;
+    if (DomEditor.isSelectedEmptyParagraph(editor)) {
+      Transforms.removeNodes(editor, {
+        mode: 'highest'
+      });
+    }
+    var tableNode = genTableNode(rowNum, colNum);
+    Transforms.insertNodes(editor, tableNode, {
+      mode: 'highest'
+    });
+  };
+  return InsertTable;
+}();
+
+var insertTableMenuConf = {
+  key: 'insertTable',
+  factory: function factory() {
+    return new InsertTable();
+  }
+};
+var deleteTableMenuConf = {
+  key: 'deleteTable',
+  factory: function factory() {
+    return new DeleteTable();
+  }
+};
+var insertTableRowConf = {
+  key: 'insertTableRow',
+  factory: function factory() {
+    return new InsertRow();
+  }
+};
+var deleteTableRowConf = {
+  key: 'deleteTableRow',
+  factory: function factory() {
+    return new DeleteRow();
+  }
+};
+var insertTableColConf = {
+  key: 'insertTableCol',
+  factory: function factory() {
+    return new InsertCol();
+  }
+};
+var deleteTableColConf = {
+  key: 'deleteTableCol',
+  factory: function factory() {
+    return new DeleteCol();
+  }
+};
+var tableHeaderMenuConf = {
+  key: 'tableHeader',
+  factory: function factory() {
+    return new TableHeader();
+  }
+};
+var tableFullWidthMenuConf = {
+  key: 'tableFullWidth',
+  factory: function factory() {
+    return new TableFullWidth();
+  }
+};
+
+var table = {
+  renderElems: [renderTableConf, renderTableRowConf, renderTableCellConf],
+  elemsToHtml: [tableToHtmlConf, tableRowToHtmlConf, tableCellToHtmlConf],
+  preParseHtml: [preParseTableHtmlConf],
+  parseElemsHtml: [parseCellHtmlConf, parseRowHtmlConf, parseTableHtmlConf],
+  menus: [insertTableMenuConf, deleteTableMenuConf, insertTableRowConf, deleteTableRowConf, insertTableColConf, deleteTableColConf, tableHeaderMenuConf, tableFullWidthMenuConf],
+  editorPlugin: withTable
+};
+
+export { table as default };
+//# sourceMappingURL=index.esm.js.map