@glodon-open/header-vue3/lib/index.es.js

OPEN 提供控制台头部导航，供 PC 引用，保持统一的设计风格。

/*! 
@license @glodon-open/header-vue3
Copyright (c) Glodon Company Limited, All Rights Reserved.

This source code is licensed under the apache-2.0 license found in the
LICENSE file in the root directory of this source tree.
 */
import { getCurrentInstance, shallowRef, reactive, watchEffect, computed, openBlock, createBlock, renderSlot, ref, onMounted, onBeforeUnmount, createVNode, Transition, withCtx, toDisplayString, unref, createCommentVNode, createTextVNode, defineComponent, mergeProps, withModifiers } from "vue";
var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
var check = function(it) {
  return it && it.Math == Math && it;
};
var global$m = check(typeof globalThis == "object" && globalThis) || check(typeof window == "object" && window) || check(typeof self == "object" && self) || check(typeof commonjsGlobal == "object" && commonjsGlobal) || function() {
  return this;
}() || Function("return this")();
var objectGetOwnPropertyDescriptor = {};
var fails$p = function(exec2) {
  try {
    return !!exec2();
  } catch (error) {
    return true;
  }
};
var fails$o = fails$p;
var descriptors = !fails$o(function() {
  return Object.defineProperty({}, 1, { get: function() {
    return 7;
  } })[1] != 7;
});
var fails$n = fails$p;
var functionBindNative = !fails$n(function() {
  var test2 = function() {
  }.bind();
  return typeof test2 != "function" || test2.hasOwnProperty("prototype");
});
var NATIVE_BIND$3 = functionBindNative;
var call$j = Function.prototype.call;
var functionCall = NATIVE_BIND$3 ? call$j.bind(call$j) : function() {
  return call$j.apply(call$j, arguments);
};
var objectPropertyIsEnumerable = {};
var $propertyIsEnumerable$2 = {}.propertyIsEnumerable;
var getOwnPropertyDescriptor$2 = Object.getOwnPropertyDescriptor;
var NASHORN_BUG = getOwnPropertyDescriptor$2 && !$propertyIsEnumerable$2.call({ 1: 2 }, 1);
objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
  var descriptor = getOwnPropertyDescriptor$2(this, V);
  return !!descriptor && descriptor.enumerable;
} : $propertyIsEnumerable$2;
var createPropertyDescriptor$4 = function(bitmap, value) {
  return {
    enumerable: !(bitmap & 1),
    configurable: !(bitmap & 2),
    writable: !(bitmap & 4),
    value
  };
};
var NATIVE_BIND$2 = functionBindNative;
var FunctionPrototype$3 = Function.prototype;
var call$i = FunctionPrototype$3.call;
var uncurryThisWithBind = NATIVE_BIND$2 && FunctionPrototype$3.bind.bind(call$i, call$i);
var functionUncurryThis = NATIVE_BIND$2 ? uncurryThisWithBind : function(fn) {
  return function() {
    return call$i.apply(fn, arguments);
  };
};
var uncurryThis$r = functionUncurryThis;
var toString$a = uncurryThis$r({}.toString);
var stringSlice$6 = uncurryThis$r("".slice);
var classofRaw$2 = function(it) {
  return stringSlice$6(toString$a(it), 8, -1);
};
var uncurryThis$q = functionUncurryThis;
var fails$m = fails$p;
var classof$b = classofRaw$2;
var $Object$3 = Object;
var split = uncurryThis$q("".split);
var indexedObject = fails$m(function() {
  return !$Object$3("z").propertyIsEnumerable(0);
}) ? function(it) {
  return classof$b(it) == "String" ? split(it, "") : $Object$3(it);
} : $Object$3;
var isNullOrUndefined$5 = function(it) {
  return it === null || it === void 0;
};
var isNullOrUndefined$4 = isNullOrUndefined$5;
var $TypeError$g = TypeError;
var requireObjectCoercible$5 = function(it) {
  if (isNullOrUndefined$4(it))
    throw $TypeError$g("Can't call method on " + it);
  return it;
};
var IndexedObject$3 = indexedObject;
var requireObjectCoercible$4 = requireObjectCoercible$5;
var toIndexedObject$a = function(it) {
  return IndexedObject$3(requireObjectCoercible$4(it));
};
var documentAll$2 = typeof document == "object" && document.all;
var IS_HTMLDDA = typeof documentAll$2 == "undefined" && documentAll$2 !== void 0;
var documentAll_1 = {
  all: documentAll$2,
  IS_HTMLDDA
};
var $documentAll$1 = documentAll_1;
var documentAll$1 = $documentAll$1.all;
var isCallable$m = $documentAll$1.IS_HTMLDDA ? function(argument) {
  return typeof argument == "function" || argument === documentAll$1;
} : function(argument) {
  return typeof argument == "function";
};
var isCallable$l = isCallable$m;
var $documentAll = documentAll_1;
var documentAll = $documentAll.all;
var isObject$a = $documentAll.IS_HTMLDDA ? function(it) {
  return typeof it == "object" ? it !== null : isCallable$l(it) || it === documentAll;
} : function(it) {
  return typeof it == "object" ? it !== null : isCallable$l(it);
};
var global$l = global$m;
var isCallable$k = isCallable$m;
var aFunction = function(argument) {
  return isCallable$k(argument) ? argument : void 0;
};
var getBuiltIn$a = function(namespace, method) {
  return arguments.length < 2 ? aFunction(global$l[namespace]) : global$l[namespace] && global$l[namespace][method];
};
var uncurryThis$p = functionUncurryThis;
var objectIsPrototypeOf = uncurryThis$p({}.isPrototypeOf);
var engineUserAgent = typeof navigator != "undefined" && String(navigator.userAgent) || "";
var global$k = global$m;
var userAgent$3 = engineUserAgent;
var process$4 = global$k.process;
var Deno$1 = global$k.Deno;
var versions = process$4 && process$4.versions || Deno$1 && Deno$1.version;
var v8 = versions && versions.v8;
var match, version$1;
if (v8) {
  match = v8.split(".");
  version$1 = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
}
if (!version$1 && userAgent$3) {
  match = userAgent$3.match(/Edge\/(\d+)/);
  if (!match || match[1] >= 74) {
    match = userAgent$3.match(/Chrome\/(\d+)/);
    if (match)
      version$1 = +match[1];
  }
}
var engineV8Version = version$1;
var V8_VERSION$3 = engineV8Version;
var fails$l = fails$p;
var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$l(function() {
  var symbol = Symbol();
  return !String(symbol) || !(Object(symbol) instanceof Symbol) || !Symbol.sham && V8_VERSION$3 && V8_VERSION$3 < 41;
});
var NATIVE_SYMBOL$6 = symbolConstructorDetection;
var useSymbolAsUid = NATIVE_SYMBOL$6 && !Symbol.sham && typeof Symbol.iterator == "symbol";
var getBuiltIn$9 = getBuiltIn$a;
var isCallable$j = isCallable$m;
var isPrototypeOf$5 = objectIsPrototypeOf;
var USE_SYMBOL_AS_UID$1 = useSymbolAsUid;
var $Object$2 = Object;
var isSymbol$4 = USE_SYMBOL_AS_UID$1 ? function(it) {
  return typeof it == "symbol";
} : function(it) {
  var $Symbol2 = getBuiltIn$9("Symbol");
  return isCallable$j($Symbol2) && isPrototypeOf$5($Symbol2.prototype, $Object$2(it));
};
var $String$5 = String;
var tryToString$5 = function(argument) {
  try {
    return $String$5(argument);
  } catch (error) {
    return "Object";
  }
};
var isCallable$i = isCallable$m;
var tryToString$4 = tryToString$5;
var $TypeError$f = TypeError;
var aCallable$9 = function(argument) {
  if (isCallable$i(argument))
    return argument;
  throw $TypeError$f(tryToString$4(argument) + " is not a function");
};
var aCallable$8 = aCallable$9;
var isNullOrUndefined$3 = isNullOrUndefined$5;
var getMethod$4 = function(V, P) {
  var func = V[P];
  return isNullOrUndefined$3(func) ? void 0 : aCallable$8(func);
};
var call$h = functionCall;
var isCallable$h = isCallable$m;
var isObject$9 = isObject$a;
var $TypeError$e = TypeError;
var ordinaryToPrimitive$1 = function(input, pref) {
  var fn, val;
  if (pref === "string" && isCallable$h(fn = input.toString) && !isObject$9(val = call$h(fn, input)))
    return val;
  if (isCallable$h(fn = input.valueOf) && !isObject$9(val = call$h(fn, input)))
    return val;
  if (pref !== "string" && isCallable$h(fn = input.toString) && !isObject$9(val = call$h(fn, input)))
    return val;
  throw $TypeError$e("Can't convert object to primitive value");
};
var shared$7 = { exports: {} };
var global$j = global$m;
var defineProperty$6 = Object.defineProperty;
var defineGlobalProperty$3 = function(key, value) {
  try {
    defineProperty$6(global$j, key, { value, configurable: true, writable: true });
  } catch (error) {
    global$j[key] = value;
  }
  return value;
};
var global$i = global$m;
var defineGlobalProperty$2 = defineGlobalProperty$3;
var SHARED = "__core-js_shared__";
var store$3 = global$i[SHARED] || defineGlobalProperty$2(SHARED, {});
var sharedStore = store$3;
var store$2 = sharedStore;
(shared$7.exports = function(key, value) {
  return store$2[key] || (store$2[key] = value !== void 0 ? value : {});
})("versions", []).push({
  version: "3.30.1",
  mode: "global",
  copyright: "\xA9 2014-2023 Denis Pushkarev (zloirock.ru)",
  license: "https://github.com/zloirock/core-js/blob/v3.30.1/LICENSE",
  source: "https://github.com/zloirock/core-js"
});
var requireObjectCoercible$3 = requireObjectCoercible$5;
var $Object$1 = Object;
var toObject$7 = function(argument) {
  return $Object$1(requireObjectCoercible$3(argument));
};
var uncurryThis$o = functionUncurryThis;
var toObject$6 = toObject$7;
var hasOwnProperty = uncurryThis$o({}.hasOwnProperty);
var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
  return hasOwnProperty(toObject$6(it), key);
};
var uncurryThis$n = functionUncurryThis;
var id = 0;
var postfix = Math.random();
var toString$9 = uncurryThis$n(1 .toString);
var uid$3 = function(key) {
  return "Symbol(" + (key === void 0 ? "" : key) + ")_" + toString$9(++id + postfix, 36);
};
var global$h = global$m;
var shared$6 = shared$7.exports;
var hasOwn$e = hasOwnProperty_1;
var uid$2 = uid$3;
var NATIVE_SYMBOL$5 = symbolConstructorDetection;
var USE_SYMBOL_AS_UID = useSymbolAsUid;
var Symbol$1 = global$h.Symbol;
var WellKnownSymbolsStore$1 = shared$6("wks");
var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$1["for"] || Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid$2;
var wellKnownSymbol$l = function(name) {
  if (!hasOwn$e(WellKnownSymbolsStore$1, name)) {
    WellKnownSymbolsStore$1[name] = NATIVE_SYMBOL$5 && hasOwn$e(Symbol$1, name) ? Symbol$1[name] : createWellKnownSymbol("Symbol." + name);
  }
  return WellKnownSymbolsStore$1[name];
};
var call$g = functionCall;
var isObject$8 = isObject$a;
var isSymbol$3 = isSymbol$4;
var getMethod$3 = getMethod$4;
var ordinaryToPrimitive = ordinaryToPrimitive$1;
var wellKnownSymbol$k = wellKnownSymbol$l;
var $TypeError$d = TypeError;
var TO_PRIMITIVE = wellKnownSymbol$k("toPrimitive");
var toPrimitive$1 = function(input, pref) {
  if (!isObject$8(input) || isSymbol$3(input))
    return input;
  var exoticToPrim = getMethod$3(input, TO_PRIMITIVE);
  var result;
  if (exoticToPrim) {
    if (pref === void 0)
      pref = "default";
    result = call$g(exoticToPrim, input, pref);
    if (!isObject$8(result) || isSymbol$3(result))
      return result;
    throw $TypeError$d("Can't convert object to primitive value");
  }
  if (pref === void 0)
    pref = "number";
  return ordinaryToPrimitive(input, pref);
};
var toPrimitive = toPrimitive$1;
var isSymbol$2 = isSymbol$4;
var toPropertyKey$4 = function(argument) {
  var key = toPrimitive(argument, "string");
  return isSymbol$2(key) ? key : key + "";
};
var global$g = global$m;
var isObject$7 = isObject$a;
var document$3 = global$g.document;
var EXISTS$1 = isObject$7(document$3) && isObject$7(document$3.createElement);
var documentCreateElement$2 = function(it) {
  return EXISTS$1 ? document$3.createElement(it) : {};
};
var DESCRIPTORS$g = descriptors;
var fails$k = fails$p;
var createElement$1 = documentCreateElement$2;
var ie8DomDefine = !DESCRIPTORS$g && !fails$k(function() {
  return Object.defineProperty(createElement$1("div"), "a", {
    get: function() {
      return 7;
    }
  }).a != 7;
});
var DESCRIPTORS$f = descriptors;
var call$f = functionCall;
var propertyIsEnumerableModule$1 = objectPropertyIsEnumerable;
var createPropertyDescriptor$3 = createPropertyDescriptor$4;
var toIndexedObject$9 = toIndexedObject$a;
var toPropertyKey$3 = toPropertyKey$4;
var hasOwn$d = hasOwnProperty_1;
var IE8_DOM_DEFINE$1 = ie8DomDefine;
var $getOwnPropertyDescriptor$2 = Object.getOwnPropertyDescriptor;
objectGetOwnPropertyDescriptor.f = DESCRIPTORS$f ? $getOwnPropertyDescriptor$2 : function getOwnPropertyDescriptor(O, P) {
  O = toIndexedObject$9(O);
  P = toPropertyKey$3(P);
  if (IE8_DOM_DEFINE$1)
    try {
      return $getOwnPropertyDescriptor$2(O, P);
    } catch (error) {
    }
  if (hasOwn$d(O, P))
    return createPropertyDescriptor$3(!call$f(propertyIsEnumerableModule$1.f, O, P), O[P]);
};
var objectDefineProperty = {};
var DESCRIPTORS$e = descriptors;
var fails$j = fails$p;
var v8PrototypeDefineBug = DESCRIPTORS$e && fails$j(function() {
  return Object.defineProperty(function() {
  }, "prototype", {
    value: 42,
    writable: false
  }).prototype != 42;
});
var isObject$6 = isObject$a;
var $String$4 = String;
var $TypeError$c = TypeError;
var anObject$f = function(argument) {
  if (isObject$6(argument))
    return argument;
  throw $TypeError$c($String$4(argument) + " is not an object");
};
var DESCRIPTORS$d = descriptors;
var IE8_DOM_DEFINE = ie8DomDefine;
var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug;
var anObject$e = anObject$f;
var toPropertyKey$2 = toPropertyKey$4;
var $TypeError$b = TypeError;
var $defineProperty$1 = Object.defineProperty;
var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
var ENUMERABLE = "enumerable";
var CONFIGURABLE$1 = "configurable";
var WRITABLE = "writable";
objectDefineProperty.f = DESCRIPTORS$d ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) {
  anObject$e(O);
  P = toPropertyKey$2(P);
  anObject$e(Attributes);
  if (typeof O === "function" && P === "prototype" && "value" in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
    var current = $getOwnPropertyDescriptor$1(O, P);
    if (current && current[WRITABLE]) {
      O[P] = Attributes.value;
      Attributes = {
        configurable: CONFIGURABLE$1 in Attributes ? Attributes[CONFIGURABLE$1] : current[CONFIGURABLE$1],
        enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
        writable: false
      };
    }
  }
  return $defineProperty$1(O, P, Attributes);
} : $defineProperty$1 : function defineProperty2(O, P, Attributes) {
  anObject$e(O);
  P = toPropertyKey$2(P);
  anObject$e(Attributes);
  if (IE8_DOM_DEFINE)
    try {
      return $defineProperty$1(O, P, Attributes);
    } catch (error) {
    }
  if ("get" in Attributes || "set" in Attributes)
    throw $TypeError$b("Accessors not supported");
  if ("value" in Attributes)
    O[P] = Attributes.value;
  return O;
};
var DESCRIPTORS$c = descriptors;
var definePropertyModule$5 = objectDefineProperty;
var createPropertyDescriptor$2 = createPropertyDescriptor$4;
var createNonEnumerableProperty$4 = DESCRIPTORS$c ? function(object, key, value) {
  return definePropertyModule$5.f(object, key, createPropertyDescriptor$2(1, value));
} : function(object, key, value) {
  object[key] = value;
  return object;
};
var makeBuiltIn$3 = { exports: {} };
var DESCRIPTORS$b = descriptors;
var hasOwn$c = hasOwnProperty_1;
var FunctionPrototype$2 = Function.prototype;
var getDescriptor = DESCRIPTORS$b && Object.getOwnPropertyDescriptor;
var EXISTS = hasOwn$c(FunctionPrototype$2, "name");
var PROPER = EXISTS && function something() {
}.name === "something";
var CONFIGURABLE = EXISTS && (!DESCRIPTORS$b || DESCRIPTORS$b && getDescriptor(FunctionPrototype$2, "name").configurable);
var functionName = {
  EXISTS,
  PROPER,
  CONFIGURABLE
};
var uncurryThis$m = functionUncurryThis;
var isCallable$g = isCallable$m;
var store$1 = sharedStore;
var functionToString$1 = uncurryThis$m(Function.toString);
if (!isCallable$g(store$1.inspectSource)) {
  store$1.inspectSource = function(it) {
    return functionToString$1(it);
  };
}
var inspectSource$3 = store$1.inspectSource;
var global$f = global$m;
var isCallable$f = isCallable$m;
var WeakMap$1 = global$f.WeakMap;
var weakMapBasicDetection = isCallable$f(WeakMap$1) && /native code/.test(String(WeakMap$1));
var shared$5 = shared$7.exports;
var uid$1 = uid$3;
var keys = shared$5("keys");
var sharedKey$3 = function(key) {
  return keys[key] || (keys[key] = uid$1(key));
};
var hiddenKeys$5 = {};
var NATIVE_WEAK_MAP = weakMapBasicDetection;
var global$e = global$m;
var isObject$5 = isObject$a;
var createNonEnumerableProperty$3 = createNonEnumerableProperty$4;
var hasOwn$b = hasOwnProperty_1;
var shared$4 = sharedStore;
var sharedKey$2 = sharedKey$3;
var hiddenKeys$4 = hiddenKeys$5;
var OBJECT_ALREADY_INITIALIZED = "Object already initialized";
var TypeError$3 = global$e.TypeError;
var WeakMap = global$e.WeakMap;
var set$1, get$1, has;
var enforce = function(it) {
  return has(it) ? get$1(it) : set$1(it, {});
};
var getterFor = function(TYPE) {
  return function(it) {
    var state;
    if (!isObject$5(it) || (state = get$1(it)).type !== TYPE) {
      throw TypeError$3("Incompatible receiver, " + TYPE + " required");
    }
    return state;
  };
};
if (NATIVE_WEAK_MAP || shared$4.state) {
  var store = shared$4.state || (shared$4.state = new WeakMap());
  store.get = store.get;
  store.has = store.has;
  store.set = store.set;
  set$1 = function(it, metadata) {
    if (store.has(it))
      throw TypeError$3(OBJECT_ALREADY_INITIALIZED);
    metadata.facade = it;
    store.set(it, metadata);
    return metadata;
  };
  get$1 = function(it) {
    return store.get(it) || {};
  };
  has = function(it) {
    return store.has(it);
  };
} else {
  var STATE = sharedKey$2("state");
  hiddenKeys$4[STATE] = true;
  set$1 = function(it, metadata) {
    if (hasOwn$b(it, STATE))
      throw TypeError$3(OBJECT_ALREADY_INITIALIZED);
    metadata.facade = it;
    createNonEnumerableProperty$3(it, STATE, metadata);
    return metadata;
  };
  get$1 = function(it) {
    return hasOwn$b(it, STATE) ? it[STATE] : {};
  };
  has = function(it) {
    return hasOwn$b(it, STATE);
  };
}
var internalState = {
  set: set$1,
  get: get$1,
  has,
  enforce,
  getterFor
};
var uncurryThis$l = functionUncurryThis;
var fails$i = fails$p;
var isCallable$e = isCallable$m;
var hasOwn$a = hasOwnProperty_1;
var DESCRIPTORS$a = descriptors;
var CONFIGURABLE_FUNCTION_NAME = functionName.CONFIGURABLE;
var inspectSource$2 = inspectSource$3;
var InternalStateModule$2 = internalState;
var enforceInternalState = InternalStateModule$2.enforce;
var getInternalState$2 = InternalStateModule$2.get;
var $String$3 = String;
var defineProperty$5 = Object.defineProperty;
var stringSlice$5 = uncurryThis$l("".slice);
var replace$4 = uncurryThis$l("".replace);
var join = uncurryThis$l([].join);
var CONFIGURABLE_LENGTH = DESCRIPTORS$a && !fails$i(function() {
  return defineProperty$5(function() {
  }, "length", { value: 8 }).length !== 8;
});
var TEMPLATE = String(String).split("String");
var makeBuiltIn$2 = makeBuiltIn$3.exports = function(value, name, options) {
  if (stringSlice$5($String$3(name), 0, 7) === "Symbol(") {
    name = "[" + replace$4($String$3(name), /^Symbol\(([^)]*)\)/, "$1") + "]";
  }
  if (options && options.getter)
    name = "get " + name;
  if (options && options.setter)
    name = "set " + name;
  if (!hasOwn$a(value, "name") || CONFIGURABLE_FUNCTION_NAME && value.name !== name) {
    if (DESCRIPTORS$a)
      defineProperty$5(value, "name", { value: name, configurable: true });
    else
      value.name = name;
  }
  if (CONFIGURABLE_LENGTH && options && hasOwn$a(options, "arity") && value.length !== options.arity) {
    defineProperty$5(value, "length", { value: options.arity });
  }
  try {
    if (options && hasOwn$a(options, "constructor") && options.constructor) {
      if (DESCRIPTORS$a)
        defineProperty$5(value, "prototype", { writable: false });
    } else if (value.prototype)
      value.prototype = void 0;
  } catch (error) {
  }
  var state = enforceInternalState(value);
  if (!hasOwn$a(state, "source")) {
    state.source = join(TEMPLATE, typeof name == "string" ? name : "");
  }
  return value;
};
Function.prototype.toString = makeBuiltIn$2(function toString() {
  return isCallable$e(this) && getInternalState$2(this).source || inspectSource$2(this);
}, "toString");
var isCallable$d = isCallable$m;
var definePropertyModule$4 = objectDefineProperty;
var makeBuiltIn$1 = makeBuiltIn$3.exports;
var defineGlobalProperty$1 = defineGlobalProperty$3;
var defineBuiltIn$8 = function(O, key, value, options) {
  if (!options)
    options = {};
  var simple = options.enumerable;
  var name = options.name !== void 0 ? options.name : key;
  if (isCallable$d(value))
    makeBuiltIn$1(value, name, options);
  if (options.global) {
    if (simple)
      O[key] = value;
    else
      defineGlobalProperty$1(key, value);
  } else {
    try {
      if (!options.unsafe)
        delete O[key];
      else if (O[key])
        simple = true;
    } catch (error) {
    }
    if (simple)
      O[key] = value;
    else
      definePropertyModule$4.f(O, key, {
        value,
        enumerable: false,
        configurable: !options.nonConfigurable,
        writable: !options.nonWritable
      });
  }
  return O;
};
var objectGetOwnPropertyNames = {};
var ceil = Math.ceil;
var floor$1 = Math.floor;
var mathTrunc = Math.trunc || function trunc(x) {
  var n = +x;
  return (n > 0 ? floor$1 : ceil)(n);
};
var trunc2 = mathTrunc;
var toIntegerOrInfinity$4 = function(argument) {
  var number = +argument;
  return number !== number || number === 0 ? 0 : trunc2(number);
};
var toIntegerOrInfinity$3 = toIntegerOrInfinity$4;
var max$2 = Math.max;
var min$2 = Math.min;
var toAbsoluteIndex$2 = function(index2, length) {
  var integer = toIntegerOrInfinity$3(index2);
  return integer < 0 ? max$2(integer + length, 0) : min$2(integer, length);
};
var toIntegerOrInfinity$2 = toIntegerOrInfinity$4;
var min$1 = Math.min;
var toLength$2 = function(argument) {
  return argument > 0 ? min$1(toIntegerOrInfinity$2(argument), 9007199254740991) : 0;
};
var toLength$1 = toLength$2;
var lengthOfArrayLike$6 = function(obj) {
  return toLength$1(obj.length);
};
var toIndexedObject$8 = toIndexedObject$a;
var toAbsoluteIndex$1 = toAbsoluteIndex$2;
var lengthOfArrayLike$5 = lengthOfArrayLike$6;
var createMethod$4 = function(IS_INCLUDES) {
  return function($this, el, fromIndex) {
    var O = toIndexedObject$8($this);
    var length = lengthOfArrayLike$5(O);
    var index2 = toAbsoluteIndex$1(fromIndex, length);
    var value;
    if (IS_INCLUDES && el != el)
      while (length > index2) {
        value = O[index2++];
        if (value != value)
          return true;
      }
    else
      for (; length > index2; index2++) {
        if ((IS_INCLUDES || index2 in O) && O[index2] === el)
          return IS_INCLUDES || index2 || 0;
      }
    return !IS_INCLUDES && -1;
  };
};
var arrayIncludes = {
  includes: createMethod$4(true),
  indexOf: createMethod$4(false)
};
var uncurryThis$k = functionUncurryThis;
var hasOwn$9 = hasOwnProperty_1;
var toIndexedObject$7 = toIndexedObject$a;
var indexOf$1 = arrayIncludes.indexOf;
var hiddenKeys$3 = hiddenKeys$5;
var push$5 = uncurryThis$k([].push);
var objectKeysInternal = function(object, names) {
  var O = toIndexedObject$7(object);
  var i = 0;
  var result = [];
  var key;
  for (key in O)
    !hasOwn$9(hiddenKeys$3, key) && hasOwn$9(O, key) && push$5(result, key);
  while (names.length > i)
    if (hasOwn$9(O, key = names[i++])) {
      ~indexOf$1(result, key) || push$5(result, key);
    }
  return result;
};
var enumBugKeys$3 = [
  "constructor",
  "hasOwnProperty",
  "isPrototypeOf",
  "propertyIsEnumerable",
  "toLocaleString",
  "toString",
  "valueOf"
];
var internalObjectKeys$1 = objectKeysInternal;
var enumBugKeys$2 = enumBugKeys$3;
var hiddenKeys$2 = enumBugKeys$2.concat("length", "prototype");
objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
  return internalObjectKeys$1(O, hiddenKeys$2);
};
var objectGetOwnPropertySymbols = {};
objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;
var getBuiltIn$8 = getBuiltIn$a;
var uncurryThis$j = functionUncurryThis;
var getOwnPropertyNamesModule$1 = objectGetOwnPropertyNames;
var getOwnPropertySymbolsModule$2 = objectGetOwnPropertySymbols;
var anObject$d = anObject$f;
var concat$1 = uncurryThis$j([].concat);
var ownKeys$3 = getBuiltIn$8("Reflect", "ownKeys") || function ownKeys(it) {
  var keys4 = getOwnPropertyNamesModule$1.f(anObject$d(it));
  var getOwnPropertySymbols2 = getOwnPropertySymbolsModule$2.f;
  return getOwnPropertySymbols2 ? concat$1(keys4, getOwnPropertySymbols2(it)) : keys4;
};
var hasOwn$8 = hasOwnProperty_1;
var ownKeys$2 = ownKeys$3;
var getOwnPropertyDescriptorModule$2 = objectGetOwnPropertyDescriptor;
var definePropertyModule$3 = objectDefineProperty;
var copyConstructorProperties$2 = function(target, source, exceptions) {
  var keys4 = ownKeys$2(source);
  var defineProperty5 = definePropertyModule$3.f;
  var getOwnPropertyDescriptor5 = getOwnPropertyDescriptorModule$2.f;
  for (var i = 0; i < keys4.length; i++) {
    var key = keys4[i];
    if (!hasOwn$8(target, key) && !(exceptions && hasOwn$8(exceptions, key))) {
      defineProperty5(target, key, getOwnPropertyDescriptor5(source, key));
    }
  }
};
var fails$h = fails$p;
var isCallable$c = isCallable$m;
var replacement = /#|\.prototype\./;
var isForced$2 = function(feature, detection) {
  var value = data[normalize(feature)];
  return value == POLYFILL ? true : value == NATIVE ? false : isCallable$c(detection) ? fails$h(detection) : !!detection;
};
var normalize = isForced$2.normalize = function(string) {
  return String(string).replace(replacement, ".").toLowerCase();
};
var data = isForced$2.data = {};
var NATIVE = isForced$2.NATIVE = "N";
var POLYFILL = isForced$2.POLYFILL = "P";
var isForced_1 = isForced$2;
var global$d = global$m;
var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f;
var createNonEnumerableProperty$2 = createNonEnumerableProperty$4;
var defineBuiltIn$7 = defineBuiltIn$8;
var defineGlobalProperty = defineGlobalProperty$3;
var copyConstructorProperties$1 = copyConstructorProperties$2;
var isForced$1 = isForced_1;
var _export = function(options, source) {
  var TARGET = options.target;
  var GLOBAL = options.global;
  var STATIC = options.stat;
  var FORCED2, target, key, targetProperty, sourceProperty, descriptor;
  if (GLOBAL) {
    target = global$d;
  } else if (STATIC) {
    target = global$d[TARGET] || defineGlobalProperty(TARGET, {});
  } else {
    target = (global$d[TARGET] || {}).prototype;
  }
  if (target)
    for (key in source) {
      sourceProperty = source[key];
      if (options.dontCallGetSet) {
        descriptor = getOwnPropertyDescriptor$1(target, key);
        targetProperty = descriptor && descriptor.value;
      } else
        targetProperty = target[key];
      FORCED2 = isForced$1(GLOBAL ? key : TARGET + (STATIC ? "." : "#") + key, options.forced);
      if (!FORCED2 && targetProperty !== void 0) {
        if (typeof sourceProperty == typeof targetProperty)
          continue;
        copyConstructorProperties$1(sourceProperty, targetProperty);
      }
      if (options.sham || targetProperty && targetProperty.sham) {
        createNonEnumerableProperty$2(sourceProperty, "sham", true);
      }
      defineBuiltIn$7(target, key, sourceProperty, options);
    }
};
var wellKnownSymbol$j = wellKnownSymbol$l;
var TO_STRING_TAG$2 = wellKnownSymbol$j("toStringTag");
var test = {};
test[TO_STRING_TAG$2] = "z";
var toStringTagSupport = String(test) === "[object z]";
var TO_STRING_TAG_SUPPORT$2 = toStringTagSupport;
var isCallable$b = isCallable$m;
var classofRaw$1 = classofRaw$2;
var wellKnownSymbol$i = wellKnownSymbol$l;
var TO_STRING_TAG$1 = wellKnownSymbol$i("toStringTag");
var $Object = Object;
var CORRECT_ARGUMENTS = classofRaw$1(function() {
  return arguments;
}()) == "Arguments";
var tryGet = function(it, key) {
  try {
    return it[key];
  } catch (error) {
  }
};
var classof$a = TO_STRING_TAG_SUPPORT$2 ? classofRaw$1 : function(it) {
  var O, tag, result;
  return it === void 0 ? "Undefined" : it === null ? "Null" : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG$1)) == "string" ? tag : CORRECT_ARGUMENTS ? classofRaw$1(O) : (result = classofRaw$1(O)) == "Object" && isCallable$b(O.callee) ? "Arguments" : result;
};
var classof$9 = classof$a;
var $String$2 = String;
var toString$8 = function(argument) {
  if (classof$9(argument) === "Symbol")
    throw TypeError("Cannot convert a Symbol value to a string");
  return $String$2(argument);
};
var objectDefineProperties = {};
var internalObjectKeys = objectKeysInternal;
var enumBugKeys$1 = enumBugKeys$3;
var objectKeys$3 = Object.keys || function keys2(O) {
  return internalObjectKeys(O, enumBugKeys$1);
};
var DESCRIPTORS$9 = descriptors;
var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug;
var definePropertyModule$2 = objectDefineProperty;
var anObject$c = anObject$f;
var toIndexedObject$6 = toIndexedObject$a;
var objectKeys$2 = objectKeys$3;
objectDefineProperties.f = DESCRIPTORS$9 && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
  anObject$c(O);
  var props = toIndexedObject$6(Properties);
  var keys4 = objectKeys$2(Properties);
  var length = keys4.length;
  var index2 = 0;
  var key;
  while (length > index2)
    definePropertyModule$2.f(O, key = keys4[index2++], props[key]);
  return O;
};
var getBuiltIn$7 = getBuiltIn$a;
var html$2 = getBuiltIn$7("document", "documentElement");
var anObject$b = anObject$f;
var definePropertiesModule$1 = objectDefineProperties;
var enumBugKeys = enumBugKeys$3;
var hiddenKeys$1 = hiddenKeys$5;
var html$1 = html$2;
var documentCreateElement$1 = documentCreateElement$2;
var sharedKey$1 = sharedKey$3;
var GT = ">";
var LT = "<";
var PROTOTYPE$1 = "prototype";
var SCRIPT = "script";
var IE_PROTO = sharedKey$1("IE_PROTO");
var EmptyConstructor = function() {
};
var scriptTag = function(content) {
  return LT + SCRIPT + GT + content + LT + "/" + SCRIPT + GT;
};
var NullProtoObjectViaActiveX = function(activeXDocument2) {
  activeXDocument2.write(scriptTag(""));
  activeXDocument2.close();
  var temp = activeXDocument2.parentWindow.Object;
  activeXDocument2 = null;
  return temp;
};
var NullProtoObjectViaIFrame = function() {
  var iframe = documentCreateElement$1("iframe");
  var JS = "java" + SCRIPT + ":";
  var iframeDocument;
  iframe.style.display = "none";
  html$1.appendChild(iframe);
  iframe.src = String(JS);
  iframeDocument = iframe.contentWindow.document;
  iframeDocument.open();
  iframeDocument.write(scriptTag("document.F=Object"));
  iframeDocument.close();
  return iframeDocument.F;
};
var activeXDocument;
var NullProtoObject = function() {
  try {
    activeXDocument = new ActiveXObject("htmlfile");
  } catch (error) {
  }
  NullProtoObject = typeof document != "undefined" ? document.domain && activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame() : NullProtoObjectViaActiveX(activeXDocument);
  var length = enumBugKeys.length;
  while (length--)
    delete NullProtoObject[PROTOTYPE$1][enumBugKeys[length]];
  return NullProtoObject();
};
hiddenKeys$1[IE_PROTO] = true;
var objectCreate = Object.create || function create(O, Properties) {
  var result;
  if (O !== null) {
    EmptyConstructor[PROTOTYPE$1] = anObject$b(O);
    result = new EmptyConstructor();
    EmptyConstructor[PROTOTYPE$1] = null;
    result[IE_PROTO] = O;
  } else
    result = NullProtoObject();
  return Properties === void 0 ? result : definePropertiesModule$1.f(result, Properties);
};
var objectGetOwnPropertyNamesExternal = {};
var toPropertyKey$1 = toPropertyKey$4;
var definePropertyModule$1 = objectDefineProperty;
var createPropertyDescriptor$1 = createPropertyDescriptor$4;
var createProperty$3 = function(object, key, value) {
  var propertyKey = toPropertyKey$1(key);
  if (propertyKey in object)
    definePropertyModule$1.f(object, propertyKey, createPropertyDescriptor$1(0, value));
  else
    object[propertyKey] = value;
};
var toAbsoluteIndex = toAbsoluteIndex$2;
var lengthOfArrayLike$4 = lengthOfArrayLike$6;
var createProperty$2 = createProperty$3;
var $Array$1 = Array;
var max$1 = Math.max;
var arraySliceSimple = function(O, start, end) {
  var length = lengthOfArrayLike$4(O);
  var k = toAbsoluteIndex(start, length);
  var fin = toAbsoluteIndex(end === void 0 ? length : end, length);
  var result = $Array$1(max$1(fin - k, 0));
  for (var n = 0; k < fin; k++, n++)
    createProperty$2(result, n, O[k]);
  result.length = n;
  return result;
};
var classof$8 = classofRaw$2;
var toIndexedObject$5 = toIndexedObject$a;
var $getOwnPropertyNames$1 = objectGetOwnPropertyNames.f;
var arraySlice$3 = arraySliceSimple;
var windowNames = typeof window == "object" && window && Object.getOwnPropertyNames ? Object.getOwnPropertyNames(window) : [];
var getWindowNames = function(it) {
  try {
    return $getOwnPropertyNames$1(it);
  } catch (error) {
    return arraySlice$3(windowNames);
  }
};
objectGetOwnPropertyNamesExternal.f = function getOwnPropertyNames2(it) {
  return windowNames && classof$8(it) == "Window" ? getWindowNames(it) : $getOwnPropertyNames$1(toIndexedObject$5(it));
};
var makeBuiltIn = makeBuiltIn$3.exports;
var defineProperty$4 = objectDefineProperty;
var defineBuiltInAccessor$4 = function(target, name, descriptor) {
  if (descriptor.get)
    makeBuiltIn(descriptor.get, name, { getter: true });
  if (descriptor.set)
    makeBuiltIn(descriptor.set, name, { setter: true });
  return defineProperty$4.f(target, name, descriptor);
};
var wellKnownSymbolWrapped = {};
var wellKnownSymbol$h = wellKnownSymbol$l;
wellKnownSymbolWrapped.f = wellKnownSymbol$h;
var global$c = global$m;
var path$1 = global$c;
var path = path$1;
var hasOwn$7 = hasOwnProperty_1;
var wrappedWellKnownSymbolModule$1 = wellKnownSymbolWrapped;
var defineProperty$3 = objectDefineProperty.f;
var wellKnownSymbolDefine = function(NAME2) {
  var Symbol2 = path.Symbol || (path.Symbol = {});
  if (!hasOwn$7(Symbol2, NAME2))
    defineProperty$3(Symbol2, NAME2, {
      value: wrappedWellKnownSymbolModule$1.f(NAME2)
    });
};
var call$e = functionCall;
var getBuiltIn$6 = getBuiltIn$a;
var wellKnownSymbol$g = wellKnownSymbol$l;
var defineBuiltIn$6 = defineBuiltIn$8;
var symbolDefineToPrimitive = function() {
  var Symbol2 = getBuiltIn$6("Symbol");
  var SymbolPrototype2 = Symbol2 && Symbol2.prototype;
  var valueOf = SymbolPrototype2 && SymbolPrototype2.valueOf;
  var TO_PRIMITIVE2 = wellKnownSymbol$g("toPrimitive");
  if (SymbolPrototype2 && !SymbolPrototype2[TO_PRIMITIVE2]) {
    defineBuiltIn$6(SymbolPrototype2, TO_PRIMITIVE2, function(hint) {
      return call$e(valueOf, this);
    }, { arity: 1 });
  }
};
var defineProperty$2 = objectDefineProperty.f;
var hasOwn$6 = hasOwnProperty_1;
var wellKnownSymbol$f = wellKnownSymbol$l;
var TO_STRING_TAG = wellKnownSymbol$f("toStringTag");
var setToStringTag$2 = function(target, TAG, STATIC) {
  if (target && !STATIC)
    target = target.prototype;
  if (target && !hasOwn$6(target, TO_STRING_TAG)) {
    defineProperty$2(target, TO_STRING_TAG, { configurable: true, value: TAG });
  }
};
var classofRaw = classofRaw$2;
var uncurryThis$i = functionUncurryThis;
var functionUncurryThisClause = function(fn) {
  if (classofRaw(fn) === "Function")
    return uncurryThis$i(fn);
};
var uncurryThis$h = functionUncurryThisClause;
var aCallable$7 = aCallable$9;
var NATIVE_BIND$1 = functionBindNative;
var bind$5 = uncurryThis$h(uncurryThis$h.bind);
var functionBindContext = function(fn, that) {
  aCallable$7(fn);
  return that === void 0 ? fn : NATIVE_BIND$1 ? bind$5(fn, that) : function() {
    return fn.apply(that, arguments);
  };
};
var classof$7 = classofRaw$2;
var isArray$3 = Array.isArray || function isArray(argument) {
  return classof$7(argument) == "Array";
};
var uncurryThis$g = functionUncurryThis;
var fails$g = fails$p;
var isCallable$a = isCallable$m;
var classof$6 = classof$a;
var getBuiltIn$5 = getBuiltIn$a;
var inspectSource$1 = inspectSource$3;
var noop = function() {
};
var empty = [];
var construct = getBuiltIn$5("Reflect", "construct");
var constructorRegExp = /^\s*(?:class|function)\b/;
var exec$2 = uncurryThis$g(constructorRegExp.exec);
var INCORRECT_TO_STRING = !constructorRegExp.exec(noop);
var isConstructorModern = function isConstructor(argument) {
  if (!isCallable$a(argument))
    return false;
  try {
    construct(noop, empty, argument);
    return true;
  } catch (error) {
    return false;
  }
};
var isConstructorLegacy = function isConstructor2(argument) {
  if (!isCallable$a(argument))
    return false;
  switch (classof$6(argument)) {
    case "AsyncFunction":
    case "GeneratorFunction":
    case "AsyncGeneratorFunction":
      return false;
  }
  try {
    return INCORRECT_TO_STRING || !!exec$2(constructorRegExp, inspectSource$1(argument));
  } catch (error) {
    return true;
  }
};
isConstructorLegacy.sham = true;
var isConstructor$2 = !construct || fails$g(function() {
  var called;
  return isConstructorModern(isConstructorModern.call) || !isConstructorModern(Object) || !isConstructorModern(function() {
    called = true;
  }) || called;
}) ? isConstructorLegacy : isConstructorModern;
var isArray$2 = isArray$3;
var isConstructor$1 = isConstructor$2;
var isObject$4 = isObject$a;
var wellKnownSymbol$e = wellKnownSymbol$l;
var SPECIES$5 = wellKnownSymbol$e("species");
var $Array = Array;
var arraySpeciesConstructor$1 = function(originalArray) {
  var C;
  if (isArray$2(originalArray)) {
    C = originalArray.constructor;
    if (isConstructor$1(C) && (C === $Array || isArray$2(C.prototype)))
      C = void 0;
    else if (isObject$4(C)) {
      C = C[SPECIES$5];
      if (C === null)
        C = void 0;
    }
  }
  return C === void 0 ? $Array : C;
};
var arraySpeciesConstructor = arraySpeciesConstructor$1;
var arraySpeciesCreate$2 = function(originalArray, length) {
  return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);
};
var bind$4 = functionBindContext;
var uncurryThis$f = functionUncurryThis;
var IndexedObject$2 = indexedObject;
var toObject$5 = toObject$7;
var lengthOfArrayLike$3 = lengthOfArrayLike$6;
var arraySpeciesCreate$1 = arraySpeciesCreate$2;
var push$4 = uncurryThis$f([].push);
var createMethod$3 = function(TYPE) {
  var IS_MAP = TYPE == 1;
  var IS_FILTER = TYPE == 2;
  var IS_SOME = TYPE == 3;
  var IS_EVERY = TYPE == 4;
  var IS_FIND_INDEX = TYPE == 6;
  var IS_FILTER_REJECT = TYPE == 7;
  var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
  return function($this, callbackfn, that, specificCreate) {
    var O = toObject$5($this);
    var self2 = IndexedObject$2(O);
    var boundFunction = bind$4(callbackfn, that);
    var length = lengthOfArrayLike$3(self2);
    var index2 = 0;
    var create4 = specificCreate || arraySpeciesCreate$1;
    var target = IS_MAP ? create4($this, length) : IS_FILTER || IS_FILTER_REJECT ? create4($this, 0) : void 0;
    var value, result;
    for (; length > index2; index2++)
      if (NO_HOLES || index2 in self2) {
        value = self2[index2];
        result = boundFunction(value, index2, O);
        if (TYPE) {
          if (IS_MAP)
            target[index2] = result;
          else if (result)
            switch (TYPE) {
              case 3:
                return true;
              case 5:
                return value;
              case 6:
                return index2;
              case 2:
                push$4(target, value);
            }
          else
            switch (TYPE) {
              case 4:
                return false;
              case 7:
                push$4(target, value);
            }
        }
      }
    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;
  };
};
var arrayIteration = {
  forEach: createMethod$3(0),
  map: createMethod$3(1),
  filter: createMethod$3(2),
  some: createMethod$3(3),
  every: createMethod$3(4),
  find: createMethod$3(5),
  findIndex: createMethod$3(6),
  filterReject: createMethod$3(7)
};
var $$p = _export;
var global$b = global$m;
var call$d = functionCall;
var uncurryThis$e = functionUncurryThis;
var DESCRIPTORS$8 = descriptors;
var NATIVE_SYMBOL$4 = symbolConstructorDetection;
var fails$f = fails$p;
var hasOwn$5 = hasOwnProperty_1;
var isPrototypeOf$4 = objectIsPrototypeOf;
var anObject$a = anObject$f;
var toIndexedObject$4 = toIndexedObject$a;
var toPropertyKey = toPropertyKey$4;
var $toString$1 = toString$8;
var createPropertyDescriptor = createPropertyDescriptor$4;
var nativeObjectCreate = objectCreate;
var objectKeys$1 = objectKeys$3;
var getOwnPropertyNamesModule = objectGetOwnPropertyNames;
var getOwnPropertyNamesExternal = objectGetOwnPropertyNamesExternal;
var getOwnPropertySymbolsModule$1 = objectGetOwnPropertySymbols;
var getOwnPropertyDescriptorModule$1 = objectGetOwnPropertyDescriptor;
var definePropertyModule = objectDefineProperty;
var definePropertiesModule = objectDefineProperties;
var propertyIsEnumerableModule = objectPropertyIsEnumerable;
var defineBuiltIn$5 = defineBuiltIn$8;
var defineBuiltInAccessor$3 = defineBuiltInAccessor$4;
var shared$3 = shared$7.exports;
var sharedKey = sharedKey$3;
var hiddenKeys = hiddenKeys$5;
var uid = uid$3;
var wellKnownSymbol$d = wellKnownSymbol$l;
var wrappedWellKnownSymbolModule = wellKnownSymbolWrapped;
var defineWellKnownSymbol = wellKnownSymbolDefine;
var defineSymbolToPrimitive = symbolDefineToPrimitive;
var setToStringTag$1 = setToStringTag$2;
var InternalStateModule$1 = internalState;
var $forEach$1 = arrayIteration.forEach;
var HIDDEN = sharedKey("hidden");
var SYMBOL = "Symbol";
var PROTOTYPE = "prototype";
var setInternalState$1 = InternalStateModule$1.set;
var getInternalState$1 = InternalStateModule$1.getterFor(SYMBOL);
var ObjectPrototype = Object[PROTOTYPE];
var $Symbol = global$b.Symbol;
var SymbolPrototype$1 = $Symbol && $Symbol[PROTOTYPE];
var TypeError$2 = global$b.TypeError;
var QObject = global$b.QObject;
var nativeGetOwnPropertyDescriptor$1 = getOwnPropertyDescriptorModule$1.f;
var nativeDefineProperty = definePropertyModule.f;
var nativeGetOwnPropertyNames = getOwnPropertyNamesExternal.f;
var nativePropertyIsEnumerable = propertyIsEnumerableModule.f;
var push$3 = uncurryThis$e([].push);
var AllSymbols = shared$3("symbols");
var ObjectPrototypeSymbols = shared$3("op-symbols");
var WellKnownSymbolsStore = shared$3("wks");
var USE_SETTER = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;
var setSymbolDescriptor = DESCRIPTORS$8 && fails$f(function() {
  return nativeObjectCreate(nativeDefineProperty({}, "a", {
    get: function() {
      return nativeDefineProperty(this, "a", { value: 7 }).a;
    }
  })).a != 7;
}) ? function(O, P, Attributes) {
  var ObjectPrototypeDescriptor = nativeGetOwnPropertyDescriptor$1(ObjectPrototype, P);
  if (ObjectPrototypeDescriptor)
    delete ObjectPrototype[P];
  nativeDefineProperty(O, P, Attributes);
  if (ObjectPrototypeDescriptor && O !== ObjectPrototype) {
    nativeDefineProperty(ObjectPrototype, P, ObjectPrototypeDescriptor);
  }
} : nativeDefineProperty;
var wrap = function(tag, description) {
  var symbol = AllSymbols[tag] = nativeObjectCreate(SymbolPrototype$1);
  setInternalState$1(symbol, {
    type: SYMBOL,
    tag,
    description
  });
  if (!DESCRIPTORS$8)
    symbol.description = description;
  return symbol;
};
var $defineProperty = function defineProperty3(O, P, Attributes) {
  if (O === ObjectPrototype)
    $defineProperty(ObjectPrototypeSymbols, P, Attributes);
  anObject$a(O);
  var key = toPropertyKey(P);
  anObject$a(Attributes);
  if (hasOwn$5(AllSymbols, key)) {
    if (!Attributes.enumerable) {
      if (!hasOwn$5(O, HIDDEN))
        nativeDefineProperty(O, HIDDEN, createPropertyDescriptor(1, {}));
      O[HIDDEN][key] = true;
    } else {
      if (hasOwn$5(O, HIDDEN) && O[HIDDEN][key])
        O[HIDDEN][key] = false;
      Attributes = nativeObjectCreate(Attributes, { enumerable: createPropertyDescriptor(0, false) });
    }
    return setSymbolDescriptor(O, key, Attributes);
  }
  return nativeDefineProperty(O, key, Attributes);
};
var $defineProperties = function defineProperties2(O, Properties) {
  anObject$a(O);
  var properties = toIndexedObject$4(Properties);
  var keys4 = objectKeys$1(properties).concat($getOwnPropertySymbols(properties));
  $forEach$1(keys4, function(key) {
    if (!DESCRIPTORS$8 || call$d($propertyIsEnumerable$1, properties, key))
      $defineProperty(O, key, properties[key]);
  });
  return O;
};
var $create = function create2(O, Properties) {
  return Properties === void 0 ? nativeObjectCreate(O) : $defineProperties(nativeObjectCreate(O), Properties);
};
var $propertyIsEnumerable$1 = function propertyIsEnumerable2(V) {
  var P = toPropertyKey(V);
  var enumerable = call$d(nativePropertyIsEnumerable, this, P);
  if (this === ObjectPrototype && hasOwn$5(AllSymbols, P) && !hasOwn$5(ObjectPrototypeSymbols, P))
    return false;
  return enumerable || !hasOwn$5(this, P) || !hasOwn$5(AllSymbols, P) || hasOwn$5(this, HIDDEN) && this[HIDDEN][P] ? enumerable : true;
};
var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor2(O, P) {
  var it = toIndexedObject$4(O);
  var key = toPropertyKey(P);
  if (it === ObjectPrototype && hasOwn$5(AllSymbols, key) && !hasOwn$5(ObjectPrototypeSymbols, key))
    return;
  var descriptor = nativeGetOwnPropertyDescriptor$1(it, key);
  if (descriptor && hasOwn$5(AllSymbols, key) && !(hasOwn$5(it, HIDDEN) && it[HIDDEN][key])) {
    descriptor.enumerable = true;
  }
  return descriptor;
};
var $getOwnPropertyNames = function getOwnPropertyNames3(O) {
  var names = nativeGetOwnPropertyNames(toIndexedObject$4(O));
  var result = [];
  $forEach$1(names, function(key) {
    if (!hasOwn$5(AllSymbols, key) && !hasOwn$5(hiddenKeys, key))
      push$3(result, key);
  });
  return result;
};
var $getOwnPropertySymbols = function(O) {
  var IS_OBJECT_PROTOTYPE = O === ObjectPrototype;
  var names = nativeGetOwnPropertyNames(IS_OBJECT_PROTOTYPE ? ObjectPrototypeSymbols : toIndexedObject$4(O));
  var result = [];
  $forEach$1(names, function(key) {
    if (hasOwn$5(AllSymbols, key) && (!IS_OBJECT_PROTOTYPE || hasOwn$5(ObjectPrototype, key))) {
      push$3(result, AllSymbols[key]);
    }
  });
  return result;
};
if (!NATIVE_SYMBOL$4) {
  $Symbol = function Symbol2() {
    if (isPrototypeOf$4(SymbolPrototype$1, this))
      throw TypeError$2("Symbol is not a constructor");
    var description = !arguments.length || arguments[0] === void 0 ? void 0 : $toString$1(arguments[0]);
    var tag = uid(description);
    var setter = function(value) {
      if (this === ObjectPrototype)
        call$d(setter, ObjectPrototypeSymbols, value);
      if (hasOwn$5(this, HIDDEN) && hasOwn$5(this[HIDDEN], tag))
        this[HIDDEN][tag] = false;
      setSymbolDescriptor(this, tag, createPropertyDescriptor(1, value));
    };
    if (DESCRIPTORS$8 && USE_SETTER)
      setSymbolDescriptor(ObjectPrototype, tag, { configurable: true, set: setter });
    return wrap(tag, description);
  };
  SymbolPrototype$1 = $Symbol[PROTOTYPE];
  defineBuiltIn$5(SymbolPrototype$1, "toString", function toString4() {
    return getInternalState$1(this).tag;
  });
  defineBuiltIn$5($Symbol, "withoutSetter", function(description) {
    return wrap(uid(description), description);
  });
  propertyIsEnumerableModule.f = $propertyIsEnumerable$1;
  definePropertyModule.f = $defineProperty;
  definePropertiesModule.f = $defineProperties;
  getOwnPropertyDescriptorModule$1.f = $getOwnPropertyDescriptor;
  getOwnPropertyNamesModule.f = getOwnPropertyNamesExternal.f = $getOwnPropertyNames;
  getOwnPropertySymbolsModule$1.f = $getOwnPropertySymbols;
  wrappedWellKnownSymbolModule.f = function(name) {
    return wrap(wellKnownSymbol$d(name), name);
  };
  if (DESCRIPTORS$8) {
    defineBuiltInAccessor$3(SymbolPrototype$1, "description", {
      configurable: true,
      get: function description() {
        return getInternalState$1(this).description;
      }
    });
    {
      defineBuiltIn$5(ObjectPrototype, "propertyIsEnumerable", $propertyIsEnumerable$1, { unsafe: true });
    }
  }
}
$$p({ global: true, constructor: true, wrap: true, forced: !NATIVE_SYMBOL$4, sham: !NATIVE_SYMBOL$4 }, {
  Symbol: $Symbol
});
$forEach$1(objectKeys$1(WellKnownSymbolsStore), function(name) {
  defineWellKnownSymbol(name);
});
$$p({ target: SYMBOL, stat: true, forced: !NATIVE_SYMBOL$4 }, {
  useSetter: function() {
    USE_SETTER = true;
  },
  useSimple: function() {
    USE_SETTER = false;
  }
});
$$p({ target: "Object", stat: true, forced: !NATIVE_SYMBOL$4, sham: !DESCRIPTORS$8 }, {
  create: $create,
  defineProperty: $defineProperty,
  defineProperties: $defineProperties,
  getOwnPropertyDescriptor: $getOwnPropertyDescriptor
});
$$p({ target: "Object", stat: true, forced: !NATIVE_SYMBOL$4 }, {
  getOwnPropertyNames: $getOwnPropertyNames
});
defineSymbolToPrimitive();
setToStringTag$1($Symbol, SYMBOL);
hiddenKeys[HIDDEN] = true;
var NATIVE_SYMBOL$3 = symbolConstructorDetection;
var symbolRegistryDetection = NATIVE_SYMBOL$3 && !!Symbol["for"] && !!Symbol.keyFor;
var $$o = _export;
var getBuiltIn$4 = getBuiltIn$a;
var hasOwn$4 = hasOwnProperty_1;
var toString$7 = toString$8;
var shared$2 = shared$7.exports;
var NATIVE_SYMBOL_REGISTRY$1 = symbolRegistryDetection;
var StringToSymbolRegistry = shared$2("string-to-symbol-registry");
var SymbolToStringRegistry$1 = shared$2("symbol-to-string-registry");
$$o({ target: "Symbol", stat: true, forced: !NATIVE_SYMBOL_REGISTRY$1 }, {
  "for": function(key) {
    var string = toString$7(key);
    if (hasOwn$4(StringToSymbolRegistry, string))
      return StringToSymbolRegistry[string];
    var symbol = getBuiltIn$4("Symbol")(string);
    StringToSymbolRegistry[string] = symbol;
    SymbolToStringRegistry$1[symbol] = string;
    return symbol;
  }
});
var $$n = _export;
var hasOwn$3 = hasOwnProperty_1;
var isSymbol$1 = isSymbol$4;
var tryToString$3 = tryToString$5;
var shared$1 = shared$7.exports;
var NATIVE_SYMBOL_REGISTRY = symbolRegistryDet