impact-ui 4.0.16 → 4.0.17-alpha.2

package/dist/node_modules/@mui/utils/node_modules/react-is/cjs/react-is.production.min.js

@@ -0,0 +1,109 @@
+import { __exports as reactIs_production_min } from "../../../../../../_virtual/react-is3.production.min.js";
+/**
+ * @license React
+ * react-is.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredReactIs_production_min;
+function requireReactIs_production_min() {
+  if (hasRequiredReactIs_production_min) return reactIs_production_min;
+  hasRequiredReactIs_production_min = 1;
+  var b = Symbol.for("react.element"), c = Symbol.for("react.portal"), d = Symbol.for("react.fragment"), e = Symbol.for("react.strict_mode"), f = Symbol.for("react.profiler"), g = Symbol.for("react.provider"), h = Symbol.for("react.context"), k = Symbol.for("react.server_context"), l = Symbol.for("react.forward_ref"), m = Symbol.for("react.suspense"), n = Symbol.for("react.suspense_list"), p = Symbol.for("react.memo"), q = Symbol.for("react.lazy"), t = Symbol.for("react.offscreen"), u;
+  u = Symbol.for("react.module.reference");
+  function v(a) {
+    if ("object" === typeof a && null !== a) {
+      var r = a.$$typeof;
+      switch (r) {
+        case b:
+          switch (a = a.type, a) {
+            case d:
+            case f:
+            case e:
+            case m:
+            case n:
+              return a;
+            default:
+              switch (a = a && a.$$typeof, a) {
+                case k:
+                case h:
+                case l:
+                case q:
+                case p:
+                case g:
+                  return a;
+                default:
+                  return r;
+              }
+          }
+        case c:
+          return r;
+      }
+    }
+  }
+  reactIs_production_min.ContextConsumer = h;
+  reactIs_production_min.ContextProvider = g;
+  reactIs_production_min.Element = b;
+  reactIs_production_min.ForwardRef = l;
+  reactIs_production_min.Fragment = d;
+  reactIs_production_min.Lazy = q;
+  reactIs_production_min.Memo = p;
+  reactIs_production_min.Portal = c;
+  reactIs_production_min.Profiler = f;
+  reactIs_production_min.StrictMode = e;
+  reactIs_production_min.Suspense = m;
+  reactIs_production_min.SuspenseList = n;
+  reactIs_production_min.isAsyncMode = function() {
+    return false;
+  };
+  reactIs_production_min.isConcurrentMode = function() {
+    return false;
+  };
+  reactIs_production_min.isContextConsumer = function(a) {
+    return v(a) === h;
+  };
+  reactIs_production_min.isContextProvider = function(a) {
+    return v(a) === g;
+  };
+  reactIs_production_min.isElement = function(a) {
+    return "object" === typeof a && null !== a && a.$$typeof === b;
+  };
+  reactIs_production_min.isForwardRef = function(a) {
+    return v(a) === l;
+  };
+  reactIs_production_min.isFragment = function(a) {
+    return v(a) === d;
+  };
+  reactIs_production_min.isLazy = function(a) {
+    return v(a) === q;
+  };
+  reactIs_production_min.isMemo = function(a) {
+    return v(a) === p;
+  };
+  reactIs_production_min.isPortal = function(a) {
+    return v(a) === c;
+  };
+  reactIs_production_min.isProfiler = function(a) {
+    return v(a) === f;
+  };
+  reactIs_production_min.isStrictMode = function(a) {
+    return v(a) === e;
+  };
+  reactIs_production_min.isSuspense = function(a) {
+    return v(a) === m;
+  };
+  reactIs_production_min.isSuspenseList = function(a) {
+    return v(a) === n;
+  };
+  reactIs_production_min.isValidElementType = function(a) {
+    return "string" === typeof a || "function" === typeof a || a === d || a === f || a === e || a === m || a === n || a === t || "object" === typeof a && null !== a && (a.$$typeof === q || a.$$typeof === p || a.$$typeof === g || a.$$typeof === h || a.$$typeof === l || a.$$typeof === u || void 0 !== a.getModuleId) ? true : false;
+  };
+  reactIs_production_min.typeOf = v;
+  return reactIs_production_min;
+}
+export {
+  requireReactIs_production_min as __require
+};

package/dist/node_modules/@mui/utils/node_modules/react-is/index.js

@@ -0,0 +1,12 @@
+import { __module as reactIs } from "../../../../../_virtual/index10.js";
+import { __require as requireReactIs_production_min } from "./cjs/react-is.production.min.js";
+import { __require as requireReactIs_development } from "./cjs/react-is.development.js";
+if (process.env.NODE_ENV === "production") {
+  reactIs.exports = requireReactIs_production_min();
+} else {
+  reactIs.exports = requireReactIs_development();
+}
+var reactIsExports = reactIs.exports;
+export {
+  reactIsExports as r
+};

package/dist/node_modules/@mui/{material/node_modules/@mui/utils/esm → utils}/refType/refType.js

@@ -1,4 +1,4 @@
-import PropTypes from "../../../../../../../prop-types/index.js";
+import PropTypes from "../../../prop-types/index.js";
 const refType = PropTypes.oneOfType([PropTypes.func, PropTypes.object]);
 export {
   refType as default

package/dist/node_modules/@mui/{material/node_modules/@mui/utils/esm → utils}/useControlled/useControlled.js

@@ -20,7 +20,7 @@ function useControlled({
       current: defaultValue
     } = React.useRef(defaultProp);
     React.useEffect(() => {
-      if (!isControlled && !Object.is(defaultValue, defaultProp)) {
+      if (!isControlled && defaultValue !== defaultProp) {
         console.error([`MUI: A component is changing the default ${state} state of an uncontrolled ${name} after being initialized. To suppress this warning opt to use a controlled ${name}.`].join("\n"));
       }
     }, [JSON.stringify(defaultProp)]);

package/dist/node_modules/@mui/{material/node_modules/@mui/utils/esm → utils}/useTimeout/useTimeout.js

@@ -1,5 +1,3 @@
-import useLazyRef from "../useLazyRef/useLazyRef.js";
-import useOnMount from "../useOnMount/useOnMount.js";
 class Timeout {
   constructor() {
     this.currentId = null;
@@ -27,12 +25,6 @@ class Timeout {
     }, delay);
   }
 }
-function useTimeout() {
-  const timeout = useLazyRef(Timeout.create).current;
-  useOnMount(timeout.disposeEffect);
-  return timeout;
-}
 export {
-  Timeout,
-  useTimeout as default
+  Timeout
 };

package/dist/node_modules/array.prototype.find/implementation.js

@@ -0,0 +1,37 @@
+import { __require as requireToObject } from "../es-object-atoms/ToObject.js";
+import { __require as requireToLength } from "../es-abstract/2024/ToLength.js";
+import { __require as requireIsCallable } from "../es-abstract/2024/IsCallable.js";
+var implementation;
+var hasRequiredImplementation;
+function requireImplementation() {
+  if (hasRequiredImplementation) return implementation;
+  hasRequiredImplementation = 1;
+  var ToObject = requireToObject();
+  var ToLength = requireToLength();
+  var IsCallable = requireIsCallable();
+  implementation = function find(predicate) {
+    var list = ToObject(this);
+    var length = ToLength(list.length);
+    if (!IsCallable(predicate)) {
+      throw new TypeError("Array#find: predicate must be a function");
+    }
+    if (length === 0) {
+      return void 0;
+    }
+    var thisArg;
+    if (arguments.length > 0) {
+      thisArg = arguments[1];
+    }
+    for (var i = 0, value; i < length; i++) {
+      value = list[i];
+      if (predicate.apply(thisArg, [value, i, list])) {
+        return value;
+      }
+    }
+    return void 0;
+  };
+  return implementation;
+}
+export {
+  requireImplementation as __require
+};

package/dist/node_modules/array.prototype.find/index.js

@@ -0,0 +1,35 @@
+import { __require as requireDefineProperties } from "../define-properties/index.js";
+import { __require as requireCallBound } from "../call-bind/callBound.js";
+import { __require as requireRequireObjectCoercible } from "../es-object-atoms/RequireObjectCoercible.js";
+import { __require as requireImplementation } from "./implementation.js";
+import { __require as requirePolyfill } from "./polyfill.js";
+import { __require as requireShim } from "./shim.js";
+var array_prototype_find;
+var hasRequiredArray_prototype_find;
+function requireArray_prototype_find() {
+  if (hasRequiredArray_prototype_find) return array_prototype_find;
+  hasRequiredArray_prototype_find = 1;
+  var define = requireDefineProperties();
+  var callBound = requireCallBound();
+  var RequireObjectCoercible = requireRequireObjectCoercible();
+  var implementation = requireImplementation();
+  var getPolyfill = requirePolyfill();
+  var shim = requireShim();
+  var $slice = callBound("Array.prototype.slice");
+  var polyfill = getPolyfill();
+  var boundFindShim = function find(array, predicate) {
+    RequireObjectCoercible(array);
+    var args = $slice(arguments, 1);
+    return polyfill.apply(array, args);
+  };
+  define(boundFindShim, {
+    getPolyfill,
+    implementation,
+    shim
+  });
+  array_prototype_find = boundFindShim;
+  return array_prototype_find;
+}
+export {
+  requireArray_prototype_find as __require
+};

package/dist/node_modules/array.prototype.find/polyfill.js

@@ -0,0 +1,17 @@
+import { __require as requireImplementation } from "./implementation.js";
+var polyfill;
+var hasRequiredPolyfill;
+function requirePolyfill() {
+  if (hasRequiredPolyfill) return polyfill;
+  hasRequiredPolyfill = 1;
+  polyfill = function getPolyfill() {
+    var implemented = Array.prototype.find && [, 1].find(function() {
+      return true;
+    }) !== 1;
+    return implemented ? Array.prototype.find : requireImplementation();
+  };
+  return polyfill;
+}
+export {
+  requirePolyfill as __require
+};

package/dist/node_modules/array.prototype.find/shim.js

@@ -0,0 +1,30 @@
+import { __require as requireDefineProperties } from "../define-properties/index.js";
+import { __require as requireEsShimUnscopables } from "../es-shim-unscopables/index.js";
+import { __require as requirePolyfill } from "./polyfill.js";
+var shim;
+var hasRequiredShim;
+function requireShim() {
+  if (hasRequiredShim) return shim;
+  hasRequiredShim = 1;
+  var define = requireDefineProperties();
+  var shimUnscopables = requireEsShimUnscopables();
+  var getPolyfill = requirePolyfill();
+  shim = function shimArrayPrototypeFind() {
+    var polyfill = getPolyfill();
+    define(
+      Array.prototype,
+      { find: polyfill },
+      {
+        find: function() {
+          return Array.prototype.find !== polyfill;
+        }
+      }
+    );
+    shimUnscopables("find");
+    return polyfill;
+  };
+  return shim;
+}
+export {
+  requireShim as __require
+};

package/dist/node_modules/call-bind/callBound.js

@@ -0,0 +1,22 @@
+import { __require as requireGetIntrinsic } from "../get-intrinsic/index.js";
+import { __require as requireCallBind } from "./index.js";
+var callBound;
+var hasRequiredCallBound;
+function requireCallBound() {
+  if (hasRequiredCallBound) return callBound;
+  hasRequiredCallBound = 1;
+  var GetIntrinsic = requireGetIntrinsic();
+  var callBind = requireCallBind();
+  var $indexOf = callBind(GetIntrinsic("String.prototype.indexOf"));
+  callBound = function callBoundIntrinsic(name, allowMissing) {
+    var intrinsic = GetIntrinsic(name, !!allowMissing);
+    if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1) {
+      return callBind(intrinsic);
+    }
+    return intrinsic;
+  };
+  return callBound;
+}
+export {
+  requireCallBound as __require
+};

package/dist/node_modules/call-bind/index.js

@@ -1,4 +1,4 @@
-import { __module as callBind } from "../../_virtual/index15.js";
+import { __module as callBind } from "../../_virtual/index8.js";
 import { __require as requireSetFunctionLength } from "../set-function-length/index.js";
 import { __require as requireEsDefineProperty } from "../es-define-property/index.js";
 import { __require as requireCallBindApplyHelpers } from "../call-bind-apply-helpers/index.js";
@@ -14,10 +14,10 @@ function requireCallBind() {
     var applyBind = requireApplyBind();
     module.exports = function callBind2(originalFunction) {
       var func = callBindBasic(arguments);
-      var adjustedLength = originalFunction.length - (arguments.length - 1);
+      var adjustedLength = 1 + originalFunction.length - (arguments.length - 1);
       return setFunctionLength(
         func,
-        1 + (adjustedLength > 0 ? adjustedLength : 0),
+        adjustedLength > 0 ? adjustedLength : 0,
         true
       );
     };

package/dist/node_modules/enzyme-shallow-equal/build/index.js

@@ -0,0 +1,53 @@
+import { __module as build } from "../../../_virtual/index5.js";
+import { __require as requireObjectIs } from "../../object-is/index.js";
+import { __require as requireHasown } from "../../hasown/index.js";
+var hasRequiredBuild;
+function requireBuild() {
+  if (hasRequiredBuild) return build.exports;
+  hasRequiredBuild = 1;
+  (function(module, exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = shallowEqual;
+    var _objectIs = _interopRequireDefault(requireObjectIs());
+    var _hasown = _interopRequireDefault(requireHasown());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function _typeof(o) {
+      "@babel/helpers - typeof";
+      return _typeof = "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(o);
+    }
+    function shallowEqual(objA, objB) {
+      if ((0, _objectIs["default"])(objA, objB)) {
+        return true;
+      }
+      if (!objA || !objB || _typeof(objA) !== "object" || _typeof(objB) !== "object") {
+        return false;
+      }
+      var keysA = Object.keys(objA);
+      var keysB = Object.keys(objB);
+      if (keysA.length !== keysB.length) {
+        return false;
+      }
+      keysA.sort();
+      keysB.sort();
+      for (var i = 0; i < keysA.length; i += 1) {
+        if (!(0, _hasown["default"])(objB, keysA[i]) || !(0, _objectIs["default"])(objA[keysA[i]], objB[keysA[i]])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    module.exports = exports.default;
+  })(build, build.exports);
+  return build.exports;
+}
+export {
+  requireBuild as __require
+};

package/dist/node_modules/es-abstract/2023/CreateMethodProperty.js

@@ -0,0 +1,46 @@
+import { __require as requireType } from "../../es-errors/type.js";
+import { __require as requireIsObject } from "../../es-object-atoms/isObject.js";
+import { __require as requireDefineOwnProperty } from "../helpers/DefineOwnProperty.js";
+import { __require as requireFromPropertyDescriptor } from "./FromPropertyDescriptor.js";
+import { __require as requireIsDataDescriptor } from "./IsDataDescriptor.js";
+import { __require as requireIsPropertyKey } from "../helpers/isPropertyKey.js";
+import { __require as requireSameValue } from "./SameValue.js";
+var CreateMethodProperty;
+var hasRequiredCreateMethodProperty;
+function requireCreateMethodProperty() {
+  if (hasRequiredCreateMethodProperty) return CreateMethodProperty;
+  hasRequiredCreateMethodProperty = 1;
+  var $TypeError = requireType();
+  var isObject = requireIsObject();
+  var DefineOwnProperty = requireDefineOwnProperty();
+  var FromPropertyDescriptor = requireFromPropertyDescriptor();
+  var IsDataDescriptor = requireIsDataDescriptor();
+  var isPropertyKey = requireIsPropertyKey();
+  var SameValue = requireSameValue();
+  CreateMethodProperty = function CreateMethodProperty2(O, P, V) {
+    if (!isObject(O)) {
+      throw new $TypeError("Assertion failed: Type(O) is not Object");
+    }
+    if (!isPropertyKey(P)) {
+      throw new $TypeError("Assertion failed: P is not a Property Key");
+    }
+    var newDesc = {
+      "[[Configurable]]": true,
+      "[[Enumerable]]": false,
+      "[[Value]]": V,
+      "[[Writable]]": true
+    };
+    return DefineOwnProperty(
+      IsDataDescriptor,
+      SameValue,
+      FromPropertyDescriptor,
+      O,
+      P,
+      newDesc
+    );
+  };
+  return CreateMethodProperty;
+}
+export {
+  requireCreateMethodProperty as __require
+};

package/dist/node_modules/es-abstract/2023/FromPropertyDescriptor.js

@@ -0,0 +1,22 @@
+import { __require as requireType } from "../../es-errors/type.js";
+import { __require as requirePropertyDescriptor } from "../helpers/records/property-descriptor.js";
+import { __require as requireFromPropertyDescriptor$1 } from "../helpers/fromPropertyDescriptor.js";
+var FromPropertyDescriptor;
+var hasRequiredFromPropertyDescriptor;
+function requireFromPropertyDescriptor() {
+  if (hasRequiredFromPropertyDescriptor) return FromPropertyDescriptor;
+  hasRequiredFromPropertyDescriptor = 1;
+  var $TypeError = requireType();
+  var isPropertyDescriptor = requirePropertyDescriptor();
+  var fromPropertyDescriptor = requireFromPropertyDescriptor$1();
+  FromPropertyDescriptor = function FromPropertyDescriptor2(Desc) {
+    if (typeof Desc !== "undefined" && !isPropertyDescriptor(Desc)) {
+      throw new $TypeError("Assertion failed: `Desc` must be a Property Descriptor");
+    }
+    return fromPropertyDescriptor(Desc);
+  };
+  return FromPropertyDescriptor;
+}
+export {
+  requireFromPropertyDescriptor as __require
+};

package/dist/node_modules/es-abstract/2023/IsDataDescriptor.js

@@ -0,0 +1,28 @@
+import { __require as requireType } from "../../es-errors/type.js";
+import { __require as requireHasown } from "../../hasown/index.js";
+import { __require as requirePropertyDescriptor } from "../helpers/records/property-descriptor.js";
+var IsDataDescriptor;
+var hasRequiredIsDataDescriptor;
+function requireIsDataDescriptor() {
+  if (hasRequiredIsDataDescriptor) return IsDataDescriptor;
+  hasRequiredIsDataDescriptor = 1;
+  var $TypeError = requireType();
+  var hasOwn = requireHasown();
+  var isPropertyDescriptor = requirePropertyDescriptor();
+  IsDataDescriptor = function IsDataDescriptor2(Desc) {
+    if (typeof Desc === "undefined") {
+      return false;
+    }
+    if (!isPropertyDescriptor(Desc)) {
+      throw new $TypeError("Assertion failed: `Desc` must be a Property Descriptor");
+    }
+    if (!hasOwn(Desc, "[[Value]]") && !hasOwn(Desc, "[[Writable]]")) {
+      return false;
+    }
+    return true;
+  };
+  return IsDataDescriptor;
+}
+export {
+  requireIsDataDescriptor as __require
+};

package/dist/node_modules/es-abstract/2023/SameValue.js

@@ -0,0 +1,21 @@
+import { __require as require_isNaN } from "../../math-intrinsics/isNaN.js";
+var SameValue;
+var hasRequiredSameValue;
+function requireSameValue() {
+  if (hasRequiredSameValue) return SameValue;
+  hasRequiredSameValue = 1;
+  var $isNaN = require_isNaN();
+  SameValue = function SameValue2(x, y) {
+    if (x === y) {
+      if (x === 0) {
+        return 1 / x === 1 / y;
+      }
+      return true;
+    }
+    return $isNaN(x) && $isNaN(y);
+  };
+  return SameValue;
+}
+export {
+  requireSameValue as __require
+};

package/dist/node_modules/es-abstract/2025/ToString.js

@@ -0,0 +1,21 @@
+import { __require as requireGetIntrinsic } from "../../get-intrinsic/index.js";
+import { __require as requireType } from "../../es-errors/type.js";
+var ToString;
+var hasRequiredToString;
+function requireToString() {
+  if (hasRequiredToString) return ToString;
+  hasRequiredToString = 1;
+  var GetIntrinsic = requireGetIntrinsic();
+  var $String = GetIntrinsic("%String%");
+  var $TypeError = requireType();
+  ToString = function ToString2(argument) {
+    if (typeof argument === "symbol") {
+      throw new $TypeError("Cannot convert a Symbol value to a string");
+    }
+    return $String(argument);
+  };
+  return ToString;
+}
+export {
+  requireToString as __require
+};

package/dist/node_modules/es-abstract/helpers/OwnPropertyKeys.js

@@ -0,0 +1,12 @@
+import { __require as requireOwnKeys } from "../../own-keys/index.js";
+var OwnPropertyKeys;
+var hasRequiredOwnPropertyKeys;
+function requireOwnPropertyKeys() {
+  if (hasRequiredOwnPropertyKeys) return OwnPropertyKeys;
+  hasRequiredOwnPropertyKeys = 1;
+  OwnPropertyKeys = requireOwnKeys();
+  return OwnPropertyKeys;
+}
+export {
+  requireOwnPropertyKeys as __require
+};

package/dist/node_modules/es-abstract-get/GetMethod.js

@@ -0,0 +1,33 @@
+import { __require as requireType } from "../es-errors/type.js";
+import { __require as requireIsCallable } from "../is-callable/index.js";
+import { __require as requireObjectInspect } from "../object-inspect/index.js";
+import { __require as requireGetV } from "./GetV.js";
+import { __require as requireIsPropertyKey } from "./isPropertyKey.js";
+var GetMethod;
+var hasRequiredGetMethod;
+function requireGetMethod() {
+  if (hasRequiredGetMethod) return GetMethod;
+  hasRequiredGetMethod = 1;
+  var $TypeError = requireType();
+  var isCallable = requireIsCallable();
+  var inspect = requireObjectInspect();
+  var GetV = requireGetV();
+  var isPropertyKey = requireIsPropertyKey();
+  GetMethod = function GetMethod2(O, P) {
+    if (!isPropertyKey(P)) {
+      throw new $TypeError("Assertion failed: P is not a Property Key");
+    }
+    var func = GetV(O, P);
+    if (func == null) {
+      return void 0;
+    }
+    if (!isCallable(func)) {
+      throw new $TypeError(inspect(P) + " is not a function: " + inspect(func));
+    }
+    return func;
+  };
+  return GetMethod;
+}
+export {
+  requireGetMethod as __require
+};

package/dist/node_modules/es-abstract-get/GetV.js

@@ -0,0 +1,25 @@
+import { __require as requireType } from "../es-errors/type.js";
+import { __require as requireObjectInspect } from "../object-inspect/index.js";
+import { __require as requireIsPropertyKey } from "./isPropertyKey.js";
+var GetV;
+var hasRequiredGetV;
+function requireGetV() {
+  if (hasRequiredGetV) return GetV;
+  hasRequiredGetV = 1;
+  var $TypeError = requireType();
+  var inspect = requireObjectInspect();
+  var isPropertyKey = requireIsPropertyKey();
+  GetV = function GetV2(V, P) {
+    if (!isPropertyKey(P)) {
+      throw new $TypeError("Assertion failed: P is not a Property Key, got " + inspect(P));
+    }
+    return (
+      /** @type {Record<typeof P, unknown>} */
+      V[P]
+    );
+  };
+  return GetV;
+}
+export {
+  requireGetV as __require
+};

package/dist/node_modules/es-abstract-get/isPropertyKey.js

@@ -0,0 +1,13 @@
+var isPropertyKey;
+var hasRequiredIsPropertyKey;
+function requireIsPropertyKey() {
+  if (hasRequiredIsPropertyKey) return isPropertyKey;
+  hasRequiredIsPropertyKey = 1;
+  isPropertyKey = function isPropertyKey2(argument) {
+    return typeof argument === "string" || typeof argument === "symbol";
+  };
+  return isPropertyKey;
+}
+export {
+  requireIsPropertyKey as __require
+};

package/dist/node_modules/es-set-tostringtag/index.js

@@ -0,0 +1,39 @@
+import { __require as requireGetIntrinsic } from "../get-intrinsic/index.js";
+import { __require as requireShams } from "../has-tostringtag/shams.js";
+import { __require as requireHasown } from "../hasown/index.js";
+import { __require as requireType } from "../es-errors/type.js";
+var esSetTostringtag;
+var hasRequiredEsSetTostringtag;
+function requireEsSetTostringtag() {
+  if (hasRequiredEsSetTostringtag) return esSetTostringtag;
+  hasRequiredEsSetTostringtag = 1;
+  var GetIntrinsic = requireGetIntrinsic();
+  var $defineProperty = GetIntrinsic("%Object.defineProperty%", true);
+  var hasToStringTag = requireShams()();
+  var hasOwn = requireHasown();
+  var $TypeError = requireType();
+  var toStringTag = hasToStringTag ? Symbol.toStringTag : null;
+  esSetTostringtag = function setToStringTag(object, value) {
+    var overrideIfSet = arguments.length > 2 && !!arguments[2] && arguments[2].force;
+    var nonConfigurable = arguments.length > 2 && !!arguments[2] && arguments[2].nonConfigurable;
+    if (typeof overrideIfSet !== "undefined" && typeof overrideIfSet !== "boolean" || typeof nonConfigurable !== "undefined" && typeof nonConfigurable !== "boolean") {
+      throw new $TypeError("if provided, the `overrideIfSet` and `nonConfigurable` options must be booleans");
+    }
+    if (toStringTag && (overrideIfSet || !hasOwn(object, toStringTag))) {
+      if ($defineProperty) {
+        $defineProperty(object, toStringTag, {
+          configurable: !nonConfigurable,
+          enumerable: false,
+          value,
+          writable: false
+        });
+      } else {
+        object[toStringTag] = value;
+      }
+    }
+  };
+  return esSetTostringtag;
+}
+export {
+  requireEsSetTostringtag as __require
+};