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

package/dist/node_modules/object.assign/implementation.js

@@ -0,0 +1,52 @@
+import { __require as requireObjectKeys } from "../object-keys/index.js";
+import { __require as requireShams } from "../has-symbols/shams.js";
+import { __require as requireCallBound } from "../call-bound/index.js";
+import { __require as requireEsObjectAtoms } from "../es-object-atoms/index.js";
+var implementation;
+var hasRequiredImplementation;
+function requireImplementation() {
+  if (hasRequiredImplementation) return implementation;
+  hasRequiredImplementation = 1;
+  var objectKeys = requireObjectKeys();
+  var hasSymbols = requireShams()();
+  var callBound = requireCallBound();
+  var $Object = requireEsObjectAtoms();
+  var $push = callBound("Array.prototype.push");
+  var $propIsEnumerable = callBound("Object.prototype.propertyIsEnumerable");
+  var originalGetSymbols = hasSymbols ? $Object.getOwnPropertySymbols : null;
+  implementation = function assign(target, source1) {
+    if (target == null) {
+      throw new TypeError("target must be an object");
+    }
+    var to = $Object(target);
+    if (arguments.length === 1) {
+      return to;
+    }
+    for (var s = 1; s < arguments.length; ++s) {
+      var from = $Object(arguments[s]);
+      var keys = objectKeys(from);
+      var getSymbols = hasSymbols && ($Object.getOwnPropertySymbols || originalGetSymbols);
+      if (getSymbols) {
+        var syms = getSymbols(from);
+        for (var j = 0; j < syms.length; ++j) {
+          var key = syms[j];
+          if ($propIsEnumerable(from, key)) {
+            $push(keys, key);
+          }
+        }
+      }
+      for (var i = 0; i < keys.length; ++i) {
+        var nextKey = keys[i];
+        if ($propIsEnumerable(from, nextKey)) {
+          var propValue = from[nextKey];
+          to[nextKey] = propValue;
+        }
+      }
+    }
+    return to;
+  };
+  return implementation;
+}
+export {
+  requireImplementation as __require
+};

package/dist/node_modules/object.assign/index.js

@@ -0,0 +1,30 @@
+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 object_assign;
+var hasRequiredObject_assign;
+function requireObject_assign() {
+  if (hasRequiredObject_assign) return object_assign;
+  hasRequiredObject_assign = 1;
+  var defineProperties = requireDefineProperties();
+  var callBind = requireCallBind();
+  var implementation = requireImplementation();
+  var getPolyfill = requirePolyfill();
+  var shim = requireShim();
+  var polyfill = callBind.apply(getPolyfill());
+  var bound = function assign(target, source1) {
+    return polyfill(Object, arguments);
+  };
+  defineProperties(bound, {
+    getPolyfill,
+    implementation,
+    shim
+  });
+  object_assign = bound;
+  return object_assign;
+}
+export {
+  requireObject_assign as __require
+};

package/dist/node_modules/object.assign/polyfill.js

@@ -0,0 +1,53 @@
+import { __require as requireImplementation } from "./implementation.js";
+var polyfill;
+var hasRequiredPolyfill;
+function requirePolyfill() {
+  if (hasRequiredPolyfill) return polyfill;
+  hasRequiredPolyfill = 1;
+  var implementation = requireImplementation();
+  var lacksProperEnumerationOrder = function() {
+    if (!Object.assign) {
+      return false;
+    }
+    var str = "abcdefghijklmnopqrst";
+    var letters = str.split("");
+    var map = {};
+    for (var i = 0; i < letters.length; ++i) {
+      map[letters[i]] = letters[i];
+    }
+    var obj = Object.assign({}, map);
+    var actual = "";
+    for (var k in obj) {
+      actual += k;
+    }
+    return str !== actual;
+  };
+  var assignHasPendingExceptions = function() {
+    if (!Object.assign || !Object.preventExtensions) {
+      return false;
+    }
+    var thrower = Object.preventExtensions({ 1: 2 });
+    try {
+      Object.assign(thrower, "xy");
+    } catch (e) {
+      return thrower[1] === "y";
+    }
+    return false;
+  };
+  polyfill = function getPolyfill() {
+    if (!Object.assign) {
+      return implementation;
+    }
+    if (lacksProperEnumerationOrder()) {
+      return implementation;
+    }
+    if (assignHasPendingExceptions()) {
+      return implementation;
+    }
+    return Object.assign;
+  };
+  return polyfill;
+}
+export {
+  requirePolyfill as __require
+};

package/dist/node_modules/object.assign/shim.js

@@ -0,0 +1,25 @@
+import { __require as requireDefineProperties } from "../define-properties/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 getPolyfill = requirePolyfill();
+  shim = function shimAssign() {
+    var polyfill = getPolyfill();
+    define(
+      Object,
+      { assign: polyfill },
+      { assign: function() {
+        return Object.assign !== polyfill;
+      } }
+    );
+    return polyfill;
+  };
+  return shim;
+}
+export {
+  requireShim as __require
+};

package/dist/node_modules/object.entries/implementation.js

@@ -0,0 +1,26 @@
+import { __require as requireRequireObjectCoercible } from "../es-object-atoms/RequireObjectCoercible.js";
+import { __require as requireCallBound } from "../call-bound/index.js";
+var implementation;
+var hasRequiredImplementation;
+function requireImplementation() {
+  if (hasRequiredImplementation) return implementation;
+  hasRequiredImplementation = 1;
+  var RequireObjectCoercible = requireRequireObjectCoercible();
+  var callBound = requireCallBound();
+  var $isEnumerable = callBound("Object.prototype.propertyIsEnumerable");
+  var $push = callBound("Array.prototype.push");
+  implementation = function entries(O) {
+    var obj = RequireObjectCoercible(O);
+    var entrys = [];
+    for (var key in obj) {
+      if ($isEnumerable(obj, key)) {
+        $push(entrys, [key, obj[key]]);
+      }
+    }
+    return entrys;
+  };
+  return implementation;
+}
+export {
+  requireImplementation as __require
+};

package/dist/node_modules/object.entries/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 object_entries;
+var hasRequiredObject_entries;
+function requireObject_entries() {
+  if (hasRequiredObject_entries) return object_entries;
+  hasRequiredObject_entries = 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
+  });
+  object_entries = polyfill;
+  return object_entries;
+}
+export {
+  requireObject_entries as __require
+};

package/dist/node_modules/object.entries/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.entries === "function" ? Object.entries : implementation;
+  };
+  return polyfill;
+}
+export {
+  requirePolyfill as __require
+};

package/dist/node_modules/object.entries/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 shimEntries() {
+    var polyfill = getPolyfill();
+    define(Object, { entries: polyfill }, {
+      entries: function testEntries() {
+        return Object.entries !== polyfill;
+      }
+    });
+    return polyfill;
+  };
+  return shim;
+}
+export {
+  requireShim as __require
+};

package/dist/node_modules/object.values/implementation.js

@@ -0,0 +1,25 @@
+import { __require as requireRequireObjectCoercible } from "../es-object-atoms/RequireObjectCoercible.js";
+import { __require as requireCallBound } from "../call-bound/index.js";
+var implementation;
+var hasRequiredImplementation;
+function requireImplementation() {
+  if (hasRequiredImplementation) return implementation;
+  hasRequiredImplementation = 1;
+  var RequireObjectCoercible = requireRequireObjectCoercible();
+  var callBound = requireCallBound();
+  var $isEnumerable = callBound("Object.prototype.propertyIsEnumerable");
+  implementation = function values(O) {
+    var obj = RequireObjectCoercible(O);
+    var vals = [];
+    for (var key in obj) {
+      if ($isEnumerable(obj, key)) {
+        vals[vals.length] = obj[key];
+      }
+    }
+    return vals;
+  };
+  return implementation;
+}
+export {
+  requireImplementation as __require
+};

package/dist/node_modules/object.values/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 object_values;
+var hasRequiredObject_values;
+function requireObject_values() {
+  if (hasRequiredObject_values) return object_values;
+  hasRequiredObject_values = 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
+  });
+  object_values = polyfill;
+  return object_values;
+}
+export {
+  requireObject_values as __require
+};

package/dist/node_modules/object.values/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.values === "function" ? Object.values : implementation;
+  };
+  return polyfill;
+}
+export {
+  requirePolyfill as __require
+};

package/dist/node_modules/object.values/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 shimValues() {
+    var polyfill = getPolyfill();
+    define(Object, { values: polyfill }, {
+      values: function testValues() {
+        return Object.values !== polyfill;
+      }
+    });
+    return polyfill;
+  };
+  return shim;
+}
+export {
+  requireShim as __require
+};

package/dist/node_modules/own-keys/index.js

@@ -0,0 +1,26 @@
+import { __require as requireGetIntrinsic } from "../get-intrinsic/index.js";
+import { __require as requireSafePushApply } from "../safe-push-apply/index.js";
+import { __require as requireObjectKeys } from "../object-keys/index.js";
+var ownKeys;
+var hasRequiredOwnKeys;
+function requireOwnKeys() {
+  if (hasRequiredOwnKeys) return ownKeys;
+  hasRequiredOwnKeys = 1;
+  var GetIntrinsic = requireGetIntrinsic();
+  var safePushApply = requireSafePushApply();
+  var $ownKeys = GetIntrinsic("%Reflect.ownKeys%", true);
+  var $gOPN = GetIntrinsic("%Object.getOwnPropertyNames%", true);
+  var $gOPS = GetIntrinsic("%Object.getOwnPropertySymbols%", true);
+  var keys = requireObjectKeys();
+  ownKeys = $ownKeys || function ownKeys2(source) {
+    var sourceKeys = ($gOPN || keys)(source);
+    if ($gOPS) {
+      safePushApply(sourceKeys, $gOPS(source));
+    }
+    return sourceKeys;
+  };
+  return ownKeys;
+}
+export {
+  requireOwnKeys as __require
+};

package/dist/node_modules/performance-now/lib/performance-now.js

@@ -0,0 +1,42 @@
+import { commonjsGlobal } from "../../../_virtual/_commonjsHelpers.js";
+import { __module as performanceNow } from "../../../_virtual/performance-now.js";
+var hasRequiredPerformanceNow;
+function requirePerformanceNow() {
+  if (hasRequiredPerformanceNow) return performanceNow.exports;
+  hasRequiredPerformanceNow = 1;
+  (function() {
+    var getNanoSeconds, hrtime, loadTime, moduleLoadTime, nodeLoadTime, upTime;
+    if (typeof performance !== "undefined" && performance !== null && performance.now) {
+      performanceNow.exports = function() {
+        return performance.now();
+      };
+    } else if (typeof process !== "undefined" && process !== null && process.hrtime) {
+      performanceNow.exports = function() {
+        return (getNanoSeconds() - nodeLoadTime) / 1e6;
+      };
+      hrtime = process.hrtime;
+      getNanoSeconds = function() {
+        var hr;
+        hr = hrtime();
+        return hr[0] * 1e9 + hr[1];
+      };
+      moduleLoadTime = getNanoSeconds();
+      upTime = process.uptime() * 1e9;
+      nodeLoadTime = moduleLoadTime - upTime;
+    } else if (Date.now) {
+      performanceNow.exports = function() {
+        return Date.now() - loadTime;
+      };
+      loadTime = Date.now();
+    } else {
+      performanceNow.exports = function() {
+        return (/* @__PURE__ */ new Date()).getTime() - loadTime;
+      };
+      loadTime = (/* @__PURE__ */ new Date()).getTime();
+    }
+  }).call(commonjsGlobal);
+  return performanceNow.exports;
+}
+export {
+  requirePerformanceNow as __require
+};

package/dist/node_modules/prop-types/index.js

@@ -1,17 +1,20 @@
-import { getDefaultExportFromCjs } from "../../_virtual/_commonjsHelpers.js";
-import { __module as propTypes } from "../../_virtual/index2.js";
+import { __module as propTypes } from "../../_virtual/index3.js";
 import { __require as requireReactIs } from "../react-is/index.js";
 import { __require as requireFactoryWithTypeCheckers } from "./factoryWithTypeCheckers.js";
 import { __require as requireFactoryWithThrowingShims } from "./factoryWithThrowingShims.js";
-if (process.env.NODE_ENV !== "production") {
-  var ReactIs = requireReactIs();
-  var throwOnDirectAccess = true;
-  propTypes.exports = requireFactoryWithTypeCheckers()(ReactIs.isElement, throwOnDirectAccess);
-} else {
-  propTypes.exports = requireFactoryWithThrowingShims()();
+var hasRequiredPropTypes;
+function requirePropTypes() {
+  if (hasRequiredPropTypes) return propTypes.exports;
+  hasRequiredPropTypes = 1;
+  if (process.env.NODE_ENV !== "production") {
+    var ReactIs = requireReactIs();
+    var throwOnDirectAccess = true;
+    propTypes.exports = requireFactoryWithTypeCheckers()(ReactIs.isElement, throwOnDirectAccess);
+  } else {
+    propTypes.exports = requireFactoryWithThrowingShims()();
+  }
+  return propTypes.exports;
 }
-var propTypesExports = propTypes.exports;
-const PropTypes = /* @__PURE__ */ getDefaultExportFromCjs(propTypesExports);
 export {
-  PropTypes as default
+  requirePropTypes as __require
 };

package/dist/node_modules/prop-types-exact/build/helpers/isPlainObject.js

@@ -0,0 +1,15 @@
+import { __require as requireIsarray } from "../../node_modules/isarray/index.js";
+var isPlainObject;
+var hasRequiredIsPlainObject;
+function requireIsPlainObject() {
+  if (hasRequiredIsPlainObject) return isPlainObject;
+  hasRequiredIsPlainObject = 1;
+  var isArray = requireIsarray();
+  isPlainObject = function isPlainObject2(x) {
+    return x && typeof x === "object" && !isArray(x);
+  };
+  return isPlainObject;
+}
+export {
+  requireIsPlainObject as __require
+};

package/dist/node_modules/prop-types-exact/node_modules/isarray/index.js

@@ -0,0 +1,14 @@
+var isarray;
+var hasRequiredIsarray;
+function requireIsarray() {
+  if (hasRequiredIsarray) return isarray;
+  hasRequiredIsarray = 1;
+  var toString = {}.toString;
+  isarray = Array.isArray || function(arr) {
+    return toString.call(arr) == "[object Array]";
+  };
+  return isarray;
+}
+export {
+  requireIsarray as __require
+};

package/dist/node_modules/prop-types-exact/src/index.js

@@ -0,0 +1,52 @@
+import { __require as requireObject_assign } from "../../object.assign/index.js";
+import { __require as requireHasown } from "../../hasown/index.js";
+import { __require as requireReflect_ownkeys } from "../../reflect.ownkeys/index.js";
+import { __require as requireType } from "../../es-errors/type.js";
+import { __require as requireIsPlainObject } from "../build/helpers/isPlainObject.js";
+var src;
+var hasRequiredSrc;
+function requireSrc() {
+  if (hasRequiredSrc) return src;
+  hasRequiredSrc = 1;
+  var assign = requireObject_assign();
+  var hasOwn = requireHasown();
+  var ownKeys = requireReflect_ownkeys();
+  var TypeError = requireType();
+  var isPlainObject = requireIsPlainObject();
+  var zeroWidthSpace = "​";
+  var specialProperty = "prop-types-exact: " + zeroWidthSpace;
+  var semaphore = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"](specialProperty) : (
+    /* istanbul ignore next */
+    specialProperty
+  );
+  function brand(fn) {
+    fn[specialProperty] = semaphore;
+    return fn;
+  }
+  function isBranded(value) {
+    return value && value[specialProperty] === semaphore;
+  }
+  src = function forbidExtraProps(propTypes) {
+    if (!isPlainObject(propTypes)) {
+      throw new TypeError("given propTypes must be an object");
+    }
+    if (hasOwn(propTypes, specialProperty) && !isBranded(propTypes[specialProperty])) {
+      throw new TypeError("Against all odds, you created a propType for a prop that uses both the zero-width space and our custom string - which, sadly, conflicts with `prop-types-exact`");
+    }
+    var forbidden = {};
+    forbidden[specialProperty] = brand(function forbidUnknownProps(props, _, componentName) {
+      var unknownProps = ownKeys(props).filter(function(prop) {
+        return !hasOwn(propTypes, prop);
+      });
+      if (unknownProps.length > 0) {
+        return new TypeError(componentName + ": unknown props found: " + unknownProps.join(", "));
+      }
+      return null;
+    });
+    return assign({}, propTypes, forbidden);
+  };
+  return src;
+}
+export {
+  requireSrc as __require
+};

package/dist/node_modules/raf/index.js

@@ -0,0 +1,66 @@
+import { __module as raf } from "../../_virtual/index6.js";
+import { __require as requirePerformanceNow } from "../performance-now/lib/performance-now.js";
+var hasRequiredRaf;
+function requireRaf() {
+  if (hasRequiredRaf) return raf.exports;
+  hasRequiredRaf = 1;
+  var now = requirePerformanceNow(), root = typeof window === "undefined" ? globalThis : window, vendors = ["moz", "webkit"], suffix = "AnimationFrame", raf$1 = root["request" + suffix], caf = root["cancel" + suffix] || root["cancelRequest" + suffix];
+  for (var i = 0; !raf$1 && i < vendors.length; i++) {
+    raf$1 = root[vendors[i] + "Request" + suffix];
+    caf = root[vendors[i] + "Cancel" + suffix] || root[vendors[i] + "CancelRequest" + suffix];
+  }
+  if (!raf$1 || !caf) {
+    var last = 0, id = 0, queue = [], frameDuration = 1e3 / 60;
+    raf$1 = function(callback) {
+      if (queue.length === 0) {
+        var _now = now(), next = Math.max(0, frameDuration - (_now - last));
+        last = next + _now;
+        setTimeout(function() {
+          var cp = queue.slice(0);
+          queue.length = 0;
+          for (var i2 = 0; i2 < cp.length; i2++) {
+            if (!cp[i2].cancelled) {
+              try {
+                cp[i2].callback(last);
+              } catch (e) {
+                setTimeout(function() {
+                  throw e;
+                }, 0);
+              }
+            }
+          }
+        }, Math.round(next));
+      }
+      queue.push({
+        handle: ++id,
+        callback,
+        cancelled: false
+      });
+      return id;
+    };
+    caf = function(handle) {
+      for (var i2 = 0; i2 < queue.length; i2++) {
+        if (queue[i2].handle === handle) {
+          queue[i2].cancelled = true;
+        }
+      }
+    };
+  }
+  raf.exports = function(fn) {
+    return raf$1.call(root, fn);
+  };
+  raf.exports.cancel = function() {
+    caf.apply(root, arguments);
+  };
+  raf.exports.polyfill = function(object) {
+    if (!object) {
+      object = root;
+    }
+    object.requestAnimationFrame = raf$1;
+    object.cancelAnimationFrame = caf;
+  };
+  return raf.exports;
+}
+export {
+  requireRaf as __require
+};