@tailor-cms/ce-table-edit 0.0.1

package/dist/index.cjs

@@ -0,0 +1,2404 @@
+"use strict";
+var import_style = require("./style.css");
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+function baseTimes$2(n, iteratee) {
+  var index = -1, result = Array(n);
+  while (++index < n) {
+    result[index] = iteratee(index);
+  }
+  return result;
+}
+var _baseTimes = baseTimes$2;
+function identity$5(value) {
+  return value;
+}
+var identity_1 = identity$5;
+var identity$4 = identity_1;
+function castFunction$2(value) {
+  return typeof value == "function" ? value : identity$4;
+}
+var _castFunction = castFunction$2;
+var reWhitespace = /\s/;
+function trimmedEndIndex$1(string) {
+  var index = string.length;
+  while (index-- && reWhitespace.test(string.charAt(index))) {
+  }
+  return index;
+}
+var _trimmedEndIndex = trimmedEndIndex$1;
+var trimmedEndIndex = _trimmedEndIndex;
+var reTrimStart = /^\s+/;
+function baseTrim$1(string) {
+  return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string;
+}
+var _baseTrim = baseTrim$1;
+function isObject$8(value) {
+  var type2 = typeof value;
+  return value != null && (type2 == "object" || type2 == "function");
+}
+var isObject_1 = isObject$8;
+var freeGlobal$1 = typeof commonjsGlobal == "object" && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+var _freeGlobal = freeGlobal$1;
+var freeGlobal = _freeGlobal;
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root$8 = freeGlobal || freeSelf || Function("return this")();
+var _root = root$8;
+var root$7 = _root;
+var Symbol$7 = root$7.Symbol;
+var _Symbol = Symbol$7;
+var Symbol$6 = _Symbol;
+var objectProto$e = Object.prototype;
+var hasOwnProperty$b = objectProto$e.hasOwnProperty;
+var nativeObjectToString$1 = objectProto$e.toString;
+var symToStringTag$1 = Symbol$6 ? Symbol$6.toStringTag : void 0;
+function getRawTag$1(value) {
+  var isOwn = hasOwnProperty$b.call(value, symToStringTag$1), tag = value[symToStringTag$1];
+  try {
+    value[symToStringTag$1] = void 0;
+    var unmasked = true;
+  } catch (e) {
+  }
+  var result = nativeObjectToString$1.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag$1] = tag;
+    } else {
+      delete value[symToStringTag$1];
+    }
+  }
+  return result;
+}
+var _getRawTag = getRawTag$1;
+var objectProto$d = Object.prototype;
+var nativeObjectToString = objectProto$d.toString;
+function objectToString$1(value) {
+  return nativeObjectToString.call(value);
+}
+var _objectToString = objectToString$1;
+var Symbol$5 = _Symbol, getRawTag = _getRawTag, objectToString = _objectToString;
+var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
+var symToStringTag = Symbol$5 ? Symbol$5.toStringTag : void 0;
+function baseGetTag$6(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+var _baseGetTag = baseGetTag$6;
+function isObjectLike$8(value) {
+  return value != null && typeof value == "object";
+}
+var isObjectLike_1 = isObjectLike$8;
+var baseGetTag$5 = _baseGetTag, isObjectLike$7 = isObjectLike_1;
+var symbolTag$3 = "[object Symbol]";
+function isSymbol$5(value) {
+  return typeof value == "symbol" || isObjectLike$7(value) && baseGetTag$5(value) == symbolTag$3;
+}
+var isSymbol_1 = isSymbol$5;
+var baseTrim = _baseTrim, isObject$7 = isObject_1, isSymbol$4 = isSymbol_1;
+var NAN = 0 / 0;
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+var reIsBinary = /^0b[01]+$/i;
+var reIsOctal = /^0o[0-7]+$/i;
+var freeParseInt = parseInt;
+function toNumber$1(value) {
+  if (typeof value == "number") {
+    return value;
+  }
+  if (isSymbol$4(value)) {
+    return NAN;
+  }
+  if (isObject$7(value)) {
+    var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+    value = isObject$7(other) ? other + "" : other;
+  }
+  if (typeof value != "string") {
+    return value === 0 ? value : +value;
+  }
+  value = baseTrim(value);
+  var isBinary = reIsBinary.test(value);
+  return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+}
+var toNumber_1 = toNumber$1;
+var toNumber = toNumber_1;
+var INFINITY$2 = 1 / 0, MAX_INTEGER = 17976931348623157e292;
+function toFinite$1(value) {
+  if (!value) {
+    return value === 0 ? value : 0;
+  }
+  value = toNumber(value);
+  if (value === INFINITY$2 || value === -INFINITY$2) {
+    var sign = value < 0 ? -1 : 1;
+    return sign * MAX_INTEGER;
+  }
+  return value === value ? value : 0;
+}
+var toFinite_1 = toFinite$1;
+var toFinite = toFinite_1;
+function toInteger$2(value) {
+  var result = toFinite(value), remainder = result % 1;
+  return result === result ? remainder ? result - remainder : result : 0;
+}
+var toInteger_1 = toInteger$2;
+var baseTimes$1 = _baseTimes, castFunction$1 = _castFunction, toInteger$1 = toInteger_1;
+var MAX_SAFE_INTEGER$2 = 9007199254740991;
+var MAX_ARRAY_LENGTH = 4294967295;
+var nativeMin = Math.min;
+function times(n, iteratee) {
+  n = toInteger$1(n);
+  if (n < 1 || n > MAX_SAFE_INTEGER$2) {
+    return [];
+  }
+  var index = MAX_ARRAY_LENGTH, length = nativeMin(n, MAX_ARRAY_LENGTH);
+  iteratee = castFunction$1(iteratee);
+  n -= MAX_ARRAY_LENGTH;
+  var result = baseTimes$1(length, iteratee);
+  while (++index < n) {
+    iteratee(index);
+  }
+  return result;
+}
+var times_1 = times;
+const times$1 = /* @__PURE__ */ getDefaultExportFromCjs(times_1);
+const byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+let getRandomValues;
+const rnds8 = new Uint8Array(16);
+function rng() {
+  if (!getRandomValues) {
+    if (typeof crypto === "undefined" || !crypto.getRandomValues) {
+      throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+    }
+    getRandomValues = crypto.getRandomValues.bind(crypto);
+  }
+  return getRandomValues(rnds8);
+}
+const randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+const native = { randomUUID };
+function v4(options, buf, offset) {
+  var _a;
+  if (native.randomUUID && !buf && !options) {
+    return native.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random ?? ((_a = options.rng) == null ? void 0 : _a.call(options)) ?? rng();
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+function listCacheClear$1() {
+  this.__data__ = [];
+  this.size = 0;
+}
+var _listCacheClear = listCacheClear$1;
+function eq$4(value, other) {
+  return value === other || value !== value && other !== other;
+}
+var eq_1 = eq$4;
+var eq$3 = eq_1;
+function assocIndexOf$4(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq$3(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+var _assocIndexOf = assocIndexOf$4;
+var assocIndexOf$3 = _assocIndexOf;
+var arrayProto = Array.prototype;
+var splice = arrayProto.splice;
+function listCacheDelete$1(key) {
+  var data = this.__data__, index = assocIndexOf$3(data, key);
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  --this.size;
+  return true;
+}
+var _listCacheDelete = listCacheDelete$1;
+var assocIndexOf$2 = _assocIndexOf;
+function listCacheGet$1(key) {
+  var data = this.__data__, index = assocIndexOf$2(data, key);
+  return index < 0 ? void 0 : data[index][1];
+}
+var _listCacheGet = listCacheGet$1;
+var assocIndexOf$1 = _assocIndexOf;
+function listCacheHas$1(key) {
+  return assocIndexOf$1(this.__data__, key) > -1;
+}
+var _listCacheHas = listCacheHas$1;
+var assocIndexOf = _assocIndexOf;
+function listCacheSet$1(key, value) {
+  var data = this.__data__, index = assocIndexOf(data, key);
+  if (index < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+var _listCacheSet = listCacheSet$1;
+var listCacheClear = _listCacheClear, listCacheDelete = _listCacheDelete, listCacheGet = _listCacheGet, listCacheHas = _listCacheHas, listCacheSet = _listCacheSet;
+function ListCache$4(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+ListCache$4.prototype.clear = listCacheClear;
+ListCache$4.prototype["delete"] = listCacheDelete;
+ListCache$4.prototype.get = listCacheGet;
+ListCache$4.prototype.has = listCacheHas;
+ListCache$4.prototype.set = listCacheSet;
+var _ListCache = ListCache$4;
+var ListCache$3 = _ListCache;
+function stackClear$1() {
+  this.__data__ = new ListCache$3();
+  this.size = 0;
+}
+var _stackClear = stackClear$1;
+function stackDelete$1(key) {
+  var data = this.__data__, result = data["delete"](key);
+  this.size = data.size;
+  return result;
+}
+var _stackDelete = stackDelete$1;
+function stackGet$1(key) {
+  return this.__data__.get(key);
+}
+var _stackGet = stackGet$1;
+function stackHas$1(key) {
+  return this.__data__.has(key);
+}
+var _stackHas = stackHas$1;
+var baseGetTag$4 = _baseGetTag, isObject$6 = isObject_1;
+var asyncTag = "[object AsyncFunction]", funcTag$2 = "[object Function]", genTag$1 = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
+function isFunction$2(value) {
+  if (!isObject$6(value)) {
+    return false;
+  }
+  var tag = baseGetTag$4(value);
+  return tag == funcTag$2 || tag == genTag$1 || tag == asyncTag || tag == proxyTag;
+}
+var isFunction_1 = isFunction$2;
+var root$6 = _root;
+var coreJsData$1 = root$6["__core-js_shared__"];
+var _coreJsData = coreJsData$1;
+var coreJsData = _coreJsData;
+var maskSrcKey = function() {
+  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+  return uid ? "Symbol(src)_1." + uid : "";
+}();
+function isMasked$1(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+var _isMasked = isMasked$1;
+var funcProto$1 = Function.prototype;
+var funcToString$1 = funcProto$1.toString;
+function toSource$2(func) {
+  if (func != null) {
+    try {
+      return funcToString$1.call(func);
+    } catch (e) {
+    }
+    try {
+      return func + "";
+    } catch (e) {
+    }
+  }
+  return "";
+}
+var _toSource = toSource$2;
+var isFunction$1 = isFunction_1, isMasked = _isMasked, isObject$5 = isObject_1, toSource$1 = _toSource;
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var funcProto = Function.prototype, objectProto$c = Object.prototype;
+var funcToString = funcProto.toString;
+var hasOwnProperty$a = objectProto$c.hasOwnProperty;
+var reIsNative = RegExp(
+  "^" + funcToString.call(hasOwnProperty$a).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function baseIsNative$1(value) {
+  if (!isObject$5(value) || isMasked(value)) {
+    return false;
+  }
+  var pattern = isFunction$1(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource$1(value));
+}
+var _baseIsNative = baseIsNative$1;
+function getValue$1(object, key) {
+  return object == null ? void 0 : object[key];
+}
+var _getValue = getValue$1;
+var baseIsNative = _baseIsNative, getValue = _getValue;
+function getNative$7(object, key) {
+  var value = getValue(object, key);
+  return baseIsNative(value) ? value : void 0;
+}
+var _getNative = getNative$7;
+var getNative$6 = _getNative, root$5 = _root;
+var Map$3 = getNative$6(root$5, "Map");
+var _Map = Map$3;
+var getNative$5 = _getNative;
+var nativeCreate$4 = getNative$5(Object, "create");
+var _nativeCreate = nativeCreate$4;
+var nativeCreate$3 = _nativeCreate;
+function hashClear$1() {
+  this.__data__ = nativeCreate$3 ? nativeCreate$3(null) : {};
+  this.size = 0;
+}
+var _hashClear = hashClear$1;
+function hashDelete$1(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var _hashDelete = hashDelete$1;
+var nativeCreate$2 = _nativeCreate;
+var HASH_UNDEFINED$2 = "__lodash_hash_undefined__";
+var objectProto$b = Object.prototype;
+var hasOwnProperty$9 = objectProto$b.hasOwnProperty;
+function hashGet$1(key) {
+  var data = this.__data__;
+  if (nativeCreate$2) {
+    var result = data[key];
+    return result === HASH_UNDEFINED$2 ? void 0 : result;
+  }
+  return hasOwnProperty$9.call(data, key) ? data[key] : void 0;
+}
+var _hashGet = hashGet$1;
+var nativeCreate$1 = _nativeCreate;
+var objectProto$a = Object.prototype;
+var hasOwnProperty$8 = objectProto$a.hasOwnProperty;
+function hashHas$1(key) {
+  var data = this.__data__;
+  return nativeCreate$1 ? data[key] !== void 0 : hasOwnProperty$8.call(data, key);
+}
+var _hashHas = hashHas$1;
+var nativeCreate = _nativeCreate;
+var HASH_UNDEFINED$1 = "__lodash_hash_undefined__";
+function hashSet$1(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED$1 : value;
+  return this;
+}
+var _hashSet = hashSet$1;
+var hashClear = _hashClear, hashDelete = _hashDelete, hashGet = _hashGet, hashHas = _hashHas, hashSet = _hashSet;
+function Hash$1(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+Hash$1.prototype.clear = hashClear;
+Hash$1.prototype["delete"] = hashDelete;
+Hash$1.prototype.get = hashGet;
+Hash$1.prototype.has = hashHas;
+Hash$1.prototype.set = hashSet;
+var _Hash = Hash$1;
+var Hash = _Hash, ListCache$2 = _ListCache, Map$2 = _Map;
+function mapCacheClear$1() {
+  this.size = 0;
+  this.__data__ = {
+    "hash": new Hash(),
+    "map": new (Map$2 || ListCache$2)(),
+    "string": new Hash()
+  };
+}
+var _mapCacheClear = mapCacheClear$1;
+function isKeyable$1(value) {
+  var type2 = typeof value;
+  return type2 == "string" || type2 == "number" || type2 == "symbol" || type2 == "boolean" ? value !== "__proto__" : value === null;
+}
+var _isKeyable = isKeyable$1;
+var isKeyable = _isKeyable;
+function getMapData$4(map, key) {
+  var data = map.__data__;
+  return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+}
+var _getMapData = getMapData$4;
+var getMapData$3 = _getMapData;
+function mapCacheDelete$1(key) {
+  var result = getMapData$3(this, key)["delete"](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var _mapCacheDelete = mapCacheDelete$1;
+var getMapData$2 = _getMapData;
+function mapCacheGet$1(key) {
+  return getMapData$2(this, key).get(key);
+}
+var _mapCacheGet = mapCacheGet$1;
+var getMapData$1 = _getMapData;
+function mapCacheHas$1(key) {
+  return getMapData$1(this, key).has(key);
+}
+var _mapCacheHas = mapCacheHas$1;
+var getMapData = _getMapData;
+function mapCacheSet$1(key, value) {
+  var data = getMapData(this, key), size2 = data.size;
+  data.set(key, value);
+  this.size += data.size == size2 ? 0 : 1;
+  return this;
+}
+var _mapCacheSet = mapCacheSet$1;
+var mapCacheClear = _mapCacheClear, mapCacheDelete = _mapCacheDelete, mapCacheGet = _mapCacheGet, mapCacheHas = _mapCacheHas, mapCacheSet = _mapCacheSet;
+function MapCache$3(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+MapCache$3.prototype.clear = mapCacheClear;
+MapCache$3.prototype["delete"] = mapCacheDelete;
+MapCache$3.prototype.get = mapCacheGet;
+MapCache$3.prototype.has = mapCacheHas;
+MapCache$3.prototype.set = mapCacheSet;
+var _MapCache = MapCache$3;
+var ListCache$1 = _ListCache, Map$1 = _Map, MapCache$2 = _MapCache;
+var LARGE_ARRAY_SIZE = 200;
+function stackSet$1(key, value) {
+  var data = this.__data__;
+  if (data instanceof ListCache$1) {
+    var pairs = data.__data__;
+    if (!Map$1 || pairs.length < LARGE_ARRAY_SIZE - 1) {
+      pairs.push([key, value]);
+      this.size = ++data.size;
+      return this;
+    }
+    data = this.__data__ = new MapCache$2(pairs);
+  }
+  data.set(key, value);
+  this.size = data.size;
+  return this;
+}
+var _stackSet = stackSet$1;
+var ListCache = _ListCache, stackClear = _stackClear, stackDelete = _stackDelete, stackGet = _stackGet, stackHas = _stackHas, stackSet = _stackSet;
+function Stack$3(entries) {
+  var data = this.__data__ = new ListCache(entries);
+  this.size = data.size;
+}
+Stack$3.prototype.clear = stackClear;
+Stack$3.prototype["delete"] = stackDelete;
+Stack$3.prototype.get = stackGet;
+Stack$3.prototype.has = stackHas;
+Stack$3.prototype.set = stackSet;
+var _Stack = Stack$3;
+var HASH_UNDEFINED = "__lodash_hash_undefined__";
+function setCacheAdd$1(value) {
+  this.__data__.set(value, HASH_UNDEFINED);
+  return this;
+}
+var _setCacheAdd = setCacheAdd$1;
+function setCacheHas$1(value) {
+  return this.__data__.has(value);
+}
+var _setCacheHas = setCacheHas$1;
+var MapCache$1 = _MapCache, setCacheAdd = _setCacheAdd, setCacheHas = _setCacheHas;
+function SetCache$1(values) {
+  var index = -1, length = values == null ? 0 : values.length;
+  this.__data__ = new MapCache$1();
+  while (++index < length) {
+    this.add(values[index]);
+  }
+}
+SetCache$1.prototype.add = SetCache$1.prototype.push = setCacheAdd;
+SetCache$1.prototype.has = setCacheHas;
+var _SetCache = SetCache$1;
+function arraySome$1(array, predicate) {
+  var index = -1, length = array == null ? 0 : array.length;
+  while (++index < length) {
+    if (predicate(array[index], index, array)) {
+      return true;
+    }
+  }
+  return false;
+}
+var _arraySome = arraySome$1;
+function cacheHas$1(cache, key) {
+  return cache.has(key);
+}
+var _cacheHas = cacheHas$1;
+var SetCache = _SetCache, arraySome = _arraySome, cacheHas = _cacheHas;
+var COMPARE_PARTIAL_FLAG$5 = 1, COMPARE_UNORDERED_FLAG$3 = 2;
+function equalArrays$2(array, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$5, arrLength = array.length, othLength = other.length;
+  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+    return false;
+  }
+  var arrStacked = stack.get(array);
+  var othStacked = stack.get(other);
+  if (arrStacked && othStacked) {
+    return arrStacked == other && othStacked == array;
+  }
+  var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG$3 ? new SetCache() : void 0;
+  stack.set(array, other);
+  stack.set(other, array);
+  while (++index < arrLength) {
+    var arrValue = array[index], othValue = other[index];
+    if (customizer) {
+      var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
+    }
+    if (compared !== void 0) {
+      if (compared) {
+        continue;
+      }
+      result = false;
+      break;
+    }
+    if (seen) {
+      if (!arraySome(other, function(othValue2, othIndex) {
+        if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
+          return seen.push(othIndex);
+        }
+      })) {
+        result = false;
+        break;
+      }
+    } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+      result = false;
+      break;
+    }
+  }
+  stack["delete"](array);
+  stack["delete"](other);
+  return result;
+}
+var _equalArrays = equalArrays$2;
+var root$4 = _root;
+var Uint8Array$3 = root$4.Uint8Array;
+var _Uint8Array = Uint8Array$3;
+function mapToArray$1(map) {
+  var index = -1, result = Array(map.size);
+  map.forEach(function(value, key) {
+    result[++index] = [key, value];
+  });
+  return result;
+}
+var _mapToArray = mapToArray$1;
+function setToArray$1(set) {
+  var index = -1, result = Array(set.size);
+  set.forEach(function(value) {
+    result[++index] = value;
+  });
+  return result;
+}
+var _setToArray = setToArray$1;
+var Symbol$4 = _Symbol, Uint8Array$2 = _Uint8Array, eq$2 = eq_1, equalArrays$1 = _equalArrays, mapToArray = _mapToArray, setToArray = _setToArray;
+var COMPARE_PARTIAL_FLAG$4 = 1, COMPARE_UNORDERED_FLAG$2 = 2;
+var boolTag$3 = "[object Boolean]", dateTag$3 = "[object Date]", errorTag$2 = "[object Error]", mapTag$6 = "[object Map]", numberTag$3 = "[object Number]", regexpTag$3 = "[object RegExp]", setTag$6 = "[object Set]", stringTag$4 = "[object String]", symbolTag$2 = "[object Symbol]";
+var arrayBufferTag$3 = "[object ArrayBuffer]", dataViewTag$4 = "[object DataView]";
+var symbolProto$2 = Symbol$4 ? Symbol$4.prototype : void 0, symbolValueOf$1 = symbolProto$2 ? symbolProto$2.valueOf : void 0;
+function equalByTag$1(object, other, tag, bitmask, customizer, equalFunc, stack) {
+  switch (tag) {
+    case dataViewTag$4:
+      if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
+        return false;
+      }
+      object = object.buffer;
+      other = other.buffer;
+    case arrayBufferTag$3:
+      if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array$2(object), new Uint8Array$2(other))) {
+        return false;
+      }
+      return true;
+    case boolTag$3:
+    case dateTag$3:
+    case numberTag$3:
+      return eq$2(+object, +other);
+    case errorTag$2:
+      return object.name == other.name && object.message == other.message;
+    case regexpTag$3:
+    case stringTag$4:
+      return object == other + "";
+    case mapTag$6:
+      var convert = mapToArray;
+    case setTag$6:
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG$4;
+      convert || (convert = setToArray);
+      if (object.size != other.size && !isPartial) {
+        return false;
+      }
+      var stacked = stack.get(object);
+      if (stacked) {
+        return stacked == other;
+      }
+      bitmask |= COMPARE_UNORDERED_FLAG$2;
+      stack.set(object, other);
+      var result = equalArrays$1(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+      stack["delete"](object);
+      return result;
+    case symbolTag$2:
+      if (symbolValueOf$1) {
+        return symbolValueOf$1.call(object) == symbolValueOf$1.call(other);
+      }
+  }
+  return false;
+}
+var _equalByTag = equalByTag$1;
+function arrayPush$3(array, values) {
+  var index = -1, length = values.length, offset = array.length;
+  while (++index < length) {
+    array[offset + index] = values[index];
+  }
+  return array;
+}
+var _arrayPush = arrayPush$3;
+var isArray$d = Array.isArray;
+var isArray_1 = isArray$d;
+var arrayPush$2 = _arrayPush, isArray$c = isArray_1;
+function baseGetAllKeys$2(object, keysFunc, symbolsFunc) {
+  var result = keysFunc(object);
+  return isArray$c(object) ? result : arrayPush$2(result, symbolsFunc(object));
+}
+var _baseGetAllKeys = baseGetAllKeys$2;
+function arrayFilter$1(array, predicate) {
+  var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
+  while (++index < length) {
+    var value = array[index];
+    if (predicate(value, index, array)) {
+      result[resIndex++] = value;
+    }
+  }
+  return result;
+}
+var _arrayFilter = arrayFilter$1;
+function stubArray$2() {
+  return [];
+}
+var stubArray_1 = stubArray$2;
+var arrayFilter = _arrayFilter, stubArray$1 = stubArray_1;
+var objectProto$9 = Object.prototype;
+var propertyIsEnumerable$1 = objectProto$9.propertyIsEnumerable;
+var nativeGetSymbols$1 = Object.getOwnPropertySymbols;
+var getSymbols$3 = !nativeGetSymbols$1 ? stubArray$1 : function(object) {
+  if (object == null) {
+    return [];
+  }
+  object = Object(object);
+  return arrayFilter(nativeGetSymbols$1(object), function(symbol) {
+    return propertyIsEnumerable$1.call(object, symbol);
+  });
+};
+var _getSymbols = getSymbols$3;
+var baseGetTag$3 = _baseGetTag, isObjectLike$6 = isObjectLike_1;
+var argsTag$3 = "[object Arguments]";
+function baseIsArguments$1(value) {
+  return isObjectLike$6(value) && baseGetTag$3(value) == argsTag$3;
+}
+var _baseIsArguments = baseIsArguments$1;
+var baseIsArguments = _baseIsArguments, isObjectLike$5 = isObjectLike_1;
+var objectProto$8 = Object.prototype;
+var hasOwnProperty$7 = objectProto$8.hasOwnProperty;
+var propertyIsEnumerable = objectProto$8.propertyIsEnumerable;
+var isArguments$3 = baseIsArguments(function() {
+  return arguments;
+}()) ? baseIsArguments : function(value) {
+  return isObjectLike$5(value) && hasOwnProperty$7.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+};
+var isArguments_1 = isArguments$3;
+var isBuffer$3 = { exports: {} };
+function stubFalse() {
+  return false;
+}
+var stubFalse_1 = stubFalse;
+isBuffer$3.exports;
+(function(module2, exports2) {
+  var root2 = _root, stubFalse2 = stubFalse_1;
+  var freeExports = exports2 && !exports2.nodeType && exports2;
+  var freeModule = freeExports && true && module2 && !module2.nodeType && module2;
+  var moduleExports = freeModule && freeModule.exports === freeExports;
+  var Buffer = moduleExports ? root2.Buffer : void 0;
+  var nativeIsBuffer = Buffer ? Buffer.isBuffer : void 0;
+  var isBuffer2 = nativeIsBuffer || stubFalse2;
+  module2.exports = isBuffer2;
+})(isBuffer$3, isBuffer$3.exports);
+var isBufferExports = isBuffer$3.exports;
+var MAX_SAFE_INTEGER$1 = 9007199254740991;
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+function isIndex$3(value, length) {
+  var type2 = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER$1 : length;
+  return !!length && (type2 == "number" || type2 != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+}
+var _isIndex = isIndex$3;
+var MAX_SAFE_INTEGER = 9007199254740991;
+function isLength$3(value) {
+  return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+var isLength_1 = isLength$3;
+var baseGetTag$2 = _baseGetTag, isLength$2 = isLength_1, isObjectLike$4 = isObjectLike_1;
+var argsTag$2 = "[object Arguments]", arrayTag$2 = "[object Array]", boolTag$2 = "[object Boolean]", dateTag$2 = "[object Date]", errorTag$1 = "[object Error]", funcTag$1 = "[object Function]", mapTag$5 = "[object Map]", numberTag$2 = "[object Number]", objectTag$3 = "[object Object]", regexpTag$2 = "[object RegExp]", setTag$5 = "[object Set]", stringTag$3 = "[object String]", weakMapTag$2 = "[object WeakMap]";
+var arrayBufferTag$2 = "[object ArrayBuffer]", dataViewTag$3 = "[object DataView]", float32Tag$2 = "[object Float32Array]", float64Tag$2 = "[object Float64Array]", int8Tag$2 = "[object Int8Array]", int16Tag$2 = "[object Int16Array]", int32Tag$2 = "[object Int32Array]", uint8Tag$2 = "[object Uint8Array]", uint8ClampedTag$2 = "[object Uint8ClampedArray]", uint16Tag$2 = "[object Uint16Array]", uint32Tag$2 = "[object Uint32Array]";
+var typedArrayTags = {};
+typedArrayTags[float32Tag$2] = typedArrayTags[float64Tag$2] = typedArrayTags[int8Tag$2] = typedArrayTags[int16Tag$2] = typedArrayTags[int32Tag$2] = typedArrayTags[uint8Tag$2] = typedArrayTags[uint8ClampedTag$2] = typedArrayTags[uint16Tag$2] = typedArrayTags[uint32Tag$2] = true;
+typedArrayTags[argsTag$2] = typedArrayTags[arrayTag$2] = typedArrayTags[arrayBufferTag$2] = typedArrayTags[boolTag$2] = typedArrayTags[dataViewTag$3] = typedArrayTags[dateTag$2] = typedArrayTags[errorTag$1] = typedArrayTags[funcTag$1] = typedArrayTags[mapTag$5] = typedArrayTags[numberTag$2] = typedArrayTags[objectTag$3] = typedArrayTags[regexpTag$2] = typedArrayTags[setTag$5] = typedArrayTags[stringTag$3] = typedArrayTags[weakMapTag$2] = false;
+function baseIsTypedArray$1(value) {
+  return isObjectLike$4(value) && isLength$2(value.length) && !!typedArrayTags[baseGetTag$2(value)];
+}
+var _baseIsTypedArray = baseIsTypedArray$1;
+function baseUnary$4(func) {
+  return function(value) {
+    return func(value);
+  };
+}
+var _baseUnary = baseUnary$4;
+var _nodeUtil = { exports: {} };
+_nodeUtil.exports;
+(function(module2, exports2) {
+  var freeGlobal2 = _freeGlobal;
+  var freeExports = exports2 && !exports2.nodeType && exports2;
+  var freeModule = freeExports && true && module2 && !module2.nodeType && module2;
+  var moduleExports = freeModule && freeModule.exports === freeExports;
+  var freeProcess = moduleExports && freeGlobal2.process;
+  var nodeUtil2 = function() {
+    try {
+      var types = freeModule && freeModule.require && freeModule.require("util").types;
+      if (types) {
+        return types;
+      }
+      return freeProcess && freeProcess.binding && freeProcess.binding("util");
+    } catch (e) {
+    }
+  }();
+  module2.exports = nodeUtil2;
+})(_nodeUtil, _nodeUtil.exports);
+var _nodeUtilExports = _nodeUtil.exports;
+var baseIsTypedArray = _baseIsTypedArray, baseUnary$3 = _baseUnary, nodeUtil$2 = _nodeUtilExports;
+var nodeIsTypedArray = nodeUtil$2 && nodeUtil$2.isTypedArray;
+var isTypedArray$2 = nodeIsTypedArray ? baseUnary$3(nodeIsTypedArray) : baseIsTypedArray;
+var isTypedArray_1 = isTypedArray$2;
+var baseTimes = _baseTimes, isArguments$2 = isArguments_1, isArray$b = isArray_1, isBuffer$2 = isBufferExports, isIndex$2 = _isIndex, isTypedArray$1 = isTypedArray_1;
+var objectProto$7 = Object.prototype;
+var hasOwnProperty$6 = objectProto$7.hasOwnProperty;
+function arrayLikeKeys$2(value, inherited) {
+  var isArr = isArray$b(value), isArg = !isArr && isArguments$2(value), isBuff = !isArr && !isArg && isBuffer$2(value), isType = !isArr && !isArg && !isBuff && isTypedArray$1(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
+  for (var key in value) {
+    if ((inherited || hasOwnProperty$6.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
+    (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+    isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+    isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
+    isIndex$2(key, length)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var _arrayLikeKeys = arrayLikeKeys$2;
+var objectProto$6 = Object.prototype;
+function isPrototype$3(value) {
+  var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$6;
+  return value === proto;
+}
+var _isPrototype = isPrototype$3;
+function overArg$2(func, transform) {
+  return function(arg) {
+    return func(transform(arg));
+  };
+}
+var _overArg = overArg$2;
+var overArg$1 = _overArg;
+var nativeKeys$1 = overArg$1(Object.keys, Object);
+var _nativeKeys = nativeKeys$1;
+var isPrototype$2 = _isPrototype, nativeKeys = _nativeKeys;
+var objectProto$5 = Object.prototype;
+var hasOwnProperty$5 = objectProto$5.hasOwnProperty;
+function baseKeys$2(object) {
+  if (!isPrototype$2(object)) {
+    return nativeKeys(object);
+  }
+  var result = [];
+  for (var key in Object(object)) {
+    if (hasOwnProperty$5.call(object, key) && key != "constructor") {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var _baseKeys = baseKeys$2;
+var isFunction = isFunction_1, isLength$1 = isLength_1;
+function isArrayLike$7(value) {
+  return value != null && isLength$1(value.length) && !isFunction(value);
+}
+var isArrayLike_1 = isArrayLike$7;
+var arrayLikeKeys$1 = _arrayLikeKeys, baseKeys$1 = _baseKeys, isArrayLike$6 = isArrayLike_1;
+function keys$6(object) {
+  return isArrayLike$6(object) ? arrayLikeKeys$1(object) : baseKeys$1(object);
+}
+var keys_1 = keys$6;
+var baseGetAllKeys$1 = _baseGetAllKeys, getSymbols$2 = _getSymbols, keys$5 = keys_1;
+function getAllKeys$2(object) {
+  return baseGetAllKeys$1(object, keys$5, getSymbols$2);
+}
+var _getAllKeys = getAllKeys$2;
+var getAllKeys$1 = _getAllKeys;
+var COMPARE_PARTIAL_FLAG$3 = 1;
+var objectProto$4 = Object.prototype;
+var hasOwnProperty$4 = objectProto$4.hasOwnProperty;
+function equalObjects$1(object, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$3, objProps = getAllKeys$1(object), objLength = objProps.length, othProps = getAllKeys$1(other), othLength = othProps.length;
+  if (objLength != othLength && !isPartial) {
+    return false;
+  }
+  var index = objLength;
+  while (index--) {
+    var key = objProps[index];
+    if (!(isPartial ? key in other : hasOwnProperty$4.call(other, key))) {
+      return false;
+    }
+  }
+  var objStacked = stack.get(object);
+  var othStacked = stack.get(other);
+  if (objStacked && othStacked) {
+    return objStacked == other && othStacked == object;
+  }
+  var result = true;
+  stack.set(object, other);
+  stack.set(other, object);
+  var skipCtor = isPartial;
+  while (++index < objLength) {
+    key = objProps[index];
+    var objValue = object[key], othValue = other[key];
+    if (customizer) {
+      var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+    }
+    if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
+      result = false;
+      break;
+    }
+    skipCtor || (skipCtor = key == "constructor");
+  }
+  if (result && !skipCtor) {
+    var objCtor = object.constructor, othCtor = other.constructor;
+    if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
+      result = false;
+    }
+  }
+  stack["delete"](object);
+  stack["delete"](other);
+  return result;
+}
+var _equalObjects = equalObjects$1;
+var getNative$4 = _getNative, root$3 = _root;
+var DataView$1 = getNative$4(root$3, "DataView");
+var _DataView = DataView$1;
+var getNative$3 = _getNative, root$2 = _root;
+var Promise$2 = getNative$3(root$2, "Promise");
+var _Promise = Promise$2;
+var getNative$2 = _getNative, root$1 = _root;
+var Set$1 = getNative$2(root$1, "Set");
+var _Set = Set$1;
+var getNative$1 = _getNative, root = _root;
+var WeakMap$1 = getNative$1(root, "WeakMap");
+var _WeakMap = WeakMap$1;
+var DataView = _DataView, Map = _Map, Promise$1 = _Promise, Set = _Set, WeakMap = _WeakMap, baseGetTag$1 = _baseGetTag, toSource = _toSource;
+var mapTag$4 = "[object Map]", objectTag$2 = "[object Object]", promiseTag = "[object Promise]", setTag$4 = "[object Set]", weakMapTag$1 = "[object WeakMap]";
+var dataViewTag$2 = "[object DataView]";
+var dataViewCtorString = toSource(DataView), mapCtorString = toSource(Map), promiseCtorString = toSource(Promise$1), setCtorString = toSource(Set), weakMapCtorString = toSource(WeakMap);
+var getTag$5 = baseGetTag$1;
+if (DataView && getTag$5(new DataView(new ArrayBuffer(1))) != dataViewTag$2 || Map && getTag$5(new Map()) != mapTag$4 || Promise$1 && getTag$5(Promise$1.resolve()) != promiseTag || Set && getTag$5(new Set()) != setTag$4 || WeakMap && getTag$5(new WeakMap()) != weakMapTag$1) {
+  getTag$5 = function(value) {
+    var result = baseGetTag$1(value), Ctor = result == objectTag$2 ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
+    if (ctorString) {
+      switch (ctorString) {
+        case dataViewCtorString:
+          return dataViewTag$2;
+        case mapCtorString:
+          return mapTag$4;
+        case promiseCtorString:
+          return promiseTag;
+        case setCtorString:
+          return setTag$4;
+        case weakMapCtorString:
+          return weakMapTag$1;
+      }
+    }
+    return result;
+  };
+}
+var _getTag = getTag$5;
+var Stack$2 = _Stack, equalArrays = _equalArrays, equalByTag = _equalByTag, equalObjects = _equalObjects, getTag$4 = _getTag, isArray$a = isArray_1, isBuffer$1 = isBufferExports, isTypedArray = isTypedArray_1;
+var COMPARE_PARTIAL_FLAG$2 = 1;
+var argsTag$1 = "[object Arguments]", arrayTag$1 = "[object Array]", objectTag$1 = "[object Object]";
+var objectProto$3 = Object.prototype;
+var hasOwnProperty$3 = objectProto$3.hasOwnProperty;
+function baseIsEqualDeep$1(object, other, bitmask, customizer, equalFunc, stack) {
+  var objIsArr = isArray$a(object), othIsArr = isArray$a(other), objTag = objIsArr ? arrayTag$1 : getTag$4(object), othTag = othIsArr ? arrayTag$1 : getTag$4(other);
+  objTag = objTag == argsTag$1 ? objectTag$1 : objTag;
+  othTag = othTag == argsTag$1 ? objectTag$1 : othTag;
+  var objIsObj = objTag == objectTag$1, othIsObj = othTag == objectTag$1, isSameTag = objTag == othTag;
+  if (isSameTag && isBuffer$1(object)) {
+    if (!isBuffer$1(other)) {
+      return false;
+    }
+    objIsArr = true;
+    objIsObj = false;
+  }
+  if (isSameTag && !objIsObj) {
+    stack || (stack = new Stack$2());
+    return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+  }
+  if (!(bitmask & COMPARE_PARTIAL_FLAG$2)) {
+    var objIsWrapped = objIsObj && hasOwnProperty$3.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty$3.call(other, "__wrapped__");
+    if (objIsWrapped || othIsWrapped) {
+      var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
+      stack || (stack = new Stack$2());
+      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+    }
+  }
+  if (!isSameTag) {
+    return false;
+  }
+  stack || (stack = new Stack$2());
+  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+}
+var _baseIsEqualDeep = baseIsEqualDeep$1;
+var baseIsEqualDeep = _baseIsEqualDeep, isObjectLike$3 = isObjectLike_1;
+function baseIsEqual$2(value, other, bitmask, customizer, stack) {
+  if (value === other) {
+    return true;
+  }
+  if (value == null || other == null || !isObjectLike$3(value) && !isObjectLike$3(other)) {
+    return value !== value && other !== other;
+  }
+  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual$2, stack);
+}
+var _baseIsEqual = baseIsEqual$2;
+var Stack$1 = _Stack, baseIsEqual$1 = _baseIsEqual;
+var COMPARE_PARTIAL_FLAG$1 = 1, COMPARE_UNORDERED_FLAG$1 = 2;
+function baseIsMatch$1(object, source, matchData, customizer) {
+  var index = matchData.length, length = index, noCustomizer = !customizer;
+  if (object == null) {
+    return !length;
+  }
+  object = Object(object);
+  while (index--) {
+    var data = matchData[index];
+    if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
+      return false;
+    }
+  }
+  while (++index < length) {
+    data = matchData[index];
+    var key = data[0], objValue = object[key], srcValue = data[1];
+    if (noCustomizer && data[2]) {
+      if (objValue === void 0 && !(key in object)) {
+        return false;
+      }
+    } else {
+      var stack = new Stack$1();
+      if (customizer) {
+        var result = customizer(objValue, srcValue, key, object, source, stack);
+      }
+      if (!(result === void 0 ? baseIsEqual$1(srcValue, objValue, COMPARE_PARTIAL_FLAG$1 | COMPARE_UNORDERED_FLAG$1, customizer, stack) : result)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+var _baseIsMatch = baseIsMatch$1;
+var isObject$4 = isObject_1;
+function isStrictComparable$2(value) {
+  return value === value && !isObject$4(value);
+}
+var _isStrictComparable = isStrictComparable$2;
+var isStrictComparable$1 = _isStrictComparable, keys$4 = keys_1;
+function getMatchData$1(object) {
+  var result = keys$4(object), length = result.length;
+  while (length--) {
+    var key = result[length], value = object[key];
+    result[length] = [key, value, isStrictComparable$1(value)];
+  }
+  return result;
+}
+var _getMatchData = getMatchData$1;
+function matchesStrictComparable$2(key, srcValue) {
+  return function(object) {
+    if (object == null) {
+      return false;
+    }
+    return object[key] === srcValue && (srcValue !== void 0 || key in Object(object));
+  };
+}
+var _matchesStrictComparable = matchesStrictComparable$2;
+var baseIsMatch = _baseIsMatch, getMatchData = _getMatchData, matchesStrictComparable$1 = _matchesStrictComparable;
+function baseMatches$1(source) {
+  var matchData = getMatchData(source);
+  if (matchData.length == 1 && matchData[0][2]) {
+    return matchesStrictComparable$1(matchData[0][0], matchData[0][1]);
+  }
+  return function(object) {
+    return object === source || baseIsMatch(object, source, matchData);
+  };
+}
+var _baseMatches = baseMatches$1;
+var isArray$9 = isArray_1, isSymbol$3 = isSymbol_1;
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/;
+function isKey$3(value, object) {
+  if (isArray$9(value)) {
+    return false;
+  }
+  var type2 = typeof value;
+  if (type2 == "number" || type2 == "symbol" || type2 == "boolean" || value == null || isSymbol$3(value)) {
+    return true;
+  }
+  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+}
+var _isKey = isKey$3;
+var MapCache = _MapCache;
+var FUNC_ERROR_TEXT = "Expected a function";
+function memoize$1(func, resolver) {
+  if (typeof func != "function" || resolver != null && typeof resolver != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  var memoized = function() {
+    var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    var result = func.apply(this, args);
+    memoized.cache = cache.set(key, result) || cache;
+    return result;
+  };
+  memoized.cache = new (memoize$1.Cache || MapCache)();
+  return memoized;
+}
+memoize$1.Cache = MapCache;
+var memoize_1 = memoize$1;
+var memoize = memoize_1;
+var MAX_MEMOIZE_SIZE = 500;
+function memoizeCapped$1(func) {
+  var result = memoize(func, function(key) {
+    if (cache.size === MAX_MEMOIZE_SIZE) {
+      cache.clear();
+    }
+    return key;
+  });
+  var cache = result.cache;
+  return result;
+}
+var _memoizeCapped = memoizeCapped$1;
+var memoizeCapped = _memoizeCapped;
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+var reEscapeChar = /\\(\\)?/g;
+var stringToPath$1 = memoizeCapped(function(string) {
+  var result = [];
+  if (string.charCodeAt(0) === 46) {
+    result.push("");
+  }
+  string.replace(rePropName, function(match, number, quote, subString) {
+    result.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
+  });
+  return result;
+});
+var _stringToPath = stringToPath$1;
+function arrayMap$2(array, iteratee) {
+  var index = -1, length = array == null ? 0 : array.length, result = Array(length);
+  while (++index < length) {
+    result[index] = iteratee(array[index], index, array);
+  }
+  return result;
+}
+var _arrayMap = arrayMap$2;
+var Symbol$3 = _Symbol, arrayMap$1 = _arrayMap, isArray$8 = isArray_1, isSymbol$2 = isSymbol_1;
+var INFINITY$1 = 1 / 0;
+var symbolProto$1 = Symbol$3 ? Symbol$3.prototype : void 0, symbolToString = symbolProto$1 ? symbolProto$1.toString : void 0;
+function baseToString$1(value) {
+  if (typeof value == "string") {
+    return value;
+  }
+  if (isArray$8(value)) {
+    return arrayMap$1(value, baseToString$1) + "";
+  }
+  if (isSymbol$2(value)) {
+    return symbolToString ? symbolToString.call(value) : "";
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY$1 ? "-0" : result;
+}
+var _baseToString = baseToString$1;
+var baseToString = _baseToString;
+function toString$1(value) {
+  return value == null ? "" : baseToString(value);
+}
+var toString_1 = toString$1;
+var isArray$7 = isArray_1, isKey$2 = _isKey, stringToPath = _stringToPath, toString = toString_1;
+function castPath$2(value, object) {
+  if (isArray$7(value)) {
+    return value;
+  }
+  return isKey$2(value, object) ? [value] : stringToPath(toString(value));
+}
+var _castPath = castPath$2;
+var isSymbol$1 = isSymbol_1;
+var INFINITY = 1 / 0;
+function toKey$4(value) {
+  if (typeof value == "string" || isSymbol$1(value)) {
+    return value;
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+}
+var _toKey = toKey$4;
+var castPath$1 = _castPath, toKey$3 = _toKey;
+function baseGet$3(object, path) {
+  path = castPath$1(path, object);
+  var index = 0, length = path.length;
+  while (object != null && index < length) {
+    object = object[toKey$3(path[index++])];
+  }
+  return index && index == length ? object : void 0;
+}
+var _baseGet = baseGet$3;
+var baseGet$2 = _baseGet;
+function get$1(object, path, defaultValue) {
+  var result = object == null ? void 0 : baseGet$2(object, path);
+  return result === void 0 ? defaultValue : result;
+}
+var get_1 = get$1;
+function baseHasIn$1(object, key) {
+  return object != null && key in Object(object);
+}
+var _baseHasIn = baseHasIn$1;
+var castPath = _castPath, isArguments$1 = isArguments_1, isArray$6 = isArray_1, isIndex$1 = _isIndex, isLength = isLength_1, toKey$2 = _toKey;
+function hasPath$1(object, path, hasFunc) {
+  path = castPath(path, object);
+  var index = -1, length = path.length, result = false;
+  while (++index < length) {
+    var key = toKey$2(path[index]);
+    if (!(result = object != null && hasFunc(object, key))) {
+      break;
+    }
+    object = object[key];
+  }
+  if (result || ++index != length) {
+    return result;
+  }
+  length = object == null ? 0 : object.length;
+  return !!length && isLength(length) && isIndex$1(key, length) && (isArray$6(object) || isArguments$1(object));
+}
+var _hasPath = hasPath$1;
+var baseHasIn = _baseHasIn, hasPath = _hasPath;
+function hasIn$1(object, path) {
+  return object != null && hasPath(object, path, baseHasIn);
+}
+var hasIn_1 = hasIn$1;
+var baseIsEqual = _baseIsEqual, get = get_1, hasIn = hasIn_1, isKey$1 = _isKey, isStrictComparable = _isStrictComparable, matchesStrictComparable = _matchesStrictComparable, toKey$1 = _toKey;
+var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
+function baseMatchesProperty$1(path, srcValue) {
+  if (isKey$1(path) && isStrictComparable(srcValue)) {
+    return matchesStrictComparable(toKey$1(path), srcValue);
+  }
+  return function(object) {
+    var objValue = get(object, path);
+    return objValue === void 0 && objValue === srcValue ? hasIn(object, path) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
+  };
+}
+var _baseMatchesProperty = baseMatchesProperty$1;
+function baseProperty$2(key) {
+  return function(object) {
+    return object == null ? void 0 : object[key];
+  };
+}
+var _baseProperty = baseProperty$2;
+var baseGet$1 = _baseGet;
+function basePropertyDeep$1(path) {
+  return function(object) {
+    return baseGet$1(object, path);
+  };
+}
+var _basePropertyDeep = basePropertyDeep$1;
+var baseProperty$1 = _baseProperty, basePropertyDeep = _basePropertyDeep, isKey = _isKey, toKey = _toKey;
+function property$1(path) {
+  return isKey(path) ? baseProperty$1(toKey(path)) : basePropertyDeep(path);
+}
+var property_1 = property$1;
+var baseMatches = _baseMatches, baseMatchesProperty = _baseMatchesProperty, identity$3 = identity_1, isArray$5 = isArray_1, property = property_1;
+function baseIteratee$3(value) {
+  if (typeof value == "function") {
+    return value;
+  }
+  if (value == null) {
+    return identity$3;
+  }
+  if (typeof value == "object") {
+    return isArray$5(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value);
+  }
+  return property(value);
+}
+var _baseIteratee = baseIteratee$3;
+var baseIteratee$2 = _baseIteratee, isArrayLike$5 = isArrayLike_1, keys$3 = keys_1;
+function createFind$1(findIndexFunc) {
+  return function(collection, predicate, fromIndex) {
+    var iterable = Object(collection);
+    if (!isArrayLike$5(collection)) {
+      var iteratee = baseIteratee$2(predicate);
+      collection = keys$3(collection);
+      predicate = function(key) {
+        return iteratee(iterable[key], key, iterable);
+      };
+    }
+    var index = findIndexFunc(collection, predicate, fromIndex);
+    return index > -1 ? iterable[iteratee ? collection[index] : index] : void 0;
+  };
+}
+var _createFind = createFind$1;
+function baseFindIndex$1(array, predicate, fromIndex, fromRight) {
+  var length = array.length, index = fromIndex + (fromRight ? 1 : -1);
+  while (fromRight ? index-- : ++index < length) {
+    if (predicate(array[index], index, array)) {
+      return index;
+    }
+  }
+  return -1;
+}
+var _baseFindIndex = baseFindIndex$1;
+var baseFindIndex = _baseFindIndex, baseIteratee$1 = _baseIteratee, toInteger = toInteger_1;
+var nativeMax$1 = Math.max;
+function findIndex$1(array, predicate, fromIndex) {
+  var length = array == null ? 0 : array.length;
+  if (!length) {
+    return -1;
+  }
+  var index = fromIndex == null ? 0 : toInteger(fromIndex);
+  if (index < 0) {
+    index = nativeMax$1(length + index, 0);
+  }
+  return baseFindIndex(array, baseIteratee$1(predicate), index);
+}
+var findIndex_1 = findIndex$1;
+var createFind = _createFind, findIndex = findIndex_1;
+var find = createFind(findIndex);
+var find_1 = find;
+const find$1 = /* @__PURE__ */ getDefaultExportFromCjs(find_1);
+function addCell$1(row, cell) {
+  if (!row.cells)
+    row.cells = {};
+  row.cells[cell.id] = cell;
+  return cell;
+}
+function addEmbed$1(embeds, cellId, tableId) {
+  const embed = {
+    id: cellId,
+    type: "TIPTAP_HTML",
+    embedded: true,
+    data: { tableId, cellId }
+  };
+  embeds[cellId] = embed;
+  return embed;
+}
+var Direction = /* @__PURE__ */ ((Direction2) => {
+  Direction2[Direction2["Before"] = -1] = "Before";
+  Direction2[Direction2["After"] = 1] = "After";
+  return Direction2;
+})(Direction || {});
+var type = "TABLE";
+var name = "Table";
+var initState = () => {
+  const tableId = v4();
+  const embeds = {};
+  const rows = {};
+  times$1(2, (position) => {
+    const rowId = v4();
+    const row = { id: rowId, position, cells: {} };
+    rows[rowId] = row;
+    times$1(3, (position2) => {
+      const cellId = v4();
+      addCell$1(row, { id: cellId, position: position2, data: {} });
+      addEmbed$1(embeds, cellId, tableId);
+    });
+  });
+  return { tableId, embeds, rows };
+};
+var ui = {
+  // Display icon, https://pictogrammers.com/library/mdi/
+  icon: "mdi-table",
+  // Does element support only full width or can be used within layouts
+  // (e.g. 50/50 layout)
+  forceFullWidth: true
+};
+var manifest$1 = {
+  type,
+  version: "1.0",
+  name,
+  ssr: false,
+  isComposite: true,
+  initState,
+  ui
+};
+var src_default = manifest$1;
+function arrayEach$2(array, iteratee) {
+  var index = -1, length = array == null ? 0 : array.length;
+  while (++index < length) {
+    if (iteratee(array[index], index, array) === false) {
+      break;
+    }
+  }
+  return array;
+}
+var _arrayEach = arrayEach$2;
+var getNative = _getNative;
+var defineProperty$2 = function() {
+  try {
+    var func = getNative(Object, "defineProperty");
+    func({}, "", {});
+    return func;
+  } catch (e) {
+  }
+}();
+var _defineProperty = defineProperty$2;
+var defineProperty$1 = _defineProperty;
+function baseAssignValue$2(object, key, value) {
+  if (key == "__proto__" && defineProperty$1) {
+    defineProperty$1(object, key, {
+      "configurable": true,
+      "enumerable": true,
+      "value": value,
+      "writable": true
+    });
+  } else {
+    object[key] = value;
+  }
+}
+var _baseAssignValue = baseAssignValue$2;
+var baseAssignValue$1 = _baseAssignValue, eq$1 = eq_1;
+var objectProto$2 = Object.prototype;
+var hasOwnProperty$2 = objectProto$2.hasOwnProperty;
+function assignValue$2(object, key, value) {
+  var objValue = object[key];
+  if (!(hasOwnProperty$2.call(object, key) && eq$1(objValue, value)) || value === void 0 && !(key in object)) {
+    baseAssignValue$1(object, key, value);
+  }
+}
+var _assignValue = assignValue$2;
+var assignValue$1 = _assignValue, baseAssignValue = _baseAssignValue;
+function copyObject$4(source, props, object, customizer) {
+  var isNew = !object;
+  object || (object = {});
+  var index = -1, length = props.length;
+  while (++index < length) {
+    var key = props[index];
+    var newValue = customizer ? customizer(object[key], source[key], key, object, source) : void 0;
+    if (newValue === void 0) {
+      newValue = source[key];
+    }
+    if (isNew) {
+      baseAssignValue(object, key, newValue);
+    } else {
+      assignValue$1(object, key, newValue);
+    }
+  }
+  return object;
+}
+var _copyObject = copyObject$4;
+var copyObject$3 = _copyObject, keys$2 = keys_1;
+function baseAssign$1(object, source) {
+  return object && copyObject$3(source, keys$2(source), object);
+}
+var _baseAssign = baseAssign$1;
+function nativeKeysIn$1(object) {
+  var result = [];
+  if (object != null) {
+    for (var key in Object(object)) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var _nativeKeysIn = nativeKeysIn$1;
+var isObject$3 = isObject_1, isPrototype$1 = _isPrototype, nativeKeysIn = _nativeKeysIn;
+var objectProto$1 = Object.prototype;
+var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+function baseKeysIn$1(object) {
+  if (!isObject$3(object)) {
+    return nativeKeysIn(object);
+  }
+  var isProto = isPrototype$1(object), result = [];
+  for (var key in object) {
+    if (!(key == "constructor" && (isProto || !hasOwnProperty$1.call(object, key)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var _baseKeysIn = baseKeysIn$1;
+var arrayLikeKeys = _arrayLikeKeys, baseKeysIn = _baseKeysIn, isArrayLike$4 = isArrayLike_1;
+function keysIn$3(object) {
+  return isArrayLike$4(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
+}
+var keysIn_1 = keysIn$3;
+var copyObject$2 = _copyObject, keysIn$2 = keysIn_1;
+function baseAssignIn$1(object, source) {
+  return object && copyObject$2(source, keysIn$2(source), object);
+}
+var _baseAssignIn = baseAssignIn$1;
+var _cloneBuffer = { exports: {} };
+_cloneBuffer.exports;
+(function(module2, exports2) {
+  var root2 = _root;
+  var freeExports = exports2 && !exports2.nodeType && exports2;
+  var freeModule = freeExports && true && module2 && !module2.nodeType && module2;
+  var moduleExports = freeModule && freeModule.exports === freeExports;
+  var Buffer = moduleExports ? root2.Buffer : void 0, allocUnsafe = Buffer ? Buffer.allocUnsafe : void 0;
+  function cloneBuffer2(buffer, isDeep) {
+    if (isDeep) {
+      return buffer.slice();
+    }
+    var length = buffer.length, result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
+    buffer.copy(result);
+    return result;
+  }
+  module2.exports = cloneBuffer2;
+})(_cloneBuffer, _cloneBuffer.exports);
+var _cloneBufferExports = _cloneBuffer.exports;
+function copyArray$1(source, array) {
+  var index = -1, length = source.length;
+  array || (array = Array(length));
+  while (++index < length) {
+    array[index] = source[index];
+  }
+  return array;
+}
+var _copyArray = copyArray$1;
+var copyObject$1 = _copyObject, getSymbols$1 = _getSymbols;
+function copySymbols$1(source, object) {
+  return copyObject$1(source, getSymbols$1(source), object);
+}
+var _copySymbols = copySymbols$1;
+var overArg = _overArg;
+var getPrototype$2 = overArg(Object.getPrototypeOf, Object);
+var _getPrototype = getPrototype$2;
+var arrayPush$1 = _arrayPush, getPrototype$1 = _getPrototype, getSymbols = _getSymbols, stubArray = stubArray_1;
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+var getSymbolsIn$2 = !nativeGetSymbols ? stubArray : function(object) {
+  var result = [];
+  while (object) {
+    arrayPush$1(result, getSymbols(object));
+    object = getPrototype$1(object);
+  }
+  return result;
+};
+var _getSymbolsIn = getSymbolsIn$2;
+var copyObject = _copyObject, getSymbolsIn$1 = _getSymbolsIn;
+function copySymbolsIn$1(source, object) {
+  return copyObject(source, getSymbolsIn$1(source), object);
+}
+var _copySymbolsIn = copySymbolsIn$1;
+var baseGetAllKeys = _baseGetAllKeys, getSymbolsIn = _getSymbolsIn, keysIn$1 = keysIn_1;
+function getAllKeysIn$1(object) {
+  return baseGetAllKeys(object, keysIn$1, getSymbolsIn);
+}
+var _getAllKeysIn = getAllKeysIn$1;
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+function initCloneArray$1(array) {
+  var length = array.length, result = new array.constructor(length);
+  if (length && typeof array[0] == "string" && hasOwnProperty.call(array, "index")) {
+    result.index = array.index;
+    result.input = array.input;
+  }
+  return result;
+}
+var _initCloneArray = initCloneArray$1;
+var Uint8Array$1 = _Uint8Array;
+function cloneArrayBuffer$3(arrayBuffer) {
+  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+  new Uint8Array$1(result).set(new Uint8Array$1(arrayBuffer));
+  return result;
+}
+var _cloneArrayBuffer = cloneArrayBuffer$3;
+var cloneArrayBuffer$2 = _cloneArrayBuffer;
+function cloneDataView$1(dataView, isDeep) {
+  var buffer = isDeep ? cloneArrayBuffer$2(dataView.buffer) : dataView.buffer;
+  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+}
+var _cloneDataView = cloneDataView$1;
+var reFlags = /\w*$/;
+function cloneRegExp$1(regexp) {
+  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
+  result.lastIndex = regexp.lastIndex;
+  return result;
+}
+var _cloneRegExp = cloneRegExp$1;
+var Symbol$2 = _Symbol;
+var symbolProto = Symbol$2 ? Symbol$2.prototype : void 0, symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+function cloneSymbol$1(symbol) {
+  return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
+}
+var _cloneSymbol = cloneSymbol$1;
+var cloneArrayBuffer$1 = _cloneArrayBuffer;
+function cloneTypedArray$1(typedArray, isDeep) {
+  var buffer = isDeep ? cloneArrayBuffer$1(typedArray.buffer) : typedArray.buffer;
+  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+}
+var _cloneTypedArray = cloneTypedArray$1;
+var cloneArrayBuffer = _cloneArrayBuffer, cloneDataView = _cloneDataView, cloneRegExp = _cloneRegExp, cloneSymbol = _cloneSymbol, cloneTypedArray = _cloneTypedArray;
+var boolTag$1 = "[object Boolean]", dateTag$1 = "[object Date]", mapTag$3 = "[object Map]", numberTag$1 = "[object Number]", regexpTag$1 = "[object RegExp]", setTag$3 = "[object Set]", stringTag$2 = "[object String]", symbolTag$1 = "[object Symbol]";
+var arrayBufferTag$1 = "[object ArrayBuffer]", dataViewTag$1 = "[object DataView]", float32Tag$1 = "[object Float32Array]", float64Tag$1 = "[object Float64Array]", int8Tag$1 = "[object Int8Array]", int16Tag$1 = "[object Int16Array]", int32Tag$1 = "[object Int32Array]", uint8Tag$1 = "[object Uint8Array]", uint8ClampedTag$1 = "[object Uint8ClampedArray]", uint16Tag$1 = "[object Uint16Array]", uint32Tag$1 = "[object Uint32Array]";
+function initCloneByTag$1(object, tag, isDeep) {
+  var Ctor = object.constructor;
+  switch (tag) {
+    case arrayBufferTag$1:
+      return cloneArrayBuffer(object);
+    case boolTag$1:
+    case dateTag$1:
+      return new Ctor(+object);
+    case dataViewTag$1:
+      return cloneDataView(object, isDeep);
+    case float32Tag$1:
+    case float64Tag$1:
+    case int8Tag$1:
+    case int16Tag$1:
+    case int32Tag$1:
+    case uint8Tag$1:
+    case uint8ClampedTag$1:
+    case uint16Tag$1:
+    case uint32Tag$1:
+      return cloneTypedArray(object, isDeep);
+    case mapTag$3:
+      return new Ctor();
+    case numberTag$1:
+    case stringTag$2:
+      return new Ctor(object);
+    case regexpTag$1:
+      return cloneRegExp(object);
+    case setTag$3:
+      return new Ctor();
+    case symbolTag$1:
+      return cloneSymbol(object);
+  }
+}
+var _initCloneByTag = initCloneByTag$1;
+var isObject$2 = isObject_1;
+var objectCreate = Object.create;
+var baseCreate$1 = function() {
+  function object() {
+  }
+  return function(proto) {
+    if (!isObject$2(proto)) {
+      return {};
+    }
+    if (objectCreate) {
+      return objectCreate(proto);
+    }
+    object.prototype = proto;
+    var result = new object();
+    object.prototype = void 0;
+    return result;
+  };
+}();
+var _baseCreate = baseCreate$1;
+var baseCreate = _baseCreate, getPrototype = _getPrototype, isPrototype = _isPrototype;
+function initCloneObject$1(object) {
+  return typeof object.constructor == "function" && !isPrototype(object) ? baseCreate(getPrototype(object)) : {};
+}
+var _initCloneObject = initCloneObject$1;
+var getTag$3 = _getTag, isObjectLike$2 = isObjectLike_1;
+var mapTag$2 = "[object Map]";
+function baseIsMap$1(value) {
+  return isObjectLike$2(value) && getTag$3(value) == mapTag$2;
+}
+var _baseIsMap = baseIsMap$1;
+var baseIsMap = _baseIsMap, baseUnary$2 = _baseUnary, nodeUtil$1 = _nodeUtilExports;
+var nodeIsMap = nodeUtil$1 && nodeUtil$1.isMap;
+var isMap$1 = nodeIsMap ? baseUnary$2(nodeIsMap) : baseIsMap;
+var isMap_1 = isMap$1;
+var getTag$2 = _getTag, isObjectLike$1 = isObjectLike_1;
+var setTag$2 = "[object Set]";
+function baseIsSet$1(value) {
+  return isObjectLike$1(value) && getTag$2(value) == setTag$2;
+}
+var _baseIsSet = baseIsSet$1;
+var baseIsSet = _baseIsSet, baseUnary$1 = _baseUnary, nodeUtil = _nodeUtilExports;
+var nodeIsSet = nodeUtil && nodeUtil.isSet;
+var isSet$1 = nodeIsSet ? baseUnary$1(nodeIsSet) : baseIsSet;
+var isSet_1 = isSet$1;
+var Stack = _Stack, arrayEach$1 = _arrayEach, assignValue = _assignValue, baseAssign = _baseAssign, baseAssignIn = _baseAssignIn, cloneBuffer = _cloneBufferExports, copyArray = _copyArray, copySymbols = _copySymbols, copySymbolsIn = _copySymbolsIn, getAllKeys = _getAllKeys, getAllKeysIn = _getAllKeysIn, getTag$1 = _getTag, initCloneArray = _initCloneArray, initCloneByTag = _initCloneByTag, initCloneObject = _initCloneObject, isArray$4 = isArray_1, isBuffer = isBufferExports, isMap = isMap_1, isObject$1 = isObject_1, isSet = isSet_1, keys$1 = keys_1, keysIn = keysIn_1;
+var CLONE_DEEP_FLAG$1 = 1, CLONE_FLAT_FLAG = 2, CLONE_SYMBOLS_FLAG$1 = 4;
+var argsTag = "[object Arguments]", arrayTag = "[object Array]", boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", mapTag$1 = "[object Map]", numberTag = "[object Number]", objectTag = "[object Object]", regexpTag = "[object RegExp]", setTag$1 = "[object Set]", stringTag$1 = "[object String]", symbolTag = "[object Symbol]", weakMapTag = "[object WeakMap]";
+var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]";
+var cloneableTags = {};
+cloneableTags[argsTag] = cloneableTags[arrayTag] = cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = cloneableTags[boolTag] = cloneableTags[dateTag] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag$1] = cloneableTags[numberTag] = cloneableTags[objectTag] = cloneableTags[regexpTag] = cloneableTags[setTag$1] = cloneableTags[stringTag$1] = cloneableTags[symbolTag] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
+cloneableTags[errorTag] = cloneableTags[funcTag] = cloneableTags[weakMapTag] = false;
+function baseClone$1(value, bitmask, customizer, key, object, stack) {
+  var result, isDeep = bitmask & CLONE_DEEP_FLAG$1, isFlat = bitmask & CLONE_FLAT_FLAG, isFull = bitmask & CLONE_SYMBOLS_FLAG$1;
+  if (customizer) {
+    result = object ? customizer(value, key, object, stack) : customizer(value);
+  }
+  if (result !== void 0) {
+    return result;
+  }
+  if (!isObject$1(value)) {
+    return value;
+  }
+  var isArr = isArray$4(value);
+  if (isArr) {
+    result = initCloneArray(value);
+    if (!isDeep) {
+      return copyArray(value, result);
+    }
+  } else {
+    var tag = getTag$1(value), isFunc = tag == funcTag || tag == genTag;
+    if (isBuffer(value)) {
+      return cloneBuffer(value, isDeep);
+    }
+    if (tag == objectTag || tag == argsTag || isFunc && !object) {
+      result = isFlat || isFunc ? {} : initCloneObject(value);
+      if (!isDeep) {
+        return isFlat ? copySymbolsIn(value, baseAssignIn(result, value)) : copySymbols(value, baseAssign(result, value));
+      }
+    } else {
+      if (!cloneableTags[tag]) {
+        return object ? value : {};
+      }
+      result = initCloneByTag(value, tag, isDeep);
+    }
+  }
+  stack || (stack = new Stack());
+  var stacked = stack.get(value);
+  if (stacked) {
+    return stacked;
+  }
+  stack.set(value, result);
+  if (isSet(value)) {
+    value.forEach(function(subValue) {
+      result.add(baseClone$1(subValue, bitmask, customizer, subValue, value, stack));
+    });
+  } else if (isMap(value)) {
+    value.forEach(function(subValue, key2) {
+      result.set(key2, baseClone$1(subValue, bitmask, customizer, key2, value, stack));
+    });
+  }
+  var keysFunc = isFull ? isFlat ? getAllKeysIn : getAllKeys : isFlat ? keysIn : keys$1;
+  var props = isArr ? void 0 : keysFunc(value);
+  arrayEach$1(props || value, function(subValue, key2) {
+    if (props) {
+      key2 = subValue;
+      subValue = value[key2];
+    }
+    assignValue(result, key2, baseClone$1(subValue, bitmask, customizer, key2, value, stack));
+  });
+  return result;
+}
+var _baseClone = baseClone$1;
+var baseClone = _baseClone;
+var CLONE_DEEP_FLAG = 1, CLONE_SYMBOLS_FLAG = 4;
+function cloneDeep(value) {
+  return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
+}
+var cloneDeep_1 = cloneDeep;
+const cloneDeep$1 = /* @__PURE__ */ getDefaultExportFromCjs(cloneDeep_1);
+function head(array) {
+  return array && array.length ? array[0] : void 0;
+}
+var head_1 = head;
+var first = head_1;
+const first$1 = /* @__PURE__ */ getDefaultExportFromCjs(first);
+function createBaseFor$1(fromRight) {
+  return function(object, iteratee, keysFunc) {
+    var index = -1, iterable = Object(object), props = keysFunc(object), length = props.length;
+    while (length--) {
+      var key = props[fromRight ? length : ++index];
+      if (iteratee(iterable[key], key, iterable) === false) {
+        break;
+      }
+    }
+    return object;
+  };
+}
+var _createBaseFor = createBaseFor$1;
+var createBaseFor = _createBaseFor;
+var baseFor$1 = createBaseFor();
+var _baseFor = baseFor$1;
+var baseFor = _baseFor, keys = keys_1;
+function baseForOwn$1(object, iteratee) {
+  return object && baseFor(object, iteratee, keys);
+}
+var _baseForOwn = baseForOwn$1;
+var isArrayLike$3 = isArrayLike_1;
+function createBaseEach$1(eachFunc, fromRight) {
+  return function(collection, iteratee) {
+    if (collection == null) {
+      return collection;
+    }
+    if (!isArrayLike$3(collection)) {
+      return eachFunc(collection, iteratee);
+    }
+    var length = collection.length, index = fromRight ? length : -1, iterable = Object(collection);
+    while (fromRight ? index-- : ++index < length) {
+      if (iteratee(iterable[index], index, iterable) === false) {
+        break;
+      }
+    }
+    return collection;
+  };
+}
+var _createBaseEach = createBaseEach$1;
+var baseForOwn = _baseForOwn, createBaseEach = _createBaseEach;
+var baseEach$2 = createBaseEach(baseForOwn);
+var _baseEach = baseEach$2;
+var arrayEach = _arrayEach, baseEach$1 = _baseEach, castFunction = _castFunction, isArray$3 = isArray_1;
+function forEach(collection, iteratee) {
+  var func = isArray$3(collection) ? arrayEach : baseEach$1;
+  return func(collection, castFunction(iteratee));
+}
+var forEach_1 = forEach;
+const forEach$1 = /* @__PURE__ */ getDefaultExportFromCjs(forEach_1);
+function last(array) {
+  var length = array == null ? 0 : array.length;
+  return length ? array[length - 1] : void 0;
+}
+var last_1 = last;
+const last$1 = /* @__PURE__ */ getDefaultExportFromCjs(last_1);
+var baseGetTag = _baseGetTag, isArray$2 = isArray_1, isObjectLike = isObjectLike_1;
+var stringTag = "[object String]";
+function isString$1(value) {
+  return typeof value == "string" || !isArray$2(value) && isObjectLike(value) && baseGetTag(value) == stringTag;
+}
+var isString_1 = isString$1;
+var baseProperty = _baseProperty;
+var asciiSize$1 = baseProperty("length");
+var _asciiSize = asciiSize$1;
+var rsAstralRange$1 = "\\ud800-\\udfff", rsComboMarksRange$1 = "\\u0300-\\u036f", reComboHalfMarksRange$1 = "\\ufe20-\\ufe2f", rsComboSymbolsRange$1 = "\\u20d0-\\u20ff", rsComboRange$1 = rsComboMarksRange$1 + reComboHalfMarksRange$1 + rsComboSymbolsRange$1, rsVarRange$1 = "\\ufe0e\\ufe0f";
+var rsZWJ$1 = "\\u200d";
+var reHasUnicode = RegExp("[" + rsZWJ$1 + rsAstralRange$1 + rsComboRange$1 + rsVarRange$1 + "]");
+function hasUnicode$1(string) {
+  return reHasUnicode.test(string);
+}
+var _hasUnicode = hasUnicode$1;
+var rsAstralRange = "\\ud800-\\udfff", rsComboMarksRange = "\\u0300-\\u036f", reComboHalfMarksRange = "\\ufe20-\\ufe2f", rsComboSymbolsRange = "\\u20d0-\\u20ff", rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange, rsVarRange = "\\ufe0e\\ufe0f";
+var rsAstral = "[" + rsAstralRange + "]", rsCombo = "[" + rsComboRange + "]", rsFitz = "\\ud83c[\\udffb-\\udfff]", rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")", rsNonAstral = "[^" + rsAstralRange + "]", rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}", rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]", rsZWJ = "\\u200d";
+var reOptMod = rsModifier + "?", rsOptVar = "[" + rsVarRange + "]?", rsOptJoin = "(?:" + rsZWJ + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*", rsSeq = rsOptVar + reOptMod + rsOptJoin, rsSymbol = "(?:" + [rsNonAstral + rsCombo + "?", rsCombo, rsRegional, rsSurrPair, rsAstral].join("|") + ")";
+var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g");
+function unicodeSize$1(string) {
+  var result = reUnicode.lastIndex = 0;
+  while (reUnicode.test(string)) {
+    ++result;
+  }
+  return result;
+}
+var _unicodeSize = unicodeSize$1;
+var asciiSize = _asciiSize, hasUnicode = _hasUnicode, unicodeSize = _unicodeSize;
+function stringSize$1(string) {
+  return hasUnicode(string) ? unicodeSize(string) : asciiSize(string);
+}
+var _stringSize = stringSize$1;
+var baseKeys = _baseKeys, getTag = _getTag, isArrayLike$2 = isArrayLike_1, isString = isString_1, stringSize = _stringSize;
+var mapTag = "[object Map]", setTag = "[object Set]";
+function size(collection) {
+  if (collection == null) {
+    return 0;
+  }
+  if (isArrayLike$2(collection)) {
+    return isString(collection) ? stringSize(collection) : collection.length;
+  }
+  var tag = getTag(collection);
+  if (tag == mapTag || tag == setTag) {
+    return collection.size;
+  }
+  return baseKeys(collection).length;
+}
+var size_1 = size;
+const size$1 = /* @__PURE__ */ getDefaultExportFromCjs(size_1);
+var Symbol$1 = _Symbol, isArguments = isArguments_1, isArray$1 = isArray_1;
+var spreadableSymbol = Symbol$1 ? Symbol$1.isConcatSpreadable : void 0;
+function isFlattenable$1(value) {
+  return isArray$1(value) || isArguments(value) || !!(spreadableSymbol && value && value[spreadableSymbol]);
+}
+var _isFlattenable = isFlattenable$1;
+var arrayPush = _arrayPush, isFlattenable = _isFlattenable;
+function baseFlatten$1(array, depth, predicate, isStrict, result) {
+  var index = -1, length = array.length;
+  predicate || (predicate = isFlattenable);
+  result || (result = []);
+  while (++index < length) {
+    var value = array[index];
+    if (depth > 0 && predicate(value)) {
+      if (depth > 1) {
+        baseFlatten$1(value, depth - 1, predicate, isStrict, result);
+      } else {
+        arrayPush(result, value);
+      }
+    } else if (!isStrict) {
+      result[result.length] = value;
+    }
+  }
+  return result;
+}
+var _baseFlatten = baseFlatten$1;
+var baseEach = _baseEach, isArrayLike$1 = isArrayLike_1;
+function baseMap$1(collection, iteratee) {
+  var index = -1, result = isArrayLike$1(collection) ? Array(collection.length) : [];
+  baseEach(collection, function(value, key, collection2) {
+    result[++index] = iteratee(value, key, collection2);
+  });
+  return result;
+}
+var _baseMap = baseMap$1;
+function baseSortBy$1(array, comparer) {
+  var length = array.length;
+  array.sort(comparer);
+  while (length--) {
+    array[length] = array[length].value;
+  }
+  return array;
+}
+var _baseSortBy = baseSortBy$1;
+var isSymbol = isSymbol_1;
+function compareAscending$1(value, other) {
+  if (value !== other) {
+    var valIsDefined = value !== void 0, valIsNull = value === null, valIsReflexive = value === value, valIsSymbol = isSymbol(value);
+    var othIsDefined = other !== void 0, othIsNull = other === null, othIsReflexive = other === other, othIsSymbol = isSymbol(other);
+    if (!othIsNull && !othIsSymbol && !valIsSymbol && value > other || valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol || valIsNull && othIsDefined && othIsReflexive || !valIsDefined && othIsReflexive || !valIsReflexive) {
+      return 1;
+    }
+    if (!valIsNull && !valIsSymbol && !othIsSymbol && value < other || othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol || othIsNull && valIsDefined && valIsReflexive || !othIsDefined && valIsReflexive || !othIsReflexive) {
+      return -1;
+    }
+  }
+  return 0;
+}
+var _compareAscending = compareAscending$1;
+var compareAscending = _compareAscending;
+function compareMultiple$1(object, other, orders) {
+  var index = -1, objCriteria = object.criteria, othCriteria = other.criteria, length = objCriteria.length, ordersLength = orders.length;
+  while (++index < length) {
+    var result = compareAscending(objCriteria[index], othCriteria[index]);
+    if (result) {
+      if (index >= ordersLength) {
+        return result;
+      }
+      var order = orders[index];
+      return result * (order == "desc" ? -1 : 1);
+    }
+  }
+  return object.index - other.index;
+}
+var _compareMultiple = compareMultiple$1;
+var arrayMap = _arrayMap, baseGet = _baseGet, baseIteratee = _baseIteratee, baseMap = _baseMap, baseSortBy = _baseSortBy, baseUnary = _baseUnary, compareMultiple = _compareMultiple, identity$2 = identity_1, isArray = isArray_1;
+function baseOrderBy$1(collection, iteratees, orders) {
+  if (iteratees.length) {
+    iteratees = arrayMap(iteratees, function(iteratee) {
+      if (isArray(iteratee)) {
+        return function(value) {
+          return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee);
+        };
+      }
+      return iteratee;
+    });
+  } else {
+    iteratees = [identity$2];
+  }
+  var index = -1;
+  iteratees = arrayMap(iteratees, baseUnary(baseIteratee));
+  var result = baseMap(collection, function(value, key, collection2) {
+    var criteria = arrayMap(iteratees, function(iteratee) {
+      return iteratee(value);
+    });
+    return { "criteria": criteria, "index": ++index, "value": value };
+  });
+  return baseSortBy(result, function(object, other) {
+    return compareMultiple(object, other, orders);
+  });
+}
+var _baseOrderBy = baseOrderBy$1;
+function apply$1(func, thisArg, args) {
+  switch (args.length) {
+    case 0:
+      return func.call(thisArg);
+    case 1:
+      return func.call(thisArg, args[0]);
+    case 2:
+      return func.call(thisArg, args[0], args[1]);
+    case 3:
+      return func.call(thisArg, args[0], args[1], args[2]);
+  }
+  return func.apply(thisArg, args);
+}
+var _apply = apply$1;
+var apply = _apply;
+var nativeMax = Math.max;
+function overRest$1(func, start, transform) {
+  start = nativeMax(start === void 0 ? func.length - 1 : start, 0);
+  return function() {
+    var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array = Array(length);
+    while (++index < length) {
+      array[index] = args[start + index];
+    }
+    index = -1;
+    var otherArgs = Array(start + 1);
+    while (++index < start) {
+      otherArgs[index] = args[index];
+    }
+    otherArgs[start] = transform(array);
+    return apply(func, this, otherArgs);
+  };
+}
+var _overRest = overRest$1;
+function constant$1(value) {
+  return function() {
+    return value;
+  };
+}
+var constant_1 = constant$1;
+var constant = constant_1, defineProperty = _defineProperty, identity$1 = identity_1;
+var baseSetToString$1 = !defineProperty ? identity$1 : function(func, string) {
+  return defineProperty(func, "toString", {
+    "configurable": true,
+    "enumerable": false,
+    "value": constant(string),
+    "writable": true
+  });
+};
+var _baseSetToString = baseSetToString$1;
+var HOT_COUNT = 800, HOT_SPAN = 16;
+var nativeNow = Date.now;
+function shortOut$1(func) {
+  var count = 0, lastCalled = 0;
+  return function() {
+    var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled);
+    lastCalled = stamp;
+    if (remaining > 0) {
+      if (++count >= HOT_COUNT) {
+        return arguments[0];
+      }
+    } else {
+      count = 0;
+    }
+    return func.apply(void 0, arguments);
+  };
+}
+var _shortOut = shortOut$1;
+var baseSetToString = _baseSetToString, shortOut = _shortOut;
+var setToString$1 = shortOut(baseSetToString);
+var _setToString = setToString$1;
+var identity = identity_1, overRest = _overRest, setToString = _setToString;
+function baseRest$1(func, start) {
+  return setToString(overRest(func, start, identity), func + "");
+}
+var _baseRest = baseRest$1;
+var eq = eq_1, isArrayLike = isArrayLike_1, isIndex = _isIndex, isObject = isObject_1;
+function isIterateeCall$1(value, index, object) {
+  if (!isObject(object)) {
+    return false;
+  }
+  var type2 = typeof index;
+  if (type2 == "number" ? isArrayLike(object) && isIndex(index, object.length) : type2 == "string" && index in object) {
+    return eq(object[index], value);
+  }
+  return false;
+}
+var _isIterateeCall = isIterateeCall$1;
+var baseFlatten = _baseFlatten, baseOrderBy = _baseOrderBy, baseRest = _baseRest, isIterateeCall = _isIterateeCall;
+var sortBy = baseRest(function(collection, iteratees) {
+  if (collection == null) {
+    return [];
+  }
+  var length = iteratees.length;
+  if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {
+    iteratees = [];
+  } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {
+    iteratees = [iteratees[0]];
+  }
+  return baseOrderBy(collection, baseFlatten(iteratees, 1), []);
+});
+var sortBy_1 = sortBy;
+const sortBy$1 = /* @__PURE__ */ getDefaultExportFromCjs(sortBy_1);
+function addCell(row, cell) {
+  if (!row.cells)
+    row.cells = {};
+  row.cells[cell.id] = cell;
+  return cell;
+}
+function removeCell(row, predicate = {}) {
+  const cell = find$1(row.cells, predicate);
+  if (!cell)
+    return;
+  delete row.cells[cell.id];
+  return cell;
+}
+function addEmbed(embeds, cellId, tableId) {
+  const embed = {
+    id: cellId,
+    type: "TIPTAP_HTML",
+    embedded: true,
+    data: { tableId, cellId }
+  };
+  embeds[cellId] = embed;
+  return embed;
+}
+function removeEmbed(embeds, predicate = {}) {
+  const embed = find$1(embeds, predicate);
+  if (!embed)
+    return;
+  delete embeds[embed.id];
+  return embed;
+}
+const _hoisted_1$1 = { class: "table-cell" };
+const _sfc_main$3 = /* @__PURE__ */ vue.defineComponent({
+  __name: "TableCell",
+  props: {
+    cell: {},
+    table: {},
+    isDisabled: { type: Boolean }
+  },
+  emits: ["save"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const save = (data) => {
+      emit("save", { ...cloneDeep$1(props.cell), data });
+    };
+    return (_ctx, _cache) => {
+      const _component_TailorContentElement = vue.resolveComponent("TailorContentElement");
+      return vue.openBlock(), vue.createElementBlock("div", _hoisted_1$1, [
+        vue.createVNode(_component_TailorContentElement, {
+          element: _ctx.cell,
+          "is-disabled": _ctx.isDisabled,
+          parent: _ctx.table,
+          onSave: save
+        }, null, 8, ["element", "is-disabled", "parent"])
+      ]);
+    };
+  }
+});
+const TableCell_vue_vue_type_style_index_0_scoped_083fd0de_lang = "";
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const TableCell = /* @__PURE__ */ _export_sfc(_sfc_main$3, [["__scopeId", "data-v-083fd0de"]]);
+const _hoisted_1 = { class: "text-subtitle-2" };
+const _hoisted_2 = { class: "body" };
+const MIN_ROWS = 1;
+const MIN_COLUMNS = 1;
+const _sfc_main$2 = /* @__PURE__ */ vue.defineComponent({
+  __name: "Edit",
+  props: {
+    element: {},
+    embedElementConfig: {},
+    isFocused: { type: Boolean },
+    isDisabled: { type: Boolean }
+  },
+  emits: ["focus", "save"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const between = (pos1, pos2) => (pos2 + pos1) / 2;
+    const limit = (anchor, direction) => anchor.position + direction;
+    function sibling(arr, item, direction) {
+      if (direction === Direction.Before) {
+        return last$1(arr.filter((it) => it.position < item.position));
+      }
+      return first$1(arr.filter((it) => it.position > item.position));
+    }
+    function calculateInsertPosition(collection, anchor, direction) {
+      const sorted = sortBy$1(collection, "position");
+      const adjacent = sibling(sorted, anchor, direction);
+      return between(
+        anchor.position,
+        adjacent && adjacent.position || limit(anchor, direction)
+      );
+    }
+    function getFocusedItem(collection, current) {
+      const sorted = sortBy$1(collection, "position");
+      return sibling(sorted, current, Direction.Before) || sibling(sorted, current, Direction.After);
+    }
+    const bus = vue.inject("$elementBus");
+    const elementData = vue.reactive(cloneDeep$1(props.element.data));
+    const table = vue.computed(() => sortBy$1(elementData.rows, "position"));
+    const rows = vue.computed(() => elementData.rows);
+    const embeds = vue.computed(() => elementData.embeds);
+    const cells = (row) => sortBy$1(row.cells, "position");
+    const findRow = (cellId) => {
+      return find$1(rows.value, (row) => !!row.cells[cellId]);
+    };
+    const focusElement = (cell) => {
+      emit("focus", {}, { ...cell, type: "HTML" }, props.element);
+    };
+    const addRow = (cellId, direction = Direction.After) => {
+      const row = findRow(cellId);
+      if (!row)
+        return;
+      const element = cloneDeep$1(props.element);
+      const { tableId, rows: rows2, embeds: embeds2 } = element.data;
+      const position = calculateInsertPosition(rows2, row, direction);
+      const newRow = { id: v4(), position, cells: {} };
+      forEach$1(row.cells, ({ position: position2 }) => {
+        const cellId2 = v4();
+        addCell(newRow, { id: cellId2, position: position2, data: {} });
+        addEmbed(embeds2, cellId2, tableId);
+      });
+      rows2[newRow.id] = newRow;
+      emit("save", element.data);
+    };
+    const addColumn = (cellId, direction = Direction.After) => {
+      const row = findRow(cellId);
+      if (!row)
+        return;
+      const cell = row.cells[cellId];
+      if (!cell)
+        return;
+      const element = cloneDeep$1(props.element);
+      const { tableId, rows: rows2, embeds: embeds2 } = element.data;
+      const position = calculateInsertPosition(row.cells, cell, direction);
+      forEach$1(rows2, (row2) => {
+        const cellId2 = v4();
+        addCell(row2, { id: cellId2, position, data: {} });
+        addEmbed(embeds2, cellId2, tableId);
+      });
+      emit("save", element.data);
+    };
+    const removeRow = (cellId) => {
+      const row = findRow(cellId);
+      if (!row || size$1(props.element.data.rows) <= MIN_ROWS)
+        return;
+      const element = cloneDeep$1(props.element);
+      const { rows: rows2, embeds: embeds2 } = element.data;
+      forEach$1(row.cells, (cell) => removeEmbed(embeds2, { id: cell.id }));
+      delete rows2[row.id];
+      const focusedRow = getFocusedItem(rows2, row);
+      if (focusedRow) {
+        const cell = first$1(cells(focusedRow));
+        if (cell)
+          focusElement(embeds2[cell.id]);
+      }
+      emit("save", { embeds: embeds2, rows: rows2 });
+    };
+    const removeColumn = (cellId) => {
+      const row = findRow(cellId);
+      if (!row || size$1(row.cells) <= MIN_COLUMNS)
+        return;
+      const cell = row.cells[cellId];
+      if (!cell)
+        return;
+      const element = cloneDeep$1(props.element);
+      const { rows: rows2, embeds: embeds2 } = element.data;
+      forEach$1(rows2, (row2) => {
+        const deletedCell = removeCell(row2, { position: cell.position });
+        if (deletedCell)
+          removeEmbed(embeds2, { id: deletedCell.id });
+      });
+      const focusedCell = getFocusedItem(row.cells, cell);
+      if (focusedCell)
+        focusElement(embeds2[focusedCell.id]);
+      emit("save", { embeds: embeds2, rows: rows2 });
+    };
+    const saveCell = (element) => {
+      elementData.embeds[element.id] = element;
+      emit("save", elementData);
+    };
+    bus.on("addRowBefore", (id) => addRow(id, Direction.Before));
+    bus.on("addRowAfter", (id) => addRow(id, Direction.After));
+    bus.on("addColumnBefore", (id) => addColumn(id, Direction.Before));
+    bus.on("addColumnAfter", (id) => addColumn(id, Direction.After));
+    bus.on("removeRow", (id) => removeRow(id));
+    bus.on("removeColumn", (id) => removeColumn(id));
+    return (_ctx, _cache) => {
+      const _component_VIcon = vue.resolveComponent("VIcon");
+      const _component_VToolbar = vue.resolveComponent("VToolbar");
+      const _component_VCard = vue.resolveComponent("VCard");
+      return vue.openBlock(), vue.createBlock(_component_VCard, {
+        class: "tce-table my-2",
+        color: "grey-lighten-5"
+      }, {
+        default: vue.withCtx(() => [
+          vue.createVNode(_component_VToolbar, {
+            class: "px-4",
+            color: "primary-darken-2",
+            height: "36"
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(_component_VIcon, {
+                icon: vue.unref(src_default).ui.icon,
+                color: "secondary-lighten-2",
+                size: "18",
+                start: ""
+              }, null, 8, ["icon"]),
+              vue.createElementVNode("span", _hoisted_1, vue.toDisplayString(vue.unref(src_default).name), 1)
+            ]),
+            _: 1
+          }),
+          vue.createElementVNode("div", _hoisted_2, [
+            vue.createElementVNode("div", {
+              class: vue.normalizeClass([{ disabled: _ctx.isDisabled }, "table ma-4"])
+            }, [
+              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(table.value, (row) => {
+                return vue.openBlock(), vue.createElementBlock("div", {
+                  key: row.id,
+                  class: "table-row"
+                }, [
+                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(cells(row), (cell) => {
+                    return vue.openBlock(), vue.createBlock(TableCell, {
+                      key: cell.id,
+                      cell: embeds.value[cell.id],
+                      "is-disabled": _ctx.isDisabled,
+                      table: _ctx.element,
+                      onSave: saveCell
+                    }, null, 8, ["cell", "is-disabled", "table"]);
+                  }), 128))
+                ]);
+              }), 128))
+            ], 2)
+          ])
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+const Edit_vue_vue_type_style_index_0_scoped_26c8921d_lang = "";
+const Edit = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__scopeId", "data-v-26c8921d"]]);
+const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
+  __name: "SideToolbar",
+  props: {
+    element: {}
+  },
+  emits: ["save"],
+  setup(__props) {
+    return (_ctx, _cache) => {
+      var _a;
+      return vue.openBlock(), vue.createElementBlock("div", null, [
+        vue.createElementVNode("p", null, "Edit element side toolbar " + vue.toDisplayString((_a = _ctx.element) == null ? void 0 : _a.id), 1)
+      ]);
+    };
+  }
+});
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "TopToolbar",
+  props: {
+    element: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const elementBus = vue.inject("$elementBus");
+    const actions = vue.computed(() => [
+      { name: "addRowBefore", label: "Add row before" },
+      { name: "addRowAfter", label: "Add row after" },
+      { name: "addColumnBefore", label: "Add column before" },
+      { name: "addColumnAfter", label: "Add column after" },
+      { name: "removeRow", label: "Delete row" },
+      { name: "removeColumn", label: "Delete column" }
+    ]);
+    const trigger = (action) => {
+      var _a;
+      elementBus.emit(action, (_a = props.element) == null ? void 0 : _a.id);
+    };
+    return (_ctx, _cache) => {
+      const _component_VIcon = vue.resolveComponent("VIcon");
+      const _component_VBtn = vue.resolveComponent("VBtn");
+      const _component_VListItemTitle = vue.resolveComponent("VListItemTitle");
+      const _component_VListItem = vue.resolveComponent("VListItem");
+      const _component_VList = vue.resolveComponent("VList");
+      const _component_VMenu = vue.resolveComponent("VMenu");
+      const _component_VToolbarItems = vue.resolveComponent("VToolbarItems");
+      const _component_VToolbar = vue.resolveComponent("VToolbar");
+      return vue.openBlock(), vue.createBlock(_component_VToolbar, {
+        class: "tce-table-toolbar elevation-0",
+        color: "transparent"
+      }, {
+        default: vue.withCtx(() => [
+          vue.createVNode(_component_VToolbarItems, null, {
+            default: vue.withCtx(() => [
+              vue.createVNode(_component_VMenu, { bottom: "" }, {
+                activator: vue.withCtx(({ props: activatorProps }) => [
+                  vue.createVNode(_component_VBtn, vue.mergeProps(activatorProps, { variant: "text" }), {
+                    default: vue.withCtx(() => [
+                      vue.createTextVNode(" Table options "),
+                      vue.createVNode(_component_VIcon, null, {
+                        default: vue.withCtx(() => [
+                          vue.createTextVNode("mdi-chevron-down")
+                        ]),
+                        _: 1
+                      })
+                    ]),
+                    _: 2
+                  }, 1040)
+                ]),
+                default: vue.withCtx(() => [
+                  vue.createVNode(_component_VList, { class: "text-left" }, {
+                    default: vue.withCtx(() => [
+                      (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(actions.value, (action) => {
+                        return vue.openBlock(), vue.createBlock(_component_VListItem, {
+                          key: action.name,
+                          onClick: ($event) => trigger(action.name)
+                        }, {
+                          default: vue.withCtx(() => [
+                            vue.createVNode(_component_VListItemTitle, null, {
+                              default: vue.withCtx(() => [
+                                vue.createTextVNode(vue.toDisplayString(action.label), 1)
+                              ]),
+                              _: 2
+                            }, 1024)
+                          ]),
+                          _: 2
+                        }, 1032, ["onClick"]);
+                      }), 128))
+                    ]),
+                    _: 1
+                  })
+                ]),
+                _: 1
+              })
+            ]),
+            _: 1
+          })
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+const TopToolbar_vue_vue_type_style_index_0_scoped_fb603823_lang = "";
+const TopToolbar = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-fb603823"]]);
+const manifest = {
+  ...src_default,
+  Edit,
+  SideToolbar: _sfc_main$1,
+  TopToolbar
+};
+exports.Edit = Edit;
+exports.SideToolbar = _sfc_main$1;
+exports.TopToolbar = TopToolbar;
+exports.default = manifest;