armtek-uikit-react 1.0.268 → 1.0.270

package/lib/cjs/node_modules/deep-equal/index.cjs

@@ -0,0 +1,397 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../object.assign/index.cjs");
+const callBound = require("../call-bind/callBound.cjs");
+const index$1 = require("../regexp.prototype.flags/index.cjs");
+const index$8 = require("../get-intrinsic/index.cjs");
+const index$2 = require("../es-get-iterator/index.cjs");
+const index$3 = require("../side-channel/index.cjs");
+const index$4 = require("../object-is/index.cjs");
+const index$9 = require("../is-arguments/index.cjs");
+const index$a = require("../isarray/index.cjs");
+const index$d = require("../is-array-buffer/index.cjs");
+const index$b = require("../is-date-object/index.cjs");
+const index$5 = require("../is-regex/index.cjs");
+const index$f = require("../is-shared-array-buffer/index.cjs");
+const index$6 = require("../object-keys/index.cjs");
+const index$7 = require("../which-boxed-primitive/index.cjs");
+const index$g = require("../which-collection/index.cjs");
+const index$c = require("../which-typed-array/index.cjs");
+const index$e = require("../array-buffer-byte-length/index.cjs");
+var deepEqual;
+var hasRequiredDeepEqual;
+function requireDeepEqual() {
+  if (hasRequiredDeepEqual) return deepEqual;
+  hasRequiredDeepEqual = 1;
+  var assign = index.__require();
+  var callBound$1 = callBound.__require();
+  var flags = index$1.__require();
+  var GetIntrinsic = /* @__PURE__ */ index$8.__require();
+  var getIterator = index$2.__require();
+  var getSideChannel = index$3.__require();
+  var is = index$4.__require();
+  var isArguments = /* @__PURE__ */ index$9.__require();
+  var isArray = index$a.__require();
+  var isArrayBuffer = /* @__PURE__ */ index$d.__require();
+  var isDate = /* @__PURE__ */ index$b.__require();
+  var isRegex = index$5.__require();
+  var isSharedArrayBuffer = /* @__PURE__ */ index$f.__require();
+  var objectKeys = index$6.__require();
+  var whichBoxedPrimitive = index$7.__require();
+  var whichCollection = /* @__PURE__ */ index$g.__require();
+  var whichTypedArray = /* @__PURE__ */ index$c.__require();
+  var byteLength = /* @__PURE__ */ index$e.__require();
+  var sabByteLength = callBound$1("SharedArrayBuffer.prototype.byteLength", true);
+  var $getTime = callBound$1("Date.prototype.getTime");
+  var gPO = Object.getPrototypeOf;
+  var $objToString = callBound$1("Object.prototype.toString");
+  var $Set = GetIntrinsic("%Set%", true);
+  var $mapHas = callBound$1("Map.prototype.has", true);
+  var $mapGet = callBound$1("Map.prototype.get", true);
+  var $mapSize = callBound$1("Map.prototype.size", true);
+  var $setAdd = callBound$1("Set.prototype.add", true);
+  var $setDelete = callBound$1("Set.prototype.delete", true);
+  var $setHas = callBound$1("Set.prototype.has", true);
+  var $setSize = callBound$1("Set.prototype.size", true);
+  function setHasEqualElement(set, val1, opts, channel) {
+    var i = getIterator(set);
+    var result;
+    while ((result = i.next()) && !result.done) {
+      if (internalDeepEqual(val1, result.value, opts, channel)) {
+        $setDelete(set, result.value);
+        return true;
+      }
+    }
+    return false;
+  }
+  function findLooseMatchingPrimitives(prim) {
+    if (typeof prim === "undefined") {
+      return null;
+    }
+    if (typeof prim === "object") {
+      return void 0;
+    }
+    if (typeof prim === "symbol") {
+      return false;
+    }
+    if (typeof prim === "string" || typeof prim === "number") {
+      return +prim === +prim;
+    }
+    return true;
+  }
+  function mapMightHaveLoosePrim(a, b, prim, item, opts, channel) {
+    var altValue = findLooseMatchingPrimitives(prim);
+    if (altValue != null) {
+      return altValue;
+    }
+    var curB = $mapGet(b, altValue);
+    var looseOpts = assign({}, opts, { strict: false });
+    if (typeof curB === "undefined" && !$mapHas(b, altValue) || !internalDeepEqual(item, curB, looseOpts, channel)) {
+      return false;
+    }
+    return !$mapHas(a, altValue) && internalDeepEqual(item, curB, looseOpts, channel);
+  }
+  function setMightHaveLoosePrim(a, b, prim) {
+    var altValue = findLooseMatchingPrimitives(prim);
+    if (altValue != null) {
+      return altValue;
+    }
+    return $setHas(b, altValue) && !$setHas(a, altValue);
+  }
+  function mapHasEqualEntry(set, map, key1, item1, opts, channel) {
+    var i = getIterator(set);
+    var result;
+    var key2;
+    while ((result = i.next()) && !result.done) {
+      key2 = result.value;
+      if (
+        // eslint-disable-next-line no-use-before-define
+        internalDeepEqual(key1, key2, opts, channel) && internalDeepEqual(item1, $mapGet(map, key2), opts, channel)
+      ) {
+        $setDelete(set, key2);
+        return true;
+      }
+    }
+    return false;
+  }
+  function internalDeepEqual(actual, expected, options, channel) {
+    var opts = options || {};
+    if (opts.strict ? is(actual, expected) : actual === expected) {
+      return true;
+    }
+    var actualBoxed = whichBoxedPrimitive(actual);
+    var expectedBoxed = whichBoxedPrimitive(expected);
+    if (actualBoxed !== expectedBoxed) {
+      return false;
+    }
+    if (!actual || !expected || typeof actual !== "object" && typeof expected !== "object") {
+      return opts.strict ? is(actual, expected) : actual == expected;
+    }
+    var hasActual = channel.has(actual);
+    var hasExpected = channel.has(expected);
+    var sentinel;
+    if (hasActual && hasExpected) {
+      if (channel.get(actual) === channel.get(expected)) {
+        return true;
+      }
+    } else {
+      sentinel = {};
+    }
+    if (!hasActual) {
+      channel.set(actual, sentinel);
+    }
+    if (!hasExpected) {
+      channel.set(expected, sentinel);
+    }
+    return objEquiv(actual, expected, opts, channel);
+  }
+  function isBuffer(x) {
+    if (!x || typeof x !== "object" || typeof x.length !== "number") {
+      return false;
+    }
+    if (typeof x.copy !== "function" || typeof x.slice !== "function") {
+      return false;
+    }
+    if (x.length > 0 && typeof x[0] !== "number") {
+      return false;
+    }
+    return !!(x.constructor && x.constructor.isBuffer && x.constructor.isBuffer(x));
+  }
+  function setEquiv(a, b, opts, channel) {
+    if ($setSize(a) !== $setSize(b)) {
+      return false;
+    }
+    var iA = getIterator(a);
+    var iB = getIterator(b);
+    var resultA;
+    var resultB;
+    var set;
+    while ((resultA = iA.next()) && !resultA.done) {
+      if (resultA.value && typeof resultA.value === "object") {
+        if (!set) {
+          set = new $Set();
+        }
+        $setAdd(set, resultA.value);
+      } else if (!$setHas(b, resultA.value)) {
+        if (opts.strict) {
+          return false;
+        }
+        if (!setMightHaveLoosePrim(a, b, resultA.value)) {
+          return false;
+        }
+        if (!set) {
+          set = new $Set();
+        }
+        $setAdd(set, resultA.value);
+      }
+    }
+    if (set) {
+      while ((resultB = iB.next()) && !resultB.done) {
+        if (resultB.value && typeof resultB.value === "object") {
+          if (!setHasEqualElement(set, resultB.value, opts.strict, channel)) {
+            return false;
+          }
+        } else if (!opts.strict && !$setHas(a, resultB.value) && !setHasEqualElement(set, resultB.value, opts.strict, channel)) {
+          return false;
+        }
+      }
+      return $setSize(set) === 0;
+    }
+    return true;
+  }
+  function mapEquiv(a, b, opts, channel) {
+    if ($mapSize(a) !== $mapSize(b)) {
+      return false;
+    }
+    var iA = getIterator(a);
+    var iB = getIterator(b);
+    var resultA;
+    var resultB;
+    var set;
+    var key;
+    var item1;
+    var item2;
+    while ((resultA = iA.next()) && !resultA.done) {
+      key = resultA.value[0];
+      item1 = resultA.value[1];
+      if (key && typeof key === "object") {
+        if (!set) {
+          set = new $Set();
+        }
+        $setAdd(set, key);
+      } else {
+        item2 = $mapGet(b, key);
+        if (typeof item2 === "undefined" && !$mapHas(b, key) || !internalDeepEqual(item1, item2, opts, channel)) {
+          if (opts.strict) {
+            return false;
+          }
+          if (!mapMightHaveLoosePrim(a, b, key, item1, opts, channel)) {
+            return false;
+          }
+          if (!set) {
+            set = new $Set();
+          }
+          $setAdd(set, key);
+        }
+      }
+    }
+    if (set) {
+      while ((resultB = iB.next()) && !resultB.done) {
+        key = resultB.value[0];
+        item2 = resultB.value[1];
+        if (key && typeof key === "object") {
+          if (!mapHasEqualEntry(set, a, key, item2, opts, channel)) {
+            return false;
+          }
+        } else if (!opts.strict && (!a.has(key) || !internalDeepEqual($mapGet(a, key), item2, opts, channel)) && !mapHasEqualEntry(set, a, key, item2, assign({}, opts, { strict: false }), channel)) {
+          return false;
+        }
+      }
+      return $setSize(set) === 0;
+    }
+    return true;
+  }
+  function objEquiv(a, b, opts, channel) {
+    var i, key;
+    if (typeof a !== typeof b) {
+      return false;
+    }
+    if (a == null || b == null) {
+      return false;
+    }
+    if ($objToString(a) !== $objToString(b)) {
+      return false;
+    }
+    if (isArguments(a) !== isArguments(b)) {
+      return false;
+    }
+    var aIsArray = isArray(a);
+    var bIsArray = isArray(b);
+    if (aIsArray !== bIsArray) {
+      return false;
+    }
+    var aIsError = a instanceof Error;
+    var bIsError = b instanceof Error;
+    if (aIsError !== bIsError) {
+      return false;
+    }
+    if (aIsError || bIsError) {
+      if (a.name !== b.name || a.message !== b.message) {
+        return false;
+      }
+    }
+    var aIsRegex = isRegex(a);
+    var bIsRegex = isRegex(b);
+    if (aIsRegex !== bIsRegex) {
+      return false;
+    }
+    if ((aIsRegex || bIsRegex) && (a.source !== b.source || flags(a) !== flags(b))) {
+      return false;
+    }
+    var aIsDate = isDate(a);
+    var bIsDate = isDate(b);
+    if (aIsDate !== bIsDate) {
+      return false;
+    }
+    if (aIsDate || bIsDate) {
+      if ($getTime(a) !== $getTime(b)) {
+        return false;
+      }
+    }
+    if (opts.strict && gPO && gPO(a) !== gPO(b)) {
+      return false;
+    }
+    var aWhich = whichTypedArray(a);
+    var bWhich = whichTypedArray(b);
+    if (aWhich !== bWhich) {
+      return false;
+    }
+    if (aWhich || bWhich) {
+      if (a.length !== b.length) {
+        return false;
+      }
+      for (i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) {
+          return false;
+        }
+      }
+      return true;
+    }
+    var aIsBuffer = isBuffer(a);
+    var bIsBuffer = isBuffer(b);
+    if (aIsBuffer !== bIsBuffer) {
+      return false;
+    }
+    if (aIsBuffer || bIsBuffer) {
+      if (a.length !== b.length) {
+        return false;
+      }
+      for (i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) {
+          return false;
+        }
+      }
+      return true;
+    }
+    var aIsArrayBuffer = isArrayBuffer(a);
+    var bIsArrayBuffer = isArrayBuffer(b);
+    if (aIsArrayBuffer !== bIsArrayBuffer) {
+      return false;
+    }
+    if (aIsArrayBuffer || bIsArrayBuffer) {
+      if (byteLength(a) !== byteLength(b)) {
+        return false;
+      }
+      return typeof Uint8Array === "function" && internalDeepEqual(new Uint8Array(a), new Uint8Array(b), opts, channel);
+    }
+    var aIsSAB = isSharedArrayBuffer(a);
+    var bIsSAB = isSharedArrayBuffer(b);
+    if (aIsSAB !== bIsSAB) {
+      return false;
+    }
+    if (aIsSAB || bIsSAB) {
+      if (sabByteLength(a) !== sabByteLength(b)) {
+        return false;
+      }
+      return typeof Uint8Array === "function" && internalDeepEqual(new Uint8Array(a), new Uint8Array(b), opts, channel);
+    }
+    if (typeof a !== typeof b) {
+      return false;
+    }
+    var ka = objectKeys(a);
+    var kb = objectKeys(b);
+    if (ka.length !== kb.length) {
+      return false;
+    }
+    ka.sort();
+    kb.sort();
+    for (i = ka.length - 1; i >= 0; i--) {
+      if (ka[i] != kb[i]) {
+        return false;
+      }
+    }
+    for (i = ka.length - 1; i >= 0; i--) {
+      key = ka[i];
+      if (!internalDeepEqual(a[key], b[key], opts, channel)) {
+        return false;
+      }
+    }
+    var aCollection = whichCollection(a);
+    var bCollection = whichCollection(b);
+    if (aCollection !== bCollection) {
+      return false;
+    }
+    if (aCollection === "Set" || bCollection === "Set") {
+      return setEquiv(a, b, opts, channel);
+    }
+    if (aCollection === "Map") {
+      return mapEquiv(a, b, opts, channel);
+    }
+    return true;
+  }
+  deepEqual = function deepEqual2(a, b, opts) {
+    return internalDeepEqual(a, b, opts, getSideChannel());
+  };
+  return deepEqual;
+}
+exports.__require = requireDeepEqual;

package/lib/cjs/node_modules/define-data-property/index.cjs

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index$1 = require("../es-define-property/index.cjs");
+const syntax = require("../es-errors/syntax.cjs");
+const type = require("../es-errors/type.cjs");
+const index = require("../gopd/index.cjs");
+var defineDataProperty;
+var hasRequiredDefineDataProperty;
+function requireDefineDataProperty() {
+  if (hasRequiredDefineDataProperty) return defineDataProperty;
+  hasRequiredDefineDataProperty = 1;
+  var $defineProperty = /* @__PURE__ */ index$1.__require();
+  var $SyntaxError = /* @__PURE__ */ syntax.__require();
+  var $TypeError = /* @__PURE__ */ type.__require();
+  var gopd = /* @__PURE__ */ index.__require();
+  defineDataProperty = function defineDataProperty2(obj, property, value) {
+    if (!obj || typeof obj !== "object" && typeof obj !== "function") {
+      throw new $TypeError("`obj` must be an object or a function`");
+    }
+    if (typeof property !== "string" && typeof property !== "symbol") {
+      throw new $TypeError("`property` must be a string or a symbol`");
+    }
+    if (arguments.length > 3 && typeof arguments[3] !== "boolean" && arguments[3] !== null) {
+      throw new $TypeError("`nonEnumerable`, if provided, must be a boolean or null");
+    }
+    if (arguments.length > 4 && typeof arguments[4] !== "boolean" && arguments[4] !== null) {
+      throw new $TypeError("`nonWritable`, if provided, must be a boolean or null");
+    }
+    if (arguments.length > 5 && typeof arguments[5] !== "boolean" && arguments[5] !== null) {
+      throw new $TypeError("`nonConfigurable`, if provided, must be a boolean or null");
+    }
+    if (arguments.length > 6 && typeof arguments[6] !== "boolean") {
+      throw new $TypeError("`loose`, if provided, must be a boolean");
+    }
+    var nonEnumerable = arguments.length > 3 ? arguments[3] : null;
+    var nonWritable = arguments.length > 4 ? arguments[4] : null;
+    var nonConfigurable = arguments.length > 5 ? arguments[5] : null;
+    var loose = arguments.length > 6 ? arguments[6] : false;
+    var desc = !!gopd && gopd(obj, property);
+    if ($defineProperty) {
+      $defineProperty(obj, property, {
+        configurable: nonConfigurable === null && desc ? desc.configurable : !nonConfigurable,
+        enumerable: nonEnumerable === null && desc ? desc.enumerable : !nonEnumerable,
+        value,
+        writable: nonWritable === null && desc ? desc.writable : !nonWritable
+      });
+    } else if (loose || !nonEnumerable && !nonWritable && !nonConfigurable) {
+      obj[property] = value;
+    } else {
+      throw new $SyntaxError("This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.");
+    }
+  };
+  return defineDataProperty;
+}
+exports.__require = requireDefineDataProperty;

package/lib/cjs/node_modules/define-properties/index.cjs

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../object-keys/index.cjs");
+const index$2 = require("../define-data-property/index.cjs");
+const index$1 = require("../has-property-descriptors/index.cjs");
+var defineProperties_1;
+var hasRequiredDefineProperties;
+function requireDefineProperties() {
+  if (hasRequiredDefineProperties) return defineProperties_1;
+  hasRequiredDefineProperties = 1;
+  var keys = index.__require();
+  var hasSymbols = typeof Symbol === "function" && typeof /* @__PURE__ */ Symbol("foo") === "symbol";
+  var toStr = Object.prototype.toString;
+  var concat = Array.prototype.concat;
+  var defineDataProperty = /* @__PURE__ */ index$2.__require();
+  var isFunction = function(fn) {
+    return typeof fn === "function" && toStr.call(fn) === "[object Function]";
+  };
+  var supportsDescriptors = /* @__PURE__ */ index$1.__require()();
+  var defineProperty = function(object, name, value, predicate) {
+    if (name in object) {
+      if (predicate === true) {
+        if (object[name] === value) {
+          return;
+        }
+      } else if (!isFunction(predicate) || !predicate()) {
+        return;
+      }
+    }
+    if (supportsDescriptors) {
+      defineDataProperty(object, name, value, true);
+    } else {
+      defineDataProperty(object, name, value);
+    }
+  };
+  var defineProperties = function(object, map) {
+    var predicates = arguments.length > 2 ? arguments[2] : {};
+    var props = keys(map);
+    if (hasSymbols) {
+      props = concat.call(props, Object.getOwnPropertySymbols(map));
+    }
+    for (var i = 0; i < props.length; i += 1) {
+      defineProperty(object, props[i], map[props[i]], predicates[props[i]]);
+    }
+  };
+  defineProperties.supportsDescriptors = !!supportsDescriptors;
+  defineProperties_1 = defineProperties;
+  return defineProperties_1;
+}
+exports.__require = requireDefineProperties;

package/lib/cjs/node_modules/dunder-proto/get.cjs

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../call-bind-apply-helpers/index.cjs");
+const index$1 = require("../gopd/index.cjs");
+var get;
+var hasRequiredGet;
+function requireGet() {
+  if (hasRequiredGet) return get;
+  hasRequiredGet = 1;
+  var callBind = index.__require();
+  var gOPD = /* @__PURE__ */ index$1.__require();
+  var hasProtoAccessor;
+  try {
+    hasProtoAccessor = /** @type {{ __proto__?: typeof Array.prototype }} */
+    [].__proto__ === Array.prototype;
+  } catch (e) {
+    if (!e || typeof e !== "object" || !("code" in e) || e.code !== "ERR_PROTO_ACCESS") {
+      throw e;
+    }
+  }
+  var desc = !!hasProtoAccessor && gOPD && gOPD(
+    Object.prototype,
+    /** @type {keyof typeof Object.prototype} */
+    "__proto__"
+  );
+  var $Object = Object;
+  var $getPrototypeOf = $Object.getPrototypeOf;
+  get = desc && typeof desc.get === "function" ? callBind([desc.get]) : typeof $getPrototypeOf === "function" ? (
+    /** @type {import('./get')} */
+    function getDunder(value) {
+      return $getPrototypeOf(value == null ? value : $Object(value));
+    }
+  ) : false;
+  return get;
+}
+exports.__require = requireGet;

package/lib/cjs/node_modules/es-define-property/index.cjs

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var esDefineProperty;
+var hasRequiredEsDefineProperty;
+function requireEsDefineProperty() {
+  if (hasRequiredEsDefineProperty) return esDefineProperty;
+  hasRequiredEsDefineProperty = 1;
+  var $defineProperty = Object.defineProperty || false;
+  if ($defineProperty) {
+    try {
+      $defineProperty({}, "a", { value: 1 });
+    } catch (e) {
+      $defineProperty = false;
+    }
+  }
+  esDefineProperty = $defineProperty;
+  return esDefineProperty;
+}
+exports.__require = requireEsDefineProperty;

package/lib/cjs/node_modules/es-errors/eval.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var _eval;
+var hasRequired_eval;
+function require_eval() {
+  if (hasRequired_eval) return _eval;
+  hasRequired_eval = 1;
+  _eval = EvalError;
+  return _eval;
+}
+exports.__require = require_eval;

package/lib/cjs/node_modules/es-errors/index.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var esErrors;
+var hasRequiredEsErrors;
+function requireEsErrors() {
+  if (hasRequiredEsErrors) return esErrors;
+  hasRequiredEsErrors = 1;
+  esErrors = Error;
+  return esErrors;
+}
+exports.__require = requireEsErrors;

package/lib/cjs/node_modules/es-errors/range.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var range;
+var hasRequiredRange;
+function requireRange() {
+  if (hasRequiredRange) return range;
+  hasRequiredRange = 1;
+  range = RangeError;
+  return range;
+}
+exports.__require = requireRange;

package/lib/cjs/node_modules/es-errors/ref.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var ref;
+var hasRequiredRef;
+function requireRef() {
+  if (hasRequiredRef) return ref;
+  hasRequiredRef = 1;
+  ref = ReferenceError;
+  return ref;
+}
+exports.__require = requireRef;

package/lib/cjs/node_modules/es-errors/syntax.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var syntax;
+var hasRequiredSyntax;
+function requireSyntax() {
+  if (hasRequiredSyntax) return syntax;
+  hasRequiredSyntax = 1;
+  syntax = SyntaxError;
+  return syntax;
+}
+exports.__require = requireSyntax;

package/lib/cjs/node_modules/es-errors/type.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var type;
+var hasRequiredType;
+function requireType() {
+  if (hasRequiredType) return type;
+  hasRequiredType = 1;
+  type = TypeError;
+  return type;
+}
+exports.__require = requireType;

package/lib/cjs/node_modules/es-errors/uri.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var uri;
+var hasRequiredUri;
+function requireUri() {
+  if (hasRequiredUri) return uri;
+  hasRequiredUri = 1;
+  uri = URIError;
+  return uri;
+}
+exports.__require = requireUri;