@mt-utils/obs-server/dist/index.js

通用OBS文件上传下载

import axios from "axios";
function _assertThisInitialized$1(e) {
  if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  return e;
}
function asyncGeneratorStep$1(n, t, e, r, o, a, c) {
  try {
    var i = n[a](c), u = i.value;
  } catch (n2) {
    return void e(n2);
  }
  i.done ? t(u) : Promise.resolve(u).then(r, o);
}
function _asyncToGenerator$1(n) {
  return function() {
    var t = this, e = arguments;
    return new Promise(function(r, o) {
      var a = n.apply(t, e);
      function _next(n2) {
        asyncGeneratorStep$1(a, r, o, _next, _throw, "next", n2);
      }
      function _throw(n2) {
        asyncGeneratorStep$1(a, r, o, _next, _throw, "throw", n2);
      }
      _next(void 0);
    });
  };
}
function _callSuper$1(t, o, e) {
  return o = _getPrototypeOf$1(o), _possibleConstructorReturn$1(t, _isNativeReflectConstruct$1() ? Reflect.construct(o, e || [], _getPrototypeOf$1(t).constructor) : o.apply(t, e));
}
function _classCallCheck$1(a, n) {
  if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
}
function _construct$1(t, e, r) {
  if (_isNativeReflectConstruct$1()) return Reflect.construct.apply(null, arguments);
  var o = [null];
  o.push.apply(o, e);
  var p = new (t.bind.apply(t, o))();
  return r && _setPrototypeOf$1(p, r.prototype), p;
}
function _defineProperties$1(e, r) {
  for (var t = 0; t < r.length; t++) {
    var o = r[t];
    o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e, _toPropertyKey$1(o.key), o);
  }
}
function _createClass$1(e, r, t) {
  return r && _defineProperties$1(e.prototype, r), t && _defineProperties$1(e, t), Object.defineProperty(e, "prototype", {
    writable: false
  }), e;
}
function _defineProperty$1(e, r, t) {
  return (r = _toPropertyKey$1(r)) in e ? Object.defineProperty(e, r, {
    value: t,
    enumerable: true,
    configurable: true,
    writable: true
  }) : e[r] = t, e;
}
function _getPrototypeOf$1(t) {
  return _getPrototypeOf$1 = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(t2) {
    return t2.__proto__ || Object.getPrototypeOf(t2);
  }, _getPrototypeOf$1(t);
}
function _inherits$1(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$1(t, e);
}
function _isNativeFunction$1(t) {
  try {
    return -1 !== Function.toString.call(t).indexOf("[native code]");
  } catch (n) {
    return "function" == typeof t;
  }
}
function _isNativeReflectConstruct$1() {
  try {
    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
    }));
  } catch (t2) {
  }
  return (_isNativeReflectConstruct$1 = function() {
    return !!t;
  })();
}
function ownKeys$8(e, r) {
  var t = Object.keys(e);
  if (Object.getOwnPropertySymbols) {
    var o = Object.getOwnPropertySymbols(e);
    r && (o = o.filter(function(r2) {
      return Object.getOwnPropertyDescriptor(e, r2).enumerable;
    })), t.push.apply(t, o);
  }
  return t;
}
function _objectSpread2$1(e) {
  for (var r = 1; r < arguments.length; r++) {
    var t = null != arguments[r] ? arguments[r] : {};
    r % 2 ? ownKeys$8(Object(t), true).forEach(function(r2) {
      _defineProperty$1(e, r2, t[r2]);
    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$8(Object(t)).forEach(function(r2) {
      Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
    });
  }
  return e;
}
function _possibleConstructorReturn$1(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$1(t);
}
function _regeneratorRuntime$1() {
  _regeneratorRuntime$1 = function() {
    return e;
  };
  var t, e = {}, r = Object.prototype, n = r.hasOwnProperty, o = Object.defineProperty || function(t2, e2, r2) {
    t2[e2] = r2.value;
  }, i = "function" == typeof Symbol ? Symbol : {}, a = i.iterator || "@@iterator", c = i.asyncIterator || "@@asyncIterator", u = i.toStringTag || "@@toStringTag";
  function define(t2, e2, r2) {
    return Object.defineProperty(t2, e2, {
      value: r2,
      enumerable: true,
      configurable: true,
      writable: true
    }), t2[e2];
  }
  try {
    define({}, "");
  } catch (t2) {
    define = function(t3, e2, r2) {
      return t3[e2] = r2;
    };
  }
  function wrap3(t2, e2, r2, n2) {
    var i2 = e2 && e2.prototype instanceof Generator ? e2 : Generator, a2 = Object.create(i2.prototype), c2 = new Context(n2 || []);
    return o(a2, "_invoke", {
      value: makeInvokeMethod(t2, r2, c2)
    }), a2;
  }
  function tryCatch(t2, e2, r2) {
    try {
      return {
        type: "normal",
        arg: t2.call(e2, r2)
      };
    } catch (t3) {
      return {
        type: "throw",
        arg: t3
      };
    }
  }
  e.wrap = wrap3;
  var h = "suspendedStart", l = "suspendedYield", f = "executing", s = "completed", y = {};
  function Generator() {
  }
  function GeneratorFunction() {
  }
  function GeneratorFunctionPrototype() {
  }
  var p = {};
  define(p, a, function() {
    return this;
  });
  var d = Object.getPrototypeOf, v = d && d(d(values5([])));
  v && v !== r && n.call(v, a) && (p = v);
  var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
  function defineIteratorMethods(t2) {
    ["next", "throw", "return"].forEach(function(e2) {
      define(t2, e2, function(t3) {
        return this._invoke(e2, t3);
      });
    });
  }
  function AsyncIterator(t2, e2) {
    function invoke(r3, o2, i2, a2) {
      var c2 = tryCatch(t2[r3], t2, o2);
      if ("throw" !== c2.type) {
        var u2 = c2.arg, h2 = u2.value;
        return h2 && "object" == typeof h2 && n.call(h2, "__await") ? e2.resolve(h2.__await).then(function(t3) {
          invoke("next", t3, i2, a2);
        }, function(t3) {
          invoke("throw", t3, i2, a2);
        }) : e2.resolve(h2).then(function(t3) {
          u2.value = t3, i2(u2);
        }, function(t3) {
          return invoke("throw", t3, i2, a2);
        });
      }
      a2(c2.arg);
    }
    var r2;
    o(this, "_invoke", {
      value: function(t3, n2) {
        function callInvokeWithMethodAndArg() {
          return new e2(function(e3, r3) {
            invoke(t3, n2, e3, r3);
          });
        }
        return r2 = r2 ? r2.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
      }
    });
  }
  function makeInvokeMethod(e2, r2, n2) {
    var o2 = h;
    return function(i2, a2) {
      if (o2 === f) throw Error("Generator is already running");
      if (o2 === s) {
        if ("throw" === i2) throw a2;
        return {
          value: t,
          done: true
        };
      }
      for (n2.method = i2, n2.arg = a2; ; ) {
        var c2 = n2.delegate;
        if (c2) {
          var u2 = maybeInvokeDelegate(c2, n2);
          if (u2) {
            if (u2 === y) continue;
            return u2;
          }
        }
        if ("next" === n2.method) n2.sent = n2._sent = n2.arg;
        else if ("throw" === n2.method) {
          if (o2 === h) throw o2 = s, n2.arg;
          n2.dispatchException(n2.arg);
        } else "return" === n2.method && n2.abrupt("return", n2.arg);
        o2 = f;
        var p2 = tryCatch(e2, r2, n2);
        if ("normal" === p2.type) {
          if (o2 = n2.done ? s : l, p2.arg === y) continue;
          return {
            value: p2.arg,
            done: n2.done
          };
        }
        "throw" === p2.type && (o2 = s, n2.method = "throw", n2.arg = p2.arg);
      }
    };
  }
  function maybeInvokeDelegate(e2, r2) {
    var n2 = r2.method, o2 = e2.iterator[n2];
    if (o2 === t) return r2.delegate = null, "throw" === n2 && e2.iterator.return && (r2.method = "return", r2.arg = t, maybeInvokeDelegate(e2, r2), "throw" === r2.method) || "return" !== n2 && (r2.method = "throw", r2.arg = new TypeError("The iterator does not provide a '" + n2 + "' method")), y;
    var i2 = tryCatch(o2, e2.iterator, r2.arg);
    if ("throw" === i2.type) return r2.method = "throw", r2.arg = i2.arg, r2.delegate = null, y;
    var a2 = i2.arg;
    return a2 ? a2.done ? (r2[e2.resultName] = a2.value, r2.next = e2.nextLoc, "return" !== r2.method && (r2.method = "next", r2.arg = t), r2.delegate = null, y) : a2 : (r2.method = "throw", r2.arg = new TypeError("iterator result is not an object"), r2.delegate = null, y);
  }
  function pushTryEntry(t2) {
    var e2 = {
      tryLoc: t2[0]
    };
    1 in t2 && (e2.catchLoc = t2[1]), 2 in t2 && (e2.finallyLoc = t2[2], e2.afterLoc = t2[3]), this.tryEntries.push(e2);
  }
  function resetTryEntry(t2) {
    var e2 = t2.completion || {};
    e2.type = "normal", delete e2.arg, t2.completion = e2;
  }
  function Context(t2) {
    this.tryEntries = [{
      tryLoc: "root"
    }], t2.forEach(pushTryEntry, this), this.reset(true);
  }
  function values5(e2) {
    if (e2 || "" === e2) {
      var r2 = e2[a];
      if (r2) return r2.call(e2);
      if ("function" == typeof e2.next) return e2;
      if (!isNaN(e2.length)) {
        var o2 = -1, i2 = function next9() {
          for (; ++o2 < e2.length; ) if (n.call(e2, o2)) return next9.value = e2[o2], next9.done = false, next9;
          return next9.value = t, next9.done = true, next9;
        };
        return i2.next = i2;
      }
    }
    throw new TypeError(typeof e2 + " is not iterable");
  }
  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
    value: GeneratorFunctionPrototype,
    configurable: true
  }), o(GeneratorFunctionPrototype, "constructor", {
    value: GeneratorFunction,
    configurable: true
  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function(t2) {
    var e2 = "function" == typeof t2 && t2.constructor;
    return !!e2 && (e2 === GeneratorFunction || "GeneratorFunction" === (e2.displayName || e2.name));
  }, e.mark = function(t2) {
    return Object.setPrototypeOf ? Object.setPrototypeOf(t2, GeneratorFunctionPrototype) : (t2.__proto__ = GeneratorFunctionPrototype, define(t2, u, "GeneratorFunction")), t2.prototype = Object.create(g), t2;
  }, e.awrap = function(t2) {
    return {
      __await: t2
    };
  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function() {
    return this;
  }), e.AsyncIterator = AsyncIterator, e.async = function(t2, r2, n2, o2, i2) {
    void 0 === i2 && (i2 = Promise);
    var a2 = new AsyncIterator(wrap3(t2, r2, n2, o2), i2);
    return e.isGeneratorFunction(r2) ? a2 : a2.next().then(function(t3) {
      return t3.done ? t3.value : a2.next();
    });
  }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function() {
    return this;
  }), define(g, "toString", function() {
    return "[object Generator]";
  }), e.keys = function(t2) {
    var e2 = Object(t2), r2 = [];
    for (var n2 in e2) r2.push(n2);
    return r2.reverse(), function next9() {
      for (; r2.length; ) {
        var t3 = r2.pop();
        if (t3 in e2) return next9.value = t3, next9.done = false, next9;
      }
      return next9.done = true, next9;
    };
  }, e.values = values5, Context.prototype = {
    constructor: Context,
    reset: function(e2) {
      if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = false, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e2) for (var r2 in this) "t" === r2.charAt(0) && n.call(this, r2) && !isNaN(+r2.slice(1)) && (this[r2] = t);
    },
    stop: function() {
      this.done = true;
      var t2 = this.tryEntries[0].completion;
      if ("throw" === t2.type) throw t2.arg;
      return this.rval;
    },
    dispatchException: function(e2) {
      if (this.done) throw e2;
      var r2 = this;
      function handle(n2, o3) {
        return a2.type = "throw", a2.arg = e2, r2.next = n2, o3 && (r2.method = "next", r2.arg = t), !!o3;
      }
      for (var o2 = this.tryEntries.length - 1; o2 >= 0; --o2) {
        var i2 = this.tryEntries[o2], a2 = i2.completion;
        if ("root" === i2.tryLoc) return handle("end");
        if (i2.tryLoc <= this.prev) {
          var c2 = n.call(i2, "catchLoc"), u2 = n.call(i2, "finallyLoc");
          if (c2 && u2) {
            if (this.prev < i2.catchLoc) return handle(i2.catchLoc, true);
            if (this.prev < i2.finallyLoc) return handle(i2.finallyLoc);
          } else if (c2) {
            if (this.prev < i2.catchLoc) return handle(i2.catchLoc, true);
          } else {
            if (!u2) throw Error("try statement without catch or finally");
            if (this.prev < i2.finallyLoc) return handle(i2.finallyLoc);
          }
        }
      }
    },
    abrupt: function(t2, e2) {
      for (var r2 = this.tryEntries.length - 1; r2 >= 0; --r2) {
        var o2 = this.tryEntries[r2];
        if (o2.tryLoc <= this.prev && n.call(o2, "finallyLoc") && this.prev < o2.finallyLoc) {
          var i2 = o2;
          break;
        }
      }
      i2 && ("break" === t2 || "continue" === t2) && i2.tryLoc <= e2 && e2 <= i2.finallyLoc && (i2 = null);
      var a2 = i2 ? i2.completion : {};
      return a2.type = t2, a2.arg = e2, i2 ? (this.method = "next", this.next = i2.finallyLoc, y) : this.complete(a2);
    },
    complete: function(t2, e2) {
      if ("throw" === t2.type) throw t2.arg;
      return "break" === t2.type || "continue" === t2.type ? this.next = t2.arg : "return" === t2.type ? (this.rval = this.arg = t2.arg, this.method = "return", this.next = "end") : "normal" === t2.type && e2 && (this.next = e2), y;
    },
    finish: function(t2) {
      for (var e2 = this.tryEntries.length - 1; e2 >= 0; --e2) {
        var r2 = this.tryEntries[e2];
        if (r2.finallyLoc === t2) return this.complete(r2.completion, r2.afterLoc), resetTryEntry(r2), y;
      }
    },
    catch: function(t2) {
      for (var e2 = this.tryEntries.length - 1; e2 >= 0; --e2) {
        var r2 = this.tryEntries[e2];
        if (r2.tryLoc === t2) {
          var n2 = r2.completion;
          if ("throw" === n2.type) {
            var o2 = n2.arg;
            resetTryEntry(r2);
          }
          return o2;
        }
      }
      throw Error("illegal catch attempt");
    },
    delegateYield: function(e2, r2, n2) {
      return this.delegate = {
        iterator: values5(e2),
        resultName: r2,
        nextLoc: n2
      }, "next" === this.method && (this.arg = t), y;
    }
  }, e;
}
function _setPrototypeOf$1(t, e) {
  return _setPrototypeOf$1 = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t2, e2) {
    return t2.__proto__ = e2, t2;
  }, _setPrototypeOf$1(t, e);
}
function _toPrimitive$1(t, r) {
  if ("object" != typeof t || !t) return t;
  var e = t[Symbol.toPrimitive];
  if (void 0 !== e) {
    var i = e.call(t, r || "default");
    if ("object" != typeof i) return i;
    throw new TypeError("@@toPrimitive must return a primitive value.");
  }
  return ("string" === r ? String : Number)(t);
}
function _toPropertyKey$1(t) {
  var i = _toPrimitive$1(t, "string");
  return "symbol" == typeof i ? i : i + "";
}
function _typeof$1(o) {
  "@babel/helpers - typeof";
  return _typeof$1 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
    return typeof o2;
  } : function(o2) {
    return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
  }, _typeof$1(o);
}
function _wrapNativeSuper$1(t) {
  var r = "function" == typeof Map ? /* @__PURE__ */ new Map() : void 0;
  return _wrapNativeSuper$1 = function(t2) {
    if (null === t2 || !_isNativeFunction$1(t2)) return t2;
    if ("function" != typeof t2) throw new TypeError("Super expression must either be null or a function");
    if (void 0 !== r) {
      if (r.has(t2)) return r.get(t2);
      r.set(t2, Wrapper);
    }
    function Wrapper() {
      return _construct$1(t2, arguments, _getPrototypeOf$1(this).constructor);
    }
    return Wrapper.prototype = Object.create(t2.prototype, {
      constructor: {
        value: Wrapper,
        enumerable: false,
        writable: true,
        configurable: true
      }
    }), _setPrototypeOf$1(Wrapper, t2);
  }, _wrapNativeSuper$1(t);
}
var commonjsGlobal$1 = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
var check$1 = function check(it) {
  return it && it.Math === Math && it;
};
var globalThis_1$1 = (
  // eslint-disable-next-line es/no-global-this -- safe
  check$1((typeof globalThis === "undefined" ? "undefined" : _typeof$1(globalThis)) == "object" && globalThis) || check$1((typeof window === "undefined" ? "undefined" : _typeof$1(window)) == "object" && window) || // eslint-disable-next-line no-restricted-globals -- safe
  check$1((typeof self === "undefined" ? "undefined" : _typeof$1(self)) == "object" && self) || check$1(_typeof$1(commonjsGlobal$1) == "object" && commonjsGlobal$1) || check$1(_typeof$1(commonjsGlobal$1) == "object" && commonjsGlobal$1) || // eslint-disable-next-line no-new-func -- fallback
  /* @__PURE__ */ function() {
    return this;
  }() || Function("return this")()
);
var objectGetOwnPropertyDescriptor$1 = {};
var fails$2s = function fails(exec2) {
  try {
    return !!exec2();
  } catch (error3) {
    return true;
  }
};
var fails$2r = fails$2s;
var descriptors$1 = !fails$2r(function() {
  return Object.defineProperty({}, 1, {
    get: function get7() {
      return 7;
    }
  })[1] !== 7;
});
var fails$2q = fails$2s;
var functionBindNative$1 = !fails$2q(function() {
  var test2 = (function() {
  }).bind();
  return typeof test2 != "function" || test2.hasOwnProperty("prototype");
});
var NATIVE_BIND$9 = functionBindNative$1;
var call$1z = Function.prototype.call;
var functionCall$1 = NATIVE_BIND$9 ? call$1z.bind(call$1z) : function() {
  return call$1z.apply(call$1z, arguments);
};
var objectPropertyIsEnumerable$1 = {};
var $propertyIsEnumerable$5 = {}.propertyIsEnumerable;
var getOwnPropertyDescriptor$k = Object.getOwnPropertyDescriptor;
var NASHORN_BUG$1 = getOwnPropertyDescriptor$k && !$propertyIsEnumerable$5.call({
  1: 2
}, 1);
objectPropertyIsEnumerable$1.f = NASHORN_BUG$1 ? function propertyIsEnumerable(V) {
  var descriptor = getOwnPropertyDescriptor$k(this, V);
  return !!descriptor && descriptor.enumerable;
} : $propertyIsEnumerable$5;
var createPropertyDescriptor$k = function createPropertyDescriptor(bitmap, value) {
  return {
    enumerable: !(bitmap & 1),
    configurable: !(bitmap & 2),
    writable: !(bitmap & 4),
    value
  };
};
var NATIVE_BIND$8 = functionBindNative$1;
var FunctionPrototype$9 = Function.prototype;
var call$1y = FunctionPrototype$9.call;
var uncurryThisWithBind$1 = NATIVE_BIND$8 && FunctionPrototype$9.bind.bind(call$1y, call$1y);
var functionUncurryThis$1 = NATIVE_BIND$8 ? uncurryThisWithBind$1 : function(fn) {
  return function() {
    return call$1y.apply(fn, arguments);
  };
};
var uncurryThis$2v = functionUncurryThis$1;
var toString$_ = uncurryThis$2v({}.toString);
var stringSlice$x = uncurryThis$2v("".slice);
var classofRaw$4 = function classofRaw(it) {
  return stringSlice$x(toString$_(it), 8, -1);
};
var uncurryThis$2u = functionUncurryThis$1;
var fails$2p = fails$2s;
var classof$H = classofRaw$4;
var $Object$h = Object;
var split$9 = uncurryThis$2u("".split);
var indexedObject$1 = fails$2p(function() {
  return !$Object$h("z").propertyIsEnumerable(0);
}) ? function(it) {
  return classof$H(it) === "String" ? split$9(it, "") : $Object$h(it);
} : $Object$h;
var isNullOrUndefined$w = function isNullOrUndefined(it) {
  return it === null || it === void 0;
};
var isNullOrUndefined$v = isNullOrUndefined$w;
var $TypeError$X = TypeError;
var requireObjectCoercible$E = function requireObjectCoercible(it) {
  if (isNullOrUndefined$v(it)) throw new $TypeError$X("Can't call method on " + it);
  return it;
};
var IndexedObject$9 = indexedObject$1;
var requireObjectCoercible$D = requireObjectCoercible$E;
var toIndexedObject$u = function toIndexedObject(it) {
  return IndexedObject$9(requireObjectCoercible$D(it));
};
var documentAll$1 = (typeof document === "undefined" ? "undefined" : _typeof$1(document)) == "object" && document.all;
var isCallable$17 = typeof documentAll$1 == "undefined" && documentAll$1 !== void 0 ? function(argument) {
  return typeof argument == "function" || argument === documentAll$1;
} : function(argument) {
  return typeof argument == "function";
};
var isCallable$16 = isCallable$17;
var isObject$1c = function isObject(it) {
  return _typeof$1(it) == "object" ? it !== null : isCallable$16(it);
};
var globalThis$1O = globalThis_1$1;
var isCallable$15 = isCallable$17;
var aFunction$1 = function aFunction(argument) {
  return isCallable$15(argument) ? argument : void 0;
};
var getBuiltIn$K = function getBuiltIn(namespace, method) {
  return arguments.length < 2 ? aFunction$1(globalThis$1O[namespace]) : globalThis$1O[namespace] && globalThis$1O[namespace][method];
};
var uncurryThis$2t = functionUncurryThis$1;
var objectIsPrototypeOf$1 = uncurryThis$2t({}.isPrototypeOf);
var globalThis$1N = globalThis_1$1;
var navigator$1 = globalThis$1N.navigator;
var userAgent$h = navigator$1 && navigator$1.userAgent;
var environmentUserAgent$1 = userAgent$h ? String(userAgent$h) : "";
var globalThis$1M = globalThis_1$1;
var userAgent$g = environmentUserAgent$1;
var process$7 = globalThis$1M.process;
var Deno$2 = globalThis$1M.Deno;
var versions$1 = process$7 && process$7.versions || Deno$2 && Deno$2.version;
var v8$1 = versions$1 && versions$1.v8;
var match$1, version$1;
if (v8$1) {
  match$1 = v8$1.split(".");
  version$1 = match$1[0] > 0 && match$1[0] < 4 ? 1 : +(match$1[0] + match$1[1]);
}
if (!version$1 && userAgent$g) {
  match$1 = userAgent$g.match(/Edge\/(\d+)/);
  if (!match$1 || match$1[1] >= 74) {
    match$1 = userAgent$g.match(/Chrome\/(\d+)/);
    if (match$1) version$1 = +match$1[1];
  }
}
var environmentV8Version$1 = version$1;
var V8_VERSION$7 = environmentV8Version$1;
var fails$2o = fails$2s;
var globalThis$1L = globalThis_1$1;
var $String$f = globalThis$1L.String;
var symbolConstructorDetection$1 = !!Object.getOwnPropertySymbols && !fails$2o(function() {
  var symbol = Symbol("symbol detection");
  return !$String$f(symbol) || !(Object(symbol) instanceof Symbol) || // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
  !Symbol.sham && V8_VERSION$7 && V8_VERSION$7 < 41;
});
var NATIVE_SYMBOL$d = symbolConstructorDetection$1;
var useSymbolAsUid$1 = NATIVE_SYMBOL$d && !Symbol.sham && _typeof$1(Symbol.iterator) == "symbol";
var getBuiltIn$J = getBuiltIn$K;
var isCallable$14 = isCallable$17;
var isPrototypeOf$n = objectIsPrototypeOf$1;
var USE_SYMBOL_AS_UID$3 = useSymbolAsUid$1;
var $Object$g = Object;
var isSymbol$d = USE_SYMBOL_AS_UID$3 ? function(it) {
  return _typeof$1(it) == "symbol";
} : function(it) {
  var $Symbol2 = getBuiltIn$J("Symbol");
  return isCallable$14($Symbol2) && isPrototypeOf$n($Symbol2.prototype, $Object$g(it));
};
var $String$e = String;
var tryToString$e = function tryToString(argument) {
  try {
    return $String$e(argument);
  } catch (error3) {
    return "Object";
  }
};
var isCallable$13 = isCallable$17;
var tryToString$d = tryToString$e;
var $TypeError$W = TypeError;
var aCallable$U = function aCallable(argument) {
  if (isCallable$13(argument)) return argument;
  throw new $TypeError$W(tryToString$d(argument) + " is not a function");
};
var aCallable$T = aCallable$U;
var isNullOrUndefined$u = isNullOrUndefined$w;
var getMethod$m = function getMethod(V, P) {
  var func = V[P];
  return isNullOrUndefined$u(func) ? void 0 : aCallable$T(func);
};
var call$1x = functionCall$1;
var isCallable$12 = isCallable$17;
var isObject$1b = isObject$1c;
var $TypeError$V = TypeError;
var ordinaryToPrimitive$4 = function ordinaryToPrimitive(input, pref) {
  var fn, val;
  if (pref === "string" && isCallable$12(fn = input.toString) && !isObject$1b(val = call$1x(fn, input))) return val;
  if (isCallable$12(fn = input.valueOf) && !isObject$1b(val = call$1x(fn, input))) return val;
  if (pref !== "string" && isCallable$12(fn = input.toString) && !isObject$1b(val = call$1x(fn, input))) return val;
  throw new $TypeError$V("Can't convert object to primitive value");
};
var sharedStore$1 = { exports: {} };
var isPure$1 = false;
var globalThis$1K = globalThis_1$1;
var defineProperty$o = Object.defineProperty;
var defineGlobalProperty$6 = function defineGlobalProperty(key, value) {
  try {
    defineProperty$o(globalThis$1K, key, {
      value,
      configurable: true,
      writable: true
    });
  } catch (error3) {
    globalThis$1K[key] = value;
  }
  return value;
};
var globalThis$1J = globalThis_1$1;
var defineGlobalProperty$5 = defineGlobalProperty$6;
var SHARED$1 = "__core-js_shared__";
var store$b = sharedStore$1.exports = globalThis$1J[SHARED$1] || defineGlobalProperty$5(SHARED$1, {});
(store$b.versions || (store$b.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$1 = sharedStore$1.exports;
var store$a = sharedStoreExports$1;
var shared$g = function shared(key, value) {
  return store$a[key] || (store$a[key] = value || {});
};
var requireObjectCoercible$C = requireObjectCoercible$E;
var $Object$f = Object;
var toObject$U = function toObject(argument) {
  return $Object$f(requireObjectCoercible$C(argument));
};
var uncurryThis$2s = functionUncurryThis$1;
var toObject$T = toObject$U;
var hasOwnProperty$1 = uncurryThis$2s({}.hasOwnProperty);
var hasOwnProperty_1$1 = Object.hasOwn || function hasOwn(it, key) {
  return hasOwnProperty$1(toObject$T(it), key);
};
var uncurryThis$2r = functionUncurryThis$1;
var id$5 = 0;
var postfix$1 = Math.random();
var toString$Z = uncurryThis$2r(1 .toString);
var uid$a = function uid(key) {
  return "Symbol(" + (key === void 0 ? "" : key) + ")_" + toString$Z(++id$5 + postfix$1, 36);
};
var globalThis$1I = globalThis_1$1;
var shared$f = shared$g;
var hasOwn$S = hasOwnProperty_1$1;
var uid$9 = uid$a;
var NATIVE_SYMBOL$c = symbolConstructorDetection$1;
var USE_SYMBOL_AS_UID$2 = useSymbolAsUid$1;
var _Symbol$7 = globalThis$1I.Symbol;
var WellKnownSymbolsStore$3 = shared$f("wks");
var createWellKnownSymbol$1 = USE_SYMBOL_AS_UID$2 ? _Symbol$7["for"] || _Symbol$7 : _Symbol$7 && _Symbol$7.withoutSetter || uid$9;
var wellKnownSymbol$1c = function wellKnownSymbol(name) {
  if (!hasOwn$S(WellKnownSymbolsStore$3, name)) {
    WellKnownSymbolsStore$3[name] = NATIVE_SYMBOL$c && hasOwn$S(_Symbol$7, name) ? _Symbol$7[name] : createWellKnownSymbol$1("Symbol." + name);
  }
  return WellKnownSymbolsStore$3[name];
};
var call$1w = functionCall$1;
var isObject$1a = isObject$1c;
var isSymbol$c = isSymbol$d;
var getMethod$l = getMethod$m;
var ordinaryToPrimitive$3 = ordinaryToPrimitive$4;
var wellKnownSymbol$1b = wellKnownSymbol$1c;
var $TypeError$U = TypeError;
var TO_PRIMITIVE$3 = wellKnownSymbol$1b("toPrimitive");
var toPrimitive$8 = function toPrimitive(input, pref) {
  if (!isObject$1a(input) || isSymbol$c(input)) return input;
  var exoticToPrim = getMethod$l(input, TO_PRIMITIVE$3);
  var result;
  if (exoticToPrim) {
    if (pref === void 0) pref = "default";
    result = call$1w(exoticToPrim, input, pref);
    if (!isObject$1a(result) || isSymbol$c(result)) return result;
    throw new $TypeError$U("Can't convert object to primitive value");
  }
  if (pref === void 0) pref = "number";
  return ordinaryToPrimitive$3(input, pref);
};
var toPrimitive$7 = toPrimitive$8;
var isSymbol$b = isSymbol$d;
var toPropertyKey$e = function toPropertyKey(argument) {
  var key = toPrimitive$7(argument, "string");
  return isSymbol$b(key) ? key : key + "";
};
var globalThis$1H = globalThis_1$1;
var isObject$19 = isObject$1c;
var document$6 = globalThis$1H.document;
var EXISTS$3 = isObject$19(document$6) && isObject$19(document$6.createElement);
var documentCreateElement$4 = function documentCreateElement(it) {
  return EXISTS$3 ? document$6.createElement(it) : {};
};
var DESCRIPTORS$1l = descriptors$1;
var fails$2n = fails$2s;
var createElement$3 = documentCreateElement$4;
var ie8DomDefine$1 = !DESCRIPTORS$1l && !fails$2n(function() {
  return Object.defineProperty(createElement$3("div"), "a", {
    get: function get7() {
      return 7;
    }
  }).a !== 7;
});
var DESCRIPTORS$1k = descriptors$1;
var call$1v = functionCall$1;
var propertyIsEnumerableModule$5 = objectPropertyIsEnumerable$1;
var createPropertyDescriptor$j = createPropertyDescriptor$k;
var toIndexedObject$t = toIndexedObject$u;
var toPropertyKey$d = toPropertyKey$e;
var hasOwn$R = hasOwnProperty_1$1;
var IE8_DOM_DEFINE$3 = ie8DomDefine$1;
var $getOwnPropertyDescriptor$5 = Object.getOwnPropertyDescriptor;
objectGetOwnPropertyDescriptor$1.f = DESCRIPTORS$1k ? $getOwnPropertyDescriptor$5 : function getOwnPropertyDescriptor(O, P) {
  O = toIndexedObject$t(O);
  P = toPropertyKey$d(P);
  if (IE8_DOM_DEFINE$3) try {
    return $getOwnPropertyDescriptor$5(O, P);
  } catch (error3) {
  }
  if (hasOwn$R(O, P)) return createPropertyDescriptor$j(!call$1v(propertyIsEnumerableModule$5.f, O, P), O[P]);
};
var objectDefineProperty$1 = {};
var DESCRIPTORS$1j = descriptors$1;
var fails$2m = fails$2s;
var v8PrototypeDefineBug$1 = DESCRIPTORS$1j && fails$2m(function() {
  return Object.defineProperty(function() {
  }, "prototype", {
    value: 42,
    writable: false
  }).prototype !== 42;
});
var isObject$18 = isObject$1c;
var $String$d = String;
var $TypeError$T = TypeError;
var anObject$1y = function anObject(argument) {
  if (isObject$18(argument)) return argument;
  throw new $TypeError$T($String$d(argument) + " is not an object");
};
var DESCRIPTORS$1i = descriptors$1;
var IE8_DOM_DEFINE$2 = ie8DomDefine$1;
var V8_PROTOTYPE_DEFINE_BUG$3 = v8PrototypeDefineBug$1;
var anObject$1x = anObject$1y;
var toPropertyKey$c = toPropertyKey$e;
var $TypeError$S = TypeError;
var $defineProperty$3 = Object.defineProperty;
var $getOwnPropertyDescriptor$4 = Object.getOwnPropertyDescriptor;
var ENUMERABLE$1 = "enumerable";
var CONFIGURABLE$3 = "configurable";
var WRITABLE$1 = "writable";
objectDefineProperty$1.f = DESCRIPTORS$1i ? V8_PROTOTYPE_DEFINE_BUG$3 ? function defineProperty(O, P, Attributes) {
  anObject$1x(O);
  P = toPropertyKey$c(P);
  anObject$1x(Attributes);
  if (typeof O === "function" && P === "prototype" && "value" in Attributes && WRITABLE$1 in Attributes && !Attributes[WRITABLE$1]) {
    var current = $getOwnPropertyDescriptor$4(O, P);
    if (current && current[WRITABLE$1]) {
      O[P] = Attributes.value;
      Attributes = {
        configurable: CONFIGURABLE$3 in Attributes ? Attributes[CONFIGURABLE$3] : current[CONFIGURABLE$3],
        enumerable: ENUMERABLE$1 in Attributes ? Attributes[ENUMERABLE$1] : current[ENUMERABLE$1],
        writable: false
      };
    }
  }
  return $defineProperty$3(O, P, Attributes);
} : $defineProperty$3 : function defineProperty2(O, P, Attributes) {
  anObject$1x(O);
  P = toPropertyKey$c(P);
  anObject$1x(Attributes);
  if (IE8_DOM_DEFINE$2) try {
    return $defineProperty$3(O, P, Attributes);
  } catch (error3) {
  }
  if ("get" in Attributes || "set" in Attributes) throw new $TypeError$S("Accessors not supported");
  if ("value" in Attributes) O[P] = Attributes.value;
  return O;
};
var DESCRIPTORS$1h = descriptors$1;
var definePropertyModule$n = objectDefineProperty$1;
var createPropertyDescriptor$i = createPropertyDescriptor$k;
var createNonEnumerableProperty$r = DESCRIPTORS$1h ? function(object, key, value) {
  return definePropertyModule$n.f(object, key, createPropertyDescriptor$i(1, value));
} : function(object, key, value) {
  object[key] = value;
  return object;
};
var makeBuiltIn$9 = { exports: {} };
var DESCRIPTORS$1g = descriptors$1;
var hasOwn$Q = hasOwnProperty_1$1;
var FunctionPrototype$8 = Function.prototype;
var getDescriptor$1 = DESCRIPTORS$1g && Object.getOwnPropertyDescriptor;
var EXISTS$2 = hasOwn$Q(FunctionPrototype$8, "name");
var PROPER$1 = EXISTS$2 && (function something() {
}).name === "something";
var CONFIGURABLE$2 = EXISTS$2 && (!DESCRIPTORS$1g || DESCRIPTORS$1g && getDescriptor$1(FunctionPrototype$8, "name").configurable);
var functionName$1 = {
  EXISTS: EXISTS$2,
  PROPER: PROPER$1,
  CONFIGURABLE: CONFIGURABLE$2
};
var uncurryThis$2q = functionUncurryThis$1;
var isCallable$11 = isCallable$17;
var store$9 = sharedStoreExports$1;
var functionToString$3 = uncurryThis$2q(Function.toString);
if (!isCallable$11(store$9.inspectSource)) {
  store$9.inspectSource = function(it) {
    return functionToString$3(it);
  };
}
var inspectSource$7 = store$9.inspectSource;
var globalThis$1G = globalThis_1$1;
var isCallable$10 = isCallable$17;
var WeakMap$8 = globalThis$1G.WeakMap;
var weakMapBasicDetection$1 = isCallable$10(WeakMap$8) && /native code/.test(String(WeakMap$8));
var shared$e = shared$g;
var uid$8 = uid$a;
var keys$4 = shared$e("keys");
var sharedKey$8 = function sharedKey(key) {
  return keys$4[key] || (keys$4[key] = uid$8(key));
};
var hiddenKeys$d = {};
var NATIVE_WEAK_MAP$3 = weakMapBasicDetection$1;
var globalThis$1F = globalThis_1$1;
var isObject$17 = isObject$1c;
var createNonEnumerableProperty$q = createNonEnumerableProperty$r;
var hasOwn$P = hasOwnProperty_1$1;
var shared$d = sharedStoreExports$1;
var sharedKey$7 = sharedKey$8;
var hiddenKeys$c = hiddenKeys$d;
var OBJECT_ALREADY_INITIALIZED$1 = "Object already initialized";
var TypeError$e = globalThis$1F.TypeError;
var WeakMap$7 = globalThis$1F.WeakMap;
var set$i, get$8, has$m;
var enforce$1 = function enforce(it) {
  return has$m(it) ? get$8(it) : set$i(it, {});
};
var getterFor$2 = function getterFor(TYPE) {
  return function(it) {
    var state;
    if (!isObject$17(it) || (state = get$8(it)).type !== TYPE) {
      throw new TypeError$e("Incompatible receiver, " + TYPE + " required");
    }
    return state;
  };
};
if (NATIVE_WEAK_MAP$3 || shared$d.state) {
  var store$8 = shared$d.state || (shared$d.state = new WeakMap$7());
  store$8.get = store$8.get;
  store$8.has = store$8.has;
  store$8.set = store$8.set;
  set$i = function set7(it, metadata3) {
    if (store$8.has(it)) throw new TypeError$e(OBJECT_ALREADY_INITIALIZED$1);
    metadata3.facade = it;
    store$8.set(it, metadata3);
    return metadata3;
  };
  get$8 = function get7(it) {
    return store$8.get(it) || {};
  };
  has$m = function has6(it) {
    return store$8.has(it);
  };
} else {
  var STATE$1 = sharedKey$7("state");
  hiddenKeys$c[STATE$1] = true;
  set$i = function set7(it, metadata3) {
    if (hasOwn$P(it, STATE$1)) throw new TypeError$e(OBJECT_ALREADY_INITIALIZED$1);
    metadata3.facade = it;
    createNonEnumerableProperty$q(it, STATE$1, metadata3);
    return metadata3;
  };
  get$8 = function get7(it) {
    return hasOwn$P(it, STATE$1) ? it[STATE$1] : {};
  };
  has$m = function has6(it) {
    return hasOwn$P(it, STATE$1);
  };
}
var internalState$1 = {
  set: set$i,
  get: get$8,
  has: has$m,
  enforce: enforce$1,
  getterFor: getterFor$2
};
var uncurryThis$2p = functionUncurryThis$1;
var fails$2l = fails$2s;
var isCallable$$ = isCallable$17;
var hasOwn$O = hasOwnProperty_1$1;
var DESCRIPTORS$1f = descriptors$1;
var CONFIGURABLE_FUNCTION_NAME$5 = functionName$1.CONFIGURABLE;
var inspectSource$6 = inspectSource$7;
var InternalStateModule$v = internalState$1;
var enforceInternalState$9 = InternalStateModule$v.enforce;
var getInternalState$j = InternalStateModule$v.get;
var $String$c = String;
var defineProperty$n = Object.defineProperty;
var stringSlice$w = uncurryThis$2p("".slice);
var replace$n = uncurryThis$2p("".replace);
var join$e = uncurryThis$2p([].join);
var CONFIGURABLE_LENGTH$1 = DESCRIPTORS$1f && !fails$2l(function() {
  return defineProperty$n(function() {
  }, "length", {
    value: 8
  }).length !== 8;
});
var TEMPLATE$1 = String(String).split("String");
var makeBuiltIn$8 = makeBuiltIn$9.exports = function(value, name, options) {
  if (stringSlice$w($String$c(name), 0, 7) === "Symbol(") {
    name = "[" + replace$n($String$c(name), /^Symbol\(([^)]*)\).*$/, "$1") + "]";
  }
  if (options && options.getter) name = "get " + name;
  if (options && options.setter) name = "set " + name;
  if (!hasOwn$O(value, "name") || CONFIGURABLE_FUNCTION_NAME$5 && value.name !== name) {
    if (DESCRIPTORS$1f) defineProperty$n(value, "name", {
      value: name,
      configurable: true
    });
    else value.name = name;
  }
  if (CONFIGURABLE_LENGTH$1 && options && hasOwn$O(options, "arity") && value.length !== options.arity) {
    defineProperty$n(value, "length", {
      value: options.arity
    });
  }
  try {
    if (options && hasOwn$O(options, "constructor") && options.constructor) {
      if (DESCRIPTORS$1f) defineProperty$n(value, "prototype", {
        writable: false
      });
    } else if (value.prototype) value.prototype = void 0;
  } catch (error3) {
  }
  var state = enforceInternalState$9(value);
  if (!hasOwn$O(state, "source")) {
    state.source = join$e(TEMPLATE$1, typeof name == "string" ? name : "");
  }
  return value;
};
Function.prototype.toString = makeBuiltIn$8(function toString() {
  return isCallable$$(this) && getInternalState$j(this).source || inspectSource$6(this);
}, "toString");
var makeBuiltInExports$1 = makeBuiltIn$9.exports;
var isCallable$_ = isCallable$17;
var definePropertyModule$m = objectDefineProperty$1;
var makeBuiltIn$7 = makeBuiltInExports$1;
var defineGlobalProperty$4 = defineGlobalProperty$6;
var defineBuiltIn$G = function defineBuiltIn(O, key, value, options) {
  if (!options) options = {};
  var simple = options.enumerable;
  var name = options.name !== void 0 ? options.name : key;
  if (isCallable$_(value)) makeBuiltIn$7(value, name, options);
  if (options.global) {
    if (simple) O[key] = value;
    else defineGlobalProperty$4(key, value);
  } else {
    try {
      if (!options.unsafe) delete O[key];
      else if (O[key]) simple = true;
    } catch (error3) {
    }
    if (simple) O[key] = value;
    else definePropertyModule$m.f(O, key, {
      value,
      enumerable: false,
      configurable: !options.nonConfigurable,
      writable: !options.nonWritable
    });
  }
  return O;
};
var objectGetOwnPropertyNames$1 = {};
var ceil$3 = Math.ceil;
var floor$j = Math.floor;
var mathTrunc$1 = Math.trunc || function trunc(x) {
  var n = +x;
  return (n > 0 ? floor$j : ceil$3)(n);
};
var trunc$2 = mathTrunc$1;
var toIntegerOrInfinity$u = function toIntegerOrInfinity(argument) {
  var number = +argument;
  return number !== number || number === 0 ? 0 : trunc$2(number);
};
var toIntegerOrInfinity$t = toIntegerOrInfinity$u;
var max$d = Math.max;
var min$j = Math.min;
var toAbsoluteIndex$g = function toAbsoluteIndex(index2, length) {
  var integer = toIntegerOrInfinity$t(index2);
  return integer < 0 ? max$d(integer + length, 0) : min$j(integer, length);
};
var toIntegerOrInfinity$s = toIntegerOrInfinity$u;
var min$i = Math.min;
var toLength$q = function toLength(argument) {
  var len = toIntegerOrInfinity$s(argument);
  return len > 0 ? min$i(len, 9007199254740991) : 0;
};
var toLength$p = toLength$q;
var lengthOfArrayLike$I = function lengthOfArrayLike(obj) {
  return toLength$p(obj.length);
};
var toIndexedObject$s = toIndexedObject$u;
var toAbsoluteIndex$f = toAbsoluteIndex$g;
var lengthOfArrayLike$H = lengthOfArrayLike$I;
var createMethod$c = function createMethod(IS_INCLUDES) {
  return function($this, el, fromIndex) {
    var O = toIndexedObject$s($this);
    var length = lengthOfArrayLike$H(O);
    if (length === 0) return !IS_INCLUDES && -1;
    var index2 = toAbsoluteIndex$f(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$1 = {
  // `Array.prototype.includes` method
  // https://tc39.es/ecma262/#sec-array.prototype.includes
  includes: createMethod$c(true),
  // `Array.prototype.indexOf` method
  // https://tc39.es/ecma262/#sec-array.prototype.indexof
  indexOf: createMethod$c(false)
};
var uncurryThis$2o = functionUncurryThis$1;
var hasOwn$N = hasOwnProperty_1$1;
var toIndexedObject$r = toIndexedObject$u;
var indexOf$4 = arrayIncludes$1.indexOf;
var hiddenKeys$b = hiddenKeys$d;
var push$z = uncurryThis$2o([].push);
var objectKeysInternal$1 = function objectKeysInternal(object, names) {
  var O = toIndexedObject$r(object);
  var i = 0;
  var result = [];
  var key;
  for (key in O) !hasOwn$N(hiddenKeys$b, key) && hasOwn$N(O, key) && push$z(result, key);
  while (names.length > i) if (hasOwn$N(O, key = names[i++])) {
    ~indexOf$4(result, key) || push$z(result, key);
  }
  return result;
};
var enumBugKeys$7 = ["constructor", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toLocaleString", "toString", "valueOf"];
var internalObjectKeys$3 = objectKeysInternal$1;
var enumBugKeys$6 = enumBugKeys$7;
var hiddenKeys$a = enumBugKeys$6.concat("length", "prototype");
objectGetOwnPropertyNames$1.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
  return internalObjectKeys$3(O, hiddenKeys$a);
};
var objectGetOwnPropertySymbols$1 = {};
objectGetOwnPropertySymbols$1.f = Object.getOwnPropertySymbols;
var getBuiltIn$I = getBuiltIn$K;
var uncurryThis$2n = functionUncurryThis$1;
var getOwnPropertyNamesModule$5 = objectGetOwnPropertyNames$1;
var getOwnPropertySymbolsModule$7 = objectGetOwnPropertySymbols$1;
var anObject$1w = anObject$1y;
var concat$8 = uncurryThis$2n([].concat);
var ownKeys$7 = getBuiltIn$I("Reflect", "ownKeys") || function ownKeys(it) {
  var keys7 = getOwnPropertyNamesModule$5.f(anObject$1w(it));
  var getOwnPropertySymbols3 = getOwnPropertySymbolsModule$7.f;
  return getOwnPropertySymbols3 ? concat$8(keys7, getOwnPropertySymbols3(it)) : keys7;
};
var hasOwn$M = hasOwnProperty_1$1;
var ownKeys$6 = ownKeys$7;
var getOwnPropertyDescriptorModule$d = objectGetOwnPropertyDescriptor$1;
var definePropertyModule$l = objectDefineProperty$1;
var copyConstructorProperties$a = function copyConstructorProperties(target, source, exceptions) {
  var keys7 = ownKeys$6(source);
  var defineProperty8 = definePropertyModule$l.f;
  var getOwnPropertyDescriptor8 = getOwnPropertyDescriptorModule$d.f;
  for (var i = 0; i < keys7.length; i++) {
    var key = keys7[i];
    if (!hasOwn$M(target, key) && !(exceptions && hasOwn$M(exceptions, key))) {
      defineProperty8(target, key, getOwnPropertyDescriptor8(source, key));
    }
  }
};
var fails$2k = fails$2s;
var isCallable$Z = isCallable$17;
var replacement$1 = /#|\.prototype\./;
var isForced$a = function isForced(feature, detection) {
  var value = data$1[normalize$1(feature)];
  return value === POLYFILL$1 ? true : value === NATIVE$1 ? false : isCallable$Z(detection) ? fails$2k(detection) : !!detection;
};
var normalize$1 = isForced$a.normalize = function(string) {
  return String(string).replace(replacement$1, ".").toLowerCase();
};
var data$1 = isForced$a.data = {};
var NATIVE$1 = isForced$a.NATIVE = "N";
var POLYFILL$1 = isForced$a.POLYFILL = "P";
var isForced_1$1 = isForced$a;
var globalThis$1E = globalThis_1$1;
var getOwnPropertyDescriptor$j = objectGetOwnPropertyDescriptor$1.f;
var createNonEnumerableProperty$p = createNonEnumerableProperty$r;
var defineBuiltIn$F = defineBuiltIn$G;
var defineGlobalProperty2 = defineGlobalProperty$6;
var copyConstructorProperties$9 = copyConstructorProperties$a;
var isForced$9 = isForced_1$1;
var _export$1 = function _export(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$1E;
  } else if (STATIC) {
    target = globalThis$1E[TARGET] || defineGlobalProperty2(TARGET, {});
  } else {
    target = globalThis$1E[TARGET] && globalThis$1E[TARGET].prototype;
  }
  if (target) for (key in source) {
    sourceProperty = source[key];
    if (options.dontCallGetSet) {
      descriptor = getOwnPropertyDescriptor$j(target, key);
      targetProperty = descriptor && descriptor.value;
    } else targetProperty = target[key];
    FORCED2 = isForced$9(GLOBAL ? key : TARGET + (STATIC ? "." : "#") + key, options.forced);
    if (!FORCED2 && targetProperty !== void 0) {
      if (_typeof$1(sourceProperty) == _typeof$1(targetProperty)) continue;
      copyConstructorProperties$9(sourceProperty, targetProperty);
    }
    if (options.sham || targetProperty && targetProperty.sham) {
      createNonEnumerableProperty$p(sourceProperty, "sham", true);
    }
    defineBuiltIn$F(target, key, sourceProperty, options);
  }
};
var wellKnownSymbol$1a = wellKnownSymbol$1c;
var TO_STRING_TAG$9 = wellKnownSymbol$1a("toStringTag");
var test$5 = {};
test$5[TO_STRING_TAG$9] = "z";
var toStringTagSupport$1 = String(test$5) === "[object z]";
var TO_STRING_TAG_SUPPORT$5 = toStringTagSupport$1;
var isCallable$Y = isCallable$17;
var classofRaw$3 = classofRaw$4;
var wellKnownSymbol$19 = wellKnownSymbol$1c;
var TO_STRING_TAG$8 = wellKnownSymbol$19("toStringTag");
var $Object$e = Object;
var CORRECT_ARGUMENTS$1 = classofRaw$3(/* @__PURE__ */ function() {
  return arguments;
}()) === "Arguments";
var tryGet$1 = function tryGet(it, key) {
  try {
    return it[key];
  } catch (error3) {
  }
};
var classof$G = TO_STRING_TAG_SUPPORT$5 ? classofRaw$3 : function(it) {
  var O, tag, result;
  return it === void 0 ? "Undefined" : it === null ? "Null" : typeof (tag = tryGet$1(O = $Object$e(it), TO_STRING_TAG$8)) == "string" ? tag : CORRECT_ARGUMENTS$1 ? classofRaw$3(O) : (result = classofRaw$3(O)) === "Object" && isCallable$Y(O.callee) ? "Arguments" : result;
};
var classof$F = classof$G;
var $String$b = String;
var toString$Y = function toString2(argument) {
  if (classof$F(argument) === "Symbol") throw new TypeError("Cannot convert a Symbol value to a string");
  return $String$b(argument);
};
var objectDefineProperties$1 = {};
var internalObjectKeys$2 = objectKeysInternal$1;
var enumBugKeys$5 = enumBugKeys$7;
var objectKeys$9 = Object.keys || function keys(O) {
  return internalObjectKeys$2(O, enumBugKeys$5);
};
var DESCRIPTORS$1e = descriptors$1;
var V8_PROTOTYPE_DEFINE_BUG$2 = v8PrototypeDefineBug$1;
var definePropertyModule$k = objectDefineProperty$1;
var anObject$1v = anObject$1y;
var toIndexedObject$q = toIndexedObject$u;
var objectKeys$8 = objectKeys$9;
objectDefineProperties$1.f = DESCRIPTORS$1e && !V8_PROTOTYPE_DEFINE_BUG$2 ? Object.defineProperties : function defineProperties(O, Properties) {
  anObject$1v(O);
  var props = toIndexedObject$q(Properties);
  var keys7 = objectKeys$8(Properties);
  var length = keys7.length;
  var index2 = 0;
  var key;
  while (length > index2) definePropertyModule$k.f(O, key = keys7[index2++], props[key]);
  return O;
};
var getBuiltIn$H = getBuiltIn$K;
var html$5 = getBuiltIn$H("document", "documentElement");
var anObject$1u = anObject$1y;
var definePropertiesModule$3 = objectDefineProperties$1;
var enumBugKeys$4 = enumBugKeys$7;
var hiddenKeys$9 = hiddenKeys$d;
var html$4 = html$5;
var documentCreateElement$3 = documentCreateElement$4;
var sharedKey$6 = sharedKey$8;
var GT$1 = ">";
var LT$1 = "<";
var PROTOTYPE$5 = "prototype";
var SCRIPT$1 = "script";
var IE_PROTO$3 = sharedKey$6("IE_PROTO");
var EmptyConstructor$1 = function EmptyConstructor() {
};
var scriptTag$1 = function scriptTag(content) {
  return LT$1 + SCRIPT$1 + GT$1 + content + LT$1 + "/" + SCRIPT$1 + GT$1;
};
var NullProtoObjectViaActiveX$1 = function NullProtoObjectViaActiveX(activeXDocument2) {
  activeXDocument2.write(scriptTag$1(""));
  activeXDocument2.close();
  var temp = activeXDocument2.parentWindow.Object;
  activeXDocument2 = null;
  return temp;
};
var NullProtoObjectViaIFrame$1 = function NullProtoObjectViaIFrame() {
  var iframe = documentCreateElement$3("iframe");
  var JS = "java" + SCRIPT$1 + ":";
  var iframeDocument;
  iframe.style.display = "none";
  html$4.appendChild(iframe);
  iframe.src = String(JS);
  iframeDocument = iframe.contentWindow.document;
  iframeDocument.open();
  iframeDocument.write(scriptTag$1("document.F=Object"));
  iframeDocument.close();
  return iframeDocument.F;
};
var activeXDocument$1;
var _NullProtoObject$1 = function NullProtoObject() {
  try {
    activeXDocument$1 = new ActiveXObject("htmlfile");
  } catch (error3) {
  }
  _NullProtoObject$1 = typeof document != "undefined" ? document.domain && activeXDocument$1 ? NullProtoObjectViaActiveX$1(activeXDocument$1) : NullProtoObjectViaIFrame$1() : NullProtoObjectViaActiveX$1(activeXDocument$1);
  var length = enumBugKeys$4.length;
  while (length--) delete _NullProtoObject$1[PROTOTYPE$5][enumBugKeys$4[length]];
  return _NullProtoObject$1();
};
hiddenKeys$9[IE_PROTO$3] = true;
var objectCreate$1 = Object.create || function create(O, Properties) {
  var result;
  if (O !== null) {
    EmptyConstructor$1[PROTOTYPE$5] = anObject$1u(O);
    result = new EmptyConstructor$1();
    EmptyConstructor$1[PROTOTYPE$5] = null;
    result[IE_PROTO$3] = O;
  } else result = _NullProtoObject$1();
  return Properties === void 0 ? result : definePropertiesModule$3.f(result, Properties);
};
var