armtek-uikit-react 1.0.268 → 1.0.269

package/lib/esm/node_modules/react-is/cjs/react-is.development.js

@@ -0,0 +1,191 @@
+import { __exports as reactIs_development } from "../../../_virtual/react-is.development.js";
+var hasRequiredReactIs_development;
+function requireReactIs_development() {
+  if (hasRequiredReactIs_development) return reactIs_development;
+  hasRequiredReactIs_development = 1;
+  if (process.env.NODE_ENV !== "production") {
+    (function() {
+      var REACT_ELEMENT_TYPE = 60103;
+      var REACT_PORTAL_TYPE = 60106;
+      var REACT_FRAGMENT_TYPE = 60107;
+      var REACT_STRICT_MODE_TYPE = 60108;
+      var REACT_PROFILER_TYPE = 60114;
+      var REACT_PROVIDER_TYPE = 60109;
+      var REACT_CONTEXT_TYPE = 60110;
+      var REACT_FORWARD_REF_TYPE = 60112;
+      var REACT_SUSPENSE_TYPE = 60113;
+      var REACT_SUSPENSE_LIST_TYPE = 60120;
+      var REACT_MEMO_TYPE = 60115;
+      var REACT_LAZY_TYPE = 60116;
+      var REACT_BLOCK_TYPE = 60121;
+      var REACT_SERVER_BLOCK_TYPE = 60122;
+      var REACT_FUNDAMENTAL_TYPE = 60117;
+      var REACT_DEBUG_TRACING_MODE_TYPE = 60129;
+      var REACT_LEGACY_HIDDEN_TYPE = 60131;
+      if (typeof Symbol === "function" && Symbol.for) {
+        var symbolFor = Symbol.for;
+        REACT_ELEMENT_TYPE = symbolFor("react.element");
+        REACT_PORTAL_TYPE = symbolFor("react.portal");
+        REACT_FRAGMENT_TYPE = symbolFor("react.fragment");
+        REACT_STRICT_MODE_TYPE = symbolFor("react.strict_mode");
+        REACT_PROFILER_TYPE = symbolFor("react.profiler");
+        REACT_PROVIDER_TYPE = symbolFor("react.provider");
+        REACT_CONTEXT_TYPE = symbolFor("react.context");
+        REACT_FORWARD_REF_TYPE = symbolFor("react.forward_ref");
+        REACT_SUSPENSE_TYPE = symbolFor("react.suspense");
+        REACT_SUSPENSE_LIST_TYPE = symbolFor("react.suspense_list");
+        REACT_MEMO_TYPE = symbolFor("react.memo");
+        REACT_LAZY_TYPE = symbolFor("react.lazy");
+        REACT_BLOCK_TYPE = symbolFor("react.block");
+        REACT_SERVER_BLOCK_TYPE = symbolFor("react.server.block");
+        REACT_FUNDAMENTAL_TYPE = symbolFor("react.fundamental");
+        symbolFor("react.scope");
+        symbolFor("react.opaque.id");
+        REACT_DEBUG_TRACING_MODE_TYPE = symbolFor("react.debug_trace_mode");
+        symbolFor("react.offscreen");
+        REACT_LEGACY_HIDDEN_TYPE = symbolFor("react.legacy_hidden");
+      }
+      var enableScopeAPI = false;
+      function isValidElementType(type) {
+        if (typeof type === "string" || typeof type === "function") {
+          return true;
+        }
+        if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || type === REACT_DEBUG_TRACING_MODE_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || type === REACT_LEGACY_HIDDEN_TYPE || enableScopeAPI) {
+          return true;
+        }
+        if (typeof type === "object" && type !== null) {
+          if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_BLOCK_TYPE || type[0] === REACT_SERVER_BLOCK_TYPE) {
+            return true;
+          }
+        }
+        return false;
+      }
+      function typeOf(object) {
+        if (typeof object === "object" && object !== null) {
+          var $$typeof = object.$$typeof;
+          switch ($$typeof) {
+            case REACT_ELEMENT_TYPE:
+              var type = object.type;
+              switch (type) {
+                case REACT_FRAGMENT_TYPE:
+                case REACT_PROFILER_TYPE:
+                case REACT_STRICT_MODE_TYPE:
+                case REACT_SUSPENSE_TYPE:
+                case REACT_SUSPENSE_LIST_TYPE:
+                  return type;
+                default:
+                  var $$typeofType = type && type.$$typeof;
+                  switch ($$typeofType) {
+                    case REACT_CONTEXT_TYPE:
+                    case REACT_FORWARD_REF_TYPE:
+                    case REACT_LAZY_TYPE:
+                    case REACT_MEMO_TYPE:
+                    case REACT_PROVIDER_TYPE:
+                      return $$typeofType;
+                    default:
+                      return $$typeof;
+                  }
+              }
+            case REACT_PORTAL_TYPE:
+              return $$typeof;
+          }
+        }
+        return void 0;
+      }
+      var ContextConsumer = REACT_CONTEXT_TYPE;
+      var ContextProvider = REACT_PROVIDER_TYPE;
+      var Element = REACT_ELEMENT_TYPE;
+      var ForwardRef = REACT_FORWARD_REF_TYPE;
+      var Fragment = REACT_FRAGMENT_TYPE;
+      var Lazy = REACT_LAZY_TYPE;
+      var Memo = REACT_MEMO_TYPE;
+      var Portal = REACT_PORTAL_TYPE;
+      var Profiler = REACT_PROFILER_TYPE;
+      var StrictMode = REACT_STRICT_MODE_TYPE;
+      var Suspense = REACT_SUSPENSE_TYPE;
+      var hasWarnedAboutDeprecatedIsAsyncMode = false;
+      var hasWarnedAboutDeprecatedIsConcurrentMode = false;
+      function isAsyncMode(object) {
+        {
+          if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+            hasWarnedAboutDeprecatedIsAsyncMode = true;
+            console["warn"]("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 18+.");
+          }
+        }
+        return false;
+      }
+      function isConcurrentMode(object) {
+        {
+          if (!hasWarnedAboutDeprecatedIsConcurrentMode) {
+            hasWarnedAboutDeprecatedIsConcurrentMode = true;
+            console["warn"]("The ReactIs.isConcurrentMode() alias has been deprecated, and will be removed in React 18+.");
+          }
+        }
+        return false;
+      }
+      function isContextConsumer(object) {
+        return typeOf(object) === REACT_CONTEXT_TYPE;
+      }
+      function isContextProvider(object) {
+        return typeOf(object) === REACT_PROVIDER_TYPE;
+      }
+      function isElement(object) {
+        return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+      }
+      function isForwardRef(object) {
+        return typeOf(object) === REACT_FORWARD_REF_TYPE;
+      }
+      function isFragment(object) {
+        return typeOf(object) === REACT_FRAGMENT_TYPE;
+      }
+      function isLazy(object) {
+        return typeOf(object) === REACT_LAZY_TYPE;
+      }
+      function isMemo(object) {
+        return typeOf(object) === REACT_MEMO_TYPE;
+      }
+      function isPortal(object) {
+        return typeOf(object) === REACT_PORTAL_TYPE;
+      }
+      function isProfiler(object) {
+        return typeOf(object) === REACT_PROFILER_TYPE;
+      }
+      function isStrictMode(object) {
+        return typeOf(object) === REACT_STRICT_MODE_TYPE;
+      }
+      function isSuspense(object) {
+        return typeOf(object) === REACT_SUSPENSE_TYPE;
+      }
+      reactIs_development.ContextConsumer = ContextConsumer;
+      reactIs_development.ContextProvider = ContextProvider;
+      reactIs_development.Element = Element;
+      reactIs_development.ForwardRef = ForwardRef;
+      reactIs_development.Fragment = Fragment;
+      reactIs_development.Lazy = Lazy;
+      reactIs_development.Memo = Memo;
+      reactIs_development.Portal = Portal;
+      reactIs_development.Profiler = Profiler;
+      reactIs_development.StrictMode = StrictMode;
+      reactIs_development.Suspense = Suspense;
+      reactIs_development.isAsyncMode = isAsyncMode;
+      reactIs_development.isConcurrentMode = isConcurrentMode;
+      reactIs_development.isContextConsumer = isContextConsumer;
+      reactIs_development.isContextProvider = isContextProvider;
+      reactIs_development.isElement = isElement;
+      reactIs_development.isForwardRef = isForwardRef;
+      reactIs_development.isFragment = isFragment;
+      reactIs_development.isLazy = isLazy;
+      reactIs_development.isMemo = isMemo;
+      reactIs_development.isPortal = isPortal;
+      reactIs_development.isProfiler = isProfiler;
+      reactIs_development.isStrictMode = isStrictMode;
+      reactIs_development.isSuspense = isSuspense;
+      reactIs_development.isValidElementType = isValidElementType;
+      reactIs_development.typeOf = typeOf;
+    })();
+  }
+  return reactIs_development;
+}
+export {
+  requireReactIs_development as __require
+};

package/lib/esm/node_modules/react-is/cjs/react-is.production.min.js

@@ -0,0 +1,115 @@
+import { __exports as reactIs_production_min } from "../../../_virtual/react-is.production.min.js";
+var hasRequiredReactIs_production_min;
+function requireReactIs_production_min() {
+  if (hasRequiredReactIs_production_min) return reactIs_production_min;
+  hasRequiredReactIs_production_min = 1;
+  var b = 60103, c = 60106, d = 60107, e = 60108, f = 60114, g = 60109, h = 60110, k = 60112, l = 60113, m = 60120, n = 60115, p = 60116, q = 60121, r = 60122, u = 60117, v = 60129, w = 60131;
+  if ("function" === typeof Symbol && Symbol.for) {
+    var x = Symbol.for;
+    b = x("react.element");
+    c = x("react.portal");
+    d = x("react.fragment");
+    e = x("react.strict_mode");
+    f = x("react.profiler");
+    g = x("react.provider");
+    h = x("react.context");
+    k = x("react.forward_ref");
+    l = x("react.suspense");
+    m = x("react.suspense_list");
+    n = x("react.memo");
+    p = x("react.lazy");
+    q = x("react.block");
+    r = x("react.server.block");
+    u = x("react.fundamental");
+    v = x("react.debug_trace_mode");
+    w = x("react.legacy_hidden");
+  }
+  function y(a) {
+    if ("object" === typeof a && null !== a) {
+      var t = a.$$typeof;
+      switch (t) {
+        case b:
+          switch (a = a.type, a) {
+            case d:
+            case f:
+            case e:
+            case l:
+            case m:
+              return a;
+            default:
+              switch (a = a && a.$$typeof, a) {
+                case h:
+                case k:
+                case p:
+                case n:
+                case g:
+                  return a;
+                default:
+                  return t;
+              }
+          }
+        case c:
+          return t;
+      }
+    }
+  }
+  var z = g, A = b, B = k, C = d, D = p, E = n, F = c, G = f, H = e, I = l;
+  reactIs_production_min.ContextConsumer = h;
+  reactIs_production_min.ContextProvider = z;
+  reactIs_production_min.Element = A;
+  reactIs_production_min.ForwardRef = B;
+  reactIs_production_min.Fragment = C;
+  reactIs_production_min.Lazy = D;
+  reactIs_production_min.Memo = E;
+  reactIs_production_min.Portal = F;
+  reactIs_production_min.Profiler = G;
+  reactIs_production_min.StrictMode = H;
+  reactIs_production_min.Suspense = I;
+  reactIs_production_min.isAsyncMode = function() {
+    return false;
+  };
+  reactIs_production_min.isConcurrentMode = function() {
+    return false;
+  };
+  reactIs_production_min.isContextConsumer = function(a) {
+    return y(a) === h;
+  };
+  reactIs_production_min.isContextProvider = function(a) {
+    return y(a) === g;
+  };
+  reactIs_production_min.isElement = function(a) {
+    return "object" === typeof a && null !== a && a.$$typeof === b;
+  };
+  reactIs_production_min.isForwardRef = function(a) {
+    return y(a) === k;
+  };
+  reactIs_production_min.isFragment = function(a) {
+    return y(a) === d;
+  };
+  reactIs_production_min.isLazy = function(a) {
+    return y(a) === p;
+  };
+  reactIs_production_min.isMemo = function(a) {
+    return y(a) === n;
+  };
+  reactIs_production_min.isPortal = function(a) {
+    return y(a) === c;
+  };
+  reactIs_production_min.isProfiler = function(a) {
+    return y(a) === f;
+  };
+  reactIs_production_min.isStrictMode = function(a) {
+    return y(a) === e;
+  };
+  reactIs_production_min.isSuspense = function(a) {
+    return y(a) === l;
+  };
+  reactIs_production_min.isValidElementType = function(a) {
+    return "string" === typeof a || "function" === typeof a || a === d || a === f || a === v || a === e || a === l || a === m || a === w || "object" === typeof a && null !== a && (a.$$typeof === p || a.$$typeof === n || a.$$typeof === g || a.$$typeof === h || a.$$typeof === k || a.$$typeof === u || a.$$typeof === q || a[0] === r) ? true : false;
+  };
+  reactIs_production_min.typeOf = y;
+  return reactIs_production_min;
+}
+export {
+  requireReactIs_production_min as __require
+};

package/lib/esm/node_modules/react-is/index.js

@@ -0,0 +1,17 @@
+import { __module as reactIs } from "../../_virtual/index6.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";
+var hasRequiredReactIs;
+function requireReactIs() {
+  if (hasRequiredReactIs) return reactIs.exports;
+  hasRequiredReactIs = 1;
+  if (process.env.NODE_ENV === "production") {
+    reactIs.exports = requireReactIs_production_min();
+  } else {
+    reactIs.exports = requireReactIs_development();
+  }
+  return reactIs.exports;
+}
+export {
+  requireReactIs as __require
+};

package/lib/esm/node_modules/regexp.prototype.flags/implementation.js

@@ -0,0 +1,46 @@
+import { __require as requireSetFunctionName } from "../set-function-name/index.js";
+import { __require as requireType } from "../es-errors/type.js";
+var implementation;
+var hasRequiredImplementation;
+function requireImplementation() {
+  if (hasRequiredImplementation) return implementation;
+  hasRequiredImplementation = 1;
+  var setFunctionName = requireSetFunctionName();
+  var $TypeError = /* @__PURE__ */ requireType();
+  var $Object = Object;
+  implementation = setFunctionName(function flags() {
+    if (this == null || this !== $Object(this)) {
+      throw new $TypeError("RegExp.prototype.flags getter called on non-object");
+    }
+    var result = "";
+    if (this.hasIndices) {
+      result += "d";
+    }
+    if (this.global) {
+      result += "g";
+    }
+    if (this.ignoreCase) {
+      result += "i";
+    }
+    if (this.multiline) {
+      result += "m";
+    }
+    if (this.dotAll) {
+      result += "s";
+    }
+    if (this.unicode) {
+      result += "u";
+    }
+    if (this.unicodeSets) {
+      result += "v";
+    }
+    if (this.sticky) {
+      result += "y";
+    }
+    return result;
+  }, "get flags", true);
+  return implementation;
+}
+export {
+  requireImplementation as __require
+};

package/lib/esm/node_modules/regexp.prototype.flags/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 regexp_prototype_flags;
+var hasRequiredRegexp_prototype_flags;
+function requireRegexp_prototype_flags() {
+  if (hasRequiredRegexp_prototype_flags) return regexp_prototype_flags;
+  hasRequiredRegexp_prototype_flags = 1;
+  var define = requireDefineProperties();
+  var callBind = requireCallBind();
+  var implementation = requireImplementation();
+  var getPolyfill = requirePolyfill();
+  var shim = requireShim();
+  var flagsBound = callBind(getPolyfill());
+  define(flagsBound, {
+    getPolyfill,
+    implementation,
+    shim
+  });
+  regexp_prototype_flags = flagsBound;
+  return regexp_prototype_flags;
+}
+export {
+  requireRegexp_prototype_flags as __require
+};

package/lib/esm/node_modules/regexp.prototype.flags/polyfill.js

@@ -0,0 +1,39 @@
+import { __require as requireImplementation } from "./implementation.js";
+import { __require as requireDefineProperties } from "../define-properties/index.js";
+var polyfill;
+var hasRequiredPolyfill;
+function requirePolyfill() {
+  if (hasRequiredPolyfill) return polyfill;
+  hasRequiredPolyfill = 1;
+  var implementation = requireImplementation();
+  var supportsDescriptors = requireDefineProperties().supportsDescriptors;
+  var $gOPD = Object.getOwnPropertyDescriptor;
+  polyfill = function getPolyfill() {
+    if (supportsDescriptors && /a/mig.flags === "gim") {
+      var descriptor = $gOPD(RegExp.prototype, "flags");
+      if (descriptor && typeof descriptor.get === "function" && "dotAll" in RegExp.prototype && "hasIndices" in RegExp.prototype) {
+        var calls = "";
+        var o = {};
+        Object.defineProperty(o, "hasIndices", {
+          get: function() {
+            calls += "d";
+          }
+        });
+        Object.defineProperty(o, "sticky", {
+          get: function() {
+            calls += "y";
+          }
+        });
+        descriptor.get.call(o);
+        if (calls === "dy") {
+          return descriptor.get;
+        }
+      }
+    }
+    return implementation;
+  };
+  return polyfill;
+}
+export {
+  requirePolyfill as __require
+};

package/lib/esm/node_modules/regexp.prototype.flags/shim.js

@@ -0,0 +1,38 @@
+import { __require as requireDefineProperties } from "../define-properties/index.js";
+import { __require as requirePolyfill } from "./polyfill.js";
+import { __require as requireGopd } from "../gopd/index.js";
+import { __require as requireEsErrors } from "../es-errors/index.js";
+import { __require as requireGetProto } from "../get-proto/index.js";
+var shim;
+var hasRequiredShim;
+function requireShim() {
+  if (hasRequiredShim) return shim;
+  hasRequiredShim = 1;
+  var supportsDescriptors = requireDefineProperties().supportsDescriptors;
+  var getPolyfill = requirePolyfill();
+  var gOPD = /* @__PURE__ */ requireGopd();
+  var defineProperty = Object.defineProperty;
+  var $TypeError = /* @__PURE__ */ requireEsErrors();
+  var getProto = requireGetProto();
+  var regex = /a/;
+  shim = function shimFlags() {
+    if (!supportsDescriptors || !getProto) {
+      throw new $TypeError("RegExp.prototype.flags requires a true ES5 environment that supports property descriptors");
+    }
+    var polyfill = getPolyfill();
+    var proto = getProto(regex);
+    var descriptor = gOPD(proto, "flags");
+    if (!descriptor || descriptor.get !== polyfill) {
+      defineProperty(proto, "flags", {
+        configurable: true,
+        enumerable: false,
+        get: polyfill
+      });
+    }
+    return polyfill;
+  };
+  return shim;
+}
+export {
+  requireShim as __require
+};

package/lib/esm/node_modules/safe-regex-test/index.js

@@ -0,0 +1,25 @@
+import { __require as requireCallBound } from "../call-bound/index.js";
+import { __require as requireIsRegex } from "../is-regex/index.js";
+import { __require as requireType } from "../es-errors/type.js";
+var safeRegexTest;
+var hasRequiredSafeRegexTest;
+function requireSafeRegexTest() {
+  if (hasRequiredSafeRegexTest) return safeRegexTest;
+  hasRequiredSafeRegexTest = 1;
+  var callBound = /* @__PURE__ */ requireCallBound();
+  var isRegex = requireIsRegex();
+  var $exec = callBound("RegExp.prototype.exec");
+  var $TypeError = /* @__PURE__ */ requireType();
+  safeRegexTest = function regexTester(regex) {
+    if (!isRegex(regex)) {
+      throw new $TypeError("`regex` must be a RegExp");
+    }
+    return function test(s) {
+      return $exec(regex, s) !== null;
+    };
+  };
+  return safeRegexTest;
+}
+export {
+  requireSafeRegexTest as __require
+};

package/lib/esm/node_modules/set-function-length/index.js

@@ -0,0 +1,61 @@
+import { __require as requireGetIntrinsic } from "../get-intrinsic/index.js";
+import { __require as requireDefineDataProperty } from "../define-data-property/index.js";
+import { __require as requireHasPropertyDescriptors } from "../has-property-descriptors/index.js";
+import { __require as requireGopd } from "../gopd/index.js";
+import { __require as requireType } from "../es-errors/type.js";
+var setFunctionLength;
+var hasRequiredSetFunctionLength;
+function requireSetFunctionLength() {
+  if (hasRequiredSetFunctionLength) return setFunctionLength;
+  hasRequiredSetFunctionLength = 1;
+  var GetIntrinsic = /* @__PURE__ */ requireGetIntrinsic();
+  var define = /* @__PURE__ */ requireDefineDataProperty();
+  var hasDescriptors = /* @__PURE__ */ requireHasPropertyDescriptors()();
+  var gOPD = /* @__PURE__ */ requireGopd();
+  var $TypeError = /* @__PURE__ */ requireType();
+  var $floor = GetIntrinsic("%Math.floor%");
+  setFunctionLength = function setFunctionLength2(fn, length) {
+    if (typeof fn !== "function") {
+      throw new $TypeError("`fn` is not a function");
+    }
+    if (typeof length !== "number" || length < 0 || length > 4294967295 || $floor(length) !== length) {
+      throw new $TypeError("`length` must be a positive 32-bit integer");
+    }
+    var loose = arguments.length > 2 && !!arguments[2];
+    var functionLengthIsConfigurable = true;
+    var functionLengthIsWritable = true;
+    if ("length" in fn && gOPD) {
+      var desc = gOPD(fn, "length");
+      if (desc && !desc.configurable) {
+        functionLengthIsConfigurable = false;
+      }
+      if (desc && !desc.writable) {
+        functionLengthIsWritable = false;
+      }
+    }
+    if (functionLengthIsConfigurable || functionLengthIsWritable || !loose) {
+      if (hasDescriptors) {
+        define(
+          /** @type {Parameters<define>[0]} */
+          fn,
+          "length",
+          length,
+          true,
+          true
+        );
+      } else {
+        define(
+          /** @type {Parameters<define>[0]} */
+          fn,
+          "length",
+          length
+        );
+      }
+    }
+    return fn;
+  };
+  return setFunctionLength;
+}
+export {
+  requireSetFunctionLength as __require
+};

package/lib/esm/node_modules/set-function-name/index.js

@@ -0,0 +1,44 @@
+import { __require as requireDefineDataProperty } from "../define-data-property/index.js";
+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";
+var setFunctionName;
+var hasRequiredSetFunctionName;
+function requireSetFunctionName() {
+  if (hasRequiredSetFunctionName) return setFunctionName;
+  hasRequiredSetFunctionName = 1;
+  var define = /* @__PURE__ */ requireDefineDataProperty();
+  var hasDescriptors = /* @__PURE__ */ requireHasPropertyDescriptors()();
+  var functionsHaveConfigurableNames = requireFunctionsHaveNames().functionsHaveConfigurableNames();
+  var $TypeError = /* @__PURE__ */ requireType();
+  setFunctionName = function setFunctionName2(fn, name) {
+    if (typeof fn !== "function") {
+      throw new $TypeError("`fn` is not a function");
+    }
+    var loose = arguments.length > 2 && !!arguments[2];
+    if (!loose || functionsHaveConfigurableNames) {
+      if (hasDescriptors) {
+        define(
+          /** @type {Parameters<define>[0]} */
+          fn,
+          "name",
+          name,
+          true,
+          true
+        );
+      } else {
+        define(
+          /** @type {Parameters<define>[0]} */
+          fn,
+          "name",
+          name
+        );
+      }
+    }
+    return fn;
+  };
+  return setFunctionName;
+}
+export {
+  requireSetFunctionName as __require
+};

package/lib/esm/node_modules/side-channel/index.js

@@ -0,0 +1,47 @@
+import { __require as requireType } from "../es-errors/type.js";
+import { __require as requireObjectInspect } from "../object-inspect/index.js";
+import { __require as requireSideChannelList } from "../side-channel-list/index.js";
+import { __require as requireSideChannelMap } from "../side-channel-map/index.js";
+import { __require as requireSideChannelWeakmap } from "../side-channel-weakmap/index.js";
+var sideChannel;
+var hasRequiredSideChannel;
+function requireSideChannel() {
+  if (hasRequiredSideChannel) return sideChannel;
+  hasRequiredSideChannel = 1;
+  var $TypeError = /* @__PURE__ */ requireType();
+  var inspect = /* @__PURE__ */ requireObjectInspect();
+  var getSideChannelList = requireSideChannelList();
+  var getSideChannelMap = requireSideChannelMap();
+  var getSideChannelWeakMap = requireSideChannelWeakmap();
+  var makeChannel = getSideChannelWeakMap || getSideChannelMap || getSideChannelList;
+  sideChannel = function getSideChannel() {
+    var $channelData;
+    var channel = {
+      assert: function(key) {
+        if (!channel.has(key)) {
+          throw new $TypeError("Side channel does not contain " + inspect(key));
+        }
+      },
+      "delete": function(key) {
+        return !!$channelData && $channelData["delete"](key);
+      },
+      get: function(key) {
+        return $channelData && $channelData.get(key);
+      },
+      has: function(key) {
+        return !!$channelData && $channelData.has(key);
+      },
+      set: function(key, value) {
+        if (!$channelData) {
+          $channelData = makeChannel();
+        }
+        $channelData.set(key, value);
+      }
+    };
+    return channel;
+  };
+  return sideChannel;
+}
+export {
+  requireSideChannel as __require
+};