@antv/s2-vue 1.0.0

package/esm/index.js

@@ -0,0 +1,2379 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { customMerge, DEFAULT_OPTIONS, extendLocale, S2Event, i18n, S2_PREFIX_CLS, TOOLTIP_PREFIX_CLS, getIcon, getTooltipDefaultOptions, BaseTooltip, getBaseCellData, TableSheet as TableSheet$1, PivotSheet as PivotSheet$1 } from "@antv/s2";
+import { shallowRef, ref, computed, watch, defineComponent, resolveComponent, openBlock, createElementBlock, normalizeClass, createVNode, createElementVNode, toDisplayString, Fragment, renderList, createCommentVNode, createTextVNode, createBlock, withCtx, render, onMounted, reactive, isProxy, onBeforeUnmount, toRaw, resolveDynamicComponent } from "vue";
+import { Pagination, Menu, Dropdown, Spin } from "ant-design-vue";
+const SHEET_COMPONENT_DEFAULT_OPTIONS = {
+  tooltip: {
+    showTooltip: true,
+    autoAdjustBoundary: "body",
+    operation: {
+      hiddenColumns: true,
+      trend: false,
+      sort: true
+    }
+  },
+  showDefaultHeaderActionIcon: true
+};
+const getBaseSheetComponentOptions = (...options) => customMerge(DEFAULT_OPTIONS, SHEET_COMPONENT_DEFAULT_OPTIONS, ...options);
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+var freeGlobal$1 = freeGlobal;
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = freeGlobal$1 || freeSelf || Function("return this")();
+var root$1 = root;
+var Symbol$1 = root$1.Symbol;
+var Symbol$2 = Symbol$1;
+var objectProto$c = Object.prototype;
+var hasOwnProperty$9 = objectProto$c.hasOwnProperty;
+var nativeObjectToString$1 = objectProto$c.toString;
+var symToStringTag$1 = Symbol$2 ? Symbol$2.toStringTag : void 0;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty$9.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 objectProto$b = Object.prototype;
+var nativeObjectToString = objectProto$b.toString;
+function objectToString(value) {
+  return nativeObjectToString.call(value);
+}
+var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
+var symToStringTag = Symbol$2 ? Symbol$2.toStringTag : void 0;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+var symbolTag$1 = "[object Symbol]";
+function isSymbol(value) {
+  return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag$1;
+}
+function arrayMap(array, iteratee) {
+  var index2 = -1, length = array == null ? 0 : array.length, result = Array(length);
+  while (++index2 < length) {
+    result[index2] = iteratee(array[index2], index2, array);
+  }
+  return result;
+}
+var isArray = Array.isArray;
+var isArray$1 = isArray;
+var INFINITY$1 = 1 / 0;
+var symbolProto$1 = Symbol$2 ? Symbol$2.prototype : void 0, symbolToString = symbolProto$1 ? symbolProto$1.toString : void 0;
+function baseToString(value) {
+  if (typeof value == "string") {
+    return value;
+  }
+  if (isArray$1(value)) {
+    return arrayMap(value, baseToString) + "";
+  }
+  if (isSymbol(value)) {
+    return symbolToString ? symbolToString.call(value) : "";
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY$1 ? "-0" : result;
+}
+var reWhitespace = /\s/;
+function trimmedEndIndex(string) {
+  var index2 = string.length;
+  while (index2-- && reWhitespace.test(string.charAt(index2))) {
+  }
+  return index2;
+}
+var reTrimStart = /^\s+/;
+function baseTrim(string) {
+  return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string;
+}
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+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(value) {
+  if (typeof value == "number") {
+    return value;
+  }
+  if (isSymbol(value)) {
+    return NAN;
+  }
+  if (isObject(value)) {
+    var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+    value = isObject(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;
+}
+function identity(value) {
+  return value;
+}
+var asyncTag = "[object AsyncFunction]", funcTag$1 = "[object Function]", genTag = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
+function isFunction(value) {
+  if (!isObject(value)) {
+    return false;
+  }
+  var tag = baseGetTag(value);
+  return tag == funcTag$1 || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var coreJsData = root$1["__core-js_shared__"];
+var coreJsData$1 = coreJsData;
+var maskSrcKey = function() {
+  var uid = /[^.]+$/.exec(coreJsData$1 && coreJsData$1.keys && coreJsData$1.keys.IE_PROTO || "");
+  return uid ? "Symbol(src)_1." + uid : "";
+}();
+function isMasked(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+var funcProto$1 = Function.prototype;
+var funcToString$1 = funcProto$1.toString;
+function toSource(func) {
+  if (func != null) {
+    try {
+      return funcToString$1.call(func);
+    } catch (e) {
+    }
+    try {
+      return func + "";
+    } catch (e) {
+    }
+  }
+  return "";
+}
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var funcProto = Function.prototype, objectProto$a = Object.prototype;
+var funcToString = funcProto.toString;
+var hasOwnProperty$8 = objectProto$a.hasOwnProperty;
+var reIsNative = RegExp("^" + funcToString.call(hasOwnProperty$8).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
+function baseIsNative(value) {
+  if (!isObject(value) || isMasked(value)) {
+    return false;
+  }
+  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource(value));
+}
+function getValue(object, key) {
+  return object == null ? void 0 : object[key];
+}
+function getNative(object, key) {
+  var value = getValue(object, key);
+  return baseIsNative(value) ? value : void 0;
+}
+var WeakMap = getNative(root$1, "WeakMap");
+var WeakMap$1 = WeakMap;
+var MAX_SAFE_INTEGER$1 = 9007199254740991;
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+function isIndex(value, length) {
+  var type = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER$1 : length;
+  return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+}
+function eq(value, other) {
+  return value === other || value !== value && other !== other;
+}
+var MAX_SAFE_INTEGER = 9007199254740991;
+function isLength(value) {
+  return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+function isArrayLike(value) {
+  return value != null && isLength(value.length) && !isFunction(value);
+}
+var objectProto$9 = Object.prototype;
+function isPrototype(value) {
+  var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$9;
+  return value === proto;
+}
+function baseTimes(n, iteratee) {
+  var index2 = -1, result = Array(n);
+  while (++index2 < n) {
+    result[index2] = iteratee(index2);
+  }
+  return result;
+}
+var argsTag$2 = "[object Arguments]";
+function baseIsArguments(value) {
+  return isObjectLike(value) && baseGetTag(value) == argsTag$2;
+}
+var objectProto$8 = Object.prototype;
+var hasOwnProperty$7 = objectProto$8.hasOwnProperty;
+var propertyIsEnumerable$1 = objectProto$8.propertyIsEnumerable;
+var isArguments = baseIsArguments(function() {
+  return arguments;
+}()) ? baseIsArguments : function(value) {
+  return isObjectLike(value) && hasOwnProperty$7.call(value, "callee") && !propertyIsEnumerable$1.call(value, "callee");
+};
+var isArguments$1 = isArguments;
+function stubFalse() {
+  return false;
+}
+var freeExports$1 = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule$1 = freeExports$1 && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports$1 = freeModule$1 && freeModule$1.exports === freeExports$1;
+var Buffer2 = moduleExports$1 ? root$1.Buffer : void 0;
+var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0;
+var isBuffer = nativeIsBuffer || stubFalse;
+var isBuffer$1 = isBuffer;
+var argsTag$1 = "[object Arguments]", arrayTag$1 = "[object Array]", boolTag$2 = "[object Boolean]", dateTag$1 = "[object Date]", errorTag$1 = "[object Error]", funcTag = "[object Function]", mapTag$4 = "[object Map]", numberTag$1 = "[object Number]", objectTag$2 = "[object Object]", regexpTag$1 = "[object RegExp]", setTag$4 = "[object Set]", stringTag$2 = "[object String]", weakMapTag$1 = "[object WeakMap]";
+var arrayBufferTag$1 = "[object ArrayBuffer]", dataViewTag$2 = "[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 typedArrayTags = {};
+typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+typedArrayTags[argsTag$1] = typedArrayTags[arrayTag$1] = typedArrayTags[arrayBufferTag$1] = typedArrayTags[boolTag$2] = typedArrayTags[dataViewTag$2] = typedArrayTags[dateTag$1] = typedArrayTags[errorTag$1] = typedArrayTags[funcTag] = typedArrayTags[mapTag$4] = typedArrayTags[numberTag$1] = typedArrayTags[objectTag$2] = typedArrayTags[regexpTag$1] = typedArrayTags[setTag$4] = typedArrayTags[stringTag$2] = typedArrayTags[weakMapTag$1] = false;
+function baseIsTypedArray(value) {
+  return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+}
+function baseUnary(func) {
+  return function(value) {
+    return func(value);
+  };
+}
+var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports = freeModule && freeModule.exports === freeExports;
+var freeProcess = moduleExports && freeGlobal$1.process;
+var nodeUtil = function() {
+  try {
+    var types = freeModule && freeModule.require && freeModule.require("util").types;
+    if (types) {
+      return types;
+    }
+    return freeProcess && freeProcess.binding && freeProcess.binding("util");
+  } catch (e) {
+  }
+}();
+var nodeUtil$1 = nodeUtil;
+var nodeIsTypedArray = nodeUtil$1 && nodeUtil$1.isTypedArray;
+var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+var isTypedArray$1 = isTypedArray;
+var objectProto$7 = Object.prototype;
+var hasOwnProperty$6 = objectProto$7.hasOwnProperty;
+function arrayLikeKeys(value, inherited) {
+  var isArr = isArray$1(value), isArg = !isArr && isArguments$1(value), isBuff = !isArr && !isArg && isBuffer$1(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 && (key == "length" || isBuff && (key == "offset" || key == "parent") || isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || isIndex(key, length)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+function overArg(func, transform) {
+  return function(arg) {
+    return func(transform(arg));
+  };
+}
+var nativeKeys = overArg(Object.keys, Object);
+var nativeKeys$1 = nativeKeys;
+var objectProto$6 = Object.prototype;
+var hasOwnProperty$5 = objectProto$6.hasOwnProperty;
+function baseKeys(object) {
+  if (!isPrototype(object)) {
+    return nativeKeys$1(object);
+  }
+  var result = [];
+  for (var key in Object(object)) {
+    if (hasOwnProperty$5.call(object, key) && key != "constructor") {
+      result.push(key);
+    }
+  }
+  return result;
+}
+function keys(object) {
+  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+}
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/;
+function isKey(value, object) {
+  if (isArray$1(value)) {
+    return false;
+  }
+  var type = typeof value;
+  if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol(value)) {
+    return true;
+  }
+  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+}
+var nativeCreate = getNative(Object, "create");
+var nativeCreate$1 = nativeCreate;
+function hashClear() {
+  this.__data__ = nativeCreate$1 ? nativeCreate$1(null) : {};
+  this.size = 0;
+}
+function hashDelete(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var HASH_UNDEFINED$2 = "__lodash_hash_undefined__";
+var objectProto$5 = Object.prototype;
+var hasOwnProperty$4 = objectProto$5.hasOwnProperty;
+function hashGet(key) {
+  var data = this.__data__;
+  if (nativeCreate$1) {
+    var result = data[key];
+    return result === HASH_UNDEFINED$2 ? void 0 : result;
+  }
+  return hasOwnProperty$4.call(data, key) ? data[key] : void 0;
+}
+var objectProto$4 = Object.prototype;
+var hasOwnProperty$3 = objectProto$4.hasOwnProperty;
+function hashHas(key) {
+  var data = this.__data__;
+  return nativeCreate$1 ? data[key] !== void 0 : hasOwnProperty$3.call(data, key);
+}
+var HASH_UNDEFINED$1 = "__lodash_hash_undefined__";
+function hashSet(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = nativeCreate$1 && value === void 0 ? HASH_UNDEFINED$1 : value;
+  return this;
+}
+function Hash(entries) {
+  var index2 = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index2 < length) {
+    var entry = entries[index2];
+    this.set(entry[0], entry[1]);
+  }
+}
+Hash.prototype.clear = hashClear;
+Hash.prototype["delete"] = hashDelete;
+Hash.prototype.get = hashGet;
+Hash.prototype.has = hashHas;
+Hash.prototype.set = hashSet;
+function listCacheClear() {
+  this.__data__ = [];
+  this.size = 0;
+}
+function assocIndexOf(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+var arrayProto = Array.prototype;
+var splice = arrayProto.splice;
+function listCacheDelete(key) {
+  var data = this.__data__, index2 = assocIndexOf(data, key);
+  if (index2 < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index2 == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index2, 1);
+  }
+  --this.size;
+  return true;
+}
+function listCacheGet(key) {
+  var data = this.__data__, index2 = assocIndexOf(data, key);
+  return index2 < 0 ? void 0 : data[index2][1];
+}
+function listCacheHas(key) {
+  return assocIndexOf(this.__data__, key) > -1;
+}
+function listCacheSet(key, value) {
+  var data = this.__data__, index2 = assocIndexOf(data, key);
+  if (index2 < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index2][1] = value;
+  }
+  return this;
+}
+function ListCache(entries) {
+  var index2 = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index2 < length) {
+    var entry = entries[index2];
+    this.set(entry[0], entry[1]);
+  }
+}
+ListCache.prototype.clear = listCacheClear;
+ListCache.prototype["delete"] = listCacheDelete;
+ListCache.prototype.get = listCacheGet;
+ListCache.prototype.has = listCacheHas;
+ListCache.prototype.set = listCacheSet;
+var Map = getNative(root$1, "Map");
+var Map$1 = Map;
+function mapCacheClear() {
+  this.size = 0;
+  this.__data__ = {
+    "hash": new Hash(),
+    "map": new (Map$1 || ListCache)(),
+    "string": new Hash()
+  };
+}
+function isKeyable(value) {
+  var type = typeof value;
+  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+}
+function getMapData(map, key) {
+  var data = map.__data__;
+  return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+}
+function mapCacheDelete(key) {
+  var result = getMapData(this, key)["delete"](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+function mapCacheGet(key) {
+  return getMapData(this, key).get(key);
+}
+function mapCacheHas(key) {
+  return getMapData(this, key).has(key);
+}
+function mapCacheSet(key, value) {
+  var data = getMapData(this, key), size2 = data.size;
+  data.set(key, value);
+  this.size += data.size == size2 ? 0 : 1;
+  return this;
+}
+function MapCache(entries) {
+  var index2 = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index2 < length) {
+    var entry = entries[index2];
+    this.set(entry[0], entry[1]);
+  }
+}
+MapCache.prototype.clear = mapCacheClear;
+MapCache.prototype["delete"] = mapCacheDelete;
+MapCache.prototype.get = mapCacheGet;
+MapCache.prototype.has = mapCacheHas;
+MapCache.prototype.set = mapCacheSet;
+var FUNC_ERROR_TEXT$1 = "Expected a function";
+function memoize(func, resolver) {
+  if (typeof func != "function" || resolver != null && typeof resolver != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT$1);
+  }
+  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.Cache || MapCache)();
+  return memoized;
+}
+memoize.Cache = MapCache;
+var MAX_MEMOIZE_SIZE = 500;
+function memoizeCapped(func) {
+  var result = memoize(func, function(key) {
+    if (cache.size === MAX_MEMOIZE_SIZE) {
+      cache.clear();
+    }
+    return key;
+  });
+  var cache = result.cache;
+  return result;
+}
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+var reEscapeChar = /\\(\\)?/g;
+var stringToPath = 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$1 = stringToPath;
+function toString(value) {
+  return value == null ? "" : baseToString(value);
+}
+function castPath(value, object) {
+  if (isArray$1(value)) {
+    return value;
+  }
+  return isKey(value, object) ? [value] : stringToPath$1(toString(value));
+}
+var INFINITY = 1 / 0;
+function toKey(value) {
+  if (typeof value == "string" || isSymbol(value)) {
+    return value;
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+}
+function baseGet(object, path) {
+  path = castPath(path, object);
+  var index2 = 0, length = path.length;
+  while (object != null && index2 < length) {
+    object = object[toKey(path[index2++])];
+  }
+  return index2 && index2 == length ? object : void 0;
+}
+function get(object, path, defaultValue) {
+  var result = object == null ? void 0 : baseGet(object, path);
+  return result === void 0 ? defaultValue : result;
+}
+function arrayPush(array, values) {
+  var index2 = -1, length = values.length, offset = array.length;
+  while (++index2 < length) {
+    array[offset + index2] = values[index2];
+  }
+  return array;
+}
+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(string) {
+  return reHasUnicode.test(string);
+}
+function arrayReduce(array, iteratee, accumulator, initAccum) {
+  var index2 = -1, length = array == null ? 0 : array.length;
+  if (initAccum && length) {
+    accumulator = array[++index2];
+  }
+  while (++index2 < length) {
+    accumulator = iteratee(accumulator, array[index2], index2, array);
+  }
+  return accumulator;
+}
+function stackClear() {
+  this.__data__ = new ListCache();
+  this.size = 0;
+}
+function stackDelete(key) {
+  var data = this.__data__, result = data["delete"](key);
+  this.size = data.size;
+  return result;
+}
+function stackGet(key) {
+  return this.__data__.get(key);
+}
+function stackHas(key) {
+  return this.__data__.has(key);
+}
+var LARGE_ARRAY_SIZE = 200;
+function stackSet(key, value) {
+  var data = this.__data__;
+  if (data instanceof ListCache) {
+    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(pairs);
+  }
+  data.set(key, value);
+  this.size = data.size;
+  return this;
+}
+function Stack(entries) {
+  var data = this.__data__ = new ListCache(entries);
+  this.size = data.size;
+}
+Stack.prototype.clear = stackClear;
+Stack.prototype["delete"] = stackDelete;
+Stack.prototype.get = stackGet;
+Stack.prototype.has = stackHas;
+Stack.prototype.set = stackSet;
+function arrayFilter(array, predicate) {
+  var index2 = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
+  while (++index2 < length) {
+    var value = array[index2];
+    if (predicate(value, index2, array)) {
+      result[resIndex++] = value;
+    }
+  }
+  return result;
+}
+function stubArray() {
+  return [];
+}
+var objectProto$3 = Object.prototype;
+var propertyIsEnumerable = objectProto$3.propertyIsEnumerable;
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
+  if (object == null) {
+    return [];
+  }
+  object = Object(object);
+  return arrayFilter(nativeGetSymbols(object), function(symbol) {
+    return propertyIsEnumerable.call(object, symbol);
+  });
+};
+var getSymbols$1 = getSymbols;
+function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+  var result = keysFunc(object);
+  return isArray$1(object) ? result : arrayPush(result, symbolsFunc(object));
+}
+function getAllKeys(object) {
+  return baseGetAllKeys(object, keys, getSymbols$1);
+}
+var DataView = getNative(root$1, "DataView");
+var DataView$1 = DataView;
+var Promise$1 = getNative(root$1, "Promise");
+var Promise$2 = Promise$1;
+var Set = getNative(root$1, "Set");
+var Set$1 = Set;
+var mapTag$3 = "[object Map]", objectTag$1 = "[object Object]", promiseTag = "[object Promise]", setTag$3 = "[object Set]", weakMapTag = "[object WeakMap]";
+var dataViewTag$1 = "[object DataView]";
+var dataViewCtorString = toSource(DataView$1), mapCtorString = toSource(Map$1), promiseCtorString = toSource(Promise$2), setCtorString = toSource(Set$1), weakMapCtorString = toSource(WeakMap$1);
+var getTag = baseGetTag;
+if (DataView$1 && getTag(new DataView$1(new ArrayBuffer(1))) != dataViewTag$1 || Map$1 && getTag(new Map$1()) != mapTag$3 || Promise$2 && getTag(Promise$2.resolve()) != promiseTag || Set$1 && getTag(new Set$1()) != setTag$3 || WeakMap$1 && getTag(new WeakMap$1()) != weakMapTag) {
+  getTag = function(value) {
+    var result = baseGetTag(value), Ctor = result == objectTag$1 ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
+    if (ctorString) {
+      switch (ctorString) {
+        case dataViewCtorString:
+          return dataViewTag$1;
+        case mapCtorString:
+          return mapTag$3;
+        case promiseCtorString:
+          return promiseTag;
+        case setCtorString:
+          return setTag$3;
+        case weakMapCtorString:
+          return weakMapTag;
+      }
+    }
+    return result;
+  };
+}
+var getTag$1 = getTag;
+var Uint8Array2 = root$1.Uint8Array;
+var Uint8Array$1 = Uint8Array2;
+var HASH_UNDEFINED = "__lodash_hash_undefined__";
+function setCacheAdd(value) {
+  this.__data__.set(value, HASH_UNDEFINED);
+  return this;
+}
+function setCacheHas(value) {
+  return this.__data__.has(value);
+}
+function SetCache(values) {
+  var index2 = -1, length = values == null ? 0 : values.length;
+  this.__data__ = new MapCache();
+  while (++index2 < length) {
+    this.add(values[index2]);
+  }
+}
+SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+SetCache.prototype.has = setCacheHas;
+function arraySome(array, predicate) {
+  var index2 = -1, length = array == null ? 0 : array.length;
+  while (++index2 < length) {
+    if (predicate(array[index2], index2, array)) {
+      return true;
+    }
+  }
+  return false;
+}
+function cacheHas(cache, key) {
+  return cache.has(key);
+}
+var COMPARE_PARTIAL_FLAG$5 = 1, COMPARE_UNORDERED_FLAG$3 = 2;
+function equalArrays(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 index2 = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG$3 ? new SetCache() : void 0;
+  stack.set(array, other);
+  stack.set(other, array);
+  while (++index2 < arrLength) {
+    var arrValue = array[index2], othValue = other[index2];
+    if (customizer) {
+      var compared = isPartial ? customizer(othValue, arrValue, index2, other, array, stack) : customizer(arrValue, othValue, index2, 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;
+}
+function mapToArray(map) {
+  var index2 = -1, result = Array(map.size);
+  map.forEach(function(value, key) {
+    result[++index2] = [key, value];
+  });
+  return result;
+}
+function setToArray(set) {
+  var index2 = -1, result = Array(set.size);
+  set.forEach(function(value) {
+    result[++index2] = value;
+  });
+  return result;
+}
+var COMPARE_PARTIAL_FLAG$4 = 1, COMPARE_UNORDERED_FLAG$2 = 2;
+var boolTag$1 = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", mapTag$2 = "[object Map]", numberTag = "[object Number]", regexpTag = "[object RegExp]", setTag$2 = "[object Set]", stringTag$1 = "[object String]", symbolTag = "[object Symbol]";
+var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]";
+var symbolProto = Symbol$2 ? Symbol$2.prototype : void 0, symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+  switch (tag) {
+    case dataViewTag:
+      if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
+        return false;
+      }
+      object = object.buffer;
+      other = other.buffer;
+    case arrayBufferTag:
+      if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array$1(object), new Uint8Array$1(other))) {
+        return false;
+      }
+      return true;
+    case boolTag$1:
+    case dateTag:
+    case numberTag:
+      return eq(+object, +other);
+    case errorTag:
+      return object.name == other.name && object.message == other.message;
+    case regexpTag:
+    case stringTag$1:
+      return object == other + "";
+    case mapTag$2:
+      var convert = mapToArray;
+    case setTag$2:
+      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(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+      stack["delete"](object);
+      return result;
+    case symbolTag:
+      if (symbolValueOf) {
+        return symbolValueOf.call(object) == symbolValueOf.call(other);
+      }
+  }
+  return false;
+}
+var COMPARE_PARTIAL_FLAG$3 = 1;
+var objectProto$2 = Object.prototype;
+var hasOwnProperty$2 = objectProto$2.hasOwnProperty;
+function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$3, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
+  if (objLength != othLength && !isPartial) {
+    return false;
+  }
+  var index2 = objLength;
+  while (index2--) {
+    var key = objProps[index2];
+    if (!(isPartial ? key in other : hasOwnProperty$2.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 (++index2 < objLength) {
+    key = objProps[index2];
+    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 COMPARE_PARTIAL_FLAG$2 = 1;
+var argsTag = "[object Arguments]", arrayTag = "[object Array]", objectTag = "[object Object]";
+var objectProto$1 = Object.prototype;
+var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+  var objIsArr = isArray$1(object), othIsArr = isArray$1(other), objTag = objIsArr ? arrayTag : getTag$1(object), othTag = othIsArr ? arrayTag : getTag$1(other);
+  objTag = objTag == argsTag ? objectTag : objTag;
+  othTag = othTag == argsTag ? objectTag : othTag;
+  var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, 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());
+    return objIsArr || isTypedArray$1(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$1.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty$1.call(other, "__wrapped__");
+    if (objIsWrapped || othIsWrapped) {
+      var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
+      stack || (stack = new Stack());
+      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+    }
+  }
+  if (!isSameTag) {
+    return false;
+  }
+  stack || (stack = new Stack());
+  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+}
+function baseIsEqual(value, other, bitmask, customizer, stack) {
+  if (value === other) {
+    return true;
+  }
+  if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
+    return value !== value && other !== other;
+  }
+  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
+}
+var COMPARE_PARTIAL_FLAG$1 = 1, COMPARE_UNORDERED_FLAG$1 = 2;
+function baseIsMatch(object, source, matchData, customizer) {
+  var index2 = matchData.length, length = index2, noCustomizer = !customizer;
+  if (object == null) {
+    return !length;
+  }
+  object = Object(object);
+  while (index2--) {
+    var data = matchData[index2];
+    if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
+      return false;
+    }
+  }
+  while (++index2 < length) {
+    data = matchData[index2];
+    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();
+      if (customizer) {
+        var result = customizer(objValue, srcValue, key, object, source, stack);
+      }
+      if (!(result === void 0 ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG$1 | COMPARE_UNORDERED_FLAG$1, customizer, stack) : result)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function isStrictComparable(value) {
+  return value === value && !isObject(value);
+}
+function getMatchData(object) {
+  var result = keys(object), length = result.length;
+  while (length--) {
+    var key = result[length], value = object[key];
+    result[length] = [key, value, isStrictComparable(value)];
+  }
+  return result;
+}
+function matchesStrictComparable(key, srcValue) {
+  return function(object) {
+    if (object == null) {
+      return false;
+    }
+    return object[key] === srcValue && (srcValue !== void 0 || key in Object(object));
+  };
+}
+function baseMatches(source) {
+  var matchData = getMatchData(source);
+  if (matchData.length == 1 && matchData[0][2]) {
+    return matchesStrictComparable(matchData[0][0], matchData[0][1]);
+  }
+  return function(object) {
+    return object === source || baseIsMatch(object, source, matchData);
+  };
+}
+function baseHasIn(object, key) {
+  return object != null && key in Object(object);
+}
+function hasPath(object, path, hasFunc) {
+  path = castPath(path, object);
+  var index2 = -1, length = path.length, result = false;
+  while (++index2 < length) {
+    var key = toKey(path[index2]);
+    if (!(result = object != null && hasFunc(object, key))) {
+      break;
+    }
+    object = object[key];
+  }
+  if (result || ++index2 != length) {
+    return result;
+  }
+  length = object == null ? 0 : object.length;
+  return !!length && isLength(length) && isIndex(key, length) && (isArray$1(object) || isArguments$1(object));
+}
+function hasIn(object, path) {
+  return object != null && hasPath(object, path, baseHasIn);
+}
+var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
+function baseMatchesProperty(path, srcValue) {
+  if (isKey(path) && isStrictComparable(srcValue)) {
+    return matchesStrictComparable(toKey(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);
+  };
+}
+function baseProperty(key) {
+  return function(object) {
+    return object == null ? void 0 : object[key];
+  };
+}
+function basePropertyDeep(path) {
+  return function(object) {
+    return baseGet(object, path);
+  };
+}
+function property(path) {
+  return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
+}
+function baseIteratee(value) {
+  if (typeof value == "function") {
+    return value;
+  }
+  if (value == null) {
+    return identity;
+  }
+  if (typeof value == "object") {
+    return isArray$1(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value);
+  }
+  return property(value);
+}
+function createBaseFor(fromRight) {
+  return function(object, iteratee, keysFunc) {
+    var index2 = -1, iterable = Object(object), props = keysFunc(object), length = props.length;
+    while (length--) {
+      var key = props[fromRight ? length : ++index2];
+      if (iteratee(iterable[key], key, iterable) === false) {
+        break;
+      }
+    }
+    return object;
+  };
+}
+var baseFor = createBaseFor();
+var baseFor$1 = baseFor;
+function baseForOwn(object, iteratee) {
+  return object && baseFor$1(object, iteratee, keys);
+}
+function createBaseEach(eachFunc, fromRight) {
+  return function(collection, iteratee) {
+    if (collection == null) {
+      return collection;
+    }
+    if (!isArrayLike(collection)) {
+      return eachFunc(collection, iteratee);
+    }
+    var length = collection.length, index2 = fromRight ? length : -1, iterable = Object(collection);
+    while (fromRight ? index2-- : ++index2 < length) {
+      if (iteratee(iterable[index2], index2, iterable) === false) {
+        break;
+      }
+    }
+    return collection;
+  };
+}
+var baseEach = createBaseEach(baseForOwn);
+var baseEach$1 = baseEach;
+var now = function() {
+  return root$1.Date.now();
+};
+var now$1 = now;
+var FUNC_ERROR_TEXT = "Expected a function";
+var nativeMax = Math.max, nativeMin = Math.min;
+function debounce(func, wait, options) {
+  var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
+  if (typeof func != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  wait = toNumber(wait) || 0;
+  if (isObject(options)) {
+    leading = !!options.leading;
+    maxing = "maxWait" in options;
+    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
+    trailing = "trailing" in options ? !!options.trailing : trailing;
+  }
+  function invokeFunc(time) {
+    var args = lastArgs, thisArg = lastThis;
+    lastArgs = lastThis = void 0;
+    lastInvokeTime = time;
+    result = func.apply(thisArg, args);
+    return result;
+  }
+  function leadingEdge(time) {
+    lastInvokeTime = time;
+    timerId = setTimeout(timerExpired, wait);
+    return leading ? invokeFunc(time) : result;
+  }
+  function remainingWait(time) {
+    var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
+    return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
+  }
+  function shouldInvoke(time) {
+    var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
+    return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+  }
+  function timerExpired() {
+    var time = now$1();
+    if (shouldInvoke(time)) {
+      return trailingEdge(time);
+    }
+    timerId = setTimeout(timerExpired, remainingWait(time));
+  }
+  function trailingEdge(time) {
+    timerId = void 0;
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = lastThis = void 0;
+    return result;
+  }
+  function cancel() {
+    if (timerId !== void 0) {
+      clearTimeout(timerId);
+    }
+    lastInvokeTime = 0;
+    lastArgs = lastCallTime = lastThis = timerId = void 0;
+  }
+  function flush() {
+    return timerId === void 0 ? result : trailingEdge(now$1());
+  }
+  function debounced() {
+    var time = now$1(), isInvoking = shouldInvoke(time);
+    lastArgs = arguments;
+    lastThis = this;
+    lastCallTime = time;
+    if (isInvoking) {
+      if (timerId === void 0) {
+        return leadingEdge(lastCallTime);
+      }
+      if (maxing) {
+        clearTimeout(timerId);
+        timerId = setTimeout(timerExpired, wait);
+        return invokeFunc(lastCallTime);
+      }
+    }
+    if (timerId === void 0) {
+      timerId = setTimeout(timerExpired, wait);
+    }
+    return result;
+  }
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  return debounced;
+}
+var stringTag = "[object String]";
+function isString(value) {
+  return typeof value == "string" || !isArray$1(value) && isObjectLike(value) && baseGetTag(value) == stringTag;
+}
+var boolTag = "[object Boolean]";
+function isBoolean(value) {
+  return value === true || value === false || isObjectLike(value) && baseGetTag(value) == boolTag;
+}
+var mapTag$1 = "[object Map]", setTag$1 = "[object Set]";
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+function isEmpty(value) {
+  if (value == null) {
+    return true;
+  }
+  if (isArrayLike(value) && (isArray$1(value) || typeof value == "string" || typeof value.splice == "function" || isBuffer$1(value) || isTypedArray$1(value) || isArguments$1(value))) {
+    return !value.length;
+  }
+  var tag = getTag$1(value);
+  if (tag == mapTag$1 || tag == setTag$1) {
+    return !value.size;
+  }
+  if (isPrototype(value)) {
+    return !baseKeys(value).length;
+  }
+  for (var key in value) {
+    if (hasOwnProperty.call(value, key)) {
+      return false;
+    }
+  }
+  return true;
+}
+var asciiSize = baseProperty("length");
+var asciiSize$1 = asciiSize;
+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(string) {
+  var result = reUnicode.lastIndex = 0;
+  while (reUnicode.test(string)) {
+    ++result;
+  }
+  return result;
+}
+function stringSize(string) {
+  return hasUnicode(string) ? unicodeSize(string) : asciiSize$1(string);
+}
+function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
+  eachFunc(collection, function(value, index2, collection2) {
+    accumulator = initAccum ? (initAccum = false, value) : iteratee(accumulator, value, index2, collection2);
+  });
+  return accumulator;
+}
+function reduce(collection, iteratee, accumulator) {
+  var func = isArray$1(collection) ? arrayReduce : baseReduce, initAccum = arguments.length < 3;
+  return func(collection, baseIteratee(iteratee), accumulator, initAccum, baseEach$1);
+}
+var mapTag = "[object Map]", setTag = "[object Set]";
+function size(collection) {
+  if (collection == null) {
+    return 0;
+  }
+  if (isArrayLike(collection)) {
+    return isString(collection) ? stringSize(collection) : collection.length;
+  }
+  var tag = getTag$1(collection);
+  if (tag == mapTag || tag == setTag) {
+    return collection.size;
+  }
+  return baseKeys(collection).length;
+}
+const RESIZE_RENDER_DELAY = 200;
+const analyzeAdaptive = (paramsContainer, adaptive) => {
+  var _a, _b, _c;
+  let container = paramsContainer;
+  let adaptiveWidth = true;
+  let adaptiveHeight = false;
+  if (typeof adaptive !== "boolean") {
+    container = ((_a = adaptive == null ? void 0 : adaptive.getContainer) == null ? void 0 : _a.call(adaptive)) || paramsContainer;
+    adaptiveWidth = (_b = adaptive == null ? void 0 : adaptive.width) != null ? _b : true;
+    adaptiveHeight = (_c = adaptive == null ? void 0 : adaptive.height) != null ? _c : true;
+  }
+  return { container, adaptiveWidth, adaptiveHeight };
+};
+const createResizeObserver = (params) => {
+  let isFirstRender = true;
+  const { s2, adaptive, container, wrapper } = params;
+  const {
+    container: actualWrapper,
+    adaptiveWidth,
+    adaptiveHeight
+  } = analyzeAdaptive(wrapper, adaptive);
+  if (!actualWrapper || !container || !adaptive || !s2) {
+    return;
+  }
+  const render2 = (width, height) => {
+    s2 == null ? void 0 : s2.changeSheetSize(width, height);
+    s2 == null ? void 0 : s2.render(false);
+  };
+  const debounceRender = debounce(render2, RESIZE_RENDER_DELAY);
+  const onResize = () => {
+    const { width: nodeWidth, height: nodeHeight } = container == null ? void 0 : container.getBoundingClientRect();
+    const width = adaptiveWidth ? Math.floor(nodeWidth != null ? nodeWidth : s2.options.width) : s2.options.width;
+    const height = adaptiveHeight ? Math.floor(nodeHeight != null ? nodeHeight : s2.options.height) : s2.options.height;
+    if (!adaptiveWidth && !adaptiveHeight) {
+      return;
+    }
+    if (isFirstRender) {
+      render2(width, height);
+      isFirstRender = false;
+      return;
+    }
+    debounceRender(width, height);
+  };
+  const resizeObserver = new ResizeObserver(([entry] = []) => {
+    if (entry) {
+      onResize();
+    }
+  });
+  resizeObserver.observe(actualWrapper, {
+    box: "border-box"
+  });
+  return () => {
+    resizeObserver.unobserve(actualWrapper);
+  };
+};
+const EN_US = {
+  \u9009\u62E9\u5206\u6790\u4FE1\u606F: "Select Analysis Information",
+  \u5207\u6362\u6307\u6807: "Switch indicator",
+  \u786E\u5B9A: "Ok",
+  \u53D6\u6D88: "Cancel",
+  \u91CD\u7F6E: "Reset",
+  \u8BF7\u8F93\u5165\u5173\u952E\u5B57\u641C\u7D22: "Please enter a keyword search",
+  \u641C\u7D22: "Search",
+  \u6062\u590D: "Recover",
+  "\u5DF2\u9009 {} \u9879": "selected {} item",
+  \u6240\u9009\u9879: "selected items",
+  \u9009\u62E9\u4E0B\u94BB\u7EF4\u5EA6: "Select drill down dimension",
+  \u6062\u590D\u9ED8\u8BA4: "Restore default",
+  \u641C\u7D22\u5B57\u6BB5: "Search field",
+  \u884C\u5217\u5207\u6362: "Switch Dimensions",
+  \u884C\u5934: "Rows",
+  \u5217\u5934: "Cols",
+  \u503C: "Values",
+  \u5C55\u5F00\u5B50\u9879: "Expand Children",
+  \u9996\u5B57\u6BCD: "Alphabetical order",
+  \u624B\u52A8\u6392\u5E8F: "Custom order",
+  \u5176\u4ED6\u5B57\u6BB5: "Other field",
+  \u9AD8\u7EA7\u6392\u5E8F: "Advanced order",
+  \u8BBE\u7F6E\u987A\u5E8F: "SetManual",
+  \u53EF\u9009\u5B57\u6BB5: "Fields",
+  "\u6309\u4EE5\u4E0B\u89C4\u5219\u8FDB\u884C\u6392\u5E8F\uFF08\u4F18\u5148\u7EA7\u7531\u4F4E\u5230\u9AD8\uFF09": "Order according to the following rules (from low to high priority)",
+  \u6309: "By",
+  \u8BF4\u660E: "Description"
+};
+const ZH_CN = {
+  \u9009\u62E9\u5206\u6790\u4FE1\u606F: "\u9009\u62E9\u5206\u6790\u4FE1\u606F",
+  \u5207\u6362\u6307\u6807: "\u5207\u6362\u6307\u6807",
+  \u786E\u5B9A: "\u786E\u5B9A",
+  \u53D6\u6D88: "\u53D6\u6D88",
+  \u91CD\u7F6E: "\u91CD\u7F6E",
+  \u8BF7\u8F93\u5165\u5173\u952E\u5B57\u641C\u7D22: "\u8BF7\u8F93\u5165\u5173\u952E\u5B57\u641C\u7D22",
+  \u641C\u7D22: "\u641C\u7D22",
+  \u6062\u590D: "\u6062\u590D",
+  "\u5DF2\u9009 {} \u9879": "\u5DF2\u9009 {} \u9879",
+  \u6240\u9009\u9879: "\u6240\u9009\u9879",
+  \u9009\u62E9\u4E0B\u94BB\u7EF4\u5EA6: "\u9009\u62E9\u4E0B\u94BB\u7EF4\u5EA6",
+  \u6062\u590D\u9ED8\u8BA4: "\u6062\u590D\u9ED8\u8BA4",
+  \u641C\u7D22\u5B57\u6BB5: "\u641C\u7D22\u5B57\u6BB5",
+  \u884C\u5217\u5207\u6362: "\u884C\u5217\u5207\u6362",
+  \u884C\u5934: "\u884C\u5934",
+  \u5217\u5934: "\u5217\u5934",
+  \u503C: "\u503C",
+  \u5C55\u5F00\u5B50\u9879: "\u5C55\u5F00\u5B50\u9879",
+  \u9996\u5B57\u6BCD: "\u9996\u5B57\u6BCD",
+  \u624B\u52A8\u6392\u5E8F: "\u624B\u52A8\u6392\u5E8F",
+  \u5176\u4ED6\u5B57\u6BB5: "\u5176\u4ED6\u5B57\u6BB5",
+  \u9AD8\u7EA7\u6392\u5E8F: "\u9AD8\u7EA7\u6392\u5E8F",
+  \u8BBE\u7F6E\u987A\u5E8F: "\u8BBE\u7F6E\u987A\u5E8F",
+  \u53EF\u9009\u5B57\u6BB5: "\u53EF\u9009\u5B57\u6BB5",
+  "\u6309\u4EE5\u4E0B\u89C4\u5219\u8FDB\u884C\u6392\u5E8F\uFF08\u4F18\u5148\u7EA7\u7531\u4F4E\u5230\u9AD8\uFF09": "\u6309\u4EE5\u4E0B\u89C4\u5219\u8FDB\u884C\u6392\u5E8F\uFF08\u4F18\u5148\u7EA7\u7531\u4F4E\u5230\u9AD8\uFF09",
+  \u6309: "\u6309",
+  \u8BF4\u660E: "\u8BF4\u660E"
+};
+const Locale = {
+  zh_CN: ZH_CN,
+  en_US: EN_US
+};
+extendLocale(Locale);
+const useExpose = (expose) => {
+  const s2Ref = shallowRef();
+  expose({
+    get instance() {
+      var _a;
+      return (_a = s2Ref.value) == null ? void 0 : _a.instance;
+    }
+  });
+  return s2Ref;
+};
+const DEFAULT_PAGE_NUMBER = 1;
+const DEFAULT_PAGE_SIZE = 10;
+const usePagination = (s2Ref, props) => {
+  var _a, _b, _c, _d, _e, _f;
+  const current = ref((_c = (_b = (_a = props.options) == null ? void 0 : _a.pagination) == null ? void 0 : _b.current) != null ? _c : DEFAULT_PAGE_NUMBER);
+  const pageSize = ref((_f = (_e = (_d = props.options) == null ? void 0 : _d.pagination) == null ? void 0 : _e.pageSize) != null ? _f : DEFAULT_PAGE_SIZE);
+  const total = ref(0);
+  const change = (nextCurrent) => {
+    current.value = nextCurrent;
+  };
+  const showSizeChange = (nextPageSize) => {
+    pageSize.value = nextPageSize;
+  };
+  const visible = computed(() => {
+    var _a2;
+    return props.showPagination && !isEmpty((_a2 = props.options) == null ? void 0 : _a2.pagination);
+  });
+  watch([current, pageSize], () => {
+    var _a2;
+    if (!s2Ref.value) {
+      return;
+    }
+    const nextPagination = isEmpty((_a2 = props.options) == null ? void 0 : _a2.pagination) ? null : {
+      current: current.value,
+      pageSize: pageSize.value
+    };
+    s2Ref.value.updatePagination(nextPagination);
+    s2Ref.value.render(false);
+  });
+  watch([() => {
+    var _a2;
+    return (_a2 = props.options) == null ? void 0 : _a2.pagination;
+  }, s2Ref], () => {
+    var _a2, _b2, _c2, _d2, _e2, _f2, _g, _h, _i;
+    current.value = (_c2 = (_b2 = (_a2 = props.options) == null ? void 0 : _a2.pagination) == null ? void 0 : _b2.current) != null ? _c2 : DEFAULT_PAGE_NUMBER;
+    pageSize.value = (_f2 = (_e2 = (_d2 = props.options) == null ? void 0 : _d2.pagination) == null ? void 0 : _e2.pageSize) != null ? _f2 : DEFAULT_PAGE_SIZE;
+    total.value = (_i = (_h = (_g = s2Ref.value) == null ? void 0 : _g.facet) == null ? void 0 : _h.viewCellHeights.getTotalLength()) != null ? _i : 0;
+  }, {
+    immediate: true
+  });
+  watch(s2Ref, (value, oldValue, onCleanup) => {
+    if (!s2Ref.value) {
+      return;
+    }
+    const totalUpdateCallback = (data) => {
+      var _a2;
+      if (isEmpty((_a2 = props.options) == null ? void 0 : _a2.pagination)) {
+        return;
+      }
+      total.value = data.total;
+    };
+    s2Ref.value.on(S2Event.LAYOUT_PAGINATION, totalUpdateCallback);
+    onCleanup(() => {
+      var _a2;
+      (_a2 = s2Ref.value) == null ? void 0 : _a2.off(S2Event.LAYOUT_PAGINATION, totalUpdateCallback);
+    });
+  });
+  return {
+    visible,
+    current,
+    pageSize,
+    total,
+    change,
+    showSizeChange
+  };
+};
+var _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const PRE_CLASS = `${S2_PREFIX_CLS}-pagination`;
+const _sfc_main$d = defineComponent({
+  name: "s2-pagination",
+  props: {
+    current: {
+      type: Number,
+      default: DEFAULT_PAGE_NUMBER
+    },
+    total: {
+      type: Number,
+      default: 0
+    },
+    pageSize: {
+      type: Number,
+      default: DEFAULT_PAGE_SIZE
+    }
+  },
+  emits: ["change", "showSizeChange"],
+  setup: (props) => {
+    const showQuickJumper = computed(() => {
+      return props.total / props.pageSize > 5;
+    });
+    return {
+      showQuickJumper,
+      PRE_CLASS,
+      i18n
+    };
+  },
+  components: {
+    AntDPagination: Pagination
+  }
+});
+function _sfc_render$d(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_AntDPagination = resolveComponent("AntDPagination");
+  return openBlock(), createElementBlock("div", {
+    class: normalizeClass(_ctx.PRE_CLASS)
+  }, [
+    createVNode(_component_AntDPagination, {
+      "default-current": 1,
+      current: _ctx.current,
+      total: _ctx.total,
+      pageSize: _ctx.pageSize,
+      showSizeChanger: true,
+      onShowSizeChange: _cache[0] || (_cache[0] = (_, size2) => _ctx.$emit("showSizeChange", size2)),
+      size: "small",
+      showQuickJumper: _ctx.showQuickJumper,
+      onChange: _cache[1] || (_cache[1] = (current) => _ctx.$emit("change", current))
+    }, null, 8, ["current", "total", "pageSize", "showQuickJumper"]),
+    createElementVNode("span", {
+      class: normalizeClass(`${_ctx.PRE_CLASS}-count`)
+    }, toDisplayString(_ctx.i18n("\u5171\u8BA1")) + " " + toDisplayString(_ctx.total || " - ") + " " + toDisplayString(_ctx.i18n("\u6761")), 3)
+  ], 2);
+}
+var S2Pagination = /* @__PURE__ */ _export_sfc(_sfc_main$d, [["render", _sfc_render$d]]);
+const _sfc_main$c = defineComponent({
+  name: "TooltipDetail",
+  props: ["list"],
+  setup() {
+    return {
+      TOOLTIP_PREFIX_CLS
+    };
+  }
+});
+function _sfc_render$c(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.list, (item, index2) => {
+    return openBlock(), createElementBlock("div", {
+      key: `${item.value}-${index2}`,
+      class: normalizeClass(`${_ctx.TOOLTIP_PREFIX_CLS}-detail-list`)
+    }, [
+      createElementVNode("div", {
+        class: normalizeClass(`${_ctx.TOOLTIP_PREFIX_CLS}-detail-item`)
+      }, [
+        createElementVNode("span", {
+          class: normalizeClass(`${_ctx.TOOLTIP_PREFIX_CLS}-detail-item-key`)
+        }, toDisplayString(item.name), 3),
+        createElementVNode("span", {
+          class: normalizeClass(`${_ctx.TOOLTIP_PREFIX_CLS}-detail-item-val ${_ctx.TOOLTIP_PREFIX_CLS}-highlight`)
+        }, toDisplayString(item.value), 3)
+      ], 2)
+    ], 2);
+  }), 128);
+}
+var TooltipDetail = /* @__PURE__ */ _export_sfc(_sfc_main$c, [["render", _sfc_render$c]]);
+const _sfc_main$b = defineComponent({
+  name: "TooltipHeadInfo",
+  props: ["rows", "cols"],
+  setup() {
+    return {
+      TOOLTIP_PREFIX_CLS
+    };
+  },
+  components: {}
+});
+const _hoisted_1$1 = { key: 0 };
+function _sfc_render$b(_ctx, _cache, $props, $setup, $data, $options) {
+  var _a, _b, _c, _d;
+  return ((_a = _ctx.cols) == null ? void 0 : _a.length) || ((_b = _ctx.rows) == null ? void 0 : _b.length) ? (openBlock(), createElementBlock("div", {
+    key: 0,
+    class: normalizeClass(`${_ctx.TOOLTIP_PREFIX_CLS}-head-info-list`)
+  }, [
+    (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.cols, (col) => {
+      return openBlock(), createElementBlock("span", {
+        key: col.value
+      }, toDisplayString(col.value) + "/", 1);
+    }), 128)),
+    ((_c = _ctx.cols) == null ? void 0 : _c.length) > 0 && ((_d = _ctx.rows) == null ? void 0 : _d.length) > 0 ? (openBlock(), createElementBlock("span", _hoisted_1$1, "\uFF0C")) : createCommentVNode("", true),
+    (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.rows, (row) => {
+      return openBlock(), createElementBlock("span", {
+        key: row.value
+      }, toDisplayString(row.value) + "/", 1);
+    }), 128))
+  ], 2)) : createCommentVNode("", true);
+}
+var TooltipHeadInfo = /* @__PURE__ */ _export_sfc(_sfc_main$b, [["render", _sfc_render$b]]);
+const _sfc_main$a = defineComponent({
+  name: "TooltipInfos",
+  props: ["infos"],
+  setup() {
+    return {
+      TOOLTIP_PREFIX_CLS
+    };
+  },
+  components: {}
+});
+function _sfc_render$a(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("div", {
+    class: normalizeClass(`${_ctx.TOOLTIP_PREFIX_CLS}-infos`)
+  }, toDisplayString(_ctx.infos), 3);
+}
+var TooltipInfos = /* @__PURE__ */ _export_sfc(_sfc_main$a, [["render", _sfc_render$a]]);
+const _sfc_main$9 = defineComponent({
+  name: "TooltipSimpleTips",
+  props: ["name", "tips"],
+  setup() {
+    return {
+      TOOLTIP_PREFIX_CLS
+    };
+  },
+  components: {}
+});
+function _sfc_render$9(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock(Fragment, null, [
+    _ctx.name ? (openBlock(), createElementBlock("div", {
+      key: 0,
+      class: normalizeClass(`${_ctx.TOOLTIP_PREFIX_CLS}-name`)
+    }, toDisplayString(_ctx.name), 3)) : createCommentVNode("", true),
+    _ctx.tips ? (openBlock(), createElementBlock("div", {
+      key: 1,
+      class: normalizeClass(`${_ctx.TOOLTIP_PREFIX_CLS}-tips`)
+    }, toDisplayString(_ctx.tips), 3)) : createCommentVNode("", true)
+  ], 64);
+}
+var TooltipSimpleTips = /* @__PURE__ */ _export_sfc(_sfc_main$9, [["render", _sfc_render$9]]);
+const _sfc_main$8 = defineComponent({
+  name: "TooltipSummary",
+  props: ["summaries"],
+  setup(props) {
+    const count = computed(() => reduce(props.summaries, (pre, next) => pre + size(next == null ? void 0 : next.selectedData), 0));
+    return {
+      count: count.value,
+      i18n,
+      TOOLTIP_PREFIX_CLS
+    };
+  },
+  components: {}
+});
+function _sfc_render$8(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("div", {
+    class: normalizeClass(`${_ctx.TOOLTIP_PREFIX_CLS}-summary`)
+  }, [
+    createElementVNode("div", {
+      class: normalizeClass(`${_ctx.TOOLTIP_PREFIX_CLS}-summary-item`)
+    }, [
+      createElementVNode("span", {
+        class: normalizeClass(`${_ctx.TOOLTIP_PREFIX_CLS}-selected`)
+      }, toDisplayString(_ctx.count) + " " + toDisplayString(_ctx.i18n("\u9879")), 3),
+      createTextVNode(" " + toDisplayString(_ctx.i18n("\u5DF2\u9009\u62E9")), 1)
+    ], 2),
+    (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.summaries, (summary) => {
+      return openBlock(), createElementBlock("div", {
+        key: `${summary.name}-${summary.value}`,
+        class: normalizeClass(`${_ctx.TOOLTIP_PREFIX_CLS}-summary-item`)
+      }, [
+        createElementVNode("span", {
+          class: normalizeClass(`${_ctx.TOOLTIP_PREFIX_CLS}-summary-key`)
+        }, toDisplayString(summary.name) + " " + toDisplayString(_ctx.i18n("\u603B\u548C")), 3),
+        createElementVNode("span", {
+          class: normalizeClass(`${_ctx.TOOLTIP_PREFIX_CLS}-summary-val ${_ctx.TOOLTIP_PREFIX_CLS}-bold`)
+        }, toDisplayString(summary.value), 3)
+      ], 2);
+    }), 128))
+  ], 2);
+}
+var TooltipSummary = /* @__PURE__ */ _export_sfc(_sfc_main$8, [["render", _sfc_render$8]]);
+const _sfc_main$7 = defineComponent({
+  name: "TooltipOperatorTitle",
+  props: ["menu"],
+  setup(props) {
+    const icon = computed(() => getIcon(props.menu.icon));
+    return {
+      TOOLTIP_PREFIX_CLS,
+      icon
+    };
+  }
+});
+const _hoisted_1 = ["innerHTML"];
+function _sfc_render$7(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("span", null, [
+    _ctx.icon ? (openBlock(), createElementBlock("span", {
+      key: 0,
+      innerHTML: _ctx.icon,
+      class: normalizeClass(`${_ctx.TOOLTIP_PREFIX_CLS}-operator-icon`)
+    }, null, 10, _hoisted_1)) : createCommentVNode("", true),
+    createElementVNode("span", {
+      class: normalizeClass(`${_ctx.TOOLTIP_PREFIX_CLS}-operator-text`)
+    }, toDisplayString(_ctx.menu.text), 3)
+  ]);
+}
+var TooltipOperatorTitle = /* @__PURE__ */ _export_sfc(_sfc_main$7, [["render", _sfc_render$7]]);
+const _sfc_main$6 = defineComponent({
+  name: "TooltipOperatorMenu",
+  props: ["menu", "cell"],
+  setup(props) {
+    const onMenuTitleClick = () => {
+      var _a, _b;
+      (_b = (_a = props.menu).onClick) == null ? void 0 : _b.call(_a, props.cell);
+    };
+    return {
+      onMenuTitleClick,
+      TOOLTIP_PREFIX_CLS
+    };
+  },
+  components: {
+    MenuItem: Menu.Item,
+    SubMenu: Menu.SubMenu,
+    TooltipOperatorTitle
+  }
+});
+function _sfc_render$6(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_TooltipOperatorTitle = resolveComponent("TooltipOperatorTitle");
+  const _component_TooltipOperatorMenu = resolveComponent("TooltipOperatorMenu");
+  const _component_MenuItem = resolveComponent("MenuItem");
+  const _component_SubMenu = resolveComponent("SubMenu");
+  return openBlock(), createBlock(_component_SubMenu, {
+    key: _ctx.menu.key,
+    popupClassName: `${_ctx.TOOLTIP_PREFIX_CLS}-operator-submenu-popup`,
+    onTitleClick: _ctx.onMenuTitleClick
+  }, {
+    title: withCtx(() => [
+      createVNode(_component_TooltipOperatorTitle, {
+        menu: _ctx.menu,
+        onClick: _ctx.onMenuTitleClick
+      }, null, 8, ["menu", "onClick"])
+    ]),
+    default: withCtx(() => [
+      (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.menu.children, (subMenu) => {
+        var _a;
+        return openBlock(), createElementBlock(Fragment, {
+          key: subMenu.key
+        }, [
+          ((_a = subMenu == null ? void 0 : subMenu.children) == null ? void 0 : _a.length) ? (openBlock(), createBlock(_component_TooltipOperatorMenu, {
+            key: 0,
+            menu: subMenu,
+            cell: _ctx.cell
+          }, null, 8, ["menu", "cell"])) : (openBlock(), createBlock(_component_MenuItem, {
+            title: subMenu.text,
+            key: subMenu.key
+          }, {
+            default: withCtx(() => [
+              createVNode(_component_TooltipOperatorTitle, {
+                menu: subMenu,
+                onClick: _ctx.onMenuTitleClick
+              }, null, 8, ["menu", "onClick"])
+            ]),
+            _: 2
+          }, 1032, ["title"]))
+        ], 64);
+      }), 128))
+    ]),
+    _: 1
+  }, 8, ["popupClassName", "onTitleClick"]);
+}
+var TooltipOperatorMenu = /* @__PURE__ */ _export_sfc(_sfc_main$6, [["render", _sfc_render$6]]);
+var index_vue_vue_type_style_index_0_lang$1 = "";
+const _sfc_main$5 = defineComponent({
+  name: "TooltipOperator",
+  props: [
+    "menus",
+    "onlyMenu",
+    "onClick",
+    "cell"
+  ],
+  setup() {
+    return {
+      TOOLTIP_PREFIX_CLS
+    };
+  },
+  components: {
+    Menu,
+    Dropdown,
+    TooltipOperatorTitle,
+    TooltipOperatorMenu
+  }
+});
+function _sfc_render$5(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_TooltipOperatorMenu = resolveComponent("TooltipOperatorMenu");
+  const _component_Menu = resolveComponent("Menu");
+  const _component_TooltipOperatorTitle = resolveComponent("TooltipOperatorTitle");
+  const _component_Dropdown = resolveComponent("Dropdown");
+  return openBlock(), createElementBlock("div", {
+    class: normalizeClass(`${_ctx.TOOLTIP_PREFIX_CLS}-operator`)
+  }, [
+    _ctx.onlyMenu ? (openBlock(), createBlock(_component_Menu, {
+      key: 0,
+      class: normalizeClass(`${_ctx.TOOLTIP_PREFIX_CLS}-operator-menus`),
+      onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$.emit("click"))
+    }, {
+      default: withCtx(() => [
+        (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.menus, (menu) => {
+          return openBlock(), createBlock(_component_TooltipOperatorMenu, {
+            key: menu.key,
+            menu,
+            cell: _ctx.cell
+          }, null, 8, ["menu", "cell"]);
+        }), 128))
+      ]),
+      _: 1
+    }, 8, ["class"])) : (openBlock(true), createElementBlock(Fragment, { key: 1 }, renderList(_ctx.menus, (menu) => {
+      return openBlock(), createBlock(_component_Dropdown, {
+        key: menu.key,
+        class: normalizeClass(`${_ctx.TOOLTIP_PREFIX_CLS}-operator-dropdown`)
+      }, {
+        overlay: withCtx(() => {
+          var _a;
+          return [
+            ((_a = menu == null ? void 0 : menu.children) == null ? void 0 : _a.length) ? (openBlock(), createBlock(_component_Menu, {
+              key: 0,
+              class: normalizeClass(`${_ctx.TOOLTIP_PREFIX_CLS}-operator-menus`),
+              onClick: _cache[1] || (_cache[1] = ($event) => _ctx.$.emit("click"))
+            }, {
+              default: withCtx(() => [
+                (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.menus, (menu2) => {
+                  return openBlock(), createBlock(_component_TooltipOperatorMenu, {
+                    key: menu2.key,
+                    menu: menu2,
+                    cell: _ctx.cell
+                  }, null, 8, ["menu", "cell"]);
+                }), 128))
+              ]),
+              _: 2
+            }, 1032, ["class"])) : createCommentVNode("", true)
+          ];
+        }),
+        default: withCtx(() => [
+          createVNode(_component_TooltipOperatorTitle, {
+            menu,
+            onClick: ($event) => {
+              var _a;
+              return (_a = menu.onClick) == null ? void 0 : _a.call(menu, _ctx.cell);
+            }
+          }, null, 8, ["menu", "onClick"])
+        ]),
+        _: 2
+      }, 1032, ["class"]);
+    }), 128))
+  ], 2);
+}
+var TooltipOperator = /* @__PURE__ */ _export_sfc(_sfc_main$5, [["render", _sfc_render$5]]);
+var index_vue_vue_type_style_index_0_lang = "";
+const _sfc_main$4 = defineComponent({
+  name: "TooltipComponent",
+  props: [
+    "content",
+    "data",
+    "options",
+    "cell",
+    "position",
+    "event"
+  ],
+  setup(props) {
+    const { operator, onlyMenu } = getTooltipDefaultOptions(props.options);
+    return {
+      operator,
+      onlyMenu
+    };
+  },
+  components: {
+    TooltipDetail,
+    TooltipHeadInfo,
+    TooltipInfos,
+    TooltipSimpleTips,
+    TooltipSummary,
+    TooltipOperator
+  }
+});
+function _sfc_render$4(_ctx, _cache, $props, $setup, $data, $options) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
+  const _component_TooltipOperator = resolveComponent("TooltipOperator");
+  const _component_TooltipSimpleTips = resolveComponent("TooltipSimpleTips");
+  const _component_TooltipSummary = resolveComponent("TooltipSummary");
+  const _component_TooltipHeadInfo = resolveComponent("TooltipHeadInfo");
+  const _component_TooltipDetail = resolveComponent("TooltipDetail");
+  const _component_TooltipInfos = resolveComponent("TooltipInfos");
+  return _ctx.onlyMenu ? (openBlock(), createBlock(_component_TooltipOperator, {
+    key: 0,
+    menus: ((_a = _ctx.operator) == null ? void 0 : _a.menus) || [],
+    onlyMenu: true,
+    cell: _ctx.cell,
+    onClick: (_b = _ctx.operator) == null ? void 0 : _b.onClick
+  }, null, 8, ["menus", "cell", "onClick"])) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+    createVNode(_component_TooltipOperator, {
+      menus: ((_c = _ctx.operator) == null ? void 0 : _c.menus) || [],
+      onlyMenu: false,
+      cell: _ctx.cell,
+      onClick: (_d = _ctx.operator) == null ? void 0 : _d.onClick
+    }, null, 8, ["menus", "cell", "onClick"]),
+    _ctx.content ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+      createTextVNode(toDisplayString(_ctx.content), 1)
+    ], 64)) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+      createVNode(_component_TooltipSimpleTips, {
+        name: (_e = _ctx.data) == null ? void 0 : _e.name,
+        tips: (_f = _ctx.data) == null ? void 0 : _f.tips
+      }, null, 8, ["name", "tips"]),
+      ((_h = (_g = _ctx.data) == null ? void 0 : _g.summaries) == null ? void 0 : _h.length) ? (openBlock(), createBlock(_component_TooltipSummary, {
+        key: 0,
+        summaries: (_i = _ctx.data) == null ? void 0 : _i.summaries
+      }, null, 8, ["summaries"])) : createCommentVNode("", true),
+      createVNode(_component_TooltipHeadInfo, {
+        rows: ((_k = (_j = _ctx.data) == null ? void 0 : _j.headInfo) == null ? void 0 : _k.rows) || [],
+        cols: ((_m = (_l = _ctx.data) == null ? void 0 : _l.headInfo) == null ? void 0 : _m.cols) || []
+      }, null, 8, ["rows", "cols"]),
+      createVNode(_component_TooltipDetail, {
+        list: ((_n = _ctx.data) == null ? void 0 : _n.details) || []
+      }, null, 8, ["list"]),
+      ((_o = _ctx.data) == null ? void 0 : _o.infos) ? (openBlock(), createBlock(_component_TooltipInfos, {
+        key: 1,
+        infos: (_p = _ctx.data) == null ? void 0 : _p.infos
+      }, null, 8, ["infos"])) : createCommentVNode("", true)
+    ], 64))
+  ], 64));
+}
+var TooltipComponent = /* @__PURE__ */ _export_sfc(_sfc_main$4, [["render", _sfc_render$4]]);
+class CustomTooltip extends BaseTooltip {
+  constructor(spreadsheet) {
+    super(spreadsheet);
+  }
+  renderContent() {
+    var _a, _b;
+    const { tooltip } = this.spreadsheet.options;
+    const showOptions = this.options;
+    const cell = this.spreadsheet.getCell((_a = showOptions.event) == null ? void 0 : _a.target);
+    const content = (_b = showOptions.content) != null ? _b : tooltip == null ? void 0 : tooltip.content;
+    const tooltipProps = __spreadProps(__spreadValues({}, showOptions), {
+      cell,
+      content
+    });
+    const tooltipVNode = createVNode(TooltipComponent, tooltipProps);
+    render(null, this.container);
+    render(tooltipVNode, this.container);
+  }
+  destroy() {
+    super.destroy();
+    if (this.container) {
+      render(null, this.container);
+    }
+  }
+}
+const RENDER_TOOLTIP_OPTION = {
+  tooltip: {
+    renderTooltip: (spreadsheet) => new CustomTooltip(spreadsheet)
+  }
+};
+[
+  {
+    name: i18n("\u5347\u5E8F"),
+    value: "ASC"
+  },
+  {
+    name: i18n("\u964D\u5E8F"),
+    value: "DESC"
+  }
+];
+[
+  {
+    label: i18n("\u9996\u5B57\u6BCD"),
+    value: "sortMethod"
+  },
+  {
+    label: i18n("\u624B\u52A8\u6392\u5E8F"),
+    value: "sortBy"
+  },
+  {
+    label: i18n("\u5176\u4ED6\u5B57\u6BB5"),
+    value: "sortByMeasure",
+    children: []
+  }
+];
+const getSheetComponentOptions = (...options) => getBaseSheetComponentOptions(RENDER_TOOLTIP_OPTION, ...options);
+const useCellEvent = (s2Ref, emit, eventName, emitName) => {
+  var _a;
+  const handler = (event) => {
+    const param = getBaseCellData(event);
+    emit(emitName, param);
+  };
+  (_a = s2Ref.value) == null ? void 0 : _a.on(eventName, handler);
+};
+const useS2Event = (s2Ref, emit, eventName, emitName) => {
+  var _a;
+  const handler = (params) => {
+    emit(emitName, params);
+  };
+  (_a = s2Ref.value) == null ? void 0 : _a.on(eventName, handler);
+};
+const useEvents = (s2Ref, emit) => {
+  onMounted(() => {
+    if (!s2Ref.value) {
+      return;
+    }
+    useCellEvent(s2Ref, emit, S2Event.ROW_CELL_HOVER, "rowCellHover");
+    useCellEvent(s2Ref, emit, S2Event.ROW_CELL_CLICK, "rowCellClick");
+    useCellEvent(s2Ref, emit, S2Event.ROW_CELL_DOUBLE_CLICK, "rowCellDoubleClick");
+    useCellEvent(s2Ref, emit, S2Event.ROW_CELL_CONTEXT_MENU, "rowCellContextMenu");
+    useCellEvent(s2Ref, emit, S2Event.ROW_CELL_MOUSE_DOWN, "rowCellMouseDown");
+    useCellEvent(s2Ref, emit, S2Event.ROW_CELL_MOUSE_UP, "rowCellMouseUp");
+    useCellEvent(s2Ref, emit, S2Event.ROW_CELL_MOUSE_MOVE, "rowCellMouseMove");
+    useS2Event(s2Ref, emit, S2Event.ROW_CELL_COLLAPSE_TREE_ROWS, "rowCellCollapseTreeRows");
+    useCellEvent(s2Ref, emit, S2Event.COL_CELL_HOVER, "colCellHover");
+    useCellEvent(s2Ref, emit, S2Event.COL_CELL_CLICK, "colCellClick");
+    useCellEvent(s2Ref, emit, S2Event.COL_CELL_DOUBLE_CLICK, "colCellDoubleClick");
+    useCellEvent(s2Ref, emit, S2Event.COL_CELL_CONTEXT_MENU, "colCellContextMenu");
+    useCellEvent(s2Ref, emit, S2Event.COL_CELL_MOUSE_DOWN, "colCellMouseDown");
+    useCellEvent(s2Ref, emit, S2Event.COL_CELL_MOUSE_UP, "colCellMouseUp");
+    useCellEvent(s2Ref, emit, S2Event.COL_CELL_MOUSE_MOVE, "colCellMouseMove");
+    useCellEvent(s2Ref, emit, S2Event.DATA_CELL_HOVER, "dataCellHover");
+    useCellEvent(s2Ref, emit, S2Event.DATA_CELL_CLICK, "dataCellClick");
+    useCellEvent(s2Ref, emit, S2Event.DATA_CELL_DOUBLE_CLICK, "dataCellDoubleClick");
+    useCellEvent(s2Ref, emit, S2Event.DATA_CELL_CONTEXT_MENU, "dataCellContextMenu");
+    useCellEvent(s2Ref, emit, S2Event.DATA_CELL_MOUSE_DOWN, "dataCellMouseDown");
+    useCellEvent(s2Ref, emit, S2Event.DATA_CELL_MOUSE_UP, "dataCellMouseUp");
+    useCellEvent(s2Ref, emit, S2Event.DATA_CELL_MOUSE_MOVE, "dataCellMouseMove");
+    useS2Event(s2Ref, emit, S2Event.DATA_CELL_TREND_ICON_CLICK, "dataCellTrendIconClick");
+    useS2Event(s2Ref, emit, S2Event.DATE_CELL_BRUSH_SELECTION, "dataCellBrushSelection");
+    useCellEvent(s2Ref, emit, S2Event.CORNER_CELL_HOVER, "cornerCellHover");
+    useCellEvent(s2Ref, emit, S2Event.CORNER_CELL_CLICK, "cornerCellClick");
+    useCellEvent(s2Ref, emit, S2Event.CORNER_CELL_DOUBLE_CLICK, "cornerCellDoubleClick");
+    useCellEvent(s2Ref, emit, S2Event.CORNER_CELL_CONTEXT_MENU, "cornerCellContextMenu");
+    useCellEvent(s2Ref, emit, S2Event.CORNER_CELL_MOUSE_DOWN, "cornerCellMouseDown");
+    useCellEvent(s2Ref, emit, S2Event.CORNER_CELL_MOUSE_UP, "cornerCellMouseUp");
+    useCellEvent(s2Ref, emit, S2Event.CORNER_CELL_MOUSE_MOVE, "cornerCellMouseMove");
+    useCellEvent(s2Ref, emit, S2Event.MERGED_CELLS_HOVER, "mergedCellsHover");
+    useCellEvent(s2Ref, emit, S2Event.MERGED_CELLS_CLICK, "mergedCellsClick");
+    useCellEvent(s2Ref, emit, S2Event.MERGED_CELLS_DOUBLE_CLICK, "mergedCellsDoubleClick");
+    useCellEvent(s2Ref, emit, S2Event.MERGED_CELLS_CONTEXT_MENU, "mergedCellsContextMenu");
+    useCellEvent(s2Ref, emit, S2Event.MERGED_CELLS_MOUSE_DOWN, "mergedCellsMouseDown");
+    useCellEvent(s2Ref, emit, S2Event.MERGED_CELLS_MOUSE_UP, "mergedCellsMouseUp");
+    useCellEvent(s2Ref, emit, S2Event.MERGED_CELLS_MOUSE_MOVE, "mergedCellsMouseMove");
+    useS2Event(s2Ref, emit, S2Event.RANGE_SORT, "rangeSort");
+    useS2Event(s2Ref, emit, S2Event.RANGE_SORTED, "rangeSorted");
+    useS2Event(s2Ref, emit, S2Event.RANGE_FILTER, "rangeFilter");
+    useS2Event(s2Ref, emit, S2Event.RANGE_FILTERED, "rangeFiltered");
+    useS2Event(s2Ref, emit, S2Event.LAYOUT_AFTER_HEADER_LAYOUT, "layoutAfterHeaderLayout");
+    useS2Event(s2Ref, emit, S2Event.LAYOUT_PAGINATION, "layoutPagination");
+    useS2Event(s2Ref, emit, S2Event.LAYOUT_CELL_SCROLL, "layoutCellScroll");
+    useS2Event(s2Ref, emit, S2Event.LAYOUT_AFTER_COLLAPSE_ROWS, "layoutAfterCollapseRows");
+    useS2Event(s2Ref, emit, S2Event.LAYOUT_TREE_ROWS_COLLAPSE_ALL, "collapseRowsAll");
+    useS2Event(s2Ref, emit, S2Event.LAYOUT_COLS_EXPANDED, "layoutColsExpanded");
+    useS2Event(s2Ref, emit, S2Event.LAYOUT_COLS_HIDDEN, "layoutColsHidden");
+    useS2Event(s2Ref, emit, S2Event.LAYOUT_BEFORE_RENDER, "beforeRender");
+    useS2Event(s2Ref, emit, S2Event.LAYOUT_AFTER_RENDER, "afterRender");
+    useS2Event(s2Ref, emit, S2Event.LAYOUT_DESTROY, "destroy");
+    useS2Event(s2Ref, emit, S2Event.LAYOUT_RESIZE, "layoutResize");
+    useS2Event(s2Ref, emit, S2Event.LAYOUT_RESIZE_SERIES_WIDTH, "layoutResizeSeriesWidth");
+    useS2Event(s2Ref, emit, S2Event.LAYOUT_RESIZE_ROW_WIDTH, "layoutResizeRowWidth");
+    useS2Event(s2Ref, emit, S2Event.LAYOUT_RESIZE_ROW_HEIGHT, "layoutResizeRowHeight");
+    useS2Event(s2Ref, emit, S2Event.LAYOUT_RESIZE_COL_WIDTH, "layoutResizeColWidth");
+    useS2Event(s2Ref, emit, S2Event.LAYOUT_RESIZE_COL_HEIGHT, "layoutResizeColHeight");
+    useS2Event(s2Ref, emit, S2Event.LAYOUT_RESIZE_TREE_WIDTH, "layoutResizeTreeWidth");
+    useS2Event(s2Ref, emit, S2Event.LAYOUT_RESIZE_MOUSE_DOWN, "layoutResizeMouseDown");
+    useS2Event(s2Ref, emit, S2Event.LAYOUT_RESIZE_MOUSE_UP, "layoutResizeMouseUp");
+    useS2Event(s2Ref, emit, S2Event.LAYOUT_RESIZE_MOUSE_MOVE, "layoutResizeMouseMove");
+    useS2Event(s2Ref, emit, S2Event.GLOBAL_KEYBOARD_DOWN, "keyBoardDown");
+    useS2Event(s2Ref, emit, S2Event.GLOBAL_KEYBOARD_UP, "keyBoardUp");
+    useS2Event(s2Ref, emit, S2Event.GLOBAL_COPIED, "copied");
+    useS2Event(s2Ref, emit, S2Event.GLOBAL_ACTION_ICON_HOVER, "actionIconHover");
+    useS2Event(s2Ref, emit, S2Event.GLOBAL_ACTION_ICON_CLICK, "actionIconClick");
+    useS2Event(s2Ref, emit, S2Event.GLOBAL_CONTEXT_MENU, "contextMenu");
+    useS2Event(s2Ref, emit, S2Event.GLOBAL_HOVER, "mouseHover");
+    useS2Event(s2Ref, emit, S2Event.GLOBAL_CLICK, "click");
+    useS2Event(s2Ref, emit, S2Event.GLOBAL_DOUBLE_CLICK, "doubleClick");
+    useS2Event(s2Ref, emit, S2Event.GLOBAL_SELECTED, "selected");
+    useS2Event(s2Ref, emit, S2Event.GLOBAL_MOUSE_UP, "mouseUp");
+    useS2Event(s2Ref, emit, S2Event.GLOBAL_RESET, "reset");
+    useS2Event(s2Ref, emit, S2Event.GLOBAL_LINK_FIELD_JUMP, "linkFieldJump");
+  });
+};
+const useLoading = (s2Ref, loadingProp = false) => {
+  const loading = ref(loadingProp);
+  const setLoading = (updated) => {
+    loading.value = updated;
+  };
+  watch(s2Ref, (s2) => {
+    s2 == null ? void 0 : s2.on(S2Event.LAYOUT_BEFORE_RENDER, () => {
+      setLoading(true);
+    });
+    s2 == null ? void 0 : s2.on(S2Event.LAYOUT_AFTER_RENDER, () => {
+      setLoading(false);
+    });
+  });
+  return { loading, setLoading };
+};
+const useSheetUpdate = (s2Ref, props) => {
+  const updateFlag = reactive({
+    rerender: false,
+    reloadData: false,
+    rebuildDataset: false
+  });
+  watch(() => props.options, (options, prevOptions) => {
+    var _a, _b;
+    updateFlag.rerender = true;
+    if (!Object.is(prevOptions == null ? void 0 : prevOptions.hierarchyType, options == null ? void 0 : options.hierarchyType)) {
+      updateFlag.reloadData = true;
+      updateFlag.rebuildDataset = true;
+    }
+    (_a = s2Ref.value) == null ? void 0 : _a.setOptions(options);
+    (_b = s2Ref.value) == null ? void 0 : _b.changeSheetSize(options == null ? void 0 : options.width, options == null ? void 0 : options.height);
+  }, { deep: isProxy(props.options) });
+  watch(() => props.dataCfg, (dataCfg) => {
+    var _a;
+    updateFlag.rerender = true;
+    updateFlag.reloadData = true;
+    (_a = s2Ref.value) == null ? void 0 : _a.setDataCfg(dataCfg);
+  }, { deep: isProxy(props.dataCfg) });
+  watch(() => props.themeCfg, (themeCfg) => {
+    var _a;
+    updateFlag.rerender = true;
+    (_a = s2Ref.value) == null ? void 0 : _a.setThemeCfg(themeCfg);
+  }, {
+    deep: isProxy(props.themeCfg)
+  });
+  watch(updateFlag, (flag) => {
+    var _a;
+    if (!flag.rerender) {
+      return;
+    }
+    (_a = s2Ref.value) == null ? void 0 : _a.render(flag.reloadData, {
+      reBuildDataSet: flag.rebuildDataset
+    });
+    flag.rerender = false;
+    flag.reloadData = false;
+    flag.rebuildDataset = false;
+  });
+};
+const useResize = (s2Ref, props, dom) => {
+  const unobserve = ref();
+  watch([s2Ref, () => props.adaptive], ([s2, adaptive], _, onCleanup) => {
+    if (!s2) {
+      return;
+    }
+    unobserve.value = createResizeObserver({
+      s2,
+      adaptive,
+      wrapper: dom.wrapperRef.value,
+      container: dom.containerRef.value
+    });
+    onCleanup(() => {
+      var _a;
+      (_a = unobserve.value) == null ? void 0 : _a.call(unobserve);
+    });
+  }, { deep: true });
+};
+function useSpreadSheet(props, emit) {
+  const {
+    dataCfg,
+    options,
+    themeCfg,
+    loading: loadingProps,
+    sheetType,
+    onSpreadsheet,
+    onGetSpreadSheet
+  } = props;
+  const wrapperRef = ref();
+  const containerRef = ref();
+  const s2Ref = shallowRef();
+  const { loading, setLoading } = useLoading(s2Ref, loadingProps);
+  const pagination = usePagination(s2Ref, props);
+  const renderSpreadSheet = (container) => {
+    const rawDataCfg = toRaw(dataCfg);
+    const rawOptions = toRaw(options);
+    const s2Options = getSheetComponentOptions(rawOptions);
+    const s2Constructor = [container, rawDataCfg, s2Options];
+    if (onSpreadsheet) {
+      return onSpreadsheet(...s2Constructor);
+    }
+    if (sheetType === "table") {
+      return new TableSheet$1(container, rawDataCfg, s2Options);
+    }
+    return new PivotSheet$1(container, rawDataCfg, s2Options);
+  };
+  const buildSpreadSheet = () => {
+    setLoading(true);
+    s2Ref.value = renderSpreadSheet(containerRef.value);
+    s2Ref.value.setThemeCfg(toRaw(themeCfg));
+    s2Ref.value.render();
+    setLoading(false);
+    onGetSpreadSheet == null ? void 0 : onGetSpreadSheet(s2Ref.value);
+  };
+  onMounted(buildSpreadSheet);
+  useEvents(s2Ref, emit);
+  useSheetUpdate(s2Ref, props);
+  useResize(s2Ref, props, { wrapperRef, containerRef });
+  onBeforeUnmount(() => {
+    var _a;
+    (_a = s2Ref.value) == null ? void 0 : _a.destroy();
+  });
+  return {
+    wrapperRef,
+    containerRef,
+    s2Ref,
+    loading,
+    setLoading,
+    pagination
+  };
+}
+const initBaseSheetProps = () => ({
+  sheetType: String,
+  dataCfg: Object,
+  themeCfg: Object,
+  showPagination: {
+    type: Object,
+    default: false
+  },
+  loading: Boolean,
+  partDrillDown: Object,
+  header: Object,
+  options: {
+    type: Object,
+    default: {}
+  },
+  adaptive: {
+    type: Object,
+    default: false
+  },
+  onSpreadsheet: Function,
+  onGetSpreadSheet: Function
+});
+const initBaseSheetEmits = () => {
+  const keys2 = [
+    "spreadsheet",
+    "getSpreadSheet",
+    "rowCellHover",
+    "rowCellClick",
+    "rowCellDoubleClick",
+    "rowCellMouseDown",
+    "rowCellMouseUp",
+    "rowCellMouseMove",
+    "rowCellCollapseTreeRows",
+    "colCellHover",
+    "colCellClick",
+    "colCellDoubleClick",
+    "colCellMouseDown",
+    "colCellMouseUp",
+    "colCellMouseMove",
+    "dataCellHover",
+    "dataCellClick",
+    "dataCellDoubleClick",
+    "dataCellMouseDown",
+    "dataCellMouseUp",
+    "dataCellMouseMove",
+    "dataCellTrendIconClick",
+    "dataCellBrushSelection",
+    "cornerCellHover",
+    "cornerCellClick",
+    "cornerCellDoubleClick",
+    "cornerCellMouseDown",
+    "cornerCellMouseUp",
+    "cornerCellMouseMove",
+    "mergedCellsHover",
+    "mergedCellsClick",
+    "mergedCellsDoubleClick",
+    "mergedCellsMouseDown",
+    "mergedCellsMouseUp",
+    "mergedCellsMouseMove",
+    "rangeSort",
+    "rangeSorted",
+    "rangeFilter",
+    "rangeFiltered",
+    "layoutAfterHeaderLayout",
+    "layoutPagination",
+    "layoutCellScroll",
+    "layoutAfterCollapseRows",
+    "collapseRowsAll",
+    "layoutColsExpanded",
+    "layoutColsHidden",
+    "beforeRender",
+    "afterRender",
+    "destroy",
+    "layoutResize",
+    "layoutResizeSeriesWidth",
+    "layoutResizeRowWidth",
+    "layoutResizeRowHeight",
+    "layoutResizeColWidth",
+    "layoutResizeColHeight",
+    "layoutResizeTreeWidth",
+    "layoutResizeMouseDown",
+    "layoutResizeMouseUp",
+    "layoutResizeMouseMove",
+    "keyBoardDown",
+    "keyBoardUp",
+    "copied",
+    "actionIconHover",
+    "contextMenu",
+    "actionIconClick",
+    "mouseHover",
+    "mouseUp",
+    "selected",
+    "reset",
+    "linkFieldJump"
+  ];
+  return keys2;
+};
+var baseSheet_vue_vue_type_style_index_0_lang = "";
+const _sfc_main$3 = defineComponent({
+  name: "BaseSheet",
+  props: initBaseSheetProps(),
+  emits: initBaseSheetEmits(),
+  setup(props, ctx) {
+    const { wrapperRef, containerRef, s2Ref, loading, pagination } = useSpreadSheet(props, ctx.emit);
+    ctx.expose({
+      get instance() {
+        return s2Ref.value;
+      }
+    });
+    const handlePageChange = (nextCurrent) => {
+      var _a, _b;
+      if (props.showPagination && !isBoolean(props.showPagination)) {
+        (_b = (_a = props.showPagination).onChange) == null ? void 0 : _b.call(_a, nextCurrent);
+      }
+      pagination.change(nextCurrent);
+    };
+    const handlePageSizeChange = (nextSize) => {
+      var _a, _b;
+      if (props.showPagination && !isBoolean(props.showPagination)) {
+        (_b = (_a = props.showPagination).onShowSizeChange) == null ? void 0 : _b.call(_a, nextSize);
+      }
+      pagination.showSizeChange(nextSize);
+    };
+    return {
+      S2_PREFIX_CLS,
+      wrapperRef,
+      containerRef,
+      s2Ref,
+      loading,
+      pagination,
+      handlePageChange,
+      handlePageSizeChange
+    };
+  },
+  components: {
+    Spin,
+    S2Pagination
+  }
+});
+function _sfc_render$3(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_S2Pagination = resolveComponent("S2Pagination");
+  const _component_Spin = resolveComponent("Spin");
+  return openBlock(), createBlock(_component_Spin, {
+    wrapperClassName: _ctx.S2_PREFIX_CLS + "-spin",
+    spinning: _ctx.loading
+  }, {
+    default: withCtx(() => [
+      createElementVNode("div", {
+        ref: "wrapperRef",
+        class: normalizeClass(_ctx.S2_PREFIX_CLS + "-wrapper")
+      }, [
+        createElementVNode("div", {
+          ref: "containerRef",
+          class: normalizeClass(_ctx.S2_PREFIX_CLS + "-container")
+        }, null, 2),
+        _ctx.pagination.visible.value ? (openBlock(), createBlock(_component_S2Pagination, {
+          key: 0,
+          current: _ctx.pagination.current.value,
+          pageSize: _ctx.pagination.pageSize.value,
+          total: _ctx.pagination.total.value,
+          onChange: _ctx.handlePageChange,
+          onShowSizeChange: _ctx.handlePageSizeChange
+        }, null, 8, ["current", "pageSize", "total", "onChange", "onShowSizeChange"])) : createCommentVNode("", true)
+      ], 2)
+    ]),
+    _: 1
+  }, 8, ["wrapperClassName", "spinning"]);
+}
+var BaseSheet = /* @__PURE__ */ _export_sfc(_sfc_main$3, [["render", _sfc_render$3]]);
+const _sfc_main$2 = defineComponent({
+  name: "PivotSheet",
+  props: [],
+  emits: [],
+  setup(props, ctx) {
+    const s2Ref = useExpose(ctx.expose);
+    return { s2Ref };
+  },
+  components: {
+    BaseSheet
+  }
+});
+function _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_BaseSheet = resolveComponent("BaseSheet");
+  return openBlock(), createBlock(_component_BaseSheet, { ref: "s2Ref" }, null, 512);
+}
+var PivotSheet = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["render", _sfc_render$2]]);
+const _sfc_main$1 = defineComponent({
+  name: "TableSheet",
+  props: [],
+  emits: [],
+  setup(props, ctx) {
+    const s2Ref = useExpose(ctx.expose);
+    return { s2Ref };
+  },
+  components: {
+    BaseSheet
+  }
+});
+function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_BaseSheet = resolveComponent("BaseSheet");
+  return openBlock(), createBlock(_component_BaseSheet, { ref: "s2Ref" }, null, 512);
+}
+var TableSheet = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["render", _sfc_render$1]]);
+const _sfc_main = defineComponent({
+  name: "Sheet",
+  props: [],
+  emits: [],
+  setup(props, ctx) {
+    const s2Ref = useExpose(ctx.expose);
+    const sheetType = computed(() => {
+      const type = ctx.attrs.sheetType;
+      switch (type) {
+        case "table":
+          return TableSheet;
+        default:
+          return PivotSheet;
+      }
+    });
+    return { s2Ref, sheetType };
+  },
+  components: {
+    PivotSheet,
+    TableSheet
+  }
+});
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createBlock(resolveDynamicComponent(_ctx.sheetType), { ref: "s2Ref" }, null, 512);
+}
+var index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export { BaseSheet, PivotSheet, index as Sheet, TableSheet, useExpose };
+//# sourceMappingURL=index.js.map