@mt-utils/xunfei-lat/dist/index.js

讯飞LAT 语音转文本

import CryptoJS from "crypto-js";
var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
function _arrayLikeToArray(r, a) {
  (null == a || a > r.length) && (a = r.length);
  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
  return n;
}
function _arrayWithoutHoles(r) {
  if (Array.isArray(r)) return _arrayLikeToArray(r);
}
function _assertThisInitialized(e) {
  if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  return e;
}
function _callSuper(t, o2, e) {
  return o2 = _getPrototypeOf(o2), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o2, e || [], _getPrototypeOf(t).constructor) : o2.apply(t, e));
}
function _classCallCheck(a, n) {
  if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
}
function _defineProperties(e, r) {
  for (var t = 0; t < r.length; t++) {
    var o2 = r[t];
    o2.enumerable = o2.enumerable || false, o2.configurable = true, "value" in o2 && (o2.writable = true), Object.defineProperty(e, _toPropertyKey(o2.key), o2);
  }
}
function _createClass(e, r, t) {
  return r && _defineProperties(e.prototype, r), Object.defineProperty(e, "prototype", {
    writable: false
  }), e;
}
function _defineProperty(e, r, t) {
  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
    value: t,
    enumerable: true,
    configurable: true,
    writable: true
  }) : e[r] = t, e;
}
function _getPrototypeOf(t) {
  return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(t2) {
    return t2.__proto__ || Object.getPrototypeOf(t2);
  }, _getPrototypeOf(t);
}
function _inherits(t, e) {
  if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
  t.prototype = Object.create(e && e.prototype, {
    constructor: {
      value: t,
      writable: true,
      configurable: true
    }
  }), Object.defineProperty(t, "prototype", {
    writable: false
  }), e && _setPrototypeOf(t, e);
}
function _isNativeReflectConstruct() {
  try {
    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
    }));
  } catch (t2) {
  }
  return (_isNativeReflectConstruct = function() {
    return !!t;
  })();
}
function _iterableToArray(r) {
  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
}
function _nonIterableSpread() {
  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function ownKeys$4(e, r) {
  var t = Object.keys(e);
  if (Object.getOwnPropertySymbols) {
    var o2 = Object.getOwnPropertySymbols(e);
    r && (o2 = o2.filter(function(r2) {
      return Object.getOwnPropertyDescriptor(e, r2).enumerable;
    })), t.push.apply(t, o2);
  }
  return t;
}
function _objectSpread2(e) {
  for (var r = 1; r < arguments.length; r++) {
    var t = null != arguments[r] ? arguments[r] : {};
    r % 2 ? ownKeys$4(Object(t), true).forEach(function(r2) {
      _defineProperty(e, r2, t[r2]);
    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$4(Object(t)).forEach(function(r2) {
      Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
    });
  }
  return e;
}
function _possibleConstructorReturn(t, e) {
  if (e && ("object" == typeof e || "function" == typeof e)) return e;
  if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined");
  return _assertThisInitialized(t);
}
function _setPrototypeOf(t, e) {
  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t2, e2) {
    return t2.__proto__ = e2, t2;
  }, _setPrototypeOf(t, e);
}
function _toConsumableArray(r) {
  return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
}
function _toPrimitive(t, r) {
  if ("object" != typeof t || !t) return t;
  var e = t[Symbol.toPrimitive];
  if (void 0 !== e) {
    var i2 = e.call(t, r || "default");
    if ("object" != typeof i2) return i2;
    throw new TypeError("@@toPrimitive must return a primitive value.");
  }
  return ("string" === r ? String : Number)(t);
}
function _toPropertyKey(t) {
  var i2 = _toPrimitive(t, "string");
  return "symbol" == typeof i2 ? i2 : i2 + "";
}
function _typeof(o2) {
  "@babel/helpers - typeof";
  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o3) {
    return typeof o3;
  } : function(o3) {
    return o3 && "function" == typeof Symbol && o3.constructor === Symbol && o3 !== Symbol.prototype ? "symbol" : typeof o3;
  }, _typeof(o2);
}
function _unsupportedIterableToArray(r, a) {
  if (r) {
    if ("string" == typeof r) return _arrayLikeToArray(r, a);
    var t = {}.toString.call(r).slice(8, -1);
    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
  }
}
var check = function check2(it) {
  return it && it.Math === Math && it;
};
var globalThis_1 = (
  // eslint-disable-next-line es/no-global-this -- safe
  check((typeof globalThis === "undefined" ? "undefined" : _typeof(globalThis)) == "object" && globalThis) || check((typeof window === "undefined" ? "undefined" : _typeof(window)) == "object" && window) || // eslint-disable-next-line no-restricted-globals -- safe
  check((typeof self === "undefined" ? "undefined" : _typeof(self)) == "object" && self) || check(_typeof(commonjsGlobal) == "object" && commonjsGlobal) || check(_typeof(commonjsGlobal) == "object" && commonjsGlobal) || // eslint-disable-next-line no-new-func -- fallback
  /* @__PURE__ */ function() {
    return this;
  }() || Function("return this")()
);
var objectGetOwnPropertyDescriptor = {};
var fails$1a = function fails(exec2) {
  try {
    return !!exec2();
  } catch (error2) {
    return true;
  }
};
var fails$19 = fails$1a;
var descriptors = !fails$19(function() {
  return Object.defineProperty({}, 1, {
    get: function get6() {
      return 7;
    }
  })[1] !== 7;
});
var fails$18 = fails$1a;
var functionBindNative = !fails$18(function() {
  var test2 = (function() {
  }).bind();
  return typeof test2 != "function" || test2.hasOwnProperty("prototype");
});
var NATIVE_BIND$4 = functionBindNative;
var call$N = Function.prototype.call;
var functionCall = NATIVE_BIND$4 ? call$N.bind(call$N) : function() {
  return call$N.apply(call$N, arguments);
};
var objectPropertyIsEnumerable = {};
var $propertyIsEnumerable$2 = {}.propertyIsEnumerable;
var getOwnPropertyDescriptor$a = Object.getOwnPropertyDescriptor;
var NASHORN_BUG = getOwnPropertyDescriptor$a && !$propertyIsEnumerable$2.call({
  1: 2
}, 1);
objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
  var descriptor = getOwnPropertyDescriptor$a(this, V);
  return !!descriptor && descriptor.enumerable;
} : $propertyIsEnumerable$2;
var createPropertyDescriptor$a = function createPropertyDescriptor(bitmap, value) {
  return {
    enumerable: !(bitmap & 1),
    configurable: !(bitmap & 2),
    writable: !(bitmap & 4),
    value
  };
};
var NATIVE_BIND$3 = functionBindNative;
var FunctionPrototype$4 = Function.prototype;
var call$M = FunctionPrototype$4.call;
var uncurryThisWithBind = NATIVE_BIND$3 && FunctionPrototype$4.bind.bind(call$M, call$M);
var functionUncurryThis = NATIVE_BIND$3 ? uncurryThisWithBind : function(fn) {
  return function() {
    return call$M.apply(fn, arguments);
  };
};
var uncurryThis$18 = functionUncurryThis;
var toString$v = uncurryThis$18({}.toString);
var stringSlice$g = uncurryThis$18("".slice);
var classofRaw$2 = function classofRaw(it) {
  return stringSlice$g(toString$v(it), 8, -1);
};
var uncurryThis$17 = functionUncurryThis;
var fails$17 = fails$1a;
var classof$l = classofRaw$2;
var $Object$8 = Object;
var split$4 = uncurryThis$17("".split);
var indexedObject = fails$17(function() {
  return !$Object$8("z").propertyIsEnumerable(0);
}) ? function(it) {
  return classof$l(it) === "String" ? split$4(it, "") : $Object$8(it);
} : $Object$8;
var isNullOrUndefined$g = function isNullOrUndefined(it) {
  return it === null || it === void 0;
};
var isNullOrUndefined$f = isNullOrUndefined$g;
var $TypeError$t = TypeError;
var requireObjectCoercible$k = function requireObjectCoercible(it) {
  if (isNullOrUndefined$f(it)) throw new $TypeError$t("Can't call method on " + it);
  return it;
};
var IndexedObject$4 = indexedObject;
var requireObjectCoercible$j = requireObjectCoercible$k;
var toIndexedObject$f = function toIndexedObject(it) {
  return IndexedObject$4(requireObjectCoercible$j(it));
};
var documentAll = (typeof document === "undefined" ? "undefined" : _typeof(document)) == "object" && document.all;
var isCallable$y = typeof documentAll == "undefined" && documentAll !== void 0 ? function(argument) {
  return typeof argument == "function" || argument === documentAll;
} : function(argument) {
  return typeof argument == "function";
};
var isCallable$x = isCallable$y;
var isObject$C = function isObject(it) {
  return _typeof(it) == "object" ? it !== null : isCallable$x(it);
};
var globalThis$Q = globalThis_1;
var isCallable$w = isCallable$y;
var aFunction = function aFunction2(argument) {
  return isCallable$w(argument) ? argument : void 0;
};
var getBuiltIn$n = function getBuiltIn(namespace, method) {
  return arguments.length < 2 ? aFunction(globalThis$Q[namespace]) : globalThis$Q[namespace] && globalThis$Q[namespace][method];
};
var uncurryThis$16 = functionUncurryThis;
var objectIsPrototypeOf = uncurryThis$16({}.isPrototypeOf);
var globalThis$P = globalThis_1;
var navigator$1 = globalThis$P.navigator;
var userAgent$8 = navigator$1 && navigator$1.userAgent;
var environmentUserAgent = userAgent$8 ? String(userAgent$8) : "";
var globalThis$O = globalThis_1;
var userAgent$7 = environmentUserAgent;
var process$3 = globalThis$O.process;
var Deno$1 = globalThis$O.Deno;
var versions = process$3 && process$3.versions || Deno$1 && Deno$1.version;
var v8 = versions && versions.v8;
var match, version;
if (v8) {
  match = v8.split(".");
  version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
}
if (!version && userAgent$7) {
  match = userAgent$7.match(/Edge\/(\d+)/);
  if (!match || match[1] >= 74) {
    match = userAgent$7.match(/Chrome\/(\d+)/);
    if (match) version = +match[1];
  }
}
var environmentV8Version = version;
var V8_VERSION$3 = environmentV8Version;
var fails$16 = fails$1a;
var globalThis$N = globalThis_1;
var $String$7 = globalThis$N.String;
var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$16(function() {
  var symbol = Symbol("symbol detection");
  return !$String$7(symbol) || !(Object(symbol) instanceof Symbol) || // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
  !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$m = getBuiltIn$n;
var isCallable$v = isCallable$y;
var isPrototypeOf$b = objectIsPrototypeOf;
var USE_SYMBOL_AS_UID$1 = useSymbolAsUid;
var $Object$7 = Object;
var isSymbol$6 = USE_SYMBOL_AS_UID$1 ? function(it) {
  return _typeof(it) == "symbol";
} : function(it) {
  var $Symbol2 = getBuiltIn$m("Symbol");
  return isCallable$v($Symbol2) && isPrototypeOf$b($Symbol2.prototype, $Object$7(it));
};
var $String$6 = String;
var tryToString$7 = function tryToString(argument) {
  try {
    return $String$6(argument);
  } catch (error2) {
    return "Object";
  }
};
var isCallable$u = isCallable$y;
var tryToString$6 = tryToString$7;
var $TypeError$s = TypeError;
var aCallable$s = function aCallable(argument) {
  if (isCallable$u(argument)) return argument;
  throw new $TypeError$s(tryToString$6(argument) + " is not a function");
};
var aCallable$r = aCallable$s;
var isNullOrUndefined$e = isNullOrUndefined$g;
var getMethod$b = function getMethod(V, P) {
  var func = V[P];
  return isNullOrUndefined$e(func) ? void 0 : aCallable$r(func);
};
var call$L = functionCall;
var isCallable$t = isCallable$y;
var isObject$B = isObject$C;
var $TypeError$r = TypeError;
var ordinaryToPrimitive$2 = function ordinaryToPrimitive(input, pref) {
  var fn, val;
  if (pref === "string" && isCallable$t(fn = input.toString) && !isObject$B(val = call$L(fn, input))) return val;
  if (isCallable$t(fn = input.valueOf) && !isObject$B(val = call$L(fn, input))) return val;
  if (pref !== "string" && isCallable$t(fn = input.toString) && !isObject$B(val = call$L(fn, input))) return val;
  throw new $TypeError$r("Can't convert object to primitive value");
};
var sharedStore = { exports: {} };
var isPure = false;
var globalThis$M = globalThis_1;
var defineProperty$b = Object.defineProperty;
var defineGlobalProperty$3 = function defineGlobalProperty(key, value) {
  try {
    defineProperty$b(globalThis$M, key, {
      value,
      configurable: true,
      writable: true
    });
  } catch (error2) {
    globalThis$M[key] = value;
  }
  return value;
};
var globalThis$L = globalThis_1;
var defineGlobalProperty$2 = defineGlobalProperty$3;
var SHARED = "__core-js_shared__";
var store$5 = sharedStore.exports = globalThis$L[SHARED] || defineGlobalProperty$2(SHARED, {});
(store$5.versions || (store$5.versions = [])).push({
  version: "3.39.0",
  mode: "global",
  copyright: "© 2014-2024 Denis Pushkarev (zloirock.ru)",
  license: "https://github.com/zloirock/core-js/blob/v3.39.0/LICENSE",
  source: "https://github.com/zloirock/core-js"
});
var sharedStoreExports = sharedStore.exports;
var store$4 = sharedStoreExports;
var shared$8 = function shared(key, value) {
  return store$4[key] || (store$4[key] = value || {});
};
var requireObjectCoercible$i = requireObjectCoercible$k;
var $Object$6 = Object;
var toObject$r = function toObject(argument) {
  return $Object$6(requireObjectCoercible$i(argument));
};
var uncurryThis$15 = functionUncurryThis;
var toObject$q = toObject$r;
var hasOwnProperty = uncurryThis$15({}.hasOwnProperty);
var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
  return hasOwnProperty(toObject$q(it), key);
};
var uncurryThis$14 = functionUncurryThis;
var id$2 = 0;
var postfix = Math.random();
var toString$u = uncurryThis$14(1 .toString);
var uid$5 = function uid(key) {
  return "Symbol(" + (key === void 0 ? "" : key) + ")_" + toString$u(++id$2 + postfix, 36);
};
var globalThis$K = globalThis_1;
var shared$7 = shared$8;
var hasOwn$r = hasOwnProperty_1;
var uid$4 = uid$5;
var NATIVE_SYMBOL$5 = symbolConstructorDetection;
var USE_SYMBOL_AS_UID = useSymbolAsUid;
var _Symbol$3 = globalThis$K.Symbol;
var WellKnownSymbolsStore$1 = shared$7("wks");
var createWellKnownSymbol = USE_SYMBOL_AS_UID ? _Symbol$3["for"] || _Symbol$3 : _Symbol$3 && _Symbol$3.withoutSetter || uid$4;
var wellKnownSymbol$C = function wellKnownSymbol(name) {
  if (!hasOwn$r(WellKnownSymbolsStore$1, name)) {
    WellKnownSymbolsStore$1[name] = NATIVE_SYMBOL$5 && hasOwn$r(_Symbol$3, name) ? _Symbol$3[name] : createWellKnownSymbol("Symbol." + name);
  }
  return WellKnownSymbolsStore$1[name];
};
var call$K = functionCall;
var isObject$A = isObject$C;
var isSymbol$5 = isSymbol$6;
var getMethod$a = getMethod$b;
var ordinaryToPrimitive$1 = ordinaryToPrimitive$2;
var wellKnownSymbol$B = wellKnownSymbol$C;
var $TypeError$q = TypeError;
var TO_PRIMITIVE$1 = wellKnownSymbol$B("toPrimitive");
var toPrimitive$3 = function toPrimitive(input, pref) {
  if (!isObject$A(input) || isSymbol$5(input)) return input;
  var exoticToPrim = getMethod$a(input, TO_PRIMITIVE$1);
  var result;
  if (exoticToPrim) {
    if (pref === void 0) pref = "default";
    result = call$K(exoticToPrim, input, pref);
    if (!isObject$A(result) || isSymbol$5(result)) return result;
    throw new $TypeError$q("Can't convert object to primitive value");
  }
  if (pref === void 0) pref = "number";
  return ordinaryToPrimitive$1(input, pref);
};
var toPrimitive$2 = toPrimitive$3;
var isSymbol$4 = isSymbol$6;
var toPropertyKey$7 = function toPropertyKey(argument) {
  var key = toPrimitive$2(argument, "string");
  return isSymbol$4(key) ? key : key + "";
};
var globalThis$J = globalThis_1;
var isObject$z = isObject$C;
var document$3 = globalThis$J.document;
var EXISTS$1 = isObject$z(document$3) && isObject$z(document$3.createElement);
var documentCreateElement$2 = function documentCreateElement(it) {
  return EXISTS$1 ? document$3.createElement(it) : {};
};
var DESCRIPTORS$D = descriptors;
var fails$15 = fails$1a;
var createElement$1 = documentCreateElement$2;
var ie8DomDefine = !DESCRIPTORS$D && !fails$15(function() {
  return Object.defineProperty(createElement$1("div"), "a", {
    get: function get6() {
      return 7;
    }
  }).a !== 7;
});
var DESCRIPTORS$C = descriptors;
var call$J = functionCall;
var propertyIsEnumerableModule$2 = objectPropertyIsEnumerable;
var createPropertyDescriptor$9 = createPropertyDescriptor$a;
var toIndexedObject$e = toIndexedObject$f;
var toPropertyKey$6 = toPropertyKey$7;
var hasOwn$q = hasOwnProperty_1;
var IE8_DOM_DEFINE$1 = ie8DomDefine;
var $getOwnPropertyDescriptor$2 = Object.getOwnPropertyDescriptor;
objectGetOwnPropertyDescriptor.f = DESCRIPTORS$C ? $getOwnPropertyDescriptor$2 : function getOwnPropertyDescriptor(O, P) {
  O = toIndexedObject$e(O);
  P = toPropertyKey$6(P);
  if (IE8_DOM_DEFINE$1) try {
    return $getOwnPropertyDescriptor$2(O, P);
  } catch (error2) {
  }
  if (hasOwn$q(O, P)) return createPropertyDescriptor$9(!call$J(propertyIsEnumerableModule$2.f, O, P), O[P]);
};
var objectDefineProperty = {};
var DESCRIPTORS$B = descriptors;
var fails$14 = fails$1a;
var v8PrototypeDefineBug = DESCRIPTORS$B && fails$14(function() {
  return Object.defineProperty(function() {
  }, "prototype", {
    value: 42,
    writable: false
  }).prototype !== 42;
});
var isObject$y = isObject$C;
var $String$5 = String;
var $TypeError$p = TypeError;
var anObject$M = function anObject(argument) {
  if (isObject$y(argument)) return argument;
  throw new $TypeError$p($String$5(argument) + " is not an object");
};
var DESCRIPTORS$A = descriptors;
var IE8_DOM_DEFINE = ie8DomDefine;
var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug;
var anObject$L = anObject$M;
var toPropertyKey$5 = toPropertyKey$7;
var $TypeError$o = TypeError;
var $defineProperty$1 = Object.defineProperty;
var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
var ENUMERABLE = "enumerable";
var CONFIGURABLE$1 = "configurable";
var WRITABLE = "writable";
objectDefineProperty.f = DESCRIPTORS$A ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) {
  anObject$L(O);
  P = toPropertyKey$5(P);
  anObject$L(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$L(O);
  P = toPropertyKey$5(P);
  anObject$L(Attributes);
  if (IE8_DOM_DEFINE) try {
    return $defineProperty$1(O, P, Attributes);
  } catch (error2) {
  }
  if ("get" in Attributes || "set" in Attributes) throw new $TypeError$o("Accessors not supported");
  if ("value" in Attributes) O[P] = Attributes.value;
  return O;
};
var DESCRIPTORS$z = descriptors;
var definePropertyModule$b = objectDefineProperty;
var createPropertyDescriptor$8 = createPropertyDescriptor$a;
var createNonEnumerableProperty$d = DESCRIPTORS$z ? function(object, key, value) {
  return definePropertyModule$b.f(object, key, createPropertyDescriptor$8(1, value));
} : function(object, key, value) {
  object[key] = value;
  return object;
};
var makeBuiltIn$4 = { exports: {} };
var DESCRIPTORS$y = descriptors;
var hasOwn$p = hasOwnProperty_1;
var FunctionPrototype$3 = Function.prototype;
var getDescriptor = DESCRIPTORS$y && Object.getOwnPropertyDescriptor;
var EXISTS = hasOwn$p(FunctionPrototype$3, "name");
var PROPER = EXISTS && (function something() {
}).name === "something";
var CONFIGURABLE = EXISTS && (!DESCRIPTORS$y || DESCRIPTORS$y && getDescriptor(FunctionPrototype$3, "name").configurable);
var functionName = {
  EXISTS,
  PROPER,
  CONFIGURABLE
};
var uncurryThis$13 = functionUncurryThis;
var isCallable$s = isCallable$y;
var store$3 = sharedStoreExports;
var functionToString$1 = uncurryThis$13(Function.toString);
if (!isCallable$s(store$3.inspectSource)) {
  store$3.inspectSource = function(it) {
    return functionToString$1(it);
  };
}
var inspectSource$3 = store$3.inspectSource;
var globalThis$I = globalThis_1;
var isCallable$r = isCallable$y;
var WeakMap$4 = globalThis$I.WeakMap;
var weakMapBasicDetection = isCallable$r(WeakMap$4) && /native code/.test(String(WeakMap$4));
var shared$6 = shared$8;
var uid$3 = uid$5;
var keys$2 = shared$6("keys");
var sharedKey$4 = function sharedKey(key) {
  return keys$2[key] || (keys$2[key] = uid$3(key));
};
var hiddenKeys$6 = {};
var NATIVE_WEAK_MAP$1 = weakMapBasicDetection;
var globalThis$H = globalThis_1;
var isObject$x = isObject$C;
var createNonEnumerableProperty$c = createNonEnumerableProperty$d;
var hasOwn$o = hasOwnProperty_1;
var shared$5 = sharedStoreExports;
var sharedKey$3 = sharedKey$4;
var hiddenKeys$5 = hiddenKeys$6;
var OBJECT_ALREADY_INITIALIZED = "Object already initialized";
var TypeError$7 = globalThis$H.TypeError;
var WeakMap$3 = globalThis$H.WeakMap;
var set$9, get$4, has$b;
var enforce = function enforce2(it) {
  return has$b(it) ? get$4(it) : set$9(it, {});
};
var getterFor$1 = function getterFor(TYPE) {
  return function(it) {
    var state;
    if (!isObject$x(it) || (state = get$4(it)).type !== TYPE) {
      throw new TypeError$7("Incompatible receiver, " + TYPE + " required");
    }
    return state;
  };
};
if (NATIVE_WEAK_MAP$1 || shared$5.state) {
  var store$2 = shared$5.state || (shared$5.state = new WeakMap$3());
  store$2.get = store$2.get;
  store$2.has = store$2.has;
  store$2.set = store$2.set;
  set$9 = function set6(it, metadata3) {
    if (store$2.has(it)) throw new TypeError$7(OBJECT_ALREADY_INITIALIZED);
    metadata3.facade = it;
    store$2.set(it, metadata3);
    return metadata3;
  };
  get$4 = function get6(it) {
    return store$2.get(it) || {};
  };
  has$b = function has5(it) {
    return store$2.has(it);
  };
} else {
  var STATE = sharedKey$3("state");
  hiddenKeys$5[STATE] = true;
  set$9 = function set6(it, metadata3) {
    if (hasOwn$o(it, STATE)) throw new TypeError$7(OBJECT_ALREADY_INITIALIZED);
    metadata3.facade = it;
    createNonEnumerableProperty$c(it, STATE, metadata3);
    return metadata3;
  };
  get$4 = function get6(it) {
    return hasOwn$o(it, STATE) ? it[STATE] : {};
  };
  has$b = function has5(it) {
    return hasOwn$o(it, STATE);
  };
}
var internalState = {
  set: set$9,
  get: get$4,
  has: has$b,
  enforce,
  getterFor: getterFor$1
};
var uncurryThis$12 = functionUncurryThis;
var fails$13 = fails$1a;
var isCallable$q = isCallable$y;
var hasOwn$n = hasOwnProperty_1;
var DESCRIPTORS$x = descriptors;
var CONFIGURABLE_FUNCTION_NAME$2 = functionName.CONFIGURABLE;
var inspectSource$2 = inspectSource$3;
var InternalStateModule$f = internalState;
var enforceInternalState$4 = InternalStateModule$f.enforce;
var getInternalState$9 = InternalStateModule$f.get;
var $String$4 = String;
var defineProperty$a = Object.defineProperty;
var stringSlice$f = uncurryThis$12("".slice);
var replace$b = uncurryThis$12("".replace);
var join$7 = uncurryThis$12([].join);
var CONFIGURABLE_LENGTH = DESCRIPTORS$x && !fails$13(function() {
  return defineProperty$a(function() {
  }, "length", {
    value: 8
  }).length !== 8;
});
var TEMPLATE = String(String).split("String");
var makeBuiltIn$3 = makeBuiltIn$4.exports = function(value, name, options) {
  if (stringSlice$f($String$4(name), 0, 7) === "Symbol(") {
    name = "[" + replace$b($String$4(name), /^Symbol\(([^)]*)\).*$/, "$1") + "]";
  }
  if (options && options.getter) name = "get " + name;
  if (options && options.setter) name = "set " + name;
  if (!hasOwn$n(value, "name") || CONFIGURABLE_FUNCTION_NAME$2 && value.name !== name) {
    if (DESCRIPTORS$x) defineProperty$a(value, "name", {
      value: name,
      configurable: true
    });
    else value.name = name;
  }
  if (CONFIGURABLE_LENGTH && options && hasOwn$n(options, "arity") && value.length !== options.arity) {
    defineProperty$a(value, "length", {
      value: options.arity
    });
  }
  try {
    if (options && hasOwn$n(options, "constructor") && options.constructor) {
      if (DESCRIPTORS$x) defineProperty$a(value, "prototype", {
        writable: false
      });
    } else if (value.prototype) value.prototype = void 0;
  } catch (error2) {
  }
  var state = enforceInternalState$4(value);
  if (!hasOwn$n(state, "source")) {
    state.source = join$7(TEMPLATE, typeof name == "string" ? name : "");
  }
  return value;
};
Function.prototype.toString = makeBuiltIn$3(function toString() {
  return isCallable$q(this) && getInternalState$9(this).source || inspectSource$2(this);
}, "toString");
var makeBuiltInExports = makeBuiltIn$4.exports;
var isCallable$p = isCallable$y;
var definePropertyModule$a = objectDefineProperty;
var makeBuiltIn$2 = makeBuiltInExports;
var defineGlobalProperty$1 = defineGlobalProperty$3;
var defineBuiltIn$k = function defineBuiltIn(O, key, value, options) {
  if (!options) options = {};
  var simple = options.enumerable;
  var name = options.name !== void 0 ? options.name : key;
  if (isCallable$p(value)) makeBuiltIn$2(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 (error2) {
    }
    if (simple) O[key] = value;
    else definePropertyModule$a.f(O, key, {
      value,
      enumerable: false,
      configurable: !options.nonConfigurable,
      writable: !options.nonWritable
    });
  }
  return O;
};
var objectGetOwnPropertyNames = {};
var ceil$1 = Math.ceil;
var floor$9 = Math.floor;
var mathTrunc = Math.trunc || function trunc(x) {
  var n = +x;
  return (n > 0 ? floor$9 : ceil$1)(n);
};
var trunc$1 = mathTrunc;
var toIntegerOrInfinity$f = function toIntegerOrInfinity(argument) {
  var number = +argument;
  return number !== number || number === 0 ? 0 : trunc$1(number);
};
var toIntegerOrInfinity$e = toIntegerOrInfinity$f;
var max$6 = Math.max;
var min$9 = Math.min;
var toAbsoluteIndex$7 = function toAbsoluteIndex(index2, length) {
  var integer = toIntegerOrInfinity$e(index2);
  return integer < 0 ? max$6(integer + length, 0) : min$9(integer, length);
};
var toIntegerOrInfinity$d = toIntegerOrInfinity$f;
var min$8 = Math.min;
var toLength$c = function toLength(argument) {
  var len = toIntegerOrInfinity$d(argument);
  return len > 0 ? min$8(len, 9007199254740991) : 0;
};
var toLength$b = toLength$c;
var lengthOfArrayLike$m = function lengthOfArrayLike(obj) {
  return toLength$b(obj.length);
};
var toIndexedObject$d = toIndexedObject$f;
var toAbsoluteIndex$6 = toAbsoluteIndex$7;
var lengthOfArrayLike$l = lengthOfArrayLike$m;
var createMethod$6 = function createMethod(IS_INCLUDES) {
  return function($this, el, fromIndex) {
    var O = toIndexedObject$d($this);
    var length = lengthOfArrayLike$l(O);
    if (length === 0) return !IS_INCLUDES && -1;
    var index2 = toAbsoluteIndex$6(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 = {
  // `Array.prototype.includes` method
  // https://tc39.es/ecma262/#sec-array.prototype.includes
  includes: createMethod$6(true),
  // `Array.prototype.indexOf` method
  // https://tc39.es/ecma262/#sec-array.prototype.indexof
  indexOf: createMethod$6(false)
};
var uncurryThis$11 = functionUncurryThis;
var hasOwn$m = hasOwnProperty_1;
var toIndexedObject$c = toIndexedObject$f;
var indexOf$2 = arrayIncludes.indexOf;
var hiddenKeys$4 = hiddenKeys$6;
var push$h = uncurryThis$11([].push);
var objectKeysInternal = function objectKeysInternal2(object, names) {
  var O = toIndexedObject$c(object);
  var i2 = 0;
  var result = [];
  var key;
  for (key in O) !hasOwn$m(hiddenKeys$4, key) && hasOwn$m(O, key) && push$h(result, key);
  while (names.length > i2) if (hasOwn$m(O, key = names[i2++])) {
    ~indexOf$2(result, key) || push$h(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$3 = enumBugKeys$2.concat("length", "prototype");
objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
  return internalObjectKeys$1(O, hiddenKeys$3);
};
var objectGetOwnPropertySymbols = {};
objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;
var getBuiltIn$l = getBuiltIn$n;
var uncurryThis$10 = functionUncurryThis;
var getOwnPropertyNamesModule$2 = objectGetOwnPropertyNames;
var getOwnPropertySymbolsModule$3 = objectGetOwnPropertySymbols;
var anObject$K = anObject$M;
var concat$4 = uncurryThis$10([].concat);
var ownKeys$3 = getBuiltIn$l("Reflect", "ownKeys") || function ownKeys(it) {
  var keys6 = getOwnPropertyNamesModule$2.f(anObject$K(it));
  var getOwnPropertySymbols2 = getOwnPropertySymbolsModule$3.f;
  return getOwnPropertySymbols2 ? concat$4(keys6, getOwnPropertySymbols2(it)) : keys6;
};
var hasOwn$l = hasOwnProperty_1;
var ownKeys$2 = ownKeys$3;
var getOwnPropertyDescriptorModule$6 = objectGetOwnPropertyDescriptor;
var definePropertyModule$9 = objectDefineProperty;
var copyConstructorProperties$5 = function copyConstructorProperties(target, source, exceptions) {
  var keys6 = ownKeys$2(source);
  var defineProperty7 = definePropertyModule$9.f;
  var getOwnPropertyDescriptor7 = getOwnPropertyDescriptorModule$6.f;
  for (var i2 = 0; i2 < keys6.length; i2++) {
    var key = keys6[i2];
    if (!hasOwn$l(target, key) && !(exceptions && hasOwn$l(exceptions, key))) {
      defineProperty7(target, key, getOwnPropertyDescriptor7(source, key));
    }
  }
};
var fails$12 = fails$1a;
var isCallable$o = isCallable$y;
var replacement = /#|\.prototype\./;
var isForced$5 = function isForced(feature, detection) {
  var value = data[normalize(feature)];
  return value === POLYFILL ? true : value === NATIVE ? false : isCallable$o(detection) ? fails$12(detection) : !!detection;
};
var normalize = isForced$5.normalize = function(string) {
  return String(string).replace(replacement, ".").toLowerCase();
};
var data = isForced$5.data = {};
var NATIVE = isForced$5.NATIVE = "N";
var POLYFILL = isForced$5.POLYFILL = "P";
var isForced_1 = isForced$5;
var globalThis$G = globalThis_1;
var getOwnPropertyDescriptor$9 = objectGetOwnPropertyDescriptor.f;
var createNonEnumerableProperty$b = createNonEnumerableProperty$d;
var defineBuiltIn$j = defineBuiltIn$k;
var defineGlobalProperty2 = defineGlobalProperty$3;
var copyConstructorProperties$4 = copyConstructorProperties$5;
var isForced$4 = isForced_1;
var _export = function _export2(options, source) {
  var TARGET = options.target;
  var GLOBAL = options.global;
  var STATIC = options.stat;
  var FORCED2, target, key, targetProperty, sourceProperty, descriptor;
  if (GLOBAL) {
    target = globalThis$G;
  } else if (STATIC) {
    target = globalThis$G[TARGET] || defineGlobalProperty2(TARGET, {});
  } else {
    target = globalThis$G[TARGET] && globalThis$G[TARGET].prototype;
  }
  if (target) for (key in source) {
    sourceProperty = source[key];
    if (options.dontCallGetSet) {
      descriptor = getOwnPropertyDescriptor$9(target, key);
      targetProperty = descriptor && descriptor.value;
    } else targetProperty = target[key];
    FORCED2 = isForced$4(GLOBAL ? key : TARGET + (STATIC ? "." : "#") + key, options.forced);
    if (!FORCED2 && targetProperty !== void 0) {
      if (_typeof(sourceProperty) == _typeof(targetProperty)) continue;
      copyConstructorProperties$4(sourceProperty, targetProperty);
    }
    if (options.sham || targetProperty && targetProperty.sham) {
      createNonEnumerableProperty$b(sourceProperty, "sham", true);
    }
    defineBuiltIn$j(target, key, sourceProperty, options);
  }
};
var wellKnownSymbol$A = wellKnownSymbol$C;
var TO_STRING_TAG$4 = wellKnownSymbol$A("toStringTag");
var test$1 = {};
test$1[TO_STRING_TAG$4] = "z";
var toStringTagSupport = String(test$1) === "[object z]";
var TO_STRING_TAG_SUPPORT$2 = toStringTagSupport;
var isCallable$n = isCallable$y;
var classofRaw$1 = classofRaw$2;
var wellKnownSymbol$z = wellKnownSymbol$C;
var TO_STRING_TAG$3 = wellKnownSymbol$z("toStringTag");
var $Object$5 = Object;
var CORRECT_ARGUMENTS = classofRaw$1(/* @__PURE__ */ function() {
  return arguments;
}()) === "Arguments";
var tryGet = function tryGet2(it, key) {
  try {
    return it[key];
  } catch (error2) {
  }
};
var classof$k = 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$5(it), TO_STRING_TAG$3)) == "string" ? tag : CORRECT_ARGUMENTS ? classofRaw$1(O) : (result = classofRaw$1(O)) === "Object" && isCallable$n(O.callee) ? "Arguments" : result;
};
var classof$j = classof$k;
var $String$3 = String;
var toString$t = function toString2(argument) {
  if (classof$j(argument) === "Symbol") throw new TypeError("Cannot convert a Symbol value to a string");
  return $String$3(argument);
};
var objectDefineProperties = {};
var internalObjectKeys = objectKeysInternal;
var enumBugKeys$1 = enumBugKeys$3;
var objectKeys$4 = Object.keys || function keys(O) {
  return internalObjectKeys(O, enumBugKeys$1);
};
var DESCRIPTORS$w = descriptors;
var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug;
var definePropertyModule$8 = objectDefineProperty;
var anObject$J = anObject$M;
var toIndexedObject$b = toIndexedObject$f;
var objectKeys$3 = objectKeys$4;
objectDefineProperties.f = DESCRIPTORS$w && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
  anObject$J(O);
  var props = toIndexedObject$b(Properties);
  var keys6 = objectKeys$3(Properties);
  var length = keys6.length;
  var index2 = 0;
  var key;
  while (length > index2) definePropertyModule$8.f(O, key = keys6[index2++], props[key]);
  return O;
};
var getBuiltIn$k = getBuiltIn$n;
var html$2 = getBuiltIn$k("document", "documentElement");
var anObject$I = anObject$M;
var definePropertiesModule$1 = objectDefineProperties;
var enumBugKeys = enumBugKeys$3;
var hiddenKeys$2 = hiddenKeys$6;
var html$1 = html$2;
var documentCreateElement$1 = documentCreateElement$2;
var sharedKey$2 = sharedKey$4;
var GT = ">";
var LT = "<";
var PROTOTYPE$2 = "prototype";
var SCRIPT = "script";
var IE_PROTO$1 = sharedKey$2("IE_PROTO");
var EmptyConstructor = function EmptyConstructor2() {
};
var scriptTag = function scriptTag2(content) {
  return LT + SCRIPT + GT + content + LT + "/" + SCRIPT + GT;
};
var NullProtoObjectViaActiveX = function NullProtoObjectViaActiveX2(activeXDocument2) {
  activeXDocument2.write(scriptTag(""));
  activeXDocument2.close();
  var temp = activeXDocument2.parentWindow.Object;
  activeXDocument2 = null;
  return temp;
};
var NullProtoObjectViaIFrame = function NullProtoObjectViaIFrame2() {
  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 NullProtoObject() {
  try {
    activeXDocument = new ActiveXObject("htmlfile");
  } catch (error2) {
  }
  _NullProtoObject = typeof document != "undefined" ? document.domain && activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame() : NullProtoObjectViaActiveX(activeXDocument);
  var length = enumBugKeys.length;
  while (length--) delete _NullProtoObject[PROTOTYPE$2][enumBugKeys[length]];
  return _NullProtoObject();
};
hiddenKeys$2[IE_PROTO$1] = true;
var objectCreate = Object.create || function create(O, Properties) {
  var result;
  if (O !== null) {
    EmptyConstructor[PROTOTYPE$2] = anObject$I(O);
    result = new EmptyConstructor();
    EmptyConstructor[PROTOTYPE$2] = null;
    result[IE_PROTO$1] = O;
  } else result = _NullProtoObject();
  return Properties === void 0 ? result : definePropertiesModule$1.f(result, Properties);
};
var objectGetOwnPropertyNamesExternal = {};
var uncurryThis$$ = functionUncurryThis;
var arraySlice$9 = uncurryThis$$([].slice);
var classof$i = classofRaw$2;
var toIndexedObject$a = toIndexedObject$f;
var $getOwnPropertyNames$1 = objectGetOwnPropertyNames.f;
var arraySlice$8 = arraySlice$9;
var windowNames = (typeof window === "undefined" ? "undefined" : _typeof(window)) == "object" && window && Object.getOwnPropertyNames ? Object.getOwnPropertyNames(window) : [];
var getWindowNames = function getWindowNames2(it) {
  try {
    return $getOwnPropertyNames$1(it);
  } catch (error2) {
    return arraySlice$8(windowNames);
  }
};
objectGetOwnPropertyNamesExternal.f = function getOwnPropertyNames2(it) {
  return windowNames && classof$i(it) === "Window" ? getWindowNames(it) : $getOwnPropertyNames$1(toIndexedObject$a(it));
};
var makeBuiltIn$1 = makeBuiltInExports;
var defineProperty$9 = objectDefineProperty;
var defineBuiltInAccessor$e = function defineBuiltInAccessor(target, name, descriptor) {
  if (descriptor.get) makeBuiltIn$1(descriptor.get, name, {
    getter: true
  });
  if (descriptor.set) makeBuiltIn$1(descriptor.set, name, {
    setter: true
  });
  return defineProperty$9.f(target, name, descriptor);
};
var wellKnownSymbolWrapped = {};
var wellKnownSymbol$y = wellKnownSymbol$C;
wellKnownSymbolWrapped.f = wellKnownSymbol$y;
var globalThis$F = globalThis_1;
var path$2 = globalThis$F;
var path$1 = path$2;
var hasOwn$k = hasOwnProperty_1;
var wrappedWellKnownSymbolModule$1 = wellKnownSymbolWrapped;
var defineProperty$8 = objectDefineProperty.f;
var wellKnownSymbolDefine = function wellKnownSymbolDefine2(NAME2) {
  var _Symbol2 = path$1.Symbol || (path$1.Symbol = {});
  if (!hasOwn$k(_Symbol2, NAME2)) defineProperty$8(_Symbol2, NAME2, {
    value: wrappedWellKnownSymbolModule$1.f(NAME2)
  });
};
var call$I = functionCall;
var getBuiltIn$j = getBuiltIn$n;
var wellKnownSymbol$x = wellKnownSymbol$C;
var defineBuiltIn$i = defineBuiltIn$k;
var symbolDefineToPrimitive = function symbolDefineToPrimitive2() {
  var _Symbol2 = getBuiltIn$j("Symbol");
  var SymbolPrototype2 = _Symbol2 && _Symbol2.prototype;
  var valueOf = SymbolPrototype2 && SymbolPrototype2.valueOf;
  var TO_PRIMITIVE2 = wellKnownSymbol$x("toPrimitive");
  if (SymbolPrototype2 && !SymbolPrototype2[TO_PRIMITIVE2]) {
    defineBuiltIn$i(SymbolPrototype2, TO_PRIMITIVE2, function(hint) {
      return call$I(valueOf, this);
    }, {
      arity: 1
    });
  }
};
var defineProperty$7 = objectDefineProperty.f;
var hasOwn$j = hasOwnProperty_1;
var wellKnownSymbol$w = wellKnownSymbol$C;
var TO_STRING_TAG$2 = wellKnownSymbol$w("toStringTag");
var setToStringTag$c = function setToStringTag(target, TAG, STATIC) {
  if (target && !STATIC) target = target.prototype;
  if (target && !hasOwn$j(target, TO_STRING_TAG$2)) {
    defineProperty$7(target, TO_STRING_TAG$2, {
      configurable: true,
      value: TAG
    });
  }
};
var classofRaw2 = classofRaw$2;
var uncurryThis$_ = functionUncurryThis;
var functionUncurryThisClause = function functionUncurryThisClause2(fn) {
  if (classofRaw2(fn) === "Function") return uncurryThis$_(fn);
};
var uncurryThis$Z = functionUncurryThisClause;
var aCallable$q = aCallable$s;
var NATIVE_BIND$2 = functionBindNative;
var bind$p = uncurryThis$Z(uncurryThis$Z.bind);
var functionBindContext = function functionBindContext2(fn, that) {
  aCallable$q(fn);
  return that === void 0 ? fn : NATIVE_BIND$2 ? bind$p(fn, that) : function() {
    return fn.apply(that, arguments);
  };
};
var classof$h = classofRaw$2;
var isArray$7 = Array.isArray || function isArray(argument) {
  return classof$h(argument) === "Array";
};
var uncurryThis$Y = functionUncurryThis;
var fails$11 = fails$1a;
var isCallable$m = isCallable$y;
var classof$g = classof$k;
var getBuiltIn$i = getBuiltIn$n;
var inspectSource$1 = inspectSource$3;
var noop = function noop2() {
};
var construct$1 = getBuiltIn$i("Reflect", "construct");
var constructorRegExp = /^\s*(?:class|function)\b/;
var exec$8 = uncurryThis$Y(constructorRegExp.exec);
var INCORRECT_TO_STRING = !constructorRegExp.test(noop);
var isConstructorModern = function isConstructor(argument) {
  if (!isCallable$m(argument)) return false;
  try {
    construct$1(noop, [], argument);
    return true;
  } catch (error2) {
    return false;
  }
};
var isConstructorLegacy = function isConstructor2(argument) {
  if (!isCallable$m(argument)) return false;
  switch (classof$g(argument)) {
    case "AsyncFunction":
    case "GeneratorFunction":
    case "AsyncGeneratorFunction":
      return false;
  }
  try {
    return INCORRECT_TO_STRING || !!exec$8(constructorRegExp, inspectSource$1(argument));
  } catch (error2) {
    return true;
  }
};
isConstructorLegacy.sham = true;
var isConstructor$7 = !construct$1 || fails$11(function() {
  var called;
  return isConstructorModern(isConstructorModern.call) || !isConstructorModern(Object) || !isConstructorModern(function() {
    called = true;
  }) || called;
}) ? isConstructorLegacy : isConstructorModern;
var isArray$6 = isArray$7;
var isConstructor$6 = isConstructor$7;
var isObject$w = isObject$C;
var wellKnownSymbol$v = wellKnownSymbol$C;
var SPECIES$6 = wellKnownSymbol$v("species");
var $Array$4 = Array;
var arraySpeciesConstructor$1 = function arraySpeciesConstructor(originalArray) {
  var C;
  if (isArray$6(originalArray)) {
    C = originalArray.constructor;
    if (isConstructor$6(C) && (C === $Array$4 || isArray$6(C.prototype))) C = void 0;
    else if (isObject$w(C)) {
      C = C[SPECIES$6];
      if (C === null) C = void 0;
    }
  }
  return C === void 0 ? $Array$4 : C;
};
var arraySpeciesConstructor2 = arraySpeciesConstructor$1;
var arraySpeciesCreate$5 = function arraySpeciesCreate(originalArray, length) {
  return new (arraySpeciesConstructor2(originalArray))(length === 0 ? 0 : length);
};
var bind$o = functionBindContext;
var uncurryThis$X = functionUncurryThis;
var IndexedObject$3 = indexedObject;
var toObject$p = toObject$r;
var lengthOfArrayLike$k = lengthOfArrayLike$m;
var arraySpeciesCreate$4 = arraySpeciesCreate$5;
var push$g = uncurryThis$X([].push);
var createMethod$5 = function createMethod2(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$p($this);
    var self2 = IndexedObject$3(O);
    var length = lengthOfArrayLike$k(self2);
    var boundFunction = bind$o(callbackfn, that);
    var index2 = 0;
    var create5 = specificCreate || arraySpeciesCreate$4;
    var target = IS_MAP ? create5($this, length) : IS_FILTER || IS_FILTER_REJECT ? create5($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$g(target, value);
        }
        else switch (TYPE) {
          case 4:
            return false;
          case 7:
            push$g(target, value);
        }
      }
    }
    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;
  };
};
var arrayIteration = {
  // `Array.prototype.forEach` method
  // https://tc39.es/ecma262/#sec-array.prototype.foreach
  forEach: createMethod$5(0),
  // `Array.prototype.map` method
  // https://tc39.es/ecma262/#sec-array.prototype.map
  map: createMethod$5(1),
  // `Array.prototype.filter` method
  // https://tc39.es/ecma262/#sec-array.prototype.filter
  filter: createMethod$5(2),
  // `Array.prototype.some` method
  // https://tc39.es/ecma262/#sec-array.prototype.some
  some: createMethod$5(3),
  // `Array.prototype.every` method
  // https://tc39.es/ecma262/#sec-array.prototype.every
  every: createMethod$5(4),
  // `Array.prototype.find` method
  // https://tc39.es/ecma262/#sec-array.prototype.find
  find: createMethod$5(5),
  // `Array.prototype.findIndex` method
  // https://tc39.es/ecma262/#sec-array.prototype.findIndex
  findIndex: createMethod$5(6),
  // `Array.prototype.filterReject` method
  // https://github.com/tc39/proposal-array-filtering
  filterReject: createMethod$5(7)
};
var $$3d = _export;
var globalThis$E = globalThis_1;
var call$H = functionCall;
var uncurryThis$W = functionUncurryThis;
var DESCRIPTORS$v = descriptors;
var NATIVE_SYMBOL$4 = symbolConstructorDetection;
var fails$10 = fails$1a;
var hasOwn$i = hasOwnProperty_1;
var isPrototypeOf$a = objectIsPrototypeOf;
var anObject$H = anObject$M;
var toIndexedObject$9 = toIndexedObject$f;
var toPropertyKey$4 = toPropertyKey$7;
var $toString$3 = toString$t;
var createPropertyDescriptor$7 = createPropertyDescriptor$a;
var nativeObjectCreate = objectCreate;
var objectKeys$2 = objectKeys$4;
var getOwnPropertyNamesModule$1 = objectGetOwnPropertyNames;
var getOwnPropertyNamesExternal = objectGetOwnPropertyNamesExternal;
var getOwnPropertySymbolsModule$2 = objectGetOwnPropertySymbols;
var getOwnPropertyDescriptorModule$5 = objectGetOwnPropertyDescriptor;
var definePropertyModule$7 = objectDefineProperty;
var definePropertiesModule = objectDefineProperties;
var propertyIsEnumerableModule$1 = objectPropertyIsEnumerable;
var defineBuiltIn$h = defineBuiltIn$k;
var defineBuiltInAccessor$d = defineBuiltInAccessor$e;
var shared$4 = shared$8;
var sharedKey$1 = sharedKey$4;
var hiddenKeys$1 = hiddenKeys$6;
var uid$2 = uid$5;
var wellKnownSymbol$u = wellKnownSymbol$C;
var wrappedWellKnownSymbolModule = wellKnownSymbolWrapped;
var defineWellKnownSymbol$f = wellKnownSymbolDefine;
var defineSymbolToPrimitive$1 = symbolDefineToPrimitive;
var setToStringTag$b = setToStringTag$c;
var InternalStateModule$e = internalState;
var $forEach$2 = arrayIteration.forEach;
var HIDDEN = sharedKey$1("hidden");
var SYMBOL = "Symbol";
var PROTOTYPE$1 = "prototype";
var setInternalState$d = InternalStateModule$e.set;
var getInternalState$8 = InternalStateModule$e.getterFor(SYMBOL);
var ObjectPrototype$4 = Object[PROTOTYPE$1];
var $Symbol = globalThis$E.Symbol;
var SymbolPrototype$1 = $Symbol && $Symbol[PROTOTYPE$1];
var RangeError$4 = globalThis$E.RangeError;
var TypeError$6 = globalThis$E.TypeError;
var QObject = globalThis$E.QObject;
var nativeGetOwnPropertyDescriptor$2 = getOwnPropertyDescriptorModule$5.f;
var nativeDefineProperty$1 = definePropertyModule$7.f;
var nativeGetOwnPropertyNames = getOwnPropertyNamesExternal.f;
var nativePropertyIsEnumerable = propertyIsEnumerableModule$1.f;
var push$f = uncurryThis$W([].push);
var AllSymbols = shared$4("symbols");
var ObjectPrototypeSymbols = shared$4("op-symbols");
var WellKnownSymbolsStore = shared$4("wks");
var USE_SETTER = !QObject || !QObject[PROTOTYPE$1] || !QObject[PROTOTYPE$1].findChild;
var fallbackDefineProperty = function fallbackDefineProperty2(O, P, Attributes) {
  var ObjectPrototypeDescriptor = nativeGetOwnPropertyDescriptor$2(ObjectPrototype$4, P);
  if (ObjectPrototypeDescriptor) delete ObjectPrototype$4[P];
  nativeDefineProperty$1(O, P, Attributes);
  if (ObjectPrototypeDescriptor && O !== ObjectPrototype$4) {
    nativeDefineProperty$1(ObjectPrototype$4, P, ObjectPrototypeDescriptor);
  }
};
var setSymbolDescriptor = DESCRIPTORS$v && fails$10(function() {
  return nativeObjectCreate(nativeDefineProperty$1({}, "a", {
    get: function get6() {
      return nativeDefineProperty$1(this, "a", {
        value: 7
      }).a;
    }
  })).a !== 7;
}) ? fallbackDefineProperty : nativeDefineProperty$1;
var wrap = function wrap2(tag, description) {
  var symbol = AllSymbols[tag] = nativeObjectCreate(SymbolPrototype$1);
  setInternalState$d(symbol, {
    type: SYMBOL,
    tag,
    description
  });
  if (!DESCRIPTORS$v) symbol.description = description;
  return symbol;
};
var $defineProperty = function defineProperty3(O, P, Attributes) {
  if (O === ObjectPrototype$4) $defineProperty(ObjectPrototypeSymbols, P, Attributes);
  anObject$H(O);
  var key = toPropertyKey$4(P);
  anObject$H(Attribute