armtek-uikit-react 1.0.268 → 1.0.270

package/lib/cjs/node_modules/@testing-library/dom/node_modules/aria-query/lib/elementRoleMap.cjs

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const elementRoleMap = require("../../../../../../_virtual/elementRoleMap.cjs");
+const index = require("../../../../../deep-equal/index.cjs");
+const iterationDecorator = require("./util/iterationDecorator.cjs");
+const rolesMap = require("./rolesMap.cjs");
+var hasRequiredElementRoleMap;
+function requireElementRoleMap() {
+  if (hasRequiredElementRoleMap) return elementRoleMap.__exports;
+  hasRequiredElementRoleMap = 1;
+  Object.defineProperty(elementRoleMap.__exports, "__esModule", {
+    value: true
+  });
+  elementRoleMap.__exports.default = void 0;
+  var _deepEqual = _interopRequireDefault(index.__require());
+  var _iterationDecorator = _interopRequireDefault(iterationDecorator.__require());
+  var _rolesMap = _interopRequireDefault(rolesMap.__require());
+  function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : { default: obj };
+  }
+  function _slicedToArray(arr, i2) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i2) || _unsupportedIterableToArray(arr, i2) || _nonIterableRest();
+  }
+  function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  function _iterableToArrayLimit(arr, i2) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+      for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+        _arr.push(_s.value);
+        if (i2 && _arr.length === i2) break;
+      }
+    } catch (err) {
+      _d = true;
+      _e = err;
+    } finally {
+      try {
+        if (!_n && _i["return"] != null) _i["return"]();
+      } finally {
+        if (_d) throw _e;
+      }
+    }
+    return _arr;
+  }
+  function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+  }
+  function _createForOfIteratorHelper(o, allowArrayLike) {
+    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+    if (!it) {
+      if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike) {
+        if (it) o = it;
+        var i2 = 0;
+        var F = function F2() {
+        };
+        return { s: F, n: function n() {
+          if (i2 >= o.length) return { done: true };
+          return { done: false, value: o[i2++] };
+        }, e: function e(_e2) {
+          throw _e2;
+        }, f: F };
+      }
+      throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }
+    var normalCompletion = true, didErr = false, err;
+    return { s: function s() {
+      it = it.call(o);
+    }, n: function n() {
+      var step = it.next();
+      normalCompletion = step.done;
+      return step;
+    }, e: function e(_e3) {
+      didErr = true;
+      err = _e3;
+    }, f: function f() {
+      try {
+        if (!normalCompletion && it.return != null) it.return();
+      } finally {
+        if (didErr) throw err;
+      }
+    } };
+  }
+  function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(o);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+  }
+  function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for (var i2 = 0, arr2 = new Array(len); i2 < len; i2++) {
+      arr2[i2] = arr[i2];
+    }
+    return arr2;
+  }
+  var elementRoles = [];
+  var keys = _rolesMap.default.keys();
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    var role = _rolesMap.default.get(key);
+    if (role) {
+      var concepts = [].concat(role.baseConcepts, role.relatedConcepts);
+      for (var k = 0; k < concepts.length; k++) {
+        var relation = concepts[k];
+        if (relation.module === "HTML") {
+          var concept = relation.concept;
+          if (concept) {
+            (function() {
+              var conceptStr = JSON.stringify(concept);
+              var elementRoleRelation = elementRoles.find(function(relation2) {
+                return JSON.stringify(relation2[0]) === conceptStr;
+              });
+              var roles = void 0;
+              if (elementRoleRelation) {
+                roles = elementRoleRelation[1];
+              } else {
+                roles = [];
+              }
+              var isUnique = true;
+              for (var _i = 0; _i < roles.length; _i++) {
+                if (roles[_i] === key) {
+                  isUnique = false;
+                  break;
+                }
+              }
+              if (isUnique) {
+                roles.push(key);
+              }
+              elementRoles.push([concept, roles]);
+            })();
+          }
+        }
+      }
+    }
+  }
+  var elementRoleMap$1 = {
+    entries: function entries() {
+      return elementRoles;
+    },
+    forEach: function forEach(fn) {
+      var thisArg = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
+      var _iterator = _createForOfIteratorHelper(elementRoles), _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done; ) {
+          var _step$value = _slicedToArray(_step.value, 2), _key = _step$value[0], values = _step$value[1];
+          fn.call(thisArg, values, _key, elementRoles);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    },
+    get: function get(key2) {
+      var item = elementRoles.find(function(tuple) {
+        return (0, _deepEqual.default)(key2, tuple[0]);
+      });
+      return item && item[1];
+    },
+    has: function has(key2) {
+      return !!elementRoleMap$1.get(key2);
+    },
+    keys: function keys2() {
+      return elementRoles.map(function(_ref) {
+        var _ref2 = _slicedToArray(_ref, 1), key2 = _ref2[0];
+        return key2;
+      });
+    },
+    values: function values() {
+      return elementRoles.map(function(_ref3) {
+        var _ref4 = _slicedToArray(_ref3, 2), values2 = _ref4[1];
+        return values2;
+      });
+    }
+  };
+  var _default = (0, _iterationDecorator.default)(elementRoleMap$1, elementRoleMap$1.entries());
+  elementRoleMap.__exports.default = _default;
+  return elementRoleMap.__exports;
+}
+exports.__require = requireElementRoleMap;

package/lib/cjs/node_modules/@testing-library/dom/node_modules/aria-query/lib/etc/roles/abstract/commandRole.cjs

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const commandRole = require("../../../../../../../../../_virtual/commandRole.cjs");
+var hasRequiredCommandRole;
+function requireCommandRole() {
+  if (hasRequiredCommandRole) return commandRole.__exports;
+  hasRequiredCommandRole = 1;
+  Object.defineProperty(commandRole.__exports, "__esModule", {
+    value: true
+  });
+  commandRole.__exports.default = void 0;
+  var commandRole$1 = {
+    abstract: true,
+    accessibleNameRequired: false,
+    baseConcepts: [],
+    childrenPresentational: false,
+    nameFrom: ["author"],
+    prohibitedProps: [],
+    props: {},
+    relatedConcepts: [{
+      concept: {
+        name: "menuitem"
+      },
+      module: "HTML"
+    }],
+    requireContextRole: [],
+    requiredContextRole: [],
+    requiredOwnedElements: [],
+    requiredProps: {},
+    superClass: [["roletype", "widget"]]
+  };
+  var _default = commandRole$1;
+  commandRole.__exports.default = _default;
+  return commandRole.__exports;
+}
+exports.__require = requireCommandRole;

package/lib/cjs/node_modules/@testing-library/dom/node_modules/aria-query/lib/etc/roles/abstract/compositeRole.cjs

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const compositeRole = require("../../../../../../../../../_virtual/compositeRole.cjs");
+var hasRequiredCompositeRole;
+function requireCompositeRole() {
+  if (hasRequiredCompositeRole) return compositeRole.__exports;
+  hasRequiredCompositeRole = 1;
+  Object.defineProperty(compositeRole.__exports, "__esModule", {
+    value: true
+  });
+  compositeRole.__exports.default = void 0;
+  var compositeRole$1 = {
+    abstract: true,
+    accessibleNameRequired: false,
+    baseConcepts: [],
+    childrenPresentational: false,
+    nameFrom: ["author"],
+    prohibitedProps: [],
+    props: {
+      "aria-activedescendant": null,
+      "aria-disabled": null
+    },
+    relatedConcepts: [],
+    requireContextRole: [],
+    requiredContextRole: [],
+    requiredOwnedElements: [],
+    requiredProps: {},
+    superClass: [["roletype", "widget"]]
+  };
+  var _default = compositeRole$1;
+  compositeRole.__exports.default = _default;
+  return compositeRole.__exports;
+}
+exports.__require = requireCompositeRole;

package/lib/cjs/node_modules/@testing-library/dom/node_modules/aria-query/lib/etc/roles/abstract/inputRole.cjs

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const inputRole = require("../../../../../../../../../_virtual/inputRole.cjs");
+var hasRequiredInputRole;
+function requireInputRole() {
+  if (hasRequiredInputRole) return inputRole.__exports;
+  hasRequiredInputRole = 1;
+  Object.defineProperty(inputRole.__exports, "__esModule", {
+    value: true
+  });
+  inputRole.__exports.default = void 0;
+  var inputRole$1 = {
+    abstract: true,
+    accessibleNameRequired: false,
+    baseConcepts: [],
+    childrenPresentational: false,
+    nameFrom: ["author"],
+    prohibitedProps: [],
+    props: {
+      "aria-disabled": null
+    },
+    relatedConcepts: [{
+      concept: {
+        name: "input"
+      },
+      module: "XForms"
+    }],
+    requireContextRole: [],
+    requiredContextRole: [],
+    requiredOwnedElements: [],
+    requiredProps: {},
+    superClass: [["roletype", "widget"]]
+  };
+  var _default = inputRole$1;
+  inputRole.__exports.default = _default;
+  return inputRole.__exports;
+}
+exports.__require = requireInputRole;

package/lib/cjs/node_modules/@testing-library/dom/node_modules/aria-query/lib/etc/roles/abstract/landmarkRole.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const landmarkRole = require("../../../../../../../../../_virtual/landmarkRole.cjs");
+var hasRequiredLandmarkRole;
+function requireLandmarkRole() {
+  if (hasRequiredLandmarkRole) return landmarkRole.__exports;
+  hasRequiredLandmarkRole = 1;
+  Object.defineProperty(landmarkRole.__exports, "__esModule", {
+    value: true
+  });
+  landmarkRole.__exports.default = void 0;
+  var landmarkRole$1 = {
+    abstract: true,
+    accessibleNameRequired: false,
+    baseConcepts: [],
+    childrenPresentational: false,
+    nameFrom: ["author"],
+    prohibitedProps: [],
+    props: {},
+    relatedConcepts: [],
+    requireContextRole: [],
+    requiredContextRole: [],
+    requiredOwnedElements: [],
+    requiredProps: {},
+    superClass: [["roletype", "structure", "section"]]
+  };
+  var _default = landmarkRole$1;
+  landmarkRole.__exports.default = _default;
+  return landmarkRole.__exports;
+}
+exports.__require = requireLandmarkRole;

package/lib/cjs/node_modules/@testing-library/dom/node_modules/aria-query/lib/etc/roles/abstract/rangeRole.cjs

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const rangeRole = require("../../../../../../../../../_virtual/rangeRole.cjs");
+var hasRequiredRangeRole;
+function requireRangeRole() {
+  if (hasRequiredRangeRole) return rangeRole.__exports;
+  hasRequiredRangeRole = 1;
+  Object.defineProperty(rangeRole.__exports, "__esModule", {
+    value: true
+  });
+  rangeRole.__exports.default = void 0;
+  var rangeRole$1 = {
+    abstract: true,
+    accessibleNameRequired: false,
+    baseConcepts: [],
+    childrenPresentational: false,
+    nameFrom: ["author"],
+    prohibitedProps: [],
+    props: {
+      "aria-valuemax": null,
+      "aria-valuemin": null,
+      "aria-valuenow": null
+    },
+    relatedConcepts: [],
+    requireContextRole: [],
+    requiredContextRole: [],
+    requiredOwnedElements: [],
+    requiredProps: {},
+    superClass: [["roletype", "structure"]]
+  };
+  var _default = rangeRole$1;
+  rangeRole.__exports.default = _default;
+  return rangeRole.__exports;
+}
+exports.__require = requireRangeRole;

package/lib/cjs/node_modules/@testing-library/dom/node_modules/aria-query/lib/etc/roles/abstract/roletypeRole.cjs

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const roletypeRole = require("../../../../../../../../../_virtual/roletypeRole.cjs");
+var hasRequiredRoletypeRole;
+function requireRoletypeRole() {
+  if (hasRequiredRoletypeRole) return roletypeRole.__exports;
+  hasRequiredRoletypeRole = 1;
+  Object.defineProperty(roletypeRole.__exports, "__esModule", {
+    value: true
+  });
+  roletypeRole.__exports.default = void 0;
+  var roletypeRole$1 = {
+    abstract: true,
+    accessibleNameRequired: false,
+    baseConcepts: [],
+    childrenPresentational: false,
+    nameFrom: [],
+    prohibitedProps: [],
+    props: {
+      "aria-atomic": null,
+      "aria-busy": null,
+      "aria-controls": null,
+      "aria-current": null,
+      "aria-describedby": null,
+      "aria-details": null,
+      "aria-dropeffect": null,
+      "aria-flowto": null,
+      "aria-grabbed": null,
+      "aria-hidden": null,
+      "aria-keyshortcuts": null,
+      "aria-label": null,
+      "aria-labelledby": null,
+      "aria-live": null,
+      "aria-owns": null,
+      "aria-relevant": null,
+      "aria-roledescription": null
+    },
+    relatedConcepts: [{
+      concept: {
+        name: "rel"
+      },
+      module: "HTML"
+    }, {
+      concept: {
+        name: "role"
+      },
+      module: "XHTML"
+    }, {
+      concept: {
+        name: "type"
+      },
+      module: "Dublin Core"
+    }],
+    requireContextRole: [],
+    requiredContextRole: [],
+    requiredOwnedElements: [],
+    requiredProps: {},
+    superClass: []
+  };
+  var _default = roletypeRole$1;
+  roletypeRole.__exports.default = _default;
+  return roletypeRole.__exports;
+}
+exports.__require = requireRoletypeRole;

package/lib/cjs/node_modules/@testing-library/dom/node_modules/aria-query/lib/etc/roles/abstract/sectionRole.cjs

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const sectionRole = require("../../../../../../../../../_virtual/sectionRole.cjs");
+var hasRequiredSectionRole;
+function requireSectionRole() {
+  if (hasRequiredSectionRole) return sectionRole.__exports;
+  hasRequiredSectionRole = 1;
+  Object.defineProperty(sectionRole.__exports, "__esModule", {
+    value: true
+  });
+  sectionRole.__exports.default = void 0;
+  var sectionRole$1 = {
+    abstract: true,
+    accessibleNameRequired: false,
+    baseConcepts: [],
+    childrenPresentational: false,
+    nameFrom: [],
+    prohibitedProps: [],
+    props: {},
+    relatedConcepts: [{
+      concept: {
+        name: "frontmatter"
+      },
+      module: "DTB"
+    }, {
+      concept: {
+        name: "level"
+      },
+      module: "DTB"
+    }, {
+      concept: {
+        name: "level"
+      },
+      module: "SMIL"
+    }],
+    requireContextRole: [],
+    requiredContextRole: [],
+    requiredOwnedElements: [],
+    requiredProps: {},
+    superClass: [["roletype", "structure"]]
+  };
+  var _default = sectionRole$1;
+  sectionRole.__exports.default = _default;
+  return sectionRole.__exports;
+}
+exports.__require = requireSectionRole;

package/lib/cjs/node_modules/@testing-library/dom/node_modules/aria-query/lib/etc/roles/abstract/sectionheadRole.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const sectionheadRole = require("../../../../../../../../../_virtual/sectionheadRole.cjs");
+var hasRequiredSectionheadRole;
+function requireSectionheadRole() {
+  if (hasRequiredSectionheadRole) return sectionheadRole.__exports;
+  hasRequiredSectionheadRole = 1;
+  Object.defineProperty(sectionheadRole.__exports, "__esModule", {
+    value: true
+  });
+  sectionheadRole.__exports.default = void 0;
+  var sectionheadRole$1 = {
+    abstract: true,
+    accessibleNameRequired: false,
+    baseConcepts: [],
+    childrenPresentational: false,
+    nameFrom: ["author", "contents"],
+    prohibitedProps: [],
+    props: {},
+    relatedConcepts: [],
+    requireContextRole: [],
+    requiredContextRole: [],
+    requiredOwnedElements: [],
+    requiredProps: {},
+    superClass: [["roletype", "structure"]]
+  };
+  var _default = sectionheadRole$1;
+  sectionheadRole.__exports.default = _default;
+  return sectionheadRole.__exports;
+}
+exports.__require = requireSectionheadRole;

package/lib/cjs/node_modules/@testing-library/dom/node_modules/aria-query/lib/etc/roles/abstract/selectRole.cjs

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const selectRole = require("../../../../../../../../../_virtual/selectRole.cjs");
+var hasRequiredSelectRole;
+function requireSelectRole() {
+  if (hasRequiredSelectRole) return selectRole.__exports;
+  hasRequiredSelectRole = 1;
+  Object.defineProperty(selectRole.__exports, "__esModule", {
+    value: true
+  });
+  selectRole.__exports.default = void 0;
+  var selectRole$1 = {
+    abstract: true,
+    accessibleNameRequired: false,
+    baseConcepts: [],
+    childrenPresentational: false,
+    nameFrom: ["author"],
+    prohibitedProps: [],
+    props: {
+      "aria-orientation": null
+    },
+    relatedConcepts: [],
+    requireContextRole: [],
+    requiredContextRole: [],
+    requiredOwnedElements: [],
+    requiredProps: {},
+    superClass: [["roletype", "widget", "composite"], ["roletype", "structure", "section", "group"]]
+  };
+  var _default = selectRole$1;
+  selectRole.__exports.default = _default;
+  return selectRole.__exports;
+}
+exports.__require = requireSelectRole;

package/lib/cjs/node_modules/@testing-library/dom/node_modules/aria-query/lib/etc/roles/abstract/structureRole.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const structureRole = require("../../../../../../../../../_virtual/structureRole.cjs");
+var hasRequiredStructureRole;
+function requireStructureRole() {
+  if (hasRequiredStructureRole) return structureRole.__exports;
+  hasRequiredStructureRole = 1;
+  Object.defineProperty(structureRole.__exports, "__esModule", {
+    value: true
+  });
+  structureRole.__exports.default = void 0;
+  var structureRole$1 = {
+    abstract: true,
+    accessibleNameRequired: false,
+    baseConcepts: [],
+    childrenPresentational: false,
+    nameFrom: [],
+    prohibitedProps: [],
+    props: {},
+    relatedConcepts: [],
+    requireContextRole: [],
+    requiredContextRole: [],
+    requiredOwnedElements: [],
+    requiredProps: {},
+    superClass: [["roletype"]]
+  };
+  var _default = structureRole$1;
+  structureRole.__exports.default = _default;
+  return structureRole.__exports;
+}
+exports.__require = requireStructureRole;

package/lib/cjs/node_modules/@testing-library/dom/node_modules/aria-query/lib/etc/roles/abstract/widgetRole.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const widgetRole = require("../../../../../../../../../_virtual/widgetRole.cjs");
+var hasRequiredWidgetRole;
+function requireWidgetRole() {
+  if (hasRequiredWidgetRole) return widgetRole.__exports;
+  hasRequiredWidgetRole = 1;
+  Object.defineProperty(widgetRole.__exports, "__esModule", {
+    value: true
+  });
+  widgetRole.__exports.default = void 0;
+  var widgetRole$1 = {
+    abstract: true,
+    accessibleNameRequired: false,
+    baseConcepts: [],
+    childrenPresentational: false,
+    nameFrom: [],
+    prohibitedProps: [],
+    props: {},
+    relatedConcepts: [],
+    requireContextRole: [],
+    requiredContextRole: [],
+    requiredOwnedElements: [],
+    requiredProps: {},
+    superClass: [["roletype"]]
+  };
+  var _default = widgetRole$1;
+  widgetRole.__exports.default = _default;
+  return widgetRole.__exports;
+}
+exports.__require = requireWidgetRole;

package/lib/cjs/node_modules/@testing-library/dom/node_modules/aria-query/lib/etc/roles/abstract/windowRole.cjs

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const windowRole = require("../../../../../../../../../_virtual/windowRole.cjs");
+var hasRequiredWindowRole;
+function requireWindowRole() {
+  if (hasRequiredWindowRole) return windowRole.__exports;
+  hasRequiredWindowRole = 1;
+  Object.defineProperty(windowRole.__exports, "__esModule", {
+    value: true
+  });
+  windowRole.__exports.default = void 0;
+  var windowRole$1 = {
+    abstract: true,
+    accessibleNameRequired: false,
+    baseConcepts: [],
+    childrenPresentational: false,
+    nameFrom: ["author"],
+    prohibitedProps: [],
+    props: {
+      "aria-modal": null
+    },
+    relatedConcepts: [],
+    requireContextRole: [],
+    requiredContextRole: [],
+    requiredOwnedElements: [],
+    requiredProps: {},
+    superClass: [["roletype"]]
+  };
+  var _default = windowRole$1;
+  windowRole.__exports.default = _default;
+  return windowRole.__exports;
+}
+exports.__require = requireWindowRole;