armtek-uikit-react 1.0.268 → 1.0.270

package/lib/cjs/node_modules/object-keys/implementation.cjs

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isArguments = require("./isArguments.cjs");
+var implementation;
+var hasRequiredImplementation;
+function requireImplementation() {
+  if (hasRequiredImplementation) return implementation;
+  hasRequiredImplementation = 1;
+  var keysShim;
+  if (!Object.keys) {
+    var has = Object.prototype.hasOwnProperty;
+    var toStr = Object.prototype.toString;
+    var isArgs = isArguments.__require();
+    var isEnumerable = Object.prototype.propertyIsEnumerable;
+    var hasDontEnumBug = !isEnumerable.call({ toString: null }, "toString");
+    var hasProtoEnumBug = isEnumerable.call(function() {
+    }, "prototype");
+    var dontEnums = [
+      "toString",
+      "toLocaleString",
+      "valueOf",
+      "hasOwnProperty",
+      "isPrototypeOf",
+      "propertyIsEnumerable",
+      "constructor"
+    ];
+    var equalsConstructorPrototype = function(o) {
+      var ctor = o.constructor;
+      return ctor && ctor.prototype === o;
+    };
+    var excludedKeys = {
+      $applicationCache: true,
+      $console: true,
+      $external: true,
+      $frame: true,
+      $frameElement: true,
+      $frames: true,
+      $innerHeight: true,
+      $innerWidth: true,
+      $onmozfullscreenchange: true,
+      $onmozfullscreenerror: true,
+      $outerHeight: true,
+      $outerWidth: true,
+      $pageXOffset: true,
+      $pageYOffset: true,
+      $parent: true,
+      $scrollLeft: true,
+      $scrollTop: true,
+      $scrollX: true,
+      $scrollY: true,
+      $self: true,
+      $webkitIndexedDB: true,
+      $webkitStorageInfo: true,
+      $window: true
+    };
+    var hasAutomationEqualityBug = (function() {
+      if (typeof window === "undefined") {
+        return false;
+      }
+      for (var k in window) {
+        try {
+          if (!excludedKeys["$" + k] && has.call(window, k) && window[k] !== null && typeof window[k] === "object") {
+            try {
+              equalsConstructorPrototype(window[k]);
+            } catch (e) {
+              return true;
+            }
+          }
+        } catch (e) {
+          return true;
+        }
+      }
+      return false;
+    })();
+    var equalsConstructorPrototypeIfNotBuggy = function(o) {
+      if (typeof window === "undefined" || !hasAutomationEqualityBug) {
+        return equalsConstructorPrototype(o);
+      }
+      try {
+        return equalsConstructorPrototype(o);
+      } catch (e) {
+        return false;
+      }
+    };
+    keysShim = function keys(object) {
+      var isObject = object !== null && typeof object === "object";
+      var isFunction = toStr.call(object) === "[object Function]";
+      var isArguments2 = isArgs(object);
+      var isString = isObject && toStr.call(object) === "[object String]";
+      var theKeys = [];
+      if (!isObject && !isFunction && !isArguments2) {
+        throw new TypeError("Object.keys called on a non-object");
+      }
+      var skipProto = hasProtoEnumBug && isFunction;
+      if (isString && object.length > 0 && !has.call(object, 0)) {
+        for (var i = 0; i < object.length; ++i) {
+          theKeys.push(String(i));
+        }
+      }
+      if (isArguments2 && object.length > 0) {
+        for (var j = 0; j < object.length; ++j) {
+          theKeys.push(String(j));
+        }
+      } else {
+        for (var name in object) {
+          if (!(skipProto && name === "prototype") && has.call(object, name)) {
+            theKeys.push(String(name));
+          }
+        }
+      }
+      if (hasDontEnumBug) {
+        var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
+        for (var k = 0; k < dontEnums.length; ++k) {
+          if (!(skipConstructor && dontEnums[k] === "constructor") && has.call(object, dontEnums[k])) {
+            theKeys.push(dontEnums[k]);
+          }
+        }
+      }
+      return theKeys;
+    };
+  }
+  implementation = keysShim;
+  return implementation;
+}
+exports.__require = requireImplementation;

package/lib/cjs/node_modules/object-keys/index.cjs

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isArguments = require("./isArguments.cjs");
+const implementation = require("./implementation.cjs");
+var objectKeys;
+var hasRequiredObjectKeys;
+function requireObjectKeys() {
+  if (hasRequiredObjectKeys) return objectKeys;
+  hasRequiredObjectKeys = 1;
+  var slice = Array.prototype.slice;
+  var isArgs = isArguments.__require();
+  var origKeys = Object.keys;
+  var keysShim = origKeys ? function keys(o) {
+    return origKeys(o);
+  } : implementation.__require();
+  var originalKeys = Object.keys;
+  keysShim.shim = function shimObjectKeys() {
+    if (Object.keys) {
+      var keysWorksWithArguments = (function() {
+        var args = Object.keys(arguments);
+        return args && args.length === arguments.length;
+      })(1, 2);
+      if (!keysWorksWithArguments) {
+        Object.keys = function keys(object) {
+          if (isArgs(object)) {
+            return originalKeys(slice.call(object));
+          }
+          return originalKeys(object);
+        };
+      }
+    } else {
+      Object.keys = keysShim;
+    }
+    return Object.keys || keysShim;
+  };
+  objectKeys = keysShim;
+  return objectKeys;
+}
+exports.__require = requireObjectKeys;

package/lib/cjs/node_modules/object-keys/isArguments.cjs

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var isArguments;
+var hasRequiredIsArguments;
+function requireIsArguments() {
+  if (hasRequiredIsArguments) return isArguments;
+  hasRequiredIsArguments = 1;
+  var toStr = Object.prototype.toString;
+  isArguments = function isArguments2(value) {
+    var str = toStr.call(value);
+    var isArgs = str === "[object Arguments]";
+    if (!isArgs) {
+      isArgs = str !== "[object Array]" && value !== null && typeof value === "object" && typeof value.length === "number" && value.length >= 0 && toStr.call(value.callee) === "[object Function]";
+    }
+    return isArgs;
+  };
+  return isArguments;
+}
+exports.__require = requireIsArguments;

package/lib/cjs/node_modules/object.assign/implementation.cjs

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../object-keys/index.cjs");
+const shams = require("../has-symbols/shams.cjs");
+const index$1 = require("../call-bound/index.cjs");
+const index$2 = require("../es-object-atoms/index.cjs");
+var implementation;
+var hasRequiredImplementation;
+function requireImplementation() {
+  if (hasRequiredImplementation) return implementation;
+  hasRequiredImplementation = 1;
+  var objectKeys = index.__require();
+  var hasSymbols = shams.__require()();
+  var callBound = /* @__PURE__ */ index$1.__require();
+  var $Object = /* @__PURE__ */ index$2.__require();
+  var $push = callBound("Array.prototype.push");
+  var $propIsEnumerable = callBound("Object.prototype.propertyIsEnumerable");
+  var originalGetSymbols = hasSymbols ? $Object.getOwnPropertySymbols : null;
+  implementation = function assign(target, source1) {
+    if (target == null) {
+      throw new TypeError("target must be an object");
+    }
+    var to = $Object(target);
+    if (arguments.length === 1) {
+      return to;
+    }
+    for (var s = 1; s < arguments.length; ++s) {
+      var from = $Object(arguments[s]);
+      var keys = objectKeys(from);
+      var getSymbols = hasSymbols && ($Object.getOwnPropertySymbols || originalGetSymbols);
+      if (getSymbols) {
+        var syms = getSymbols(from);
+        for (var j = 0; j < syms.length; ++j) {
+          var key = syms[j];
+          if ($propIsEnumerable(from, key)) {
+            $push(keys, key);
+          }
+        }
+      }
+      for (var i = 0; i < keys.length; ++i) {
+        var nextKey = keys[i];
+        if ($propIsEnumerable(from, nextKey)) {
+          var propValue = from[nextKey];
+          to[nextKey] = propValue;
+        }
+      }
+    }
+    return to;
+  };
+  return implementation;
+}
+exports.__require = requireImplementation;

package/lib/cjs/node_modules/object.assign/index.cjs

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../define-properties/index.cjs");
+const index$1 = require("../call-bind/index.cjs");
+const implementation = require("./implementation.cjs");
+const polyfill = require("./polyfill.cjs");
+const shim = require("./shim.cjs");
+var object_assign;
+var hasRequiredObject_assign;
+function requireObject_assign() {
+  if (hasRequiredObject_assign) return object_assign;
+  hasRequiredObject_assign = 1;
+  var defineProperties = index.__require();
+  var callBind = index$1.__require();
+  var implementation$1 = implementation.__require();
+  var getPolyfill = polyfill.__require();
+  var shim$1 = shim.__require();
+  var polyfill$1 = callBind.apply(getPolyfill());
+  var bound = function assign(target, source1) {
+    return polyfill$1(Object, arguments);
+  };
+  defineProperties(bound, {
+    getPolyfill,
+    implementation: implementation$1,
+    shim: shim$1
+  });
+  object_assign = bound;
+  return object_assign;
+}
+exports.__require = requireObject_assign;

package/lib/cjs/node_modules/object.assign/polyfill.cjs

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const implementation = require("./implementation.cjs");
+var polyfill;
+var hasRequiredPolyfill;
+function requirePolyfill() {
+  if (hasRequiredPolyfill) return polyfill;
+  hasRequiredPolyfill = 1;
+  var implementation$1 = implementation.__require();
+  var lacksProperEnumerationOrder = function() {
+    if (!Object.assign) {
+      return false;
+    }
+    var str = "abcdefghijklmnopqrst";
+    var letters = str.split("");
+    var map = {};
+    for (var i = 0; i < letters.length; ++i) {
+      map[letters[i]] = letters[i];
+    }
+    var obj = Object.assign({}, map);
+    var actual = "";
+    for (var k in obj) {
+      actual += k;
+    }
+    return str !== actual;
+  };
+  var assignHasPendingExceptions = function() {
+    if (!Object.assign || !Object.preventExtensions) {
+      return false;
+    }
+    var thrower = Object.preventExtensions({ 1: 2 });
+    try {
+      Object.assign(thrower, "xy");
+    } catch (e) {
+      return thrower[1] === "y";
+    }
+    return false;
+  };
+  polyfill = function getPolyfill() {
+    if (!Object.assign) {
+      return implementation$1;
+    }
+    if (lacksProperEnumerationOrder()) {
+      return implementation$1;
+    }
+    if (assignHasPendingExceptions()) {
+      return implementation$1;
+    }
+    return Object.assign;
+  };
+  return polyfill;
+}
+exports.__require = requirePolyfill;

package/lib/cjs/node_modules/object.assign/shim.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../define-properties/index.cjs");
+const polyfill = require("./polyfill.cjs");
+var shim;
+var hasRequiredShim;
+function requireShim() {
+  if (hasRequiredShim) return shim;
+  hasRequiredShim = 1;
+  var define = index.__require();
+  var getPolyfill = polyfill.__require();
+  shim = function shimAssign() {
+    var polyfill2 = getPolyfill();
+    define(
+      Object,
+      { assign: polyfill2 },
+      { assign: function() {
+        return Object.assign !== polyfill2;
+      } }
+    );
+    return polyfill2;
+  };
+  return shim;
+}
+exports.__require = requireShim;

package/lib/cjs/node_modules/possible-typed-array-names/index.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var possibleTypedArrayNames;
+var hasRequiredPossibleTypedArrayNames;
+function requirePossibleTypedArrayNames() {
+  if (hasRequiredPossibleTypedArrayNames) return possibleTypedArrayNames;
+  hasRequiredPossibleTypedArrayNames = 1;
+  possibleTypedArrayNames = [
+    "Float16Array",
+    "Float32Array",
+    "Float64Array",
+    "Int8Array",
+    "Int16Array",
+    "Int32Array",
+    "Uint8Array",
+    "Uint8ClampedArray",
+    "Uint16Array",
+    "Uint32Array",
+    "BigInt64Array",
+    "BigUint64Array"
+  ];
+  return possibleTypedArrayNames;
+}
+exports.__require = requirePossibleTypedArrayNames;

package/lib/cjs/node_modules/pretty-format/build/collections.cjs

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const collections = require("../../../_virtual/collections.cjs");
+var hasRequiredCollections;
+function requireCollections() {
+  if (hasRequiredCollections) return collections.__exports;
+  hasRequiredCollections = 1;
+  Object.defineProperty(collections.__exports, "__esModule", {
+    value: true
+  });
+  collections.__exports.printIteratorEntries = printIteratorEntries;
+  collections.__exports.printIteratorValues = printIteratorValues;
+  collections.__exports.printListItems = printListItems;
+  collections.__exports.printObjectProperties = printObjectProperties;
+  const getKeysOfEnumerableProperties = (object, compareKeys) => {
+    const keys = Object.keys(object).sort(compareKeys);
+    if (Object.getOwnPropertySymbols) {
+      Object.getOwnPropertySymbols(object).forEach((symbol) => {
+        if (Object.getOwnPropertyDescriptor(object, symbol).enumerable) {
+          keys.push(symbol);
+        }
+      });
+    }
+    return keys;
+  };
+  function printIteratorEntries(iterator, config, indentation, depth, refs, printer, separator = ": ") {
+    let result = "";
+    let current = iterator.next();
+    if (!current.done) {
+      result += config.spacingOuter;
+      const indentationNext = indentation + config.indent;
+      while (!current.done) {
+        const name = printer(
+          current.value[0],
+          config,
+          indentationNext,
+          depth,
+          refs
+        );
+        const value = printer(
+          current.value[1],
+          config,
+          indentationNext,
+          depth,
+          refs
+        );
+        result += indentationNext + name + separator + value;
+        current = iterator.next();
+        if (!current.done) {
+          result += "," + config.spacingInner;
+        } else if (!config.min) {
+          result += ",";
+        }
+      }
+      result += config.spacingOuter + indentation;
+    }
+    return result;
+  }
+  function printIteratorValues(iterator, config, indentation, depth, refs, printer) {
+    let result = "";
+    let current = iterator.next();
+    if (!current.done) {
+      result += config.spacingOuter;
+      const indentationNext = indentation + config.indent;
+      while (!current.done) {
+        result += indentationNext + printer(current.value, config, indentationNext, depth, refs);
+        current = iterator.next();
+        if (!current.done) {
+          result += "," + config.spacingInner;
+        } else if (!config.min) {
+          result += ",";
+        }
+      }
+      result += config.spacingOuter + indentation;
+    }
+    return result;
+  }
+  function printListItems(list, config, indentation, depth, refs, printer) {
+    let result = "";
+    if (list.length) {
+      result += config.spacingOuter;
+      const indentationNext = indentation + config.indent;
+      for (let i = 0; i < list.length; i++) {
+        result += indentationNext;
+        if (i in list) {
+          result += printer(list[i], config, indentationNext, depth, refs);
+        }
+        if (i < list.length - 1) {
+          result += "," + config.spacingInner;
+        } else if (!config.min) {
+          result += ",";
+        }
+      }
+      result += config.spacingOuter + indentation;
+    }
+    return result;
+  }
+  function printObjectProperties(val, config, indentation, depth, refs, printer) {
+    let result = "";
+    const keys = getKeysOfEnumerableProperties(val, config.compareKeys);
+    if (keys.length) {
+      result += config.spacingOuter;
+      const indentationNext = indentation + config.indent;
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const name = printer(key, config, indentationNext, depth, refs);
+        const value = printer(val[key], config, indentationNext, depth, refs);
+        result += indentationNext + name + ": " + value;
+        if (i < keys.length - 1) {
+          result += "," + config.spacingInner;
+        } else if (!config.min) {
+          result += ",";
+        }
+      }
+      result += config.spacingOuter + indentation;
+    }
+    return result;
+  }
+  return collections.__exports;
+}
+exports.__require = requireCollections;