armtek-uikit-react 1.0.268 → 1.0.269

package/lib/esm/node_modules/deep-equal/index.js

@@ -0,0 +1,397 @@
+import { __require as requireObject_assign } from "../object.assign/index.js";
+import { __require as requireCallBound } from "../call-bind/callBound.js";
+import { __require as requireRegexp_prototype_flags } from "../regexp.prototype.flags/index.js";
+import { __require as requireGetIntrinsic } from "../get-intrinsic/index.js";
+import { __require as requireEsGetIterator } from "../es-get-iterator/index.js";
+import { __require as requireSideChannel } from "../side-channel/index.js";
+import { __require as requireObjectIs } from "../object-is/index.js";
+import { __require as requireIsArguments } from "../is-arguments/index.js";
+import { __require as requireIsarray } from "../isarray/index.js";
+import { __require as requireIsArrayBuffer } from "../is-array-buffer/index.js";
+import { __require as requireIsDateObject } from "../is-date-object/index.js";
+import { __require as requireIsRegex } from "../is-regex/index.js";
+import { __require as requireIsSharedArrayBuffer } from "../is-shared-array-buffer/index.js";
+import { __require as requireObjectKeys } from "../object-keys/index.js";
+import { __require as requireWhichBoxedPrimitive } from "../which-boxed-primitive/index.js";
+import { __require as requireWhichCollection } from "../which-collection/index.js";
+import { __require as requireWhichTypedArray } from "../which-typed-array/index.js";
+import { __require as requireArrayBufferByteLength } from "../array-buffer-byte-length/index.js";
+var deepEqual;
+var hasRequiredDeepEqual;
+function requireDeepEqual() {
+  if (hasRequiredDeepEqual) return deepEqual;
+  hasRequiredDeepEqual = 1;
+  var assign = requireObject_assign();
+  var callBound = requireCallBound();
+  var flags = requireRegexp_prototype_flags();
+  var GetIntrinsic = /* @__PURE__ */ requireGetIntrinsic();
+  var getIterator = requireEsGetIterator();
+  var getSideChannel = requireSideChannel();
+  var is = requireObjectIs();
+  var isArguments = /* @__PURE__ */ requireIsArguments();
+  var isArray = requireIsarray();
+  var isArrayBuffer = /* @__PURE__ */ requireIsArrayBuffer();
+  var isDate = /* @__PURE__ */ requireIsDateObject();
+  var isRegex = requireIsRegex();
+  var isSharedArrayBuffer = /* @__PURE__ */ requireIsSharedArrayBuffer();
+  var objectKeys = requireObjectKeys();
+  var whichBoxedPrimitive = requireWhichBoxedPrimitive();
+  var whichCollection = /* @__PURE__ */ requireWhichCollection();
+  var whichTypedArray = /* @__PURE__ */ requireWhichTypedArray();
+  var byteLength = /* @__PURE__ */ requireArrayBufferByteLength();
+  var sabByteLength = callBound("SharedArrayBuffer.prototype.byteLength", true);
+  var $getTime = callBound("Date.prototype.getTime");
+  var gPO = Object.getPrototypeOf;
+  var $objToString = callBound("Object.prototype.toString");
+  var $Set = GetIntrinsic("%Set%", true);
+  var $mapHas = callBound("Map.prototype.has", true);
+  var $mapGet = callBound("Map.prototype.get", true);
+  var $mapSize = callBound("Map.prototype.size", true);
+  var $setAdd = callBound("Set.prototype.add", true);
+  var $setDelete = callBound("Set.prototype.delete", true);
+  var $setHas = callBound("Set.prototype.has", true);
+  var $setSize = callBound("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;
+}
+export {
+  requireDeepEqual as __require
+};

package/lib/esm/node_modules/define-data-property/index.js

@@ -0,0 +1,55 @@
+import { __require as requireEsDefineProperty } from "../es-define-property/index.js";
+import { __require as requireSyntax } from "../es-errors/syntax.js";
+import { __require as requireType } from "../es-errors/type.js";
+import { __require as requireGopd } from "../gopd/index.js";
+var defineDataProperty;
+var hasRequiredDefineDataProperty;
+function requireDefineDataProperty() {
+  if (hasRequiredDefineDataProperty) return defineDataProperty;
+  hasRequiredDefineDataProperty = 1;
+  var $defineProperty = /* @__PURE__ */ requireEsDefineProperty();
+  var $SyntaxError = /* @__PURE__ */ requireSyntax();
+  var $TypeError = /* @__PURE__ */ requireType();
+  var gopd = /* @__PURE__ */ requireGopd();
+  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;
+}
+export {
+  requireDefineDataProperty as __require
+};

package/lib/esm/node_modules/define-properties/index.js

@@ -0,0 +1,50 @@
+import { __require as requireObjectKeys } from "../object-keys/index.js";
+import { __require as requireDefineDataProperty } from "../define-data-property/index.js";
+import { __require as requireHasPropertyDescriptors } from "../has-property-descriptors/index.js";
+var defineProperties_1;
+var hasRequiredDefineProperties;
+function requireDefineProperties() {
+  if (hasRequiredDefineProperties) return defineProperties_1;
+  hasRequiredDefineProperties = 1;
+  var keys = requireObjectKeys();
+  var hasSymbols = typeof Symbol === "function" && typeof /* @__PURE__ */ Symbol("foo") === "symbol";
+  var toStr = Object.prototype.toString;
+  var concat = Array.prototype.concat;
+  var defineDataProperty = /* @__PURE__ */ requireDefineDataProperty();
+  var isFunction = function(fn) {
+    return typeof fn === "function" && toStr.call(fn) === "[object Function]";
+  };
+  var supportsDescriptors = /* @__PURE__ */ requireHasPropertyDescriptors()();
+  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;
+}
+export {
+  requireDefineProperties as __require
+};

package/lib/esm/node_modules/dunder-proto/get.js

@@ -0,0 +1,36 @@
+import { __require as requireCallBindApplyHelpers } from "../call-bind-apply-helpers/index.js";
+import { __require as requireGopd } from "../gopd/index.js";
+var get;
+var hasRequiredGet;
+function requireGet() {
+  if (hasRequiredGet) return get;
+  hasRequiredGet = 1;
+  var callBind = requireCallBindApplyHelpers();
+  var gOPD = /* @__PURE__ */ requireGopd();
+  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;
+}
+export {
+  requireGet as __require
+};

package/lib/esm/node_modules/es-define-property/index.js

@@ -0,0 +1,19 @@
+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;
+}
+export {
+  requireEsDefineProperty as __require
+};

package/lib/esm/node_modules/es-errors/eval.js

@@ -0,0 +1,11 @@
+var _eval;
+var hasRequired_eval;
+function require_eval() {
+  if (hasRequired_eval) return _eval;
+  hasRequired_eval = 1;
+  _eval = EvalError;
+  return _eval;
+}
+export {
+  require_eval as __require
+};

package/lib/esm/node_modules/es-errors/index.js

@@ -0,0 +1,11 @@
+var esErrors;
+var hasRequiredEsErrors;
+function requireEsErrors() {
+  if (hasRequiredEsErrors) return esErrors;
+  hasRequiredEsErrors = 1;
+  esErrors = Error;
+  return esErrors;
+}
+export {
+  requireEsErrors as __require
+};

package/lib/esm/node_modules/es-errors/range.js

@@ -0,0 +1,11 @@
+var range;
+var hasRequiredRange;
+function requireRange() {
+  if (hasRequiredRange) return range;
+  hasRequiredRange = 1;
+  range = RangeError;
+  return range;
+}
+export {
+  requireRange as __require
+};

package/lib/esm/node_modules/es-errors/ref.js

@@ -0,0 +1,11 @@
+var ref;
+var hasRequiredRef;
+function requireRef() {
+  if (hasRequiredRef) return ref;
+  hasRequiredRef = 1;
+  ref = ReferenceError;
+  return ref;
+}
+export {
+  requireRef as __require
+};

package/lib/esm/node_modules/es-errors/syntax.js

@@ -0,0 +1,11 @@
+var syntax;
+var hasRequiredSyntax;
+function requireSyntax() {
+  if (hasRequiredSyntax) return syntax;
+  hasRequiredSyntax = 1;
+  syntax = SyntaxError;
+  return syntax;
+}
+export {
+  requireSyntax as __require
+};

package/lib/esm/node_modules/es-errors/type.js

@@ -0,0 +1,11 @@
+var type;
+var hasRequiredType;
+function requireType() {
+  if (hasRequiredType) return type;
+  hasRequiredType = 1;
+  type = TypeError;
+  return type;
+}
+export {
+  requireType as __require
+};

package/lib/esm/node_modules/es-errors/uri.js

@@ -0,0 +1,11 @@
+var uri;
+var hasRequiredUri;
+function requireUri() {
+  if (hasRequiredUri) return uri;
+  hasRequiredUri = 1;
+  uri = URIError;
+  return uri;
+}
+export {
+  requireUri as __require
+};