armtek-uikit-react 1.0.268 → 1.0.270

package/lib/cjs/node_modules/@testing-library/dom/node_modules/dom-accessibility-api/dist/accessible-name-and-description.cjs

@@ -0,0 +1,371 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const array_from = require("./polyfills/array.from.cjs");
+const SetLike = require("./polyfills/SetLike.cjs");
+const util = require("./util.cjs");
+const getRole = require("./getRole.cjs");
+function asFlatString(s) {
+  return s.trim().replace(/\s\s+/g, " ");
+}
+function isHidden(node, getComputedStyleImplementation) {
+  if (!util.isElement(node)) {
+    return false;
+  }
+  if (node.hasAttribute("hidden") || node.getAttribute("aria-hidden") === "true") {
+    return true;
+  }
+  var style = getComputedStyleImplementation(node);
+  return style.getPropertyValue("display") === "none" || style.getPropertyValue("visibility") === "hidden";
+}
+function isControl(node) {
+  return util.hasAnyConcreteRoles(node, ["button", "combobox", "listbox", "textbox"]) || hasAbstractRole(node, "range");
+}
+function hasAbstractRole(node, role) {
+  if (!util.isElement(node)) {
+    return false;
+  }
+  switch (role) {
+    case "range":
+      return util.hasAnyConcreteRoles(node, ["meter", "progressbar", "scrollbar", "slider", "spinbutton"]);
+    default:
+      throw new TypeError("No knowledge about abstract role '".concat(role, "'. This is likely a bug :("));
+  }
+}
+function querySelectorAllSubtree(element, selectors) {
+  var elements = array_from.default(element.querySelectorAll(selectors));
+  util.queryIdRefs(element, "aria-owns").forEach(function(root) {
+    elements.push.apply(elements, array_from.default(root.querySelectorAll(selectors)));
+  });
+  return elements;
+}
+function querySelectedOptions(listbox) {
+  if (util.isHTMLSelectElement(listbox)) {
+    return listbox.selectedOptions || querySelectorAllSubtree(listbox, "[selected]");
+  }
+  return querySelectorAllSubtree(listbox, '[aria-selected="true"]');
+}
+function isMarkedPresentational(node) {
+  return util.hasAnyConcreteRoles(node, ["none", "presentation"]);
+}
+function isNativeHostLanguageTextAlternativeElement(node) {
+  return util.isHTMLTableCaptionElement(node);
+}
+function allowsNameFromContent(node) {
+  return util.hasAnyConcreteRoles(node, ["button", "cell", "checkbox", "columnheader", "gridcell", "heading", "label", "legend", "link", "menuitem", "menuitemcheckbox", "menuitemradio", "option", "radio", "row", "rowheader", "switch", "tab", "tooltip", "treeitem"]);
+}
+function isDescendantOfNativeHostLanguageTextAlternativeElement(node) {
+  return false;
+}
+function getValueOfTextbox(element) {
+  if (util.isHTMLInputElement(element) || util.isHTMLTextAreaElement(element)) {
+    return element.value;
+  }
+  return element.textContent || "";
+}
+function getTextualContent(declaration) {
+  var content = declaration.getPropertyValue("content");
+  if (/^["'].*["']$/.test(content)) {
+    return content.slice(1, -1);
+  }
+  return "";
+}
+function isLabelableElement(element) {
+  var localName = getRole.getLocalName(element);
+  return localName === "button" || localName === "input" && element.getAttribute("type") !== "hidden" || localName === "meter" || localName === "output" || localName === "progress" || localName === "select" || localName === "textarea";
+}
+function findLabelableElement(element) {
+  if (isLabelableElement(element)) {
+    return element;
+  }
+  var labelableElement = null;
+  element.childNodes.forEach(function(childNode) {
+    if (labelableElement === null && util.isElement(childNode)) {
+      var descendantLabelableElement = findLabelableElement(childNode);
+      if (descendantLabelableElement !== null) {
+        labelableElement = descendantLabelableElement;
+      }
+    }
+  });
+  return labelableElement;
+}
+function getControlOfLabel(label) {
+  if (label.control !== void 0) {
+    return label.control;
+  }
+  var htmlFor = label.getAttribute("for");
+  if (htmlFor !== null) {
+    return label.ownerDocument.getElementById(htmlFor);
+  }
+  return findLabelableElement(label);
+}
+function getLabels(element) {
+  var labelsProperty = element.labels;
+  if (labelsProperty === null) {
+    return labelsProperty;
+  }
+  if (labelsProperty !== void 0) {
+    return array_from.default(labelsProperty);
+  }
+  if (!isLabelableElement(element)) {
+    return null;
+  }
+  var document = element.ownerDocument;
+  return array_from.default(document.querySelectorAll("label")).filter(function(label) {
+    return getControlOfLabel(label) === element;
+  });
+}
+function getSlotContents(slot) {
+  var assignedNodes = slot.assignedNodes();
+  if (assignedNodes.length === 0) {
+    return array_from.default(slot.childNodes);
+  }
+  return assignedNodes;
+}
+function computeTextAlternative(root) {
+  var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  var consultedNodes = new SetLike.default();
+  var window = util.safeWindow(root);
+  var _options$compute = options.compute, compute = _options$compute === void 0 ? "name" : _options$compute, _options$computedStyl = options.computedStyleSupportsPseudoElements, computedStyleSupportsPseudoElements = _options$computedStyl === void 0 ? options.getComputedStyle !== void 0 : _options$computedStyl, _options$getComputedS = options.getComputedStyle, getComputedStyle = _options$getComputedS === void 0 ? window.getComputedStyle.bind(window) : _options$getComputedS, _options$hidden = options.hidden, hidden = _options$hidden === void 0 ? false : _options$hidden;
+  function computeMiscTextAlternative(node, context) {
+    var accumulatedText = "";
+    if (util.isElement(node) && computedStyleSupportsPseudoElements) {
+      var pseudoBefore = getComputedStyle(node, "::before");
+      var beforeContent = getTextualContent(pseudoBefore);
+      accumulatedText = "".concat(beforeContent, " ").concat(accumulatedText);
+    }
+    var childNodes = util.isHTMLSlotElement(node) ? getSlotContents(node) : array_from.default(node.childNodes).concat(util.queryIdRefs(node, "aria-owns"));
+    childNodes.forEach(function(child) {
+      var result = computeTextAlternative2(child, {
+        isEmbeddedInLabel: context.isEmbeddedInLabel,
+        isReferenced: false,
+        recursion: true
+      });
+      var display = util.isElement(child) ? getComputedStyle(child).getPropertyValue("display") : "inline";
+      var separator = display !== "inline" ? " " : "";
+      accumulatedText += "".concat(separator).concat(result).concat(separator);
+    });
+    if (util.isElement(node) && computedStyleSupportsPseudoElements) {
+      var pseudoAfter = getComputedStyle(node, "::after");
+      var afterContent = getTextualContent(pseudoAfter);
+      accumulatedText = "".concat(accumulatedText, " ").concat(afterContent);
+    }
+    return accumulatedText.trim();
+  }
+  function useAttribute(element, attributeName) {
+    var attribute = element.getAttributeNode(attributeName);
+    if (attribute !== null && !consultedNodes.has(attribute) && attribute.value.trim() !== "") {
+      consultedNodes.add(attribute);
+      return attribute.value;
+    }
+    return null;
+  }
+  function computeTooltipAttributeValue(node) {
+    if (!util.isElement(node)) {
+      return null;
+    }
+    return useAttribute(node, "title");
+  }
+  function computeElementTextAlternative(node) {
+    if (!util.isElement(node)) {
+      return null;
+    }
+    if (util.isHTMLFieldSetElement(node)) {
+      consultedNodes.add(node);
+      var children = array_from.default(node.childNodes);
+      for (var i = 0; i < children.length; i += 1) {
+        var child = children[i];
+        if (util.isHTMLLegendElement(child)) {
+          return computeTextAlternative2(child, {
+            isEmbeddedInLabel: false,
+            isReferenced: false,
+            recursion: false
+          });
+        }
+      }
+    } else if (util.isHTMLTableElement(node)) {
+      consultedNodes.add(node);
+      var _children = array_from.default(node.childNodes);
+      for (var _i = 0; _i < _children.length; _i += 1) {
+        var _child = _children[_i];
+        if (util.isHTMLTableCaptionElement(_child)) {
+          return computeTextAlternative2(_child, {
+            isEmbeddedInLabel: false,
+            isReferenced: false,
+            recursion: false
+          });
+        }
+      }
+    } else if (util.isSVGSVGElement(node)) {
+      consultedNodes.add(node);
+      var _children2 = array_from.default(node.childNodes);
+      for (var _i2 = 0; _i2 < _children2.length; _i2 += 1) {
+        var _child2 = _children2[_i2];
+        if (util.isSVGTitleElement(_child2)) {
+          return _child2.textContent;
+        }
+      }
+      return null;
+    } else if (getRole.getLocalName(node) === "img" || getRole.getLocalName(node) === "area") {
+      var nameFromAlt = useAttribute(node, "alt");
+      if (nameFromAlt !== null) {
+        return nameFromAlt;
+      }
+    } else if (util.isHTMLOptGroupElement(node)) {
+      var nameFromLabel = useAttribute(node, "label");
+      if (nameFromLabel !== null) {
+        return nameFromLabel;
+      }
+    }
+    if (util.isHTMLInputElement(node) && (node.type === "button" || node.type === "submit" || node.type === "reset")) {
+      var nameFromValue = useAttribute(node, "value");
+      if (nameFromValue !== null) {
+        return nameFromValue;
+      }
+      if (node.type === "submit") {
+        return "Submit";
+      }
+      if (node.type === "reset") {
+        return "Reset";
+      }
+    }
+    var labels = getLabels(node);
+    if (labels !== null && labels.length !== 0) {
+      consultedNodes.add(node);
+      return array_from.default(labels).map(function(element) {
+        return computeTextAlternative2(element, {
+          isEmbeddedInLabel: true,
+          isReferenced: false,
+          recursion: true
+        });
+      }).filter(function(label) {
+        return label.length > 0;
+      }).join(" ");
+    }
+    if (util.isHTMLInputElement(node) && node.type === "image") {
+      var _nameFromAlt = useAttribute(node, "alt");
+      if (_nameFromAlt !== null) {
+        return _nameFromAlt;
+      }
+      var nameFromTitle = useAttribute(node, "title");
+      if (nameFromTitle !== null) {
+        return nameFromTitle;
+      }
+      return "Submit Query";
+    }
+    if (util.hasAnyConcreteRoles(node, ["button"])) {
+      var nameFromSubTree = computeMiscTextAlternative(node, {
+        isEmbeddedInLabel: false
+      });
+      if (nameFromSubTree !== "") {
+        return nameFromSubTree;
+      }
+    }
+    return null;
+  }
+  function computeTextAlternative2(current, context) {
+    if (consultedNodes.has(current)) {
+      return "";
+    }
+    if (!hidden && isHidden(current, getComputedStyle) && !context.isReferenced) {
+      consultedNodes.add(current);
+      return "";
+    }
+    var labelAttributeNode = util.isElement(current) ? current.getAttributeNode("aria-labelledby") : null;
+    var labelElements = labelAttributeNode !== null && !consultedNodes.has(labelAttributeNode) ? util.queryIdRefs(current, "aria-labelledby") : [];
+    if (compute === "name" && !context.isReferenced && labelElements.length > 0) {
+      consultedNodes.add(labelAttributeNode);
+      return labelElements.map(function(element) {
+        return computeTextAlternative2(element, {
+          isEmbeddedInLabel: context.isEmbeddedInLabel,
+          isReferenced: true,
+          // this isn't recursion as specified, otherwise we would skip
+          // `aria-label` in
+          // <input id="myself" aria-label="foo" aria-labelledby="myself"
+          recursion: false
+        });
+      }).join(" ");
+    }
+    var skipToStep2E = context.recursion && isControl(current) && compute === "name";
+    if (!skipToStep2E) {
+      var ariaLabel = (util.isElement(current) && current.getAttribute("aria-label") || "").trim();
+      if (ariaLabel !== "" && compute === "name") {
+        consultedNodes.add(current);
+        return ariaLabel;
+      }
+      if (!isMarkedPresentational(current)) {
+        var elementTextAlternative = computeElementTextAlternative(current);
+        if (elementTextAlternative !== null) {
+          consultedNodes.add(current);
+          return elementTextAlternative;
+        }
+      }
+    }
+    if (util.hasAnyConcreteRoles(current, ["menu"])) {
+      consultedNodes.add(current);
+      return "";
+    }
+    if (skipToStep2E || context.isEmbeddedInLabel || context.isReferenced) {
+      if (util.hasAnyConcreteRoles(current, ["combobox", "listbox"])) {
+        consultedNodes.add(current);
+        var selectedOptions = querySelectedOptions(current);
+        if (selectedOptions.length === 0) {
+          return util.isHTMLInputElement(current) ? current.value : "";
+        }
+        return array_from.default(selectedOptions).map(function(selectedOption) {
+          return computeTextAlternative2(selectedOption, {
+            isEmbeddedInLabel: context.isEmbeddedInLabel,
+            isReferenced: false,
+            recursion: true
+          });
+        }).join(" ");
+      }
+      if (hasAbstractRole(current, "range")) {
+        consultedNodes.add(current);
+        if (current.hasAttribute("aria-valuetext")) {
+          return current.getAttribute("aria-valuetext");
+        }
+        if (current.hasAttribute("aria-valuenow")) {
+          return current.getAttribute("aria-valuenow");
+        }
+        return current.getAttribute("value") || "";
+      }
+      if (util.hasAnyConcreteRoles(current, ["textbox"])) {
+        consultedNodes.add(current);
+        return getValueOfTextbox(current);
+      }
+    }
+    if (allowsNameFromContent(current) || util.isElement(current) && context.isReferenced || isNativeHostLanguageTextAlternativeElement(current) || isDescendantOfNativeHostLanguageTextAlternativeElement()) {
+      var accumulatedText2F = computeMiscTextAlternative(current, {
+        isEmbeddedInLabel: context.isEmbeddedInLabel
+      });
+      if (accumulatedText2F !== "") {
+        consultedNodes.add(current);
+        return accumulatedText2F;
+      }
+    }
+    if (current.nodeType === current.TEXT_NODE) {
+      consultedNodes.add(current);
+      return current.textContent || "";
+    }
+    if (context.recursion) {
+      consultedNodes.add(current);
+      return computeMiscTextAlternative(current, {
+        isEmbeddedInLabel: context.isEmbeddedInLabel
+      });
+    }
+    var tooltipAttributeValue = computeTooltipAttributeValue(current);
+    if (tooltipAttributeValue !== null) {
+      consultedNodes.add(current);
+      return tooltipAttributeValue;
+    }
+    consultedNodes.add(current);
+    return "";
+  }
+  return asFlatString(computeTextAlternative2(root, {
+    isEmbeddedInLabel: false,
+    // by spec computeAccessibleDescription starts with the referenced elements as roots
+    isReferenced: compute === "description",
+    recursion: false
+  }));
+}
+exports.computeTextAlternative = computeTextAlternative;

package/lib/cjs/node_modules/@testing-library/dom/node_modules/dom-accessibility-api/dist/accessible-name.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const accessibleNameAndDescription = require("./accessible-name-and-description.cjs");
+const util = require("./util.cjs");
+function prohibitsNaming(node) {
+  return util.hasAnyConcreteRoles(node, ["caption", "code", "deletion", "emphasis", "generic", "insertion", "paragraph", "presentation", "strong", "subscript", "superscript"]);
+}
+function computeAccessibleName(root) {
+  var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  if (prohibitsNaming(root)) {
+    return "";
+  }
+  return accessibleNameAndDescription.computeTextAlternative(root, options);
+}
+exports.computeAccessibleName = computeAccessibleName;

package/lib/cjs/node_modules/@testing-library/dom/node_modules/dom-accessibility-api/dist/getRole.cjs

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+function getLocalName(element) {
+  var _element$localName;
+  return (
+    // eslint-disable-next-line no-restricted-properties -- actual guard for environments without localName
+    (_element$localName = element.localName) !== null && _element$localName !== void 0 ? _element$localName : (
+      // eslint-disable-next-line no-restricted-properties -- required for the fallback
+      element.tagName.toLowerCase()
+    )
+  );
+}
+var localNameToRoleMappings = {
+  article: "article",
+  aside: "complementary",
+  button: "button",
+  datalist: "listbox",
+  dd: "definition",
+  details: "group",
+  dialog: "dialog",
+  dt: "term",
+  fieldset: "group",
+  figure: "figure",
+  // WARNING: Only with an accessible name
+  form: "form",
+  footer: "contentinfo",
+  h1: "heading",
+  h2: "heading",
+  h3: "heading",
+  h4: "heading",
+  h5: "heading",
+  h6: "heading",
+  header: "banner",
+  hr: "separator",
+  html: "document",
+  legend: "legend",
+  li: "listitem",
+  math: "math",
+  main: "main",
+  menu: "list",
+  nav: "navigation",
+  ol: "list",
+  optgroup: "group",
+  // WARNING: Only in certain context
+  option: "option",
+  output: "status",
+  progress: "progressbar",
+  // WARNING: Only with an accessible name
+  section: "region",
+  summary: "button",
+  table: "table",
+  tbody: "rowgroup",
+  textarea: "textbox",
+  tfoot: "rowgroup",
+  // WARNING: Only in certain context
+  td: "cell",
+  th: "columnheader",
+  thead: "rowgroup",
+  tr: "row",
+  ul: "list"
+};
+var prohibitedAttributes = {
+  caption: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  code: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  deletion: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  emphasis: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  generic: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby", "aria-roledescription"]),
+  insertion: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  paragraph: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  presentation: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  strong: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  subscript: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  superscript: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"])
+};
+function hasGlobalAriaAttributes(element, role) {
+  return [
+    "aria-atomic",
+    "aria-busy",
+    "aria-controls",
+    "aria-current",
+    "aria-describedby",
+    "aria-details",
+    // "disabled",
+    "aria-dropeffect",
+    // "errormessage",
+    "aria-flowto",
+    "aria-grabbed",
+    // "haspopup",
+    "aria-hidden",
+    // "invalid",
+    "aria-keyshortcuts",
+    "aria-label",
+    "aria-labelledby",
+    "aria-live",
+    "aria-owns",
+    "aria-relevant",
+    "aria-roledescription"
+  ].some(function(attributeName) {
+    var _prohibitedAttributes;
+    return element.hasAttribute(attributeName) && !((_prohibitedAttributes = prohibitedAttributes[role]) !== null && _prohibitedAttributes !== void 0 && _prohibitedAttributes.has(attributeName));
+  });
+}
+function ignorePresentationalRole(element, implicitRole) {
+  return hasGlobalAriaAttributes(element, implicitRole);
+}
+function getRole(element) {
+  var explicitRole = getExplicitRole(element);
+  if (explicitRole === null || explicitRole === "presentation") {
+    var implicitRole = getImplicitRole(element);
+    if (explicitRole !== "presentation" || ignorePresentationalRole(element, implicitRole || "")) {
+      return implicitRole;
+    }
+  }
+  return explicitRole;
+}
+function getImplicitRole(element) {
+  var mappedByTag = localNameToRoleMappings[getLocalName(element)];
+  if (mappedByTag !== void 0) {
+    return mappedByTag;
+  }
+  switch (getLocalName(element)) {
+    case "a":
+    case "area":
+    case "link":
+      if (element.hasAttribute("href")) {
+        return "link";
+      }
+      break;
+    case "img":
+      if (element.getAttribute("alt") === "" && !ignorePresentationalRole(element, "img")) {
+        return "presentation";
+      }
+      return "img";
+    case "input": {
+      var _ref = element, type = _ref.type;
+      switch (type) {
+        case "button":
+        case "image":
+        case "reset":
+        case "submit":
+          return "button";
+        case "checkbox":
+        case "radio":
+          return type;
+        case "range":
+          return "slider";
+        case "email":
+        case "tel":
+        case "text":
+        case "url":
+          if (element.hasAttribute("list")) {
+            return "combobox";
+          }
+          return "textbox";
+        case "search":
+          if (element.hasAttribute("list")) {
+            return "combobox";
+          }
+          return "searchbox";
+        case "number":
+          return "spinbutton";
+        default:
+          return null;
+      }
+    }
+    case "select":
+      if (element.hasAttribute("multiple") || element.size > 1) {
+        return "listbox";
+      }
+      return "combobox";
+  }
+  return null;
+}
+function getExplicitRole(element) {
+  var role = element.getAttribute("role");
+  if (role !== null) {
+    var explicitRole = role.trim().split(" ")[0];
+    if (explicitRole.length > 0) {
+      return explicitRole;
+    }
+  }
+  return null;
+}
+exports.default = getRole;
+exports.getLocalName = getLocalName;

package/lib/cjs/node_modules/@testing-library/dom/node_modules/dom-accessibility-api/dist/polyfills/SetLike.cjs

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+    return typeof obj2;
+  } : function(obj2) {
+    return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+  }, _typeof(obj);
+}
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  Object.defineProperty(Constructor, "prototype", { writable: false });
+  return Constructor;
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return _typeof(key) === "symbol" ? key : String(key);
+}
+function _toPrimitive(input, hint) {
+  if (_typeof(input) !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== void 0) {
+    var res = prim.call(input, hint);
+    if (_typeof(res) !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+var SetLike = /* @__PURE__ */ (function() {
+  function SetLike2() {
+    var items = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+    _classCallCheck(this, SetLike2);
+    _defineProperty(this, "items", void 0);
+    this.items = items;
+  }
+  _createClass(SetLike2, [{
+    key: "add",
+    value: function add(value) {
+      if (this.has(value) === false) {
+        this.items.push(value);
+      }
+      return this;
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.items = [];
+    }
+  }, {
+    key: "delete",
+    value: function _delete(value) {
+      var previousLength = this.items.length;
+      this.items = this.items.filter(function(item) {
+        return item !== value;
+      });
+      return previousLength !== this.items.length;
+    }
+  }, {
+    key: "forEach",
+    value: function forEach(callbackfn) {
+      var _this = this;
+      this.items.forEach(function(item) {
+        callbackfn(item, item, _this);
+      });
+    }
+  }, {
+    key: "has",
+    value: function has(value) {
+      return this.items.indexOf(value) !== -1;
+    }
+  }, {
+    key: "size",
+    get: function get() {
+      return this.items.length;
+    }
+  }]);
+  return SetLike2;
+})();
+const SetLike$1 = typeof Set === "undefined" ? Set : SetLike;
+exports.default = SetLike$1;