impact-ui 4.0.16 → 4.0.17-alpha.2

package/dist/node_modules/es-to-primitive/es2015.js

@@ -1,23 +1,26 @@
-import { __require as requireIsPrimitive } from "./helpers/isPrimitive.js";
 import { __require as requireIsCallable } from "../is-callable/index.js";
 import { __require as requireIsDateObject } from "../is-date-object/index.js";
 import { __require as requireIsSymbol } from "../is-symbol/index.js";
+import { __require as requireType } from "../es-errors/type.js";
+import { __require as requireIsPrimitive } from "./helpers/isPrimitive.js";
+import { __require as requireGetMethod } from "../es-abstract-get/GetMethod.js";
 var es2015;
 var hasRequiredEs2015;
 function requireEs2015() {
   if (hasRequiredEs2015) return es2015;
   hasRequiredEs2015 = 1;
   var hasSymbols = typeof Symbol === "function" && typeof Symbol.iterator === "symbol";
-  var isPrimitive = requireIsPrimitive();
   var isCallable = requireIsCallable();
   var isDate = requireIsDateObject();
   var isSymbol = requireIsSymbol();
-  var ordinaryToPrimitive = function OrdinaryToPrimitive(O, hint) {
+  var $TypeError = requireType();
+  var isPrimitive = requireIsPrimitive();
+  function OrdinaryToPrimitive(O, hint) {
     if (typeof O === "undefined" || O === null) {
-      throw new TypeError("Cannot call method on " + O);
+      throw new $TypeError("Cannot call method on " + O);
     }
     if (typeof hint !== "string" || hint !== "number" && hint !== "string") {
-      throw new TypeError('hint must be "string" or "number"');
+      throw new $TypeError('hint must be "string" or "number"');
     }
     var methodNames = hint === "string" ? ["toString", "valueOf"] : ["valueOf", "toString"];
     var method, result, i;
@@ -26,25 +29,22 @@ function requireEs2015() {
       if (isCallable(method)) {
         result = method.call(O);
         if (isPrimitive(result)) {
-          return result;
+          return (
+            /** @type {primitiveES6} */
+            result
+          );
         }
       }
     }
-    throw new TypeError("No default value");
-  };
-  var GetMethod = function GetMethod2(O, P) {
-    var func = O[P];
-    if (func !== null && typeof func !== "undefined") {
-      if (!isCallable(func)) {
-        throw new TypeError(func + " returned for property " + String(P) + " of object " + O + " is not a function");
-      }
-      return func;
-    }
-    return void 0;
-  };
+    throw new $TypeError("No default value");
+  }
+  var GetMethod = requireGetMethod();
   es2015 = function ToPrimitive(input) {
     if (isPrimitive(input)) {
-      return input;
+      return (
+        /** @type {primitiveES6} */
+        input
+      );
     }
     var hint = "default";
     if (arguments.length > 1) {
@@ -58,7 +58,7 @@ function requireEs2015() {
     if (hasSymbols) {
       if (Symbol.toPrimitive) {
         exoticToPrim = GetMethod(
-          /** @type {Record<PropertyKey, unknown>} */
+          /** @type {{ [k in SymbolConstructor['toPrimitive']]?: Function }} */
           input,
           Symbol.toPrimitive
         );
@@ -69,18 +69,18 @@ function requireEs2015() {
     if (typeof exoticToPrim !== "undefined") {
       var result = exoticToPrim.call(input, hint);
       if (isPrimitive(result)) {
-        return result;
+        return (
+          /** @type {primitiveES6} */
+          result
+        );
       }
-      throw new TypeError("unable to convert exotic object to primitive");
+      throw new $TypeError("unable to convert exotic object to primitive");
     }
     if (hint === "default" && (isDate(input) || isSymbol(input))) {
-      hint = "string";
+      hint = /** @type {const} */
+      "string";
     }
-    return ordinaryToPrimitive(
-      /** @type {object} */
-      input,
-      hint === "default" ? "number" : hint
-    );
+    return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint);
   };
   return es2015;
 }

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 { r as reactIsExports } from "../node_modules/react-is/index.js";
-var reactIs = reactIsExports;
-var FORWARD_REF_STATICS = {
-  "$$typeof": true,
-  render: true,
-  defaultProps: true,
-  displayName: true,
-  propTypes: true
+import { __require as requireReactIs } from "../../react-is/index.js";
+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/index16.js";
+import { __module as isSymbol } from "../../_virtual/index11.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/lodash/lodash.js

@@ -9,10 +9,10 @@ import { __module as lodash } from "../../_virtual/lodash.js";
  * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  */
 lodash.exports;
-(function(module, exports$1) {
+(function(module, exports) {
   (function() {
     var undefined$1;
-    var VERSION = "4.17.23";
+    var VERSION = "4.17.21";
     var LARGE_ARRAY_SIZE = 200;
     var CORE_ERROR_TEXT = "Unsupported core-js use. Try https://npms.io/search?q=ponyfill.", FUNC_ERROR_TEXT = "Expected a function", INVALID_TEMPL_VAR_ERROR_TEXT = "Invalid `variable` option passed into `_.template`";
     var HASH_UNDEFINED = "__lodash_hash_undefined__";
@@ -337,7 +337,7 @@ lodash.exports;
     var freeGlobal = typeof globalThis == "object" && globalThis && globalThis.Object === Object && globalThis;
     var freeSelf = typeof self == "object" && self && self.Object === Object && self;
     var root = freeGlobal || freeSelf || Function("return this")();
-    var freeExports = exports$1 && !exports$1.nodeType && exports$1;
+    var freeExports = exports && !exports.nodeType && exports;
     var freeModule = freeExports && true && module && !module.nodeType && module;
     var moduleExports = freeModule && freeModule.exports === freeExports;
     var freeProcess = moduleExports && freeGlobal.process;
@@ -1940,28 +1940,8 @@ lodash.exports;
       }
       function baseUnset(object, path) {
         path = castPath(path, object);
-        var index = -1, length = path.length;
-        if (!length) {
-          return true;
-        }
-        var isRootPrimitive = object == null || typeof object !== "object" && typeof object !== "function";
-        while (++index < length) {
-          var key = path[index];
-          if (typeof key !== "string") {
-            continue;
-          }
-          if (key === "__proto__" && !hasOwnProperty.call(object, "__proto__")) {
-            return false;
-          }
-          if (key === "constructor" && index + 1 < length && typeof path[index + 1] === "string" && path[index + 1] === "prototype") {
-            if (isRootPrimitive && index === 0) {
-              continue;
-            }
-            return false;
-          }
-        }
-        var obj = parent(object, path);
-        return obj == null || delete obj[toKey(last(path))];
+        object = parent(object, path);
+        return object == null || delete object[toKey(last(path))];
       }
       function baseUpdate(object, path, updater, customizer) {
         return baseSet(object, path, updater(baseGet(object, path)), customizer);