impact-ui 5.0.0-alpha.2 → 5.0.0-alpha.4

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/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-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
+};

package/dist/node_modules/function.prototype.name/implementation.js

@@ -0,0 +1,59 @@
+import { __require as requireIsCallable } from "../is-callable/index.js";
+import { __require as requireHasown } from "../hasown/index.js";
+import { __require as requireFunctionsHaveNames } from "../functions-have-names/index.js";
+import { __require as requireType } from "../es-errors/type.js";
+import { __require as requireCallBound } from "../call-bound/index.js";
+import { __require as requireIsDocument_all } from "../is-document.all/index.js";
+var implementation;
+var hasRequiredImplementation;
+function requireImplementation() {
+  if (hasRequiredImplementation) return implementation;
+  hasRequiredImplementation = 1;
+  var IsCallable = requireIsCallable();
+  var hasOwn = requireHasown();
+  var functionsHaveNames = requireFunctionsHaveNames()();
+  var $TypeError = requireType();
+  var callBound = requireCallBound();
+  var isDDA = requireIsDocument_all();
+  var $functionToString = callBound("Function.prototype.toString");
+  var $stringMatch = callBound("String.prototype.match");
+  var classRegex = /^class /;
+  var isClass = function isClassConstructor(fn) {
+    if (IsCallable(fn)) {
+      return false;
+    }
+    if (typeof fn !== "function") {
+      return false;
+    }
+    try {
+      var match = $stringMatch($functionToString(fn), classRegex);
+      return !!match;
+    } catch (e) {
+    }
+    return false;
+  };
+  var regex = /\s*function\s+([^(\s]*)\s*/;
+  var functionProto = Function.prototype;
+  implementation = function getName() {
+    if (isDDA(this) || !isClass(this) && !IsCallable(this)) {
+      throw new $TypeError("Function.prototype.name sham getter called on non-function");
+    }
+    if (functionsHaveNames && hasOwn(this, "name")) {
+      return this.name;
+    }
+    if (this === functionProto) {
+      return "";
+    }
+    var str = $functionToString(this);
+    var match = $stringMatch(str, regex);
+    var name = match && match[1];
+    return (
+      /** @type {string} */
+      name
+    );
+  };
+  return implementation;
+}
+export {
+  requireImplementation as __require
+};

package/dist/node_modules/function.prototype.name/index.js

@@ -0,0 +1,23 @@
+import { __module as function_prototype_name } from "../../_virtual/index9.js";
+import { __require as requireCallBind } from "../call-bind/index.js";
+import { __require as requireImplementation } from "./implementation.js";
+import { __require as requirePolyfill } from "./polyfill.js";
+import { __require as requireShim } from "./shim.js";
+var hasRequiredFunction_prototype_name;
+function requireFunction_prototype_name() {
+  if (hasRequiredFunction_prototype_name) return function_prototype_name.exports;
+  hasRequiredFunction_prototype_name = 1;
+  var callBind = requireCallBind();
+  var implementation = requireImplementation();
+  var getPolyfill = requirePolyfill();
+  var shim = requireShim();
+  var bound = callBind(implementation);
+  function_prototype_name.exports = bound;
+  function_prototype_name.exports.getPolyfill = getPolyfill;
+  function_prototype_name.exports.implementation = implementation;
+  function_prototype_name.exports.shim = shim;
+  return function_prototype_name.exports;
+}
+export {
+  requireFunction_prototype_name as __require
+};

package/dist/node_modules/function.prototype.name/polyfill.js

@@ -0,0 +1,15 @@
+import { __require as requireImplementation } from "./implementation.js";
+var polyfill;
+var hasRequiredPolyfill;
+function requirePolyfill() {
+  if (hasRequiredPolyfill) return polyfill;
+  hasRequiredPolyfill = 1;
+  var implementation = requireImplementation();
+  polyfill = function getPolyfill() {
+    return implementation;
+  };
+  return polyfill;
+}
+export {
+  requirePolyfill as __require
+};

package/dist/node_modules/function.prototype.name/shim.js

@@ -0,0 +1,47 @@
+import { __require as requireHasPropertyDescriptors } from "../has-property-descriptors/index.js";
+import { __require as requireFunctionsHaveNames } from "../functions-have-names/index.js";
+import { __require as requireType } from "../es-errors/type.js";
+import { __require as requirePolyfill } from "./polyfill.js";
+import { __require as requireEsDefineProperty } from "../es-define-property/index.js";
+var shim;
+var hasRequiredShim;
+function requireShim() {
+  if (hasRequiredShim) return shim;
+  hasRequiredShim = 1;
+  var supportsDescriptors = requireHasPropertyDescriptors()();
+  var functionsHaveNames = requireFunctionsHaveNames()();
+  var $TypeError = requireType();
+  var getPolyfill = requirePolyfill();
+  var defineProperty = requireEsDefineProperty();
+  shim = function shimName() {
+    var polyfill = getPolyfill();
+    if (functionsHaveNames) {
+      return polyfill;
+    }
+    if (!supportsDescriptors || !defineProperty) {
+      throw new $TypeError("Shimming Function.prototype.name support requires ES5 property descriptor support.");
+    }
+    var functionProto = Function.prototype;
+    defineProperty(functionProto, "name", {
+      configurable: true,
+      enumerable: false,
+      get: function() {
+        var name = polyfill.call(this);
+        if (this !== functionProto) {
+          defineProperty(this, "name", {
+            configurable: true,
+            enumerable: false,
+            value: name,
+            writable: false
+          });
+        }
+        return name;
+      }
+    });
+    return polyfill;
+  };
+  return shim;
+}
+export {
+  requireShim as __require
+};

package/dist/node_modules/functions-have-names/index.js

@@ -0,0 +1,36 @@
+var functionsHaveNames_1;
+var hasRequiredFunctionsHaveNames;
+function requireFunctionsHaveNames() {
+  if (hasRequiredFunctionsHaveNames) return functionsHaveNames_1;
+  hasRequiredFunctionsHaveNames = 1;
+  var functionsHaveNames = function functionsHaveNames2() {
+    return typeof (function f() {
+    }).name === "string";
+  };
+  var gOPD = Object.getOwnPropertyDescriptor;
+  if (gOPD) {
+    try {
+      gOPD([], "length");
+    } catch (e) {
+      gOPD = null;
+    }
+  }
+  functionsHaveNames.functionsHaveConfigurableNames = function functionsHaveConfigurableNames() {
+    if (!functionsHaveNames() || !gOPD) {
+      return false;
+    }
+    var desc = gOPD(function() {
+    }, "name");
+    return !!desc && !!desc.configurable;
+  };
+  var $bind = Function.prototype.bind;
+  functionsHaveNames.boundFunctionsHaveNames = function boundFunctionsHaveNames() {
+    return functionsHaveNames() && typeof $bind === "function" && (function f() {
+    }).bind().name !== "";
+  };
+  functionsHaveNames_1 = functionsHaveNames;
+  return functionsHaveNames_1;
+}
+export {
+  requireFunctionsHaveNames as __require
+};

package/dist/node_modules/globalthis/implementation.browser.js

@@ -0,0 +1,17 @@
+import { __module as implementation_browser } from "../../_virtual/implementation.browser.js";
+var hasRequiredImplementation_browser;
+function requireImplementation_browser() {
+  if (hasRequiredImplementation_browser) return implementation_browser.exports;
+  hasRequiredImplementation_browser = 1;
+  if (typeof self !== "undefined") {
+    implementation_browser.exports = self;
+  } else if (typeof window !== "undefined") {
+    implementation_browser.exports = window;
+  } else {
+    implementation_browser.exports = Function("return this")();
+  }
+  return implementation_browser.exports;
+}
+export {
+  requireImplementation_browser as __require
+};

package/dist/node_modules/globalthis/index.js

@@ -0,0 +1,28 @@
+import { __require as requireDefineProperties } from "../define-properties/index.js";
+import { __require as requireImplementation_browser } from "./implementation.browser.js";
+import { __require as requirePolyfill } from "./polyfill.js";
+import { __require as requireShim } from "./shim.js";
+var globalthis;
+var hasRequiredGlobalthis;
+function requireGlobalthis() {
+  if (hasRequiredGlobalthis) return globalthis;
+  hasRequiredGlobalthis = 1;
+  var defineProperties = requireDefineProperties();
+  var implementation = requireImplementation_browser();
+  var getPolyfill = requirePolyfill();
+  var shim = requireShim();
+  var polyfill = getPolyfill();
+  var getGlobal = function() {
+    return polyfill;
+  };
+  defineProperties(getGlobal, {
+    getPolyfill,
+    implementation,
+    shim
+  });
+  globalthis = getGlobal;
+  return globalthis;
+}
+export {
+  requireGlobalthis as __require
+};

package/dist/node_modules/globalthis/polyfill.js

@@ -0,0 +1,18 @@
+import { __require as requireImplementation_browser } from "./implementation.browser.js";
+var polyfill;
+var hasRequiredPolyfill;
+function requirePolyfill() {
+  if (hasRequiredPolyfill) return polyfill;
+  hasRequiredPolyfill = 1;
+  var implementation = requireImplementation_browser();
+  polyfill = function getPolyfill() {
+    if (typeof globalThis !== "object" || !globalThis || globalThis.Math !== Math || globalThis.Array !== Array) {
+      return implementation;
+    }
+    return globalThis;
+  };
+  return polyfill;
+}
+export {
+  requirePolyfill as __require
+};

package/dist/node_modules/globalthis/shim.js

@@ -0,0 +1,33 @@
+import { __require as requireDefineProperties } from "../define-properties/index.js";
+import { __require as requireGopd } from "../gopd/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 gOPD = requireGopd();
+  var getPolyfill = requirePolyfill();
+  shim = function shimGlobal() {
+    var polyfill = getPolyfill();
+    if (define.supportsDescriptors) {
+      var descriptor = gOPD(polyfill, "globalThis");
+      if (!descriptor || descriptor.configurable && (descriptor.enumerable || !descriptor.writable || globalThis !== polyfill)) {
+        Object.defineProperty(polyfill, "globalThis", {
+          configurable: true,
+          enumerable: false,
+          value: polyfill,
+          writable: true
+        });
+      }
+    } else if (typeof globalThis !== "object" || globalThis !== polyfill) {
+      polyfill.globalThis = polyfill;
+    }
+    return polyfill;
+  };
+  return shim;
+}
+export {
+  requireShim as __require
+};

package/dist/node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js

@@ -1,20 +1,92 @@
 import { __require as requireReactIs } from "../../react-is/index.js";
-var reactIs = requireReactIs();
-var FORWARD_REF_STATICS = {
-  "$$typeof": true,
-  render: true,
-  defaultProps: true,
-  displayName: true,
-  propTypes: true
+var hoistNonReactStatics_cjs;
+var hasRequiredHoistNonReactStatics_cjs;
+function requireHoistNonReactStatics_cjs() {
+  if (hasRequiredHoistNonReactStatics_cjs) return hoistNonReactStatics_cjs;
+  hasRequiredHoistNonReactStatics_cjs = 1;
+  var reactIs = requireReactIs();
+  var REACT_STATICS = {
+    childContextTypes: true,
+    contextType: true,
+    contextTypes: true,
+    defaultProps: true,
+    displayName: true,
+    getDefaultProps: true,
+    getDerivedStateFromError: true,
+    getDerivedStateFromProps: true,
+    mixins: true,
+    propTypes: true,
+    type: true
+  };
+  var KNOWN_STATICS = {
+    name: true,
+    length: true,
+    prototype: true,
+    caller: true,
+    callee: true,
+    arguments: true,
+    arity: true
+  };
+  var FORWARD_REF_STATICS = {
+    "$$typeof": true,
+    render: true,
+    defaultProps: true,
+    displayName: true,
+    propTypes: true
+  };
+  var MEMO_STATICS = {
+    "$$typeof": true,
+    compare: true,
+    defaultProps: true,
+    displayName: true,
+    propTypes: true,
+    type: true
+  };
+  var TYPE_STATICS = {};
+  TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;
+  TYPE_STATICS[reactIs.Memo] = MEMO_STATICS;
+  function getStatics(component) {
+    if (reactIs.isMemo(component)) {
+      return MEMO_STATICS;
+    }
+    return TYPE_STATICS[component["$$typeof"]] || REACT_STATICS;
+  }
+  var defineProperty = Object.defineProperty;
+  var getOwnPropertyNames = Object.getOwnPropertyNames;
+  var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+  var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+  var getPrototypeOf = Object.getPrototypeOf;
+  var objectPrototype = Object.prototype;
+  function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
+    if (typeof sourceComponent !== "string") {
+      if (objectPrototype) {
+        var inheritedComponent = getPrototypeOf(sourceComponent);
+        if (inheritedComponent && inheritedComponent !== objectPrototype) {
+          hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
+        }
+      }
+      var keys = getOwnPropertyNames(sourceComponent);
+      if (getOwnPropertySymbols) {
+        keys = keys.concat(getOwnPropertySymbols(sourceComponent));
+      }
+      var targetStatics = getStatics(targetComponent);
+      var sourceStatics = getStatics(sourceComponent);
+      for (var i = 0; i < keys.length; ++i) {
+        var key = keys[i];
+        if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {
+          var descriptor = getOwnPropertyDescriptor(sourceComponent, key);
+          try {
+            defineProperty(targetComponent, key, descriptor);
+          } catch (e) {
+          }
+        }
+      }
+    }
+    return targetComponent;
+  }
+  hoistNonReactStatics_cjs = hoistNonReactStatics;
+  return hoistNonReactStatics_cjs;
+}
+export {
+  requireHoistNonReactStatics_cjs as __require
 };
-var MEMO_STATICS = {
-  "$$typeof": true,
-  compare: true,
-  defaultProps: true,
-  displayName: true,
-  propTypes: true,
-  type: true
-};
-var TYPE_STATICS = {};
-TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;
-TYPE_STATICS[reactIs.Memo] = MEMO_STATICS;

package/dist/node_modules/is-document.all/index.js

@@ -0,0 +1,40 @@
+import { __require as requireCallBound } from "../call-bound/index.js";
+var isDocument_all;
+var hasRequiredIsDocument_all;
+function requireIsDocument_all() {
+  if (hasRequiredIsDocument_all) return isDocument_all;
+  hasRequiredIsDocument_all = 1;
+  var callBound = requireCallBound();
+  var toStr = callBound("Object.prototype.toString");
+  var isIE68 = !(0 in [,]);
+  var objectClass = "[object Object]";
+  var ddaClass = "[object HTMLAllCollection]";
+  var isDDA = function isDocumentDotAll() {
+    return (
+      /** @type {const} */
+      false
+    );
+  };
+  if (typeof document === "object") {
+    var all = document.all;
+    if (toStr(all) === toStr(document.all)) {
+      isDDA = /** @type {import('.')} */
+      function isDocumentDotAll2(value) {
+        if ((isIE68 || !value) && (typeof value === "undefined" || typeof value === "object")) {
+          try {
+            var str = toStr(value);
+            return (str === ddaClass || str === objectClass) && /** @type {Function} */
+            value("") == null;
+          } catch (e) {
+          }
+        }
+        return false;
+      };
+    }
+  }
+  isDocument_all = isDDA;
+  return isDocument_all;
+}
+export {
+  requireIsDocument_all as __require
+};

package/dist/node_modules/is-symbol/index.js

@@ -1,4 +1,4 @@
-import { __module as isSymbol } from "../../_virtual/index7.js";
+import { __module as isSymbol } from "../../_virtual/index12.js";
 import { __require as requireCallBound } from "../call-bound/index.js";
 import { __require as requireHasSymbols } from "../has-symbols/index.js";
 import { __require as requireSafeRegexTest } from "../safe-regex-test/index.js";

package/dist/node_modules/object-is/implementation.js

@@ -0,0 +1,25 @@
+var implementation;
+var hasRequiredImplementation;
+function requireImplementation() {
+  if (hasRequiredImplementation) return implementation;
+  hasRequiredImplementation = 1;
+  var numberIsNaN = function(value) {
+    return value !== value;
+  };
+  implementation = function is(a, b) {
+    if (a === 0 && b === 0) {
+      return 1 / a === 1 / b;
+    }
+    if (a === b) {
+      return true;
+    }
+    if (numberIsNaN(a) && numberIsNaN(b)) {
+      return true;
+    }
+    return false;
+  };
+  return implementation;
+}
+export {
+  requireImplementation as __require
+};

package/dist/node_modules/object-is/index.js

@@ -0,0 +1,27 @@
+import { __require as requireDefineProperties } from "../define-properties/index.js";
+import { __require as requireCallBind } from "../call-bind/index.js";
+import { __require as requireImplementation } from "./implementation.js";
+import { __require as requirePolyfill } from "./polyfill.js";
+import { __require as requireShim } from "./shim.js";
+var objectIs;
+var hasRequiredObjectIs;
+function requireObjectIs() {
+  if (hasRequiredObjectIs) return objectIs;
+  hasRequiredObjectIs = 1;
+  var define = requireDefineProperties();
+  var callBind = requireCallBind();
+  var implementation = requireImplementation();
+  var getPolyfill = requirePolyfill();
+  var shim = requireShim();
+  var polyfill = callBind(getPolyfill(), Object);
+  define(polyfill, {
+    getPolyfill,
+    implementation,
+    shim
+  });
+  objectIs = polyfill;
+  return objectIs;
+}
+export {
+  requireObjectIs as __require
+};

package/dist/node_modules/object-is/polyfill.js

@@ -0,0 +1,15 @@
+import { __require as requireImplementation } from "./implementation.js";
+var polyfill;
+var hasRequiredPolyfill;
+function requirePolyfill() {
+  if (hasRequiredPolyfill) return polyfill;
+  hasRequiredPolyfill = 1;
+  var implementation = requireImplementation();
+  polyfill = function getPolyfill() {
+    return typeof Object.is === "function" ? Object.is : implementation;
+  };
+  return polyfill;
+}
+export {
+  requirePolyfill as __require
+};

package/dist/node_modules/object-is/shim.js

@@ -0,0 +1,23 @@
+import { __require as requirePolyfill } from "./polyfill.js";
+import { __require as requireDefineProperties } from "../define-properties/index.js";
+var shim;
+var hasRequiredShim;
+function requireShim() {
+  if (hasRequiredShim) return shim;
+  hasRequiredShim = 1;
+  var getPolyfill = requirePolyfill();
+  var define = requireDefineProperties();
+  shim = function shimObjectIs() {
+    var polyfill = getPolyfill();
+    define(Object, { is: polyfill }, {
+      is: function testObjectIs() {
+        return Object.is !== polyfill;
+      }
+    });
+    return polyfill;
+  };
+  return shim;
+}
+export {
+  requireShim as __require
+};