@minto-ai/microsoft-lat/dist/index.js

微软LAT 语音转文本

function _arrayLikeToArray$1(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 _arrayWithHoles(r) {
  if (Array.isArray(r)) return r;
}
function _arrayWithoutHoles$1(r) {
  if (Array.isArray(r)) return _arrayLikeToArray$1(r);
}
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(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(n) {
  return function() {
    var t = this, e = arguments;
    return new Promise(function(r, o) {
      var a = n.apply(t, e);
      function _next(n2) {
        asyncGeneratorStep(a, r, o, _next, _throw, "next", n2);
      }
      function _throw(n2) {
        asyncGeneratorStep(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(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 _createForOfIteratorHelper$1(r, e) {
  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
  if (!t) {
    if (Array.isArray(r) || (t = _unsupportedIterableToArray$1(r)) || e) {
      t && (r = t);
      var n = 0, F = function() {
      };
      return {
        s: F,
        n: function() {
          return n >= r.length ? {
            done: true
          } : {
            done: false,
            value: r[n++]
          };
        },
        e: function(r2) {
          throw r2;
        },
        f: F
      };
    }
    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
  }
  var o, a = true, u = false;
  return {
    s: function() {
      t = t.call(r);
    },
    n: function() {
      var r2 = t.next();
      return a = r2.done, r2;
    },
    e: function(r2) {
      u = true, o = r2;
    },
    f: function() {
      try {
        a || null == t.return || t.return();
      } finally {
        if (u) throw o;
      }
    }
  };
}
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 _get() {
  return _get = "undefined" != typeof Reflect && Reflect.get ? Reflect.get.bind() : function(e, t, r) {
    var p = _superPropBase(e, t);
    if (p) {
      var n = Object.getOwnPropertyDescriptor(p, t);
      return n.get ? n.get.call(arguments.length < 3 ? e : r) : n.value;
    }
  }, _get.apply(null, arguments);
}
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(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 _iterableToArray$1(r) {
  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
}
function _iterableToArrayLimit(r, l) {
  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
  if (null != t) {
    var e, n, i, u, a = [], f2 = true, o = false;
    try {
      if (i = (t = t.call(r)).next, 0 === l) ;
      else for (; !(f2 = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f2 = true) ;
    } catch (r2) {
      o = true, n = r2;
    } finally {
      try {
        if (!f2 && null != t.return && (u = t.return(), Object(u) !== u)) return;
      } finally {
        if (o) throw n;
      }
    }
    return a;
  }
}
function _nonIterableRest() {
  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _nonIterableSpread$1() {
  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$7(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(e) {
  for (var r = 1; r < arguments.length; r++) {
    var t = null != arguments[r] ? arguments[r] : {};
    r % 2 ? ownKeys$7(Object(t), true).forEach(function(r2) {
      _defineProperty$1(e, r2, t[r2]);
    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$7(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() {
  _regeneratorRuntime = function() {
    return r;
  };
  var t, r = {}, e = Object.prototype, n = e.hasOwnProperty, o = "function" == typeof Symbol ? Symbol : {}, i = o.iterator || "@@iterator", a = o.asyncIterator || "@@asyncIterator", u = o.toStringTag || "@@toStringTag";
  function c(t2, r2, e2, n2) {
    return Object.defineProperty(t2, r2, {
      value: e2,
      enumerable: !n2,
      configurable: !n2,
      writable: !n2
    });
  }
  try {
    c({}, "");
  } catch (t2) {
    c = function(t3, r2, e2) {
      return t3[r2] = e2;
    };
  }
  function h(r2, e2, n2, o2) {
    var i2 = e2 && e2.prototype instanceof Generator ? e2 : Generator, a2 = Object.create(i2.prototype);
    return c(a2, "_invoke", /* @__PURE__ */ function(r3, e3, n3) {
      var o3 = 1;
      return function(i3, a3) {
        if (3 === o3) throw Error("Generator is already running");
        if (4 === o3) {
          if ("throw" === i3) throw a3;
          return {
            value: t,
            done: true
          };
        }
        for (n3.method = i3, n3.arg = a3; ; ) {
          var u2 = n3.delegate;
          if (u2) {
            var c2 = d(u2, n3);
            if (c2) {
              if (c2 === f2) continue;
              return c2;
            }
          }
          if ("next" === n3.method) n3.sent = n3._sent = n3.arg;
          else if ("throw" === n3.method) {
            if (1 === o3) throw o3 = 4, n3.arg;
            n3.dispatchException(n3.arg);
          } else "return" === n3.method && n3.abrupt("return", n3.arg);
          o3 = 3;
          var h2 = s(r3, e3, n3);
          if ("normal" === h2.type) {
            if (o3 = n3.done ? 4 : 2, h2.arg === f2) continue;
            return {
              value: h2.arg,
              done: n3.done
            };
          }
          "throw" === h2.type && (o3 = 4, n3.method = "throw", n3.arg = h2.arg);
        }
      };
    }(r2, n2, new Context(o2 || [])), true), a2;
  }
  function s(t2, r2, e2) {
    try {
      return {
        type: "normal",
        arg: t2.call(r2, e2)
      };
    } catch (t3) {
      return {
        type: "throw",
        arg: t3
      };
    }
  }
  r.wrap = h;
  var f2 = {};
  function Generator() {
  }
  function GeneratorFunction() {
  }
  function GeneratorFunctionPrototype() {
  }
  var l = {};
  c(l, i, function() {
    return this;
  });
  var p = Object.getPrototypeOf, y = p && p(p(x([])));
  y && y !== e && n.call(y, i) && (l = y);
  var v = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(l);
  function g(t2) {
    ["next", "throw", "return"].forEach(function(r2) {
      c(t2, r2, function(t3) {
        return this._invoke(r2, t3);
      });
    });
  }
  function AsyncIterator(t2, r2) {
    function e2(o3, i2, a2, u2) {
      var c2 = s(t2[o3], t2, i2);
      if ("throw" !== c2.type) {
        var h2 = c2.arg, f3 = h2.value;
        return f3 && "object" == typeof f3 && n.call(f3, "__await") ? r2.resolve(f3.__await).then(function(t3) {
          e2("next", t3, a2, u2);
        }, function(t3) {
          e2("throw", t3, a2, u2);
        }) : r2.resolve(f3).then(function(t3) {
          h2.value = t3, a2(h2);
        }, function(t3) {
          return e2("throw", t3, a2, u2);
        });
      }
      u2(c2.arg);
    }
    var o2;
    c(this, "_invoke", function(t3, n2) {
      function i2() {
        return new r2(function(r3, o3) {
          e2(t3, n2, r3, o3);
        });
      }
      return o2 = o2 ? o2.then(i2, i2) : i2();
    }, true);
  }
  function d(r2, e2) {
    var n2 = e2.method, o2 = r2.i[n2];
    if (o2 === t) return e2.delegate = null, "throw" === n2 && r2.i.return && (e2.method = "return", e2.arg = t, d(r2, e2), "throw" === e2.method) || "return" !== n2 && (e2.method = "throw", e2.arg = new TypeError("The iterator does not provide a '" + n2 + "' method")), f2;
    var i2 = s(o2, r2.i, e2.arg);
    if ("throw" === i2.type) return e2.method = "throw", e2.arg = i2.arg, e2.delegate = null, f2;
    var a2 = i2.arg;
    return a2 ? a2.done ? (e2[r2.r] = a2.value, e2.next = r2.n, "return" !== e2.method && (e2.method = "next", e2.arg = t), e2.delegate = null, f2) : a2 : (e2.method = "throw", e2.arg = new TypeError("iterator result is not an object"), e2.delegate = null, f2);
  }
  function w(t2) {
    this.tryEntries.push(t2);
  }
  function m(r2) {
    var e2 = r2[4] || {};
    e2.type = "normal", e2.arg = t, r2[4] = e2;
  }
  function Context(t2) {
    this.tryEntries = [[-1]], t2.forEach(w, this), this.reset(true);
  }
  function x(r2) {
    if (null != r2) {
      var e2 = r2[i];
      if (e2) return e2.call(r2);
      if ("function" == typeof r2.next) return r2;
      if (!isNaN(r2.length)) {
        var o2 = -1, a2 = function e3() {
          for (; ++o2 < r2.length; ) if (n.call(r2, o2)) return e3.value = r2[o2], e3.done = false, e3;
          return e3.value = t, e3.done = true, e3;
        };
        return a2.next = a2;
      }
    }
    throw new TypeError(typeof r2 + " is not iterable");
  }
  return GeneratorFunction.prototype = GeneratorFunctionPrototype, c(v, "constructor", GeneratorFunctionPrototype), c(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = c(GeneratorFunctionPrototype, u, "GeneratorFunction"), r.isGeneratorFunction = function(t2) {
    var r2 = "function" == typeof t2 && t2.constructor;
    return !!r2 && (r2 === GeneratorFunction || "GeneratorFunction" === (r2.displayName || r2.name));
  }, r.mark = function(t2) {
    return Object.setPrototypeOf ? Object.setPrototypeOf(t2, GeneratorFunctionPrototype) : (t2.__proto__ = GeneratorFunctionPrototype, c(t2, u, "GeneratorFunction")), t2.prototype = Object.create(v), t2;
  }, r.awrap = function(t2) {
    return {
      __await: t2
    };
  }, g(AsyncIterator.prototype), c(AsyncIterator.prototype, a, function() {
    return this;
  }), r.AsyncIterator = AsyncIterator, r.async = function(t2, e2, n2, o2, i2) {
    void 0 === i2 && (i2 = Promise);
    var a2 = new AsyncIterator(h(t2, e2, n2, o2), i2);
    return r.isGeneratorFunction(e2) ? a2 : a2.next().then(function(t3) {
      return t3.done ? t3.value : a2.next();
    });
  }, g(v), c(v, u, "Generator"), c(v, i, function() {
    return this;
  }), c(v, "toString", function() {
    return "[object Generator]";
  }), r.keys = function(t2) {
    var r2 = Object(t2), e2 = [];
    for (var n2 in r2) e2.unshift(n2);
    return function t3() {
      for (; e2.length; ) if ((n2 = e2.pop()) in r2) return t3.value = n2, t3.done = false, t3;
      return t3.done = true, t3;
    };
  }, r.values = x, Context.prototype = {
    constructor: Context,
    reset: function(r2) {
      if (this.prev = this.next = 0, this.sent = this._sent = t, this.done = false, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(m), !r2) for (var e2 in this) "t" === e2.charAt(0) && n.call(this, e2) && !isNaN(+e2.slice(1)) && (this[e2] = t);
    },
    stop: function() {
      this.done = true;
      var t2 = this.tryEntries[0][4];
      if ("throw" === t2.type) throw t2.arg;
      return this.rval;
    },
    dispatchException: function(r2) {
      if (this.done) throw r2;
      var e2 = this;
      function n2(t2) {
        a2.type = "throw", a2.arg = r2, e2.next = t2;
      }
      for (var o2 = e2.tryEntries.length - 1; o2 >= 0; --o2) {
        var i2 = this.tryEntries[o2], a2 = i2[4], u2 = this.prev, c2 = i2[1], h2 = i2[2];
        if (-1 === i2[0]) return n2("end"), false;
        if (!c2 && !h2) throw Error("try statement without catch or finally");
        if (null != i2[0] && i2[0] <= u2) {
          if (u2 < c2) return this.method = "next", this.arg = t, n2(c2), true;
          if (u2 < h2) return n2(h2), false;
        }
      }
    },
    abrupt: function(t2, r2) {
      for (var e2 = this.tryEntries.length - 1; e2 >= 0; --e2) {
        var n2 = this.tryEntries[e2];
        if (n2[0] > -1 && n2[0] <= this.prev && this.prev < n2[2]) {
          var o2 = n2;
          break;
        }
      }
      o2 && ("break" === t2 || "continue" === t2) && o2[0] <= r2 && r2 <= o2[2] && (o2 = null);
      var i2 = o2 ? o2[4] : {};
      return i2.type = t2, i2.arg = r2, o2 ? (this.method = "next", this.next = o2[2], f2) : this.complete(i2);
    },
    complete: function(t2, r2) {
      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 && r2 && (this.next = r2), f2;
    },
    finish: function(t2) {
      for (var r2 = this.tryEntries.length - 1; r2 >= 0; --r2) {
        var e2 = this.tryEntries[r2];
        if (e2[2] === t2) return this.complete(e2[4], e2[3]), m(e2), f2;
      }
    },
    catch: function(t2) {
      for (var r2 = this.tryEntries.length - 1; r2 >= 0; --r2) {
        var e2 = this.tryEntries[r2];
        if (e2[0] === t2) {
          var n2 = e2[4];
          if ("throw" === n2.type) {
            var o2 = n2.arg;
            m(e2);
          }
          return o2;
        }
      }
      throw Error("illegal catch attempt");
    },
    delegateYield: function(r2, e2, n2) {
      return this.delegate = {
        i: x(r2),
        r: e2,
        n: n2
      }, "next" === this.method && (this.arg = t), f2;
    }
  }, r;
}
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 _slicedToArray(r, e) {
  return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray$1(r, e) || _nonIterableRest();
}
function _superPropBase(t, o) {
  for (; !{}.hasOwnProperty.call(t, o) && null !== (t = _getPrototypeOf$1(t)); ) ;
  return t;
}
function _superPropGet(t, o, e, r) {
  var p = _get(_getPrototypeOf$1(t.prototype), o, e);
  return "function" == typeof p ? function(t2) {
    return p.apply(e, t2);
  } : p;
}
function _toConsumableArray$1(r) {
  return _arrayWithoutHoles$1(r) || _iterableToArray$1(r) || _unsupportedIterableToArray$1(r) || _nonIterableSpread$1();
}
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);
    if ("object" != typeof i) return i;
    throw new TypeError("@@toPrimitive must return a primitive value.");
  }
  return String(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 _unsupportedIterableToArray$1(r, a) {
  if (r) {
    if ("string" == typeof r) return _arrayLikeToArray$1(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$1(r, a) : void 0;
  }
}
function _wrapNativeSuper(t) {
  var r = "function" == typeof Map ? /* @__PURE__ */ new Map() : void 0;
  return _wrapNativeSuper = function(t2) {
    if (null === t2 || !_isNativeFunction(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(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(t);
}
var commonjsGlobal$1 = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
function getAugmentedNamespace(n) {
  if (n.__esModule) return n;
  var f2 = n.default;
  if (typeof f2 == "function") {
    var a = function a2() {
      if (this instanceof a2) {
        return Reflect.construct(f2, arguments, this.constructor);
      }
      return f2.apply(this, arguments);
    };
    a.prototype = f2.prototype;
  } else a = {};
  Object.defineProperty(a, "__esModule", { value: true });
  Object.keys(n).forEach(function(k) {
    var d = Object.getOwnPropertyDescriptor(n, k);
    Object.defineProperty(a, k, d.get ? d : {
      enumerable: true,
      get: function() {
        return n[k];
      }
    });
  });
  return a;
}
var $$5x = _export$1;
var globalThis$1J = globalThis_1$1;
$$5x({
  global: true,
  forced: globalThis$1J.globalThis !== globalThis$1J
}, {
  globalThis: globalThis$1J
});
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 fails$2o = function fails(exec2) {
  try {
    return !!exec2();
  } catch (error2) {
    return true;
  }
};
var $$5w = _export$1;
var isArray$j = isArray$f;
$$5w({
  target: "Array",
  stat: true
}, {
  isArray: isArray$j
});
var sharedStore$1 = { exports: {} };
var isPure$1 = false;
var fails$2n = fails$2o;
var descriptors$1 = !fails$2n(function() {
  return Object.defineProperty({}, 1, {
    get: function get7() {
      return 7;
    }
  })[1] !== 7;
});
var objectDefineProperty$1 = {};
var documentAll$1 = (typeof document === "undefined" ? "undefined" : _typeof$1(document)) == "object" && document.all;
var isCallable$12 = 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$11 = isCallable$12;
var isObject$1k = function isObject(it) {
  return _typeof$1(it) == "object" ? it !== null : isCallable$11(it);
};
var globalThis$1I = globalThis_1$1;
var isObject$1j = isObject$1k;
var document$6 = globalThis$1I.document;
var EXISTS$3 = isObject$1j(document$6) && isObject$1j(document$6.createElement);
var documentCreateElement$4 = function documentCreateElement(it) {
  return EXISTS$3 ? document$6.createElement(it) : {};
};
var DESCRIPTORS$1c = descriptors$1;
var fails$2m = fails$2o;
var createElement$3 = documentCreateElement$4;
var ie8DomDefine$1 = !DESCRIPTORS$1c && !fails$2m(function() {
  return Object.defineProperty(createElement$3("div"), "a", {
    get: function get7() {
      return 7;
    }
  }).a !== 7;
});
var DESCRIPTORS$1b = descriptors$1;
var fails$2l = fails$2o;
var v8PrototypeDefineBug$1 = DESCRIPTORS$1b && fails$2l(function() {
  return Object.defineProperty(function() {
  }, "prototype", {
    value: 42,
    writable: false
  }).prototype !== 42;
});
var isObject$1i = isObject$1k;
var $String$f = String;
var $TypeError$Q = TypeError;
var anObject$1f = function anObject(argument) {
  if (isObject$1i(argument)) return argument;
  throw new $TypeError$Q($String$f(argument) + " is not an object");
};
var fails$2k = fails$2o;
var functionBindNative$1 = !fails$2k(function() {
  var test2 = (function() {
  }).bind();
  return typeof test2 != "function" || test2.hasOwnProperty("prototype");
});
var NATIVE_BIND$9 = functionBindNative$1;
var FunctionPrototype$8 = Function.prototype;
var call$1k = FunctionPrototype$8.call;
var uncurryThisWithBind$1 = NATIVE_BIND$9 && FunctionPrototype$8.bind.bind(call$1k, call$1k);
var functionUncurryThis$1 = NATIVE_BIND$9 ? uncurryThisWithBind$1 : function(fn) {
  return function() {
    return call$1k.apply(fn, arguments);
  };
};
var $String$e = String;
var tryToString$e = function tryToString(argument) {
  try {
    return $String$e(argument);
  } catch (error2) {
    return "Object";
  }
};
var isCallable$10 = isCallable$12;
var tryToString$d = tryToString$e;
var $TypeError$P = TypeError;
var aCallable$F = function aCallable(argument) {
  if (isCallable$10(argument)) return argument;
  throw new $TypeError$P(tryToString$d(argument) + " is not a function");
};
var isNullOrUndefined$i = function isNullOrUndefined(it) {
  return it === null || it === void 0;
};
var isNullOrUndefined$h = isNullOrUndefined$i;
var $TypeError$O = TypeError;
var requireObjectCoercible$A = function requireObjectCoercible(it) {
  if (isNullOrUndefined$h(it)) throw new $TypeError$O("Can't call method on " + it);
  return it;
};
var requireObjectCoercible$z = requireObjectCoercible$A;
var $Object$e = Object;
var toObject$J = function toObject(argument) {
  return $Object$e(requireObjectCoercible$z(argument));
};
var uncurryThis$2g = functionUncurryThis$1;
var toObject$I = toObject$J;
var hasOwnProperty$3 = uncurryThis$2g({}.hasOwnProperty);
var hasOwnProperty_1$1 = Object.hasOwn || function hasOwn(it, key) {
  return hasOwnProperty$3(toObject$I(it), key);
};
var TO_STRING_TAG_SUPPORT$5 = toStringTagSupport$1;
var isCallable$$ = isCallable$12;
var classofRaw$4 = classofRaw;
var wellKnownSymbol$16 = wellKnownSymbol$U;
var TO_STRING_TAG$8 = wellKnownSymbol$16("toStringTag");
var $Object$d = Object;
var CORRECT_ARGUMENTS$1 = classofRaw$4(/* @__PURE__ */ function() {
  return arguments;
}()) === "Arguments";
var tryGet$1 = function tryGet(it, key) {
  try {
    return it[key];
  } catch (error2) {
  }
};
var classof$E = TO_STRING_TAG_SUPPORT$5 ? classofRaw$4 : function(it) {
  var O, tag, result;
  return it === void 0 ? "Undefined" : it === null ? "Null" : typeof (tag = tryGet$1(O = $Object$d(it), TO_STRING_TAG$8)) == "string" ? tag : CORRECT_ARGUMENTS$1 ? classofRaw$4(O) : (result = classofRaw$4(O)) === "Object" && isCallable$$(O.callee) ? "Arguments" : result;
};
var globalThis$1H = globalThis_1$1;
var isCallable$_ = isCallable$12;
var aFunction$1 = function aFunction(argument) {
  return isCallable$_(argument) ? argument : void 0;
};
var getBuiltIn$A = function getBuiltIn(namespace, method) {
  return arguments.length < 2 ? aFunction$1(globalThis$1H[namespace]) : globalThis$1H[namespace] && globalThis$1H[namespace][method];
};
var DESCRIPTORS$1a = descriptors$1;
var hasOwn$S = hasOwnProperty_1$1;
var FunctionPrototype$7 = Function.prototype;
var getDescriptor$1 = DESCRIPTORS$1a && Object.getOwnPropertyDescriptor;
var EXISTS$2 = hasOwn$S(FunctionPrototype$7, "name");
var PROPER$1 = EXISTS$2 && (function something() {
}).name === "something";
var CONFIGURABLE$3 = EXISTS$2 && (!DESCRIPTORS$1a || DESCRIPTORS$1a && getDescriptor$1(FunctionPrototype$7, "name").configurable);
var functionName$1 = {
  EXISTS: EXISTS$2,
  PROPER: PROPER$1,
  CONFIGURABLE: CONFIGURABLE$3
};
var makeBuiltIn$8 = { exports: {} };
var globalThis$1G = globalThis_1$1;
var isCallable$Z = isCallable$12;
var WeakMap$6 = globalThis$1G.WeakMap;
var weakMapBasicDetection$1 = isCallable$Z(WeakMap$6) && /native code/.test(String(WeakMap$6));
var createPropertyDescriptor$i = function createPropertyDescriptor(bitmap, value) {
  return {
    enumerable: !(bitmap & 1),
    configurable: !(bitmap & 2),
    writable: !(bitmap & 4),
    value
  };
};
var DESCRIPTORS$19 = descriptors$1;
var definePropertyModule$k = objectDefineProperty$1;
var createPropertyDescriptor$h = createPropertyDescriptor$i;
var createNonEnumerableProperty$o = DESCRIPTORS$19 ? function(object, key, value) {
  return definePropertyModule$k.f(object, key, createPropertyDescriptor$h(1, value));
} : function(object, key, value) {
  object[key] = value;
  return object;
};
var uncurryThis$2f = functionUncurryThis$1;
var id$5 = 0;
var postfix$1 = Math.random();
var toString$U = uncurryThis$2f(1 .toString);
var uid$a = function uid(key) {
  return "Symbol(" + (key === void 0 ? "" : key) + ")_" + toString$U(++id$5 + postfix$1, 36);
};
var shared$f = shared$a;
var uid$9 = uid$a;
var keys$3 = shared$f("keys");
var sharedKey$8 = function sharedKey(key) {
  return keys$3[key] || (keys$3[key] = uid$9(key));
};
var hiddenKeys$d = {};
var NATIVE_WEAK_MAP$3 = weakMapBasicDetection$1;
var globalThis$1F = globalThis_1$1;
var isObject$1h = isObject$1k;
var createNonEnumerableProperty$n = createNonEnumerableProperty$o;
var hasOwn$R = hasOwnProperty_1$1;
var shared$e = 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$5 = globalThis$1F.WeakMap;
var set$c, get$6, has;
var enforce$1 = function enforce(it) {
  return has(it) ? get$6(it) : set$c(it, {});
};
var getterFor = function getterFor2(TYPE) {
  return function(it) {
    var state;
    if (!isObject$1h(it) || (state = get$6(it)).type !== TYPE) {
      throw new TypeError$e("Incompatible receiver, " + TYPE + " required");
    }
    return state;
  };
};
if (NATIVE_WEAK_MAP$3 || shared$e.state) {
  var store$9 = shared$e.state || (shared$e.state = new WeakMap$5());
  store$9.get = store$9.get;
  store$9.has = store$9.has;
  store$9.set = store$9.set;
  set$c = function set7(it, metadata3) {
    if (store$9.has(it)) throw new TypeError$e(OBJECT_ALREADY_INITIALIZED$1);
    metadata3.facade = it;
    store$9.set(it, metadata3);
    return metadata3;
  };
  get$6 = function get7(it) {
    return store$9.get(it) || {};
  };
  has = function has6(it) {
    return store$9.has(it);
  };
} else {
  var STATE$1 = sharedKey$7("state");
  hiddenKeys$c[STATE$1] = true;
  set$c = function set7(it, metadata3) {
    if (hasOwn$R(it, STATE$1)) throw new TypeError$e(OBJECT_ALREADY_INITIALIZED$1);
    metadata3.facade = it;
    createNonEnumerableProperty$n(it, STATE$1, metadata3);
    return metadata3;
  };
  get$6 = function get7(it) {
    return hasOwn$R(it, STATE$1) ? it[STATE$1] : {};
  };
  has = function has6(it) {
    return hasOwn$R(it, STATE$1);
  };
}
var internalState$1 = {
  set: set$c,
  get: get$6,
  has,
  enforce: enforce$1,
  getterFor
};
var uncurryThis$2e = functionUncurryThis$1;
var fails$2j = fails$2o;
var isCallable$Y = isCallable$12;
var hasOwn$Q = hasOwnProperty_1$1;
var DESCRIPTORS$18 = descriptors$1;
var CONFIGURABLE_FUNCTION_NAME$5 = functionName$1.CONFIGURABLE;
var inspectSource$7 = inspectSource$6;
var InternalStateModule$s = internalState$1;
var enforceInternalState$9 = InternalStateModule$s.enforce;
var getInternalState$h = InternalStateModule$s.get;
var $String$d = String;
var defineProperty$n = Object.defineProperty;
var stringSlice$v = uncurryThis$2e("".slice);
var replace$m = uncurryThis$2e("".replace);
var join$d = uncurryThis$2e([].join);
var CONFIGURABLE_LENGTH$1 = DESCRIPTORS$18 && !fails$2j(function() {
  return defineProperty$n(function() {
  }, "length", {
    value: 8
  }).length !== 8;
});
var TEMPLATE$1 = String(String).split("String");
var makeBuiltIn$7 = makeBuiltIn$8.exports = function(value, name, options) {
  if (stringSlice$v($String$d(name), 0, 7) === "Symbol(") {
    name = "[" + replace$m($String$d(name), /^Symbol\(([^)]*)\).*$/, "$1") + "]";
  }
  if (options && options.getter) name = "get " + name;
  if (options && options.setter) name = "set " + name;
  if (!hasOwn$Q(value, "name") || CONFIGURABLE_FUNCTION_NAME$5 && value.name !== name) {
    if (DESCRIPTORS$18) defineProperty$n(value, "name", {
      value: name,
      configurable: true
    });
    else value.name = name;
  }
  if (CONFIGURABLE_LENGTH$1 && options && hasOwn$Q(options, "arity") && value.length !== options.arity) {
    defineProperty$n(value, "length", {
      value: options.arity
    });
  }
  try {
    if (options && hasOwn$Q(options, "constructor") && options.constructor) {
      if (DESCRIPTORS$18) defineProperty$n(value, "prototype", {
        writable: false
      });
    } else if (value.prototype) value.prototype = void 0;
  } catch (error2) {
  }
  var state = enforceInternalState$9(value);
  if (!hasOwn$Q(state, "source")) {
    state.source = join$d(TEMPLATE$1, typeof name == "string" ? name : "");
  }
  return value;
};
Function.prototype.toString = makeBuiltIn$7(function toString() {
  return isCallable$Y(this) && getInternalState$h(this).source || inspectSource$7(this);
}, "toString");
var makeBuiltInExports$1 = makeBuiltIn$8.exports;
var makeBuiltIn$6 = makeBuiltInExports$1;
var defineProperty$m = objectDefineProperty$1;
var defineBuiltInAccessor$p = function defineBuiltInAccessor(target, name, descriptor) {
  if (descriptor.get) makeBuiltIn$6(descriptor.get, name, {
    getter: true
  });
  if (descriptor.set) makeBuiltIn$6(descriptor.set, name, {
    setter: true
  });
  return defineProperty$m.f(target, name, descriptor);
};
var DESCRIPTORS$17 = descriptors$1;
var FUNCTION_NAME_EXISTS$1 = functionName$1.EXISTS;
var uncurryThis$2d = functionUncurryThis$1;
var defineBuiltInAccessor$o = defineBuiltInAccessor$p;
var FunctionPrototype$6 = Function.prototype;
var functionToString$3 = uncurryThis$2d(FunctionPrototype$6.toString);
var nameRE$1 = /function\b(?:\s|\/\*[\S\s]*?\*\/|\/\/[^\n\r]*[\n\r]+)*([^\s(/]*)/;
var regExpExec$b = uncurryThis$2d(nameRE$1.exec);
var NAME$3 = "name";
if (DESCRIPTORS$17 && !FUNCTION_NAME_EXISTS$1) {
  defineBuiltInAccessor$o(FunctionPrototype$6, NAME$3, {
    configurable: true,
    get: function get7() {
      try {
        return regExpExec$b(nameRE$1, functionToString$3(this))[1];
      } catch (error2) {
        return "";
      }
    }
  });
}
var isCallable$X = isCallable$12;
var definePropertyModule$j = objectDefineProperty$1;
var makeBuiltIn$5 = makeBuiltInExports$1;
var defineGlobalProperty$6 = defineGlobalProperty$5;
var defineBuiltIn$F = function defineBuiltIn(O, key, value, options) {
  if (!options) options = {};
  var simple = options.enumerable;
  var name = options.name !== void 0 ? options.name : key;
  if (isCallable$X(value)) makeBuiltIn$5(value, name, options);
  if (options.global) {
    if (simple) O[key] = value;
    else defineGlobalProperty$6(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$j.f(O, key, {
      value,
      enumerable: false,
      configurable: !options.nonConfigurable,
      writable: !options.nonWritable
    });
  }
  return O;
};
var classof$D = classof$E;
var $String$c = String;
var toString$T = function toString2(argument) {
  if (classof$D(argument) === "Symbol") throw new TypeError("Cannot convert a Symbol value to a string");
  return $String$c(argument);
};
var anObject$1e = anObject$1f;
var regexpFlags$2 = function regexpFlags() {
  var that = anObject$1e(this);
  var result = "";
  if (that.hasIndices) result += "d";
  if (that.global) result += "g";
  if (that.ignoreCase) result += "i";
  if (that.multiline) result += "m";
  if (that.dotAll) result += "s";
  if (that.unicode) result += "u";
  if (that.unicodeSets) result += "v";
  if (that.sticky) result += "y";
  return result;
};
var globalThis$1E = globalThis_1$1;
var DESCRIPTORS$16 = descriptors$1;
var defineBuiltInAccessor$n = defineBuiltInAccessor$p;
var regExpFlags$3 = regexpFlags$2;
var fails$2i = fails$2o;
var RegExp$2 = globalThis$1E.RegExp;
var RegExpPrototype$b = RegExp$2.prototype;
var FORCED$X = DESCRIPTORS$16 && fails$2i(function() {
  var INDICES_SUPPORT = true;
  try {
    RegExp$2(".", "d");
  } catch (error2) {
    INDICES_SUPPORT = false;
  }
  var O = {};
  var calls = "";
  var expected = INDICES_SUPPORT ? "dgimsy" : "gimsy";
  var addGetter5 = function addGetter6(key2, chr) {
    Object.defineProperty(O, key2, {
      get: function get7() {
        calls += chr;
        return true;
      }
    });
  };
  var pairs = {
    dotAll: "s",
    global: "g",
    ignoreCase: "i",
    multiline: "m",
    sticky: "y"
  };
  if (INDICES_SUPPORT) pairs.hasIndices = "d";
  for (var key in pairs) addGetter5(key, pairs[key]);
  var result = Object.getOwnPropertyDescriptor(RegExpPrototype$b, "flags").get.call(O);
  return result !== expected || calls !== expected;
});
if (FORCED$X) defineBuiltInAccessor$n(RegExpPrototype$b, "flags", {
  configurable: true,
  get: regExpFlags$3
});
var uncurryThis$2c = functionUncurryThis$1;
var objectIsPrototypeOf$1 = uncurryThis$2c({}.isPrototypeOf);
var call$1j = functionCall$1;
var hasOwn$P = hasOwnProperty_1$1;
var isPrototypeOf$l = objectIsPrototypeOf$1;
var regExpFlags$2 = regexpFlags$2;
var RegExpPrototype$a = RegExp.prototype;
var regexpGetFlags$1 = function regexpGetFlags(R) {
  var flags = R.flags;
  return flags === void 0 && !("flags" in RegExpPrototype$a) && !hasOwn$P(R, "flags") && isPrototypeOf$l(RegExpPrototype$a, R) ? call$1j(regExpFlags$2, R) : flags;
};
var PROPER_FUNCTION_NAME$7 = functionName$1.PROPER;
var defineBuiltIn$E = defineBuiltIn$F;
var anObject$1d = anObject$1f;
var $toString$7 = toString$T;
var fails$2h = fails$2o;
var getRegExpFlags$6 = regexpGetFlags$1;
var TO_STRING$3 = "toString";
var RegExpPrototype$9 = RegExp.prototype;
var nativeToString$1 = RegExpPrototype$9[TO_STRING$3];
var NOT_GENERIC$1 = fails$2h(function() {
  return nativeToString$1.call({
    source: "a",
    flags: "b"
  }) !== "/a/b";
});
var INCORRECT_NAME$1 = PROPER_FUNCTION_NAME$7 && nativeToString$1.name !== TO_STRING$3;
if (NOT_GENERIC$1 || INCORRECT_NAME$1) {
  defineBuiltIn$E(RegExpPrototype$9, TO_STRING$3, function toString8() {
    var R = anObject$1d(this);
    var pattern = $toString$7(R.source);
    var flags = $toString$7(getRegExpFlags$6(R));
    return "/" + pattern + "/" + flags;
  }, {
    unsafe: true
  });
}
var uncurryThis$2b = functionUncurryThis$1;
var isCallable$W = isCallable$12;
var store$8 = sharedStoreExports$1;
var functionToString$2 = uncurryThis$2b(Function.toString);
if (!isCallable$W(store$8.inspectSource)) {
  store$8.inspectSource = function(it) {
    return functionToString$2(it);
  };
}
var inspectSource$6 = store$8.inspectSource;
var uncurryThis$2a = functionUncurryThis$1;
var fails$2g = fails$2o;
var isCallable$V = isCallable$12;
var classof$C = classof$E;
var getBuiltIn$z = getBuiltIn$A;
var inspectSource$5 = inspectSource$6;
var noop$1 = function noop() {
};
var construct$3 = getBuiltIn$z("Reflect", "construct");
var constructorRegExp$1 = /^\s*(?:class|function)\b/;
var exec$g = uncurryThis$2a(constructorRegExp$1.exec);
var INCORRECT_TO_STRING$1 = !constructorRegExp$1.test(noop$1);
var isConstructorModern$1 = function isConstructor(argument) {
  if (!isCallable$V(argument)) return false;
  try {
    construct$3(noop$1, [], argument);
    return true;
  } catch (error2) {
    return false;
  }
};
var isConstructorLegacy$1 = function isConstructor2(argument) {
  if (!isCallable$V(argument)) return false;
  switch (classof$C(argument)) {
    case "AsyncFunction":
    case "GeneratorFunction":
    case "AsyncGeneratorFunction":
      return false;
  }
  try {
    return INCORRECT_TO_STRING$1 || !!exec$g(constructorRegExp$1, inspectSource$5(argument));
  } catch (error2) {
    return true;
  }
};
isConstructorLegacy$1.sham = true;
var isConstructor$c = !construct$3 || fails$2g(function() {
  var called;
  return isConstructorModern$1(isConstructorModern$1.call) || !isConstructorModern$1(Object) || !isConstructorModern$1(function() {
    called = true;
  }) || called;
}) ? isConstructorLegacy$1 : isConstructorModern$1;
var $$5v = _export$1;
var trunc$2 = mathTrunc$1;
$$5v({
  target: "Math",
  stat: true
}, {
  trunc: trunc$2
});
var ceil$3 = Math.ceil;
var floor$i = Math.floor;
var mathTrunc$1 = Math.trunc || function trunc(x) {
  var n = +x;
  return (n > 0 ? floor$i : ceil$3)(n);
};
var trunc2 = mathTrunc$1;
var toIntegerOrInfinity$q = function toIntegerOrInfinity(argument) {
  var number = +argument;
  return number !== number || number === 0 ? 0 : trunc2(number);
};
var toIntegerOrInfinity$p = toIntegerOrInfinity$q;
var max$9 = Math.max;
var min$h = Math.min;
var toAbsoluteIndex$g = function toAbsoluteIndex(index, length) {
  var integer = toIntegerOrInfinity$p(index);
  return integer < 0 ? max$9(integer + length, 0) : min$h(integer, length);
};
var toIntegerOrInfinity$o = toIntegerOrInfinity$q;
var min$g = Math.min;
var toLength$q = function toLength(argument) {
  var len = toIntegerOrInfinity$o(argument);
  return len > 0 ? min$g(len, 9007199254740991) : 0;
};
var toLength$p = toLength$q;
var lengthOfArrayLike$B = function lengthOfArrayLike(obj) {
  return toLength$p(obj.length);
};
var DESCRIPTORS$15 = descriptors$1;
var definePropertyModule$i = objectDefineProperty$1;
var createPropertyDescriptor$g = createPropertyDescriptor$i;
var createProperty$d = function createProperty(object, key, value) {
  if (DESCRIPTORS$15) definePropertyModule$i.f(object, key, createPropertyDescriptor$g(0, value));
  else object[key] = value;
};
var call$1i = functionCall$1;
var defineBuiltIn$D = defineBuiltIn$F;
var regexpExec$5 = regexpExec$3;
var fails$2f = fails$2o;
var wellKnownSymbol$15 = wellKnownSymbol$U;
var createNonEnumerableProperty$m = createNonEnumerableProperty$o;
var SPECIES$d = wellKnownSymbol$15("species");
var RegExpPrototype$8 = RegExp.prototype;
var fixRegexpWellKnownSymbolLogic$1 = function fixRegexpWellKnownSymbolLogic(KEY, exec2, FORCED2, SHAM) {
  var SYMBOL2 = wellKnownSymbol$15(KEY);
  var DELEGATES_TO_SYMBOL = !fails$2f(function() {
    var O = {};
    O[SYMBOL2] = function() {
      return 7;
    };
    return ""[KEY](O) !== 7;
  });
  var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails$2f(function() {
    var execCalled = false;
    var re = /a/;
    if (KEY === "split") {
      re = {};
      re.constructor = {};
      re.constructor[SPECIES$d] = function() {
        return re;
      };
      re.flags = "";
      re[SYMBOL2] = /./[SYMBOL2];
    }
    re.exec = function() {
      execCalled = true;
      return null;
    };
    re[SYMBOL2]("");
    return !execCalled;
  });
  if (!DELEGATES_TO_SYMBOL || !DELEGATES_TO_EXEC || FORCED2) {
    var nativeRegExpMethod = /./[SYMBOL2];
    var methods = exec2(SYMBOL2, ""[KEY], function(nativeMethod, regexp, str, arg2, forceStringMethod) {
      var $exec = regexp.exec;
      if ($exec === regexpExec$5 || $exec === RegExpPrototype$8.exec) {
        if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
          return {
            done: true,
            value: call$1i(nativeRegExpMethod, regexp, str, arg2)
          };
        }
        return {
          done: true,
          value: call$1i(nativeMethod, str, regexp, arg2)
        };
      }
      return {
        done: false
      };
    });
    defineBuiltIn$D(String.prototype, KEY, methods[0]);
    defineBuiltIn$D(RegExpPrototype$8, SYMBOL2, methods[1]);
  }
  if (SHAM) createNonEnumerableProperty$m(RegExpPrototype$8[SYMBOL2], "sham", true);
};
var aCallable$E = aCallable$F;
var isNullOrUndefined$g = isNullOrUndefined$i;
var getMethod$j = function getMethod(V, P) {
  var func = V[P];
  return isNullOrUndefined$g(func) ? void 0 : aCallable$E(func);
};
var uncurryThis$29 = functionUncurryThis$1;
var toIntegerOrInfinity$n = toIntegerOrInfinity$q;
var toString$S = toString$T;
var requireObjectCoercible$y = requireObjectCoercible$A;
var charAt$m = uncurryThis$29("".charAt);
var charCodeAt$7 = uncurryThis$29("".charCodeAt);
var stringSlice$u = uncurryThis$29("".slice);
var createMethod$c = function createMethod(CONVERT_TO_STRING) {
  return function($this, pos) {
    var S = toString$S(requireObjectCoercible$y($this));
    var position = toIntegerOrInfinity$n(pos);
    var size3 = S.length;
    var first, second;
    if (position < 0 || position >= size3) return CONVERT_TO_STRING ? "" : void 0;
    first = charCodeAt$7(S, position);
    return first < 55296 || first > 56319 || position + 1 === size3 || (second = charCodeAt$7(S, position + 1)) < 56320 || second > 57343 ? CONVERT_TO_STRING ? charAt$m(S, position) : first : CONVERT_TO_STRING ? stringSlice$u(S, position, position + 2) : (first - 55296 << 10) + (second - 56320) + 65536;
  };
};
var stringMultibyte$1 = {
  // `String.prototype.codePointAt` method
  // https://tc39.es/ecma262/#sec-string.prototype.codepointat
  codeAt: createMethod$c(false),
  // `String.prototype.at` method
  // https://github.com/mathiasbynens/String.prototype.at
  charAt: createMethod$c(true)
};
var charAt$l = stringMultibyte$1.charAt;
var advanceStringIndex$8 = function advanceStringIndex(S, index, unicode) {
  return index + (unicode ? charAt$l(S, index).length : 1);
};
var call$1h = functionCall$1;
var anObject$1c = anObject$1f;
var isCallable$U = isCallable$12;
var classof$B = classofRaw;
var regexpExec$4 = regexpExec$3;
var $TypeError$N = TypeError;
var regexpExecAbstract$1 = function regexpExecAbstract(R, S) {
  var exec2 = R.exec;
  if (isCallable$U(exec2)) {
    var result = call$1h(exec2, R, S);
    if (result !== null) anObject$1c(result);
    return result;
  }
  if (classof$B(R) === "RegExp") return call$1h(regexpExec$4, R, S);
  throw new $TypeError$N("RegExp#exec called on incompatible receiver");
};
var call$1g = functionCall$1;
var fixRegExpWellKnownSymbolLogic$7 = fixRegexpWellKnownSymbolLogic$1;
var anObject$1b = anObject$1f;
var isObject$1g = isObject$1k;
var toLength$o = toLength$q;
var toString$R = toString$T;
var requireObjectCoercible$x = requireObjectCoercible$A;
var getMethod$i = getMethod$j;
var advanceStringIndex$7 = advanceStringIndex$8;
var regExpExec$a = regexpExecAbstract$1;
fixRegExpWellKnownSymbolLogic$7("match", function(MATCH2, nativeMatch, maybeCallNative) {
  return [
    // `String.prototype.match` method
    // https://tc39.es/ecma262/#sec-string.prototype.match
    function match2(regexp) {
      var O = requireObjectCoercible$x(this);
      var matcher = isObject$1g(regexp) ? getMethod$i(regexp, MATCH2) : void 0;
      return matcher ? call$1g(matcher, regexp, O) : new RegExp(regexp)[MATCH2](toString$R(O));
    },
    // `RegExp.prototype[@@match]` method
    // https://tc39.es/ecma262/#sec-regexp.prototype-@@match
    function(string) {
      var rx = anObject$1b(this);
      var S = toString$R(string);
      var res = maybeCallNative(nativeMatch, rx, S);
      if (res.done) return res.value;
      if (!rx.global) return regExpExec$a(rx, S);
      var fullUnicode = rx.unicode;
      rx.lastIndex = 0;
      var A = [];
      var n = 0;
      var result;
      while ((result = regExpExec$a(rx, S)) !== null) {
        var matchStr = toString$R(result[0]);
        A[n] = matchStr;
        if (matchStr === "") rx.lastIndex = advanceStringIndex$7(S, toLength$o(rx.lastIndex), fullUnicode);
        n++;
      }
      return n === 0 ? null : A;
    }
  ];
});
var globalThis$1D = globalThis_1$1;
var navigator$2 = globalThis$1D.navigator;
var userAgent$h = navigator$2 && navigator$2.userAgent;
var environmentUserAgent$1 = userAgent$h ? String(userAgent$h) : "";
var globalThis$1C = globalThis_1$1;
var userAgent$g = environmentUserAgent$1;
var process$8 = globalThis$1C.process;
var Deno$2 = globalThis$1C.Deno;
var versions$1 = process$8 && process$8.versions || Deno$2 && Deno$2.version;
var v8$1 = versions$1 && versions$1.v8;
var match$1, version$3;
if (v8$1) {
  match$1 = v8$1.split(".");
  version$3 = match$1[0] > 0 && match$1[0] < 4 ? 1 : +(match$1[0] + match$1[1]);
}
if (!version$3 && 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$3 = +match$1[1];
  }
}
var environmentV8Version$1 = version$3;
var fails$2e = fails$2o;
var wellKnownSymbol$14 = wellKnownSymbol$U;
var V8_VERSION$7 = environmentV8Version$1;
var SPECIES$c = wellKnownSymbol$14("species");
var arrayMethodHasSpeciesSupport$a = function arrayMethodHasSpeciesSupport(METHOD_NAME) {
  return V8_VERSION$7 >= 51 || !fails$2e(function() {
    var array = [];
    var constructor = array.constructor = {};
    constructor[SPECIES$c] = function() {
      return {
        foo: 1
      };
    };
    return array[METHOD_NAME](Boolean).foo !== 1;
  });
};
var $$5u = _export$1;
var isArray$i = isArray$f;
var isConstructor$b = isConstructor$c;
var isObject$1f = isObject$1k;
var toAbsoluteIndex$f = toAbsoluteIndex$g;
var lengthOfArrayLike$A = lengthOfArrayLike$B;
var toIndexedObject$t = toIndexedObject$m;
var createProperty$c = createProperty$d;
var wellKnownSymbol$13 = wellKnownSymbol$U;
var arrayMethodHasSpeciesSupport$9 = arrayMethodHasSpeciesSupport$a;
var nativeSlice$1 = arraySlice$l;
var HAS_SPECIES_SUPPORT$7 = arrayMethodHasSpeciesSupport$9("slice");
var SPECIES$b = wellKnownSymbol$13("species");
var $Array$9 = Array;
var max$8 = Math.max;
$$5u({
  target: "Array",
  proto: true,
  forced: !HAS_SPECIES_SUPPORT$7
}, {
  slice: function slice(start, end) {
    var O = toIndexedObject$t(this);
    var length = lengthOfArrayLike$A(O);
    var k = toAbsoluteIndex$f(start, length);
    var fin = toAbsoluteIndex$f(end === void 0 ? length : end, length);
    var Constructor2, result, n;
    if (isArray$i(O)) {
      Constructor2 = O.constructor;
      if (isConstructor$b(Constructor2) && (Constructor2 === $Array$9 || isArray$i(Constructor2.prototype))) {
        Constructor2 = void 0;
      } else if (isObject$1f(Constructor2)) {
        Constructor2 = Constructor2[SPECIES$b];
        if (Constructor2 === null) Constructor2 = void 0;
      }
      if (Constructor2 === $Array$9 || Constructor2 === void 0) {
        return nativeSlice$1(O, k, fin);
      }
    }
    result = new (Constructor2 === void 0 ? $Array$9 : Constructor2)(max$8(fin - k, 0));
    for (n = 0; k < fin; k++, n++) if (k in O) createProperty$c(result, n, O[k]);
    result.length = n;
    return result;
  }
});
var uncurryThis$28 = functionUncurryThis$1;
var arraySlice$l = uncurryThis$28([].slice);
var uncurryThis$27 = functionUncurryThis$1;
var aCallable$D = aCallable$F;
var isObject$1e = isObject$1k;
var hasOwn$O = hasOwnProperty_1$1;
var arraySlice$k = arraySlice$l;
var NATIVE_BIND$8 = functionBindNative$1;
var $Function$1 = Function;
var concat$7 = uncurryThis$27([].concat);
var join$c = uncurryThis$27([].join);
var factories$1 = {};
var construct$2 = function construct(C, argsLength, args) {
  if (!hasOwn$O(factories$1, argsLength)) {
    var list = []