"));
+ }; // Not all files will be able to generate previews. In case this happens, we provide several types "generic previews" based on the file extension.
+
+
+ reader.onloadend = function createFilePreview() {
+ var imageId = makeSafeForID(fileName);
+ var previewImage = document.getElementById(imageId);
+
+ if (fileName.indexOf(".pdf") > 0) {
+ previewImage.setAttribute("onerror", "this.onerror=null;this.src=\"".concat(SPACER_GIF, "\"; this.classList.add(\"").concat(PDF_PREVIEW_CLASS, "\")"));
+ } else if (fileName.indexOf(".doc") > 0 || fileName.indexOf(".pages") > 0) {
+ previewImage.setAttribute("onerror", "this.onerror=null;this.src=\"".concat(SPACER_GIF, "\"; this.classList.add(\"").concat(WORD_PREVIEW_CLASS, "\")"));
+ } else if (fileName.indexOf(".xls") > 0 || fileName.indexOf(".numbers") > 0) {
+ previewImage.setAttribute("onerror", "this.onerror=null;this.src=\"".concat(SPACER_GIF, "\"; this.classList.add(\"").concat(EXCEL_PREVIEW_CLASS, "\")"));
+ } else if (fileName.indexOf(".mov") > 0 || fileName.indexOf(".mp4") > 0) {
+ previewImage.setAttribute("onerror", "this.onerror=null;this.src=\"".concat(SPACER_GIF, "\"; this.classList.add(\"").concat(VIDEO_PREVIEW_CLASS, "\")"));
+ } else {
+ previewImage.setAttribute("onerror", "this.onerror=null;this.src=\"".concat(SPACER_GIF, "\"; this.classList.add(\"").concat(GENERIC_PREVIEW_CLASS, "\")"));
+ } // Removes loader and displays preview
+
+
+ previewImage.classList.remove(LOADING_CLASS);
+ previewImage.src = reader.result;
+ };
+
+ if (fileNames[i]) {
+ reader.readAsDataURL(fileNames[i]);
+ } // Adds heading above file previews, pluralizes if there are multiple
+
+
+ if (i === 0) {
+ dropTarget.insertBefore(filePreviewsHeading, instructions);
+ filePreviewsHeading.innerHTML = "Selected file
Change file";
+ } else if (i >= 1) {
+ dropTarget.insertBefore(filePreviewsHeading, instructions);
+ filePreviewsHeading.innerHTML = "".concat(i + 1, " files selected
Change files");
+ } // Hides null state content and sets preview heading class
+
+
+ if (filePreviewsHeading) {
+ instructions.classList.add(HIDDEN_CLASS);
+ filePreviewsHeading.classList.add(PREVIEW_HEADING_CLASS);
+ }
+ };
+
+ for (var i = 0; i < fileNames.length; i += 1) {
+ _loop(i);
+ }
+};
+
+var fileInput = behavior({}, {
+ init: function init(root) {
+ select(DROPZONE, root).forEach(function (fileInputEl) {
+ var _buildFileInput = buildFileInput(fileInputEl),
+ instructions = _buildFileInput.instructions,
+ dropTarget = _buildFileInput.dropTarget;
+
+ dropTarget.addEventListener("dragover", function handleDragOver() {
+ this.classList.add(DRAG_CLASS);
+ }, false);
+ dropTarget.addEventListener("dragleave", function handleDragLeave() {
+ this.classList.remove(DRAG_CLASS);
+ }, false);
+ dropTarget.addEventListener("drop", function handleDrop(e) {
+ preventInvalidFiles(e, fileInputEl, instructions, dropTarget);
+ this.classList.remove(DRAG_CLASS);
+ }, false); // eslint-disable-next-line no-param-reassign
+
+ fileInputEl.onchange = function (e) {
+ handleChange(e, fileInputEl, instructions, dropTarget);
+ };
+ });
+ },
+ getFileInputContext: getFileInputContext,
+ disable: disable,
+ enable: enable
+});
+module.exports = fileInput;
+
+},{"../config":35,"../utils/behavior":44,"../utils/select":49}],23:[function(require,module,exports){
+"use strict";
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var behavior = require("../utils/behavior");
+
+var select = require("../utils/select");
+
+var _require = require("../events"),
+ CLICK = _require.CLICK;
+
+var _require2 = require("../config"),
+ PREFIX = _require2.prefix;
+
+var HIDDEN = "hidden";
+var SCOPE = ".".concat(PREFIX, "-footer--big");
+var NAV = "".concat(SCOPE, " nav");
+var BUTTON = "".concat(NAV, " .").concat(PREFIX, "-footer__primary-link");
+var COLLAPSIBLE = ".".concat(PREFIX, "-footer__primary-content--collapsible");
+var HIDE_MAX_WIDTH = 480;
+
+function showPanel() {
+ if (window.innerWidth < HIDE_MAX_WIDTH) {
+ var collapseEl = this.closest(COLLAPSIBLE);
+ collapseEl.classList.toggle(HIDDEN); // NB: this *should* always succeed because the button
+ // selector is scoped to ".{prefix}-footer-big nav"
+
+ var collapsibleEls = select(COLLAPSIBLE, collapseEl.closest(NAV));
+ collapsibleEls.forEach(function (el) {
+ if (el !== collapseEl) {
+ el.classList.add(HIDDEN);
+ }
+ });
+ }
+}
+
+var toggleHidden = function toggleHidden(isHidden) {
+ return select(COLLAPSIBLE).forEach(function (list) {
+ return list.classList.toggle(HIDDEN, isHidden);
+ });
+};
+
+var resize = function resize(event) {
+ return toggleHidden(event.matches);
+};
+
+module.exports = behavior(_defineProperty({}, CLICK, _defineProperty({}, BUTTON, showPanel)), {
+ // export for use elsewhere
+ HIDE_MAX_WIDTH: HIDE_MAX_WIDTH,
+ init: function init() {
+ toggleHidden(window.innerWidth < HIDE_MAX_WIDTH);
+ this.mediaQueryList = window.matchMedia("(max-width: ".concat(HIDE_MAX_WIDTH, "px)"));
+ this.mediaQueryList.addListener(resize);
+ },
+ teardown: function teardown() {
+ this.mediaQueryList.removeListener(resize);
+ }
+});
+
+},{"../config":35,"../events":36,"../utils/behavior":44,"../utils/select":49}],24:[function(require,module,exports){
+"use strict";
+
+var accordion = require("./accordion");
+
+var banner = require("./banner");
+
+var characterCount = require("./character-count");
+
+var comboBox = require("./combo-box");
+
+var fileInput = require("./file-input");
+
+var footer = require("./footer");
+
+var inputPrefixSuffix = require("./input-prefix-suffix");
+
+var modal = require("./modal");
+
+var navigation = require("./navigation");
+
+var password = require("./password");
+
+var search = require("./search");
+
+var skipnav = require("./skipnav");
+
+var tooltip = require("./tooltip");
+
+var validator = require("./validator");
+
+var datePicker = require("./date-picker");
+
+var dateRangePicker = require("./date-range-picker");
+
+var timePicker = require("./time-picker");
+
+var table = require("./table");
+
+module.exports = {
+ accordion: accordion,
+ banner: banner,
+ characterCount: characterCount,
+ comboBox: comboBox,
+ datePicker: datePicker,
+ dateRangePicker: dateRangePicker,
+ fileInput: fileInput,
+ footer: footer,
+ inputPrefixSuffix: inputPrefixSuffix,
+ modal: modal,
+ navigation: navigation,
+ password: password,
+ search: search,
+ skipnav: skipnav,
+ table: table,
+ timePicker: timePicker,
+ tooltip: tooltip,
+ validator: validator
+};
+
+},{"./accordion":16,"./banner":17,"./character-count":18,"./combo-box":19,"./date-picker":20,"./date-range-picker":21,"./file-input":22,"./footer":23,"./input-prefix-suffix":25,"./modal":26,"./navigation":27,"./password":28,"./search":29,"./skipnav":30,"./table":31,"./time-picker":32,"./tooltip":33,"./validator":34}],25:[function(require,module,exports){
+"use strict";
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var behavior = require("../utils/behavior");
+
+var select = require("../utils/select");
+
+var _require = require("../config"),
+ PREFIX = _require.prefix;
+
+var _require2 = require("../events"),
+ CLICK = _require2.CLICK;
+
+var CONTAINER = ".".concat(PREFIX, "-input-group");
+var INPUT = "".concat(CONTAINER, " .").concat(PREFIX, "-input");
+var DECORATION = "".concat(CONTAINER, " .").concat(PREFIX, "-input-prefix, ").concat(CONTAINER, " .").concat(PREFIX, "-input-suffix");
+var FOCUS_CLASS = "is-focused";
+
+function setFocus(el) {
+ el.closest(CONTAINER).querySelector(".".concat(PREFIX, "-input")).focus();
+}
+
+function handleFocus() {
+ this.closest(CONTAINER).classList.add(FOCUS_CLASS);
+}
+
+function handleBlur() {
+ this.closest(CONTAINER).classList.remove(FOCUS_CLASS);
+}
+
+var inputPrefixSuffix = behavior(_defineProperty({}, CLICK, _defineProperty({}, DECORATION, function () {
+ setFocus(this);
+})), {
+ init: function init(root) {
+ select(INPUT, root).forEach(function (inputEl) {
+ inputEl.addEventListener("focus", handleFocus, false);
+ inputEl.addEventListener("blur", handleBlur, false);
+ });
+ }
+});
+module.exports = inputPrefixSuffix;
+
+},{"../config":35,"../events":36,"../utils/behavior":44,"../utils/select":49}],26:[function(require,module,exports){
+"use strict";
+
+var _CLICK;
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var behavior = require("../utils/behavior");
+
+var select = require("../utils/select");
+
+var FocusTrap = require("../utils/focus-trap");
+
+var ScrollBarWidth = require("../utils/scrollbar-width");
+
+var _require = require("../events"),
+ CLICK = _require.CLICK;
+
+var _require2 = require("../config"),
+ PREFIX = _require2.prefix;
+
+var MODAL_CLASSNAME = "".concat(PREFIX, "-modal");
+var OVERLAY_CLASSNAME = "".concat(MODAL_CLASSNAME, "-overlay");
+var WRAPPER_CLASSNAME = "".concat(MODAL_CLASSNAME, "-wrapper");
+var OPENER_ATTRIBUTE = "data-open-modal";
+var CLOSER_ATTRIBUTE = "data-close-modal";
+var FORCE_ACTION_ATTRIBUTE = "data-force-action";
+var MODAL = ".".concat(MODAL_CLASSNAME);
+var INITIAL_FOCUS = ".".concat(WRAPPER_CLASSNAME, " *[data-focus]");
+var CLOSE_BUTTON = "".concat(WRAPPER_CLASSNAME, " *[").concat(CLOSER_ATTRIBUTE, "]");
+var OPENERS = "*[".concat(OPENER_ATTRIBUTE, "][aria-controls]");
+var CLOSERS = "".concat(CLOSE_BUTTON, ", .").concat(OVERLAY_CLASSNAME, ":not([").concat(FORCE_ACTION_ATTRIBUTE, "])");
+var ACTIVE_CLASS = "usa-js-modal--active";
+var PREVENT_CLICK_CLASS = "usa-js-no-click";
+var VISIBLE_CLASS = "is-visible";
+var HIDDEN_CLASS = "is-hidden";
+var nonModals = document.querySelectorAll("body > *:not(".concat(MODAL, "):not([aria-hidden])"));
+var modal;
+
+var isActive = function isActive() {
+ return document.body.classList.contains(ACTIVE_CLASS);
+};
+
+var SCROLLBAR_WIDTH = ScrollBarWidth();
+var INITIAL_PADDING = window.getComputedStyle(document.body).getPropertyValue("padding-right");
+var TEMPORARY_PADDING = parseInt(INITIAL_PADDING.replace(/px/, ""), 10) + parseInt(SCROLLBAR_WIDTH.replace(/px/, ""), 10) + "px";
+/**
+ * Is bound to escape key, closes modal when
+ */
+
+var onMenuClose = function onMenuClose() {
+ modal.toggleModal.call(modal, false);
+};
+/**
+ * Toggle the visibility of a modal window
+ *
+ * @param {KeyboardEvent} event the keydown event
+ * @returns {boolean} safeActive if mobile is open
+ */
+
+
+function toggleModal(event) {
+ var originalOpener;
+ var clickedElement = event.target;
+ var _document = document,
+ body = _document.body;
+ var safeActive = !isActive();
+ var modalId = clickedElement ? clickedElement.getAttribute("aria-controls") : document.querySelector(".usa-modal-wrapper.is-visible");
+ var targetModal = safeActive ? document.getElementById(modalId) : document.querySelector(".usa-modal-wrapper.is-visible");
+ var openFocusEl = targetModal.querySelector(INITIAL_FOCUS) ? targetModal.querySelector(INITIAL_FOCUS) : targetModal.querySelector(".usa-modal");
+ var returnFocus = document.getElementById(targetModal.getAttribute("data-opener"));
+ var menuButton = body.querySelector(OPENERS);
+ var forceUserAction = targetModal.getAttribute(FORCE_ACTION_ATTRIBUTE); // Sets the clicked element to the close button
+ // so esc key always closes modal
+
+ if (event.type === "keydown" && targetModal !== null) {
+ clickedElement = targetModal.querySelector(CLOSE_BUTTON);
+ } // When we're not hitting the escape key…
+
+
+ if (clickedElement) {
+ // Make sure we click the opener
+ // If it doesn't have an ID, make one
+ // Store id as data attribute on modal
+ if (clickedElement.hasAttribute(OPENER_ATTRIBUTE)) {
+ if (this.getAttribute("id") === null) {
+ originalOpener = "modal-".concat(Math.floor(Math.random() * 900000) + 100000);
+ this.setAttribute("id", originalOpener);
+ } else {
+ originalOpener = this.getAttribute("id");
+ }
+
+ targetModal.setAttribute("data-opener", originalOpener);
+ } // This basically stops the propagation if the element
+ // is inside the modal and not a close button or
+ // element inside a close button
+
+
+ if (clickedElement.closest(".".concat(MODAL_CLASSNAME))) {
+ if (clickedElement.hasAttribute(CLOSER_ATTRIBUTE) || clickedElement.closest("[".concat(CLOSER_ATTRIBUTE, "]"))) {// do nothing. move on.
+ } else {
+ event.stopPropagation();
+ return false;
+ }
+ }
+ } // Active class shares same as navigation
+
+
+ body.classList.toggle(ACTIVE_CLASS, safeActive);
+ targetModal.classList.toggle(VISIBLE_CLASS, safeActive);
+ targetModal.classList.toggle(HIDDEN_CLASS, !safeActive); // If user is forced to take an action, adding
+ // a class to the body that prevents clicking underneath
+ // overlay
+
+ if (forceUserAction) {
+ body.classList.toggle(PREVENT_CLICK_CLASS, safeActive);
+ } // Account for content shifting from body overflow: hidden
+ // We only check paddingRight in case apps are adding other properties
+ // to the body element
+
+
+ body.style.paddingRight = body.style.paddingRight === TEMPORARY_PADDING ? INITIAL_PADDING : TEMPORARY_PADDING; // Handle the focus actions
+
+ if (safeActive && openFocusEl) {
+ // The modal window is opened. Focus is set to close button.
+ // Binds escape key if we're not forcing
+ // the user to take an action
+ if (forceUserAction) {
+ modal.focusTrap = FocusTrap(targetModal);
+ } else {
+ modal.focusTrap = FocusTrap(targetModal, {
+ Escape: onMenuClose
+ });
+ } // Handles focus setting and interactions
+
+
+ modal.focusTrap.update(safeActive);
+ openFocusEl.focus(); // Hides everything that is not the modal from screen readers
+
+ for (var i = 0; i < nonModals.length; i += 1) {
+ nonModals[i].setAttribute("aria-hidden", "true");
+ }
+ } else if (!safeActive && menuButton && returnFocus) {
+ // The modal window is closed.
+ // Non-modals now accesible to screen reader
+ for (var _i = 0; _i < nonModals.length; _i += 1) {
+ nonModals[_i].removeAttribute("aria-hidden");
+ } // Focus is returned to the opener
+
+
+ returnFocus.focus();
+ modal.focusTrap.update(safeActive);
+ }
+
+ return safeActive;
+}
+/**
+ * Builds modal window from base HTML
+ *
+ * @param {HTMLElement} baseComponent the modal html in the DOM
+ */
+
+
+var setUpAttributes = function setUpAttributes(baseComponent) {
+ var modalContent = baseComponent;
+ var modalWrapper = document.createElement("div");
+ var overlayDiv = document.createElement("div");
+ var modalID = baseComponent.getAttribute("id");
+ var ariaLabelledBy = baseComponent.getAttribute("aria-labelledby");
+ var ariaDescribedBy = baseComponent.getAttribute("aria-describedby");
+ var forceUserAction = baseComponent.hasAttribute(FORCE_ACTION_ATTRIBUTE) ? baseComponent.hasAttribute(FORCE_ACTION_ATTRIBUTE) : false; // Rebuild the modal element
+
+ modalContent.parentNode.insertBefore(modalWrapper, modalContent);
+ modalWrapper.appendChild(modalContent);
+ modalContent.parentNode.insertBefore(overlayDiv, modalContent);
+ overlayDiv.appendChild(modalContent); // Add classes and attributes
+
+ modalWrapper.classList.add(HIDDEN_CLASS);
+ modalWrapper.classList.add(WRAPPER_CLASSNAME);
+ overlayDiv.classList.add(OVERLAY_CLASSNAME); // Set attributes
+
+ modalWrapper.setAttribute("role", "dialog");
+ modalWrapper.setAttribute("id", modalID);
+
+ if (ariaLabelledBy) {
+ modalWrapper.setAttribute("aria-labelledby", ariaLabelledBy);
+ }
+
+ if (ariaDescribedBy) {
+ modalWrapper.setAttribute("aria-describedby", ariaDescribedBy);
+ }
+
+ if (forceUserAction) {
+ modalWrapper.setAttribute(FORCE_ACTION_ATTRIBUTE, "true");
+ } // Update the base element HTML
+
+
+ baseComponent.removeAttribute("id");
+ baseComponent.removeAttribute("aria-labelledby");
+ baseComponent.removeAttribute("aria-describedby");
+ baseComponent.setAttribute("tabindex", "-1"); // Add aria-controls
+
+ var modalClosers = modalWrapper.querySelectorAll(CLOSERS);
+ select(modalClosers).forEach(function (el) {
+ el.setAttribute("aria-controls", modalID);
+ }); // Move all modals to the end of the DOM. Doing this allows us to
+ // more easily find the elements to hide from screen readers
+ // when the modal is open.
+
+ document.body.appendChild(modalWrapper);
+};
+
+modal = behavior(_defineProperty({}, CLICK, (_CLICK = {}, _defineProperty(_CLICK, OPENERS, toggleModal), _defineProperty(_CLICK, CLOSERS, toggleModal), _CLICK)), {
+ init: function init(root) {
+ select(MODAL, root).forEach(function (modalWindow) {
+ setUpAttributes(modalWindow);
+ });
+ select(OPENERS, root).forEach(function (item) {
+ // Turn anchor links into buttons because of
+ // VoiceOver on Safari
+ if (item.nodeName === "A") {
+ item.setAttribute("role", "button");
+ item.addEventListener("click", function (e) {
+ e.preventDefault();
+ });
+ } // Can uncomment when aria-haspopup="dialog" is supported
+ // https://a11ysupport.io/tech/aria/aria-haspopup_attribute
+ // Most screen readers support aria-haspopup, but might announce
+ // as opening a menu if "dialog" is not supported.
+ // item.setAttribute("aria-haspopup", "dialog");
+
+ });
+ },
+ focusTrap: null,
+ toggleModal: toggleModal
+});
+module.exports = modal;
+
+},{"../config":35,"../events":36,"../utils/behavior":44,"../utils/focus-trap":45,"../utils/scrollbar-width":48,"../utils/select":49}],27:[function(require,module,exports){
+"use strict";
+
+var _CLICK;
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var behavior = require("../utils/behavior");
+
+var select = require("../utils/select");
+
+var toggle = require("../utils/toggle");
+
+var FocusTrap = require("../utils/focus-trap");
+
+var accordion = require("./accordion");
+
+var ScrollBarWidth = require("../utils/scrollbar-width");
+
+var _require = require("../events"),
+ CLICK = _require.CLICK;
+
+var _require2 = require("../config"),
+ PREFIX = _require2.prefix;
+
+var BODY = "body";
+var NAV = ".".concat(PREFIX, "-nav");
+var NAV_LINKS = "".concat(NAV, " a");
+var NAV_CONTROL = "button.".concat(PREFIX, "-nav__link");
+var OPENERS = ".".concat(PREFIX, "-menu-btn");
+var CLOSE_BUTTON = ".".concat(PREFIX, "-nav__close");
+var OVERLAY = ".".concat(PREFIX, "-overlay");
+var CLOSERS = "".concat(CLOSE_BUTTON, ", .").concat(PREFIX, "-overlay");
+var TOGGLES = [NAV, OVERLAY].join(", ");
+var ACTIVE_CLASS = "usa-js-mobile-nav--active";
+var VISIBLE_CLASS = "is-visible";
+var navigation;
+var navActive;
+
+var isActive = function isActive() {
+ return document.body.classList.contains(ACTIVE_CLASS);
+};
+
+var SCROLLBAR_WIDTH = ScrollBarWidth();
+var INITIAL_PADDING = window.getComputedStyle(document.body).getPropertyValue('padding-right');
+var TEMPORARY_PADDING = parseInt(INITIAL_PADDING.replace(/px/, ""), 10) + parseInt(SCROLLBAR_WIDTH.replace(/px/, ""), 10) + "px";
+
+var toggleNav = function toggleNav(active) {
+ var _document = document,
+ body = _document.body;
+ var safeActive = typeof active === "boolean" ? active : !isActive();
+ body.classList.toggle(ACTIVE_CLASS, safeActive);
+ select(TOGGLES).forEach(function (el) {
+ return el.classList.toggle(VISIBLE_CLASS, safeActive);
+ });
+ navigation.focusTrap.update(safeActive);
+ var closeButton = body.querySelector(CLOSE_BUTTON);
+ var menuButton = body.querySelector(OPENERS);
+ body.style.paddingRight = body.style.paddingRight === TEMPORARY_PADDING ? INITIAL_PADDING : TEMPORARY_PADDING;
+
+ if (safeActive && closeButton) {
+ // The mobile nav was just activated, so focus on the close button,
+ // which is just before all the nav elements in the tab order.
+ closeButton.focus();
+ } else if (!safeActive && document.activeElement === closeButton && menuButton) {
+ // The mobile nav was just deactivated, and focus was on the close
+ // button, which is no longer visible. We don't want the focus to
+ // disappear into the void, so focus on the menu button if it's
+ // visible (this may have been what the user was just focused on,
+ // if they triggered the mobile nav by mistake).
+ menuButton.focus();
+ }
+
+ return safeActive;
+};
+
+var resize = function resize() {
+ var closer = document.body.querySelector(CLOSE_BUTTON);
+
+ if (isActive() && closer && closer.getBoundingClientRect().width === 0) {
+ // When the mobile nav is active, and the close box isn't visible,
+ // we know the user's viewport has been resized to be larger.
+ // Let's make the page state consistent by deactivating the mobile nav.
+ navigation.toggleNav.call(closer, false);
+ }
+};
+
+var onMenuClose = function onMenuClose() {
+ return navigation.toggleNav.call(navigation, false);
+};
+
+var hideActiveNavDropdown = function hideActiveNavDropdown() {
+ toggle(navActive, false);
+ navActive = null;
+};
+
+navigation = behavior(_defineProperty({}, CLICK, (_CLICK = {}, _defineProperty(_CLICK, NAV_CONTROL, function () {
+ // If another nav is open, close it
+ if (navActive && navActive !== this) {
+ hideActiveNavDropdown();
+ } // store a reference to the last clicked nav link element, so we
+ // can hide the dropdown if another element on the page is clicked
+
+
+ if (navActive) {
+ hideActiveNavDropdown();
+ } else {
+ navActive = this;
+ toggle(navActive, true);
+ } // Do this so the event handler on the body doesn't fire
+
+
+ return false;
+}), _defineProperty(_CLICK, BODY, function () {
+ if (navActive) {
+ hideActiveNavDropdown();
+ }
+}), _defineProperty(_CLICK, OPENERS, toggleNav), _defineProperty(_CLICK, CLOSERS, toggleNav), _defineProperty(_CLICK, NAV_LINKS, function () {
+ // A navigation link has been clicked! We want to collapse any
+ // hierarchical navigation UI it's a part of, so that the user
+ // can focus on whatever they've just selected.
+ // Some navigation links are inside accordions; when they're
+ // clicked, we want to collapse those accordions.
+ var acc = this.closest(accordion.ACCORDION);
+
+ if (acc) {
+ accordion.getButtons(acc).forEach(function (btn) {
+ return accordion.hide(btn);
+ });
+ } // If the mobile navigation menu is active, we want to hide it.
+
+
+ if (isActive()) {
+ navigation.toggleNav.call(navigation, false);
+ }
+}), _CLICK)), {
+ init: function init(root) {
+ var trapContainer = root.querySelector(NAV);
+
+ if (trapContainer) {
+ navigation.focusTrap = FocusTrap(trapContainer, {
+ Escape: onMenuClose
+ });
+ }
+
+ resize();
+ window.addEventListener("resize", resize, false);
+ },
+ teardown: function teardown() {
+ window.removeEventListener("resize", resize, false);
+ navActive = false;
+ },
+ focusTrap: null,
+ toggleNav: toggleNav
+});
+module.exports = navigation;
+
+},{"../config":35,"../events":36,"../utils/behavior":44,"../utils/focus-trap":45,"../utils/scrollbar-width":48,"../utils/select":49,"../utils/toggle":52,"./accordion":16}],28:[function(require,module,exports){
+"use strict";
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var behavior = require("../utils/behavior");
+
+var toggleFormInput = require("../utils/toggle-form-input");
+
+var _require = require("../events"),
+ CLICK = _require.CLICK;
+
+var _require2 = require("../config"),
+ PREFIX = _require2.prefix;
+
+var LINK = ".".concat(PREFIX, "-show-password, .").concat(PREFIX, "-show-multipassword");
+
+function toggle(event) {
+ event.preventDefault();
+ toggleFormInput(this);
+}
+
+module.exports = behavior(_defineProperty({}, CLICK, _defineProperty({}, LINK, toggle)));
+
+},{"../config":35,"../events":36,"../utils/behavior":44,"../utils/toggle-form-input":51}],29:[function(require,module,exports){
+"use strict";
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var ignore = require("receptor/ignore");
+
+var behavior = require("../utils/behavior");
+
+var select = require("../utils/select");
+
+var _require = require("../events"),
+ CLICK = _require.CLICK;
+
+var BUTTON = ".js-search-button";
+var FORM = ".js-search-form";
+var INPUT = "[type=search]";
+var CONTEXT = "header"; // XXX
+
+var lastButton;
+
+var getForm = function getForm(button) {
+ var context = button.closest(CONTEXT);
+ return context ? context.querySelector(FORM) : document.querySelector(FORM);
+};
+
+var toggleSearch = function toggleSearch(button, active) {
+ var form = getForm(button);
+
+ if (!form) {
+ throw new Error("No ".concat(FORM, " found for search toggle in ").concat(CONTEXT, "!"));
+ }
+ /* eslint-disable no-param-reassign */
+
+
+ button.hidden = active;
+ form.hidden = !active;
+ /* eslint-enable */
+
+ if (!active) {
+ return;
+ }
+
+ var input = form.querySelector(INPUT);
+
+ if (input) {
+ input.focus();
+ } // when the user clicks _outside_ of the form w/ignore(): hide the
+ // search, then remove the listener
+
+
+ var listener = ignore(form, function () {
+ if (lastButton) {
+ hideSearch.call(lastButton); // eslint-disable-line no-use-before-define
+ }
+
+ document.body.removeEventListener(CLICK, listener);
+ }); // Normally we would just run this code without a timeout, but
+ // IE11 and Edge will actually call the listener *immediately* because
+ // they are currently handling this exact type of event, so we'll
+ // make sure the browser is done handling the current click event,
+ // if any, before we attach the listener.
+
+ setTimeout(function () {
+ document.body.addEventListener(CLICK, listener);
+ }, 0);
+};
+
+function showSearch() {
+ toggleSearch(this, true);
+ lastButton = this;
+}
+
+function hideSearch() {
+ toggleSearch(this, false);
+ lastButton = undefined;
+}
+
+var search = behavior(_defineProperty({}, CLICK, _defineProperty({}, BUTTON, showSearch)), {
+ init: function init(target) {
+ select(BUTTON, target).forEach(function (button) {
+ toggleSearch(button, false);
+ });
+ },
+ teardown: function teardown() {
+ // forget the last button clicked
+ lastButton = undefined;
+ }
+});
+module.exports = search;
+
+},{"../events":36,"../utils/behavior":44,"../utils/select":49,"receptor/ignore":11}],30:[function(require,module,exports){
+"use strict";
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var once = require("receptor/once");
+
+var behavior = require("../utils/behavior");
+
+var _require = require("../events"),
+ CLICK = _require.CLICK;
+
+var _require2 = require("../config"),
+ PREFIX = _require2.prefix;
+
+var LINK = ".".concat(PREFIX, "-skipnav[href^=\"#\"], .").concat(PREFIX, "-footer__return-to-top [href^=\"#\"]");
+var MAINCONTENT = "main-content";
+
+function setTabindex() {
+ // NB: we know because of the selector we're delegating to below that the
+ // href already begins with '#'
+ var id = encodeURI(this.getAttribute("href"));
+ var target = document.getElementById(id === "#" ? MAINCONTENT : id.slice(1));
+
+ if (target) {
+ target.style.outline = "0";
+ target.setAttribute("tabindex", 0);
+ target.focus();
+ target.addEventListener("blur", once(function () {
+ target.setAttribute("tabindex", -1);
+ }));
+ } else {// throw an error?
+ }
+}
+
+module.exports = behavior(_defineProperty({}, CLICK, _defineProperty({}, LINK, setTabindex)));
+
+},{"../config":35,"../events":36,"../utils/behavior":44,"receptor/once":14}],31:[function(require,module,exports){
+"use strict";
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var select = require("../utils/select");
+
+var behavior = require("../utils/behavior");
+
+var _require = require("../events"),
+ CLICK = _require.CLICK;
+
+var _require2 = require("../config"),
+ PREFIX = _require2.prefix;
+
+var TABLE = ".".concat(PREFIX, "-table");
+var SORTED = "aria-sort";
+var ASCENDING = "ascending";
+var DESCENDING = "descending";
+var SORT_OVERRIDE = "data-sort-value";
+var ICON_SOURCE = "\n
\n");
+var SORT_BUTTON_CLASS = "".concat(PREFIX, "-table__header__button");
+var SORT_BUTTON = ".".concat(SORT_BUTTON_CLASS);
+var SORTABLE_HEADER = "th[data-sortable]";
+var ANNOUNCEMENT_REGION = ".".concat(PREFIX, "-table__announcement-region[aria-live=\"polite\"]");
+/** Gets the data-sort-value attribute value, if provided — otherwise, gets
+ * the innerText or textContent — of the child element (HTMLTableCellElement)
+ * at the specified index of the given table row
+ *
+ * @param {number} index
+ * @param {array
} tr
+ * @return {boolean}
+ */
+
+var getCellValue = function getCellValue(tr, index) {
+ return tr.children[index].getAttribute(SORT_OVERRIDE) || tr.children[index].innerText || tr.children[index].textContent;
+};
+/**
+ * Compares the values of two row array items at the given index, then sorts by the given direction
+ * @param {number} index
+ * @param {string} direction
+ * @return {boolean}
+ */
+
+
+var compareFunction = function compareFunction(index, isAscending) {
+ return function (thisRow, nextRow) {
+ // get values to compare from data attribute or cell content
+ var value1 = getCellValue(isAscending ? thisRow : nextRow, index);
+ var value2 = getCellValue(isAscending ? nextRow : thisRow, index); // if neither value is empty, and if both values are already numbers, compare numerically
+
+ if (value1 && value2 && !Number.isNaN(Number(value1)) && !Number.isNaN(Number(value2))) {
+ return value1 - value2;
+ } // Otherwise, compare alphabetically based on current user locale
+
+
+ return value1.toString().localeCompare(value2, navigator.language, {
+ numeric: true,
+ ignorePunctuation: true
+ });
+ };
+};
+/**
+ * Get an Array of column headers elements belonging directly to the given
+ * table element.
+ * @param {HTMLTableElement} table
+ * @return {array}
+ */
+
+
+var getColumnHeaders = function getColumnHeaders(table) {
+ var headers = select(SORTABLE_HEADER, table);
+ return headers.filter(function (header) {
+ return header.closest(TABLE) === table;
+ });
+};
+/**
+ * Update the button label within the given header element, resetting it
+ * to the default state (ready to sort ascending) if it's no longer sorted
+ * @param {HTMLTableHeaderCellElement} header
+ */
+
+
+var updateSortLabel = function updateSortLabel(header) {
+ var headerName = header.innerText;
+ var sortedAscending = header.getAttribute(SORTED) === ASCENDING;
+ var isSorted = header.getAttribute(SORTED) === ASCENDING || header.getAttribute(SORTED) === DESCENDING || false;
+ var headerLabel = "".concat(headerName, "', sortable column, currently ").concat(isSorted ? "".concat(sortedAscending ? "sorted ".concat(ASCENDING) : "sorted ".concat(DESCENDING)) : "unsorted");
+ var headerButtonLabel = "Click to sort by ".concat(headerName, " in ").concat(sortedAscending ? DESCENDING : ASCENDING, " order.");
+ header.setAttribute("aria-label", headerLabel);
+ header.querySelector(SORT_BUTTON).setAttribute("title", headerButtonLabel);
+};
+/**
+ * Remove the aria-sort attribute on the given header element, and reset the label and button icon
+ * @param {HTMLTableHeaderCellElement} header
+ */
+
+
+var unsetSort = function unsetSort(header) {
+ header.removeAttribute(SORTED);
+ updateSortLabel(header);
+};
+/**
+ * Sort rows either ascending or descending, based on a given header's aria-sort attribute
+ * @param {HTMLTableHeaderCellElement} header
+ * @param {boolean} isAscending
+ * @return {boolean} true
+ */
+
+
+var sortRows = function sortRows(header, isAscending) {
+ header.setAttribute(SORTED, isAscending === true ? DESCENDING : ASCENDING);
+ updateSortLabel(header);
+ var tbody = header.closest(TABLE).querySelector("tbody"); // We can use Array.from() and Array.sort() instead once we drop IE11 support, likely in the summer of 2021
+ //
+ // Array.from(tbody.querySelectorAll('tr').sort(
+ // compareFunction(
+ // Array.from(header.parentNode.children).indexOf(header),
+ // !isAscending)
+ // )
+ // .forEach(tr => tbody.appendChild(tr) );
+ // [].slice.call() turns array-like sets into true arrays so that we can sort them
+
+ var allRows = [].slice.call(tbody.querySelectorAll("tr"));
+ var allHeaders = [].slice.call(header.parentNode.children);
+ var thisHeaderIndex = allHeaders.indexOf(header);
+ allRows.sort(compareFunction(thisHeaderIndex, !isAscending)).forEach(function (tr) {
+ [].slice.call(tr.children).forEach(function (td) {
+ return td.removeAttribute("data-sort-active");
+ });
+ tr.children[thisHeaderIndex].setAttribute("data-sort-active", true);
+ tbody.appendChild(tr);
+ });
+ return true;
+};
+/**
+ * Update the live region immediately following the table whenever sort changes.
+ * @param {HTMLTableElement} table
+ * @param {HTMLTableHeaderCellElement} sortedHeader
+ */
+
+
+var updateLiveRegion = function updateLiveRegion(table, sortedHeader) {
+ var caption = table.querySelector("caption").innerText;
+ var sortedAscending = sortedHeader.getAttribute(SORTED) === ASCENDING;
+ var headerLabel = sortedHeader.innerText;
+ var liveRegion = table.nextElementSibling;
+
+ if (liveRegion && liveRegion.matches(ANNOUNCEMENT_REGION)) {
+ var sortAnnouncement = "The table named \"".concat(caption, "\" is now sorted by ").concat(headerLabel, " in ").concat(sortedAscending ? ASCENDING : DESCENDING, " order.");
+ liveRegion.innerText = sortAnnouncement;
+ } else {
+ throw new Error("Table containing a sortable column header is not followed by an aria-live region.");
+ }
+};
+/**
+ * Toggle a header's sort state, optionally providing a target
+ * state.
+ *
+ * @param {HTMLTableHeaderCellElement} header
+ * @param {boolean?} isAscending If no state is provided, the current
+ * state will be toggled (from false to true, and vice-versa).
+ */
+
+
+var toggleSort = function toggleSort(header, isAscending) {
+ var table = header.closest(TABLE);
+ var safeAscending = isAscending;
+
+ if (typeof safeAscending !== "boolean") {
+ safeAscending = header.getAttribute(SORTED) === ASCENDING;
+ }
+
+ if (!table) {
+ throw new Error("".concat(SORTABLE_HEADER, " is missing outer ").concat(TABLE));
+ }
+
+ safeAscending = sortRows(header, isAscending);
+
+ if (safeAscending) {
+ getColumnHeaders(table).forEach(function (otherHeader) {
+ if (otherHeader !== header) {
+ unsetSort(otherHeader);
+ }
+ });
+ updateLiveRegion(table, header);
+ }
+};
+/**
+ ** Inserts a button with icon inside a sortable header
+ * @param {HTMLTableHeaderCellElement} header
+ */
+
+
+var createHeaderButton = function createHeaderButton(header) {
+ var buttonEl = document.createElement("button");
+ buttonEl.setAttribute("tabindex", "0");
+ buttonEl.classList.add(SORT_BUTTON_CLASS);
+ buttonEl.innerHTML = "".concat(ICON_SOURCE);
+ header.appendChild(buttonEl);
+ updateSortLabel(header);
+};
+
+var table = behavior(_defineProperty({}, CLICK, _defineProperty({}, SORT_BUTTON, function (event) {
+ event.preventDefault();
+ toggleSort(event.target.closest(SORTABLE_HEADER), event.target.closest(SORTABLE_HEADER).getAttribute(SORTED) === ASCENDING);
+})), {
+ init: function init(root) {
+ var sortableHeaders = select(SORTABLE_HEADER, root);
+ sortableHeaders.forEach(function (header) {
+ return createHeaderButton(header);
+ });
+ var firstSorted = sortableHeaders.filter(function (header) {
+ return header.getAttribute(SORTED) === ASCENDING || header.getAttribute(SORTED) === DESCENDING;
+ })[0];
+
+ if (typeof firstSorted === "undefined") {
+ // no sortable headers found
+ return;
+ }
+
+ var sortDir = firstSorted.getAttribute(SORTED);
+
+ if (sortDir === ASCENDING) {
+ toggleSort(firstSorted, true);
+ } else if (sortDir === DESCENDING) {
+ toggleSort(firstSorted, false);
+ }
+ },
+ TABLE: TABLE,
+ SORTABLE_HEADER: SORTABLE_HEADER,
+ SORT_BUTTON: SORT_BUTTON
+});
+module.exports = table;
+
+},{"../config":35,"../events":36,"../utils/behavior":44,"../utils/select":49}],32:[function(require,module,exports){
+"use strict";
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _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 _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 i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) 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; }
+
+var behavior = require("../utils/behavior");
+
+var select = require("../utils/select");
+
+var _require = require("../config"),
+ PREFIX = _require.prefix;
+
+var _require2 = require("./combo-box"),
+ COMBO_BOX_CLASS = _require2.COMBO_BOX_CLASS,
+ enhanceComboBox = _require2.enhanceComboBox;
+
+var TIME_PICKER_CLASS = "".concat(PREFIX, "-time-picker");
+var TIME_PICKER = ".".concat(TIME_PICKER_CLASS);
+var MAX_TIME = 60 * 24 - 1;
+var MIN_TIME = 0;
+var DEFAULT_STEP = 30;
+var MIN_STEP = 1;
+var FILTER_DATASET = {
+ filter: "0?{{ hourQueryFilter }}:{{minuteQueryFilter}}.*{{ apQueryFilter }}m?",
+ apQueryFilter: "([ap])",
+ hourQueryFilter: "([1-9][0-2]?)",
+ minuteQueryFilter: "[\\d]+:([0-9]{0,2})"
+};
+/**
+ * Parse a string of hh:mm into minutes
+ *
+ * @param {string} timeStr the time string to parse
+ * @returns {number} the number of minutes
+ */
+
+var parseTimeString = function parseTimeString(timeStr) {
+ var minutes;
+
+ if (timeStr) {
+ var _timeStr$split$map = timeStr.split(":").map(function (str) {
+ var value;
+ var parsed = parseInt(str, 10);
+ if (!Number.isNaN(parsed)) value = parsed;
+ return value;
+ }),
+ _timeStr$split$map2 = _slicedToArray(_timeStr$split$map, 2),
+ hours = _timeStr$split$map2[0],
+ mins = _timeStr$split$map2[1];
+
+ if (hours != null && mins != null) {
+ minutes = hours * 60 + mins;
+ }
+ }
+
+ return minutes;
+};
+/**
+ * Enhance an input with the date picker elements
+ *
+ * @param {HTMLElement} el The initial wrapping element of the date picker component
+ */
+
+
+var transformTimePicker = function transformTimePicker(el) {
+ var timePickerEl = el.closest(TIME_PICKER);
+ var initialInputEl = timePickerEl.querySelector("input");
+
+ if (!initialInputEl) {
+ throw new Error("".concat(TIME_PICKER, " is missing inner input"));
+ }
+
+ var selectEl = document.createElement("select");
+ ["id", "name", "required", "aria-label", "aria-labelledby"].forEach(function (name) {
+ if (initialInputEl.hasAttribute(name)) {
+ var value = initialInputEl.getAttribute(name);
+ selectEl.setAttribute(name, value);
+ initialInputEl.removeAttribute(name);
+ }
+ });
+
+ var padZeros = function padZeros(value, length) {
+ return "0000".concat(value).slice(-length);
+ };
+
+ var getTimeContext = function getTimeContext(minutes) {
+ var minute = minutes % 60;
+ var hour24 = Math.floor(minutes / 60);
+ var hour12 = hour24 % 12 || 12;
+ var ampm = hour24 < 12 ? "am" : "pm";
+ return {
+ minute: minute,
+ hour24: hour24,
+ hour12: hour12,
+ ampm: ampm
+ };
+ };
+
+ var minTime = Math.max(MIN_TIME, parseTimeString(timePickerEl.dataset.minTime) || MIN_TIME);
+ var maxTime = Math.min(MAX_TIME, parseTimeString(timePickerEl.dataset.maxTime) || MAX_TIME);
+ var step = Math.floor(Math.max(MIN_STEP, timePickerEl.dataset.step || DEFAULT_STEP));
+
+ for (var time = minTime; time <= maxTime; time += step) {
+ var _getTimeContext = getTimeContext(time),
+ minute = _getTimeContext.minute,
+ hour24 = _getTimeContext.hour24,
+ hour12 = _getTimeContext.hour12,
+ ampm = _getTimeContext.ampm;
+
+ var option = document.createElement("option");
+ option.value = "".concat(padZeros(hour24, 2), ":").concat(padZeros(minute, 2));
+ option.text = "".concat(hour12, ":").concat(padZeros(minute, 2)).concat(ampm);
+ selectEl.appendChild(option);
+ }
+
+ timePickerEl.classList.add(COMBO_BOX_CLASS); // combo box properties
+
+ Object.keys(FILTER_DATASET).forEach(function (key) {
+ timePickerEl.dataset[key] = FILTER_DATASET[key];
+ });
+ timePickerEl.dataset.disableFiltering = "true";
+ timePickerEl.appendChild(selectEl);
+ initialInputEl.style.display = "none";
+};
+
+var timePicker = behavior({}, {
+ init: function init(root) {
+ select(TIME_PICKER, root).forEach(function (timePickerEl) {
+ transformTimePicker(timePickerEl);
+ enhanceComboBox(timePickerEl);
+ });
+ },
+ FILTER_DATASET: FILTER_DATASET
+});
+module.exports = timePicker;
+
+},{"../config":35,"../utils/behavior":44,"../utils/select":49,"./combo-box":19}],33:[function(require,module,exports){
+"use strict";
+
+// Tooltips
+var select = require("../utils/select");
+
+var behavior = require("../utils/behavior");
+
+var _require = require("../config"),
+ PREFIX = _require.prefix;
+
+var isElementInViewport = require("../utils/is-in-viewport");
+
+var TOOLTIP = ".".concat(PREFIX, "-tooltip");
+var TOOLTIP_TRIGGER_CLASS = "".concat(PREFIX, "-tooltip__trigger");
+var TOOLTIP_CLASS = "".concat(PREFIX, "-tooltip");
+var TOOLTIP_BODY_CLASS = "".concat(PREFIX, "-tooltip__body");
+var SET_CLASS = "is-set";
+var VISIBLE_CLASS = "is-visible";
+var TRIANGLE_SIZE = 5;
+var ADJUST_WIDTH_CLASS = "".concat(PREFIX, "-tooltip__body--wrap");
+/**
+ * Add one or more listeners to an element
+ * @param {DOMElement} element - DOM element to add listeners to
+ * @param {events} eventNames - space separated list of event names, e.g. 'click change'
+ * @param {Function} listener - function to attach for each event as a listener
+ */
+
+var addListenerMulti = function addListenerMulti(element, eventNames, listener) {
+ var events = eventNames.split(" ");
+
+ for (var i = 0, iLen = events.length; i < iLen; i += 1) {
+ element.addEventListener(events[i], listener, false);
+ }
+};
+/**
+ * Shows the tooltip
+ * @param {HTMLElement} tooltipTrigger - the element that initializes the tooltip
+ */
+
+
+var showToolTip = function showToolTip(tooltipBody, tooltipTrigger, position) {
+ tooltipBody.setAttribute("aria-hidden", "false"); // This sets up the tooltip body. The opacity is 0, but
+ // we can begin running the calculations below.
+
+ tooltipBody.classList.add(SET_CLASS);
+ /**
+ * Position the tooltip body when the trigger is hovered
+ * Removes old positioning classnames and reapplies. This allows
+ * positioning to change in case the user resizes browser or DOM manipulation
+ * causes tooltip to get clipped from viewport
+ *
+ * @param {string} setPos - can be "top", "bottom", "right", "left"
+ */
+
+ var setPositionClass = function setPositionClass(setPos) {
+ tooltipBody.classList.remove("".concat(TOOLTIP_BODY_CLASS, "--top"));
+ tooltipBody.classList.remove("".concat(TOOLTIP_BODY_CLASS, "--bottom"));
+ tooltipBody.classList.remove("".concat(TOOLTIP_BODY_CLASS, "--right"));
+ tooltipBody.classList.remove("".concat(TOOLTIP_BODY_CLASS, "--left"));
+ tooltipBody.classList.add("".concat(TOOLTIP_BODY_CLASS, "--").concat(setPos));
+ };
+ /**
+ * Removes old positioning styles. This allows
+ * re-positioning to change without inheriting other
+ * dynamic styles
+ *
+ * @param {HTMLElement} e - this is the tooltip body
+ */
+
+
+ var resetPositionStyles = function resetPositionStyles(e) {
+ // we don't override anything in the stylesheet when finding alt positions
+ e.style.top = null;
+ e.style.bottom = null;
+ e.style.right = null;
+ e.style.left = null;
+ e.style.margin = null;
+ };
+ /**
+ * get margin offset calculations
+ *
+ * @param {HTMLElement} target - this is the tooltip body
+ * @param {String} propertyValue - this is the tooltip body
+ */
+
+
+ var offsetMargin = function offsetMargin(target, propertyValue) {
+ return parseInt(window.getComputedStyle(target).getPropertyValue(propertyValue), 10);
+ }; // offsetLeft = the left position, and margin of the element, the left
+ // padding, scrollbar and border of the offsetParent element
+ // offsetWidth = The offsetWidth property returns the viewable width of an
+ // element in pixels, including padding, border and scrollbar, but not
+ // the margin.
+
+ /**
+ * Calculate margin offset
+ * tooltip trigger margin(position) offset + tooltipBody offsetWidth
+ * @param {String} marginPosition
+ * @param {Number} tooltipBodyOffset
+ * @param {HTMLElement} trigger
+ */
+
+
+ var calculateMarginOffset = function calculateMarginOffset(marginPosition, tooltipBodyOffset, trigger) {
+ var offset = offsetMargin(trigger, "margin-".concat(marginPosition)) > 0 ? tooltipBodyOffset - offsetMargin(trigger, "margin-".concat(marginPosition)) : tooltipBodyOffset;
+ return offset;
+ };
+ /**
+ * Positions tooltip at the top
+ * @param {HTMLElement} e - this is the tooltip body
+ */
- resize();
- window.addEventListener('resize', resize, false);
- },
- teardown: function teardown() {
- window.removeEventListener('resize', resize, false);
- navActive = false;
- },
- focusTrap: null,
- toggleNav: toggleNav
-});
+ var positionTop = function positionTop(e) {
+ resetPositionStyles(e); // ensures we start from the same point
+ // get details on the elements object with
-module.exports = navigation;
+ var topMargin = calculateMarginOffset("top", e.offsetHeight, tooltipTrigger);
+ var leftMargin = calculateMarginOffset("left", e.offsetWidth, tooltipTrigger);
+ setPositionClass("top");
+ e.style.left = "50%"; // center the element
-},{"../config":26,"../events":27,"../utils/behavior":32,"../utils/focus-trap":33,"../utils/select":35,"../utils/toggle":38,"./accordion":17}],22:[function(require,module,exports){
-'use strict';
+ e.style.top = "-".concat(TRIANGLE_SIZE, "px"); // consider the psuedo element
+ // apply our margins based on the offest
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+ e.style.margin = "-".concat(topMargin, "px 0 0 -").concat(leftMargin / 2, "px");
+ };
+ /**
+ * Positions tooltip at the bottom
+ * @param {HTMLElement} e - this is the tooltip body
+ */
+
+
+ var positionBottom = function positionBottom(e) {
+ resetPositionStyles(e);
+ var leftMargin = calculateMarginOffset("left", e.offsetWidth, tooltipTrigger);
+ setPositionClass("bottom");
+ e.style.left = "50%";
+ e.style.margin = "".concat(TRIANGLE_SIZE, "px 0 0 -").concat(leftMargin / 2, "px");
+ };
+ /**
+ * Positions tooltip at the right
+ * @param {HTMLElement} e - this is the tooltip body
+ */
+
+
+ var positionRight = function positionRight(e) {
+ resetPositionStyles(e);
+ var topMargin = calculateMarginOffset("top", e.offsetHeight, tooltipTrigger);
+ setPositionClass("right");
+ e.style.top = "50%";
+ e.style.left = "".concat(tooltipTrigger.offsetLeft + tooltipTrigger.offsetWidth + TRIANGLE_SIZE, "px");
+ e.style.margin = "-".concat(topMargin / 2, "px 0 0 0");
+ };
+ /**
+ * Positions tooltip at the right
+ * @param {HTMLElement} e - this is the tooltip body
+ */
-var behavior = require('../utils/behavior');
-var toggleFormInput = require('../utils/toggle-form-input');
-var _require = require('../events'),
- CLICK = _require.CLICK;
+ var positionLeft = function positionLeft(e) {
+ resetPositionStyles(e);
+ var topMargin = calculateMarginOffset("top", e.offsetHeight, tooltipTrigger); // we have to check for some utility margins
-var _require2 = require('../config'),
- PREFIX = _require2.prefix;
+ var leftMargin = calculateMarginOffset("left", tooltipTrigger.offsetLeft > e.offsetWidth ? tooltipTrigger.offsetLeft - e.offsetWidth : e.offsetWidth, tooltipTrigger);
+ setPositionClass("left");
+ e.style.top = "50%";
+ e.style.left = "-".concat(TRIANGLE_SIZE, "px");
+ e.style.margin = "-".concat(topMargin / 2, "px 0 0 ").concat(tooltipTrigger.offsetLeft > e.offsetWidth ? leftMargin : -leftMargin, "px"); // adjust the margin
+ };
+ /**
+ * We try to set the position based on the
+ * original intention, but make adjustments
+ * if the element is clipped out of the viewport
+ * we constrain the width only as a last resort
+ * @param {HTMLElement} element(alias tooltipBody)
+ * @param {Number} attempt (--flag)
+ */
+
+
+ var maxAttempts = 2;
+
+ function findBestPosition(element) {
+ var attempt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+ // create array of optional positions
+ var positions = [positionTop, positionBottom, positionRight, positionLeft];
+ var hasVisiblePosition = false; // we take a recursive approach
+
+ function tryPositions(i) {
+ if (i < positions.length) {
+ var pos = positions[i];
+ pos(element);
+
+ if (!isElementInViewport(element)) {
+ // eslint-disable-next-line no-param-reassign
+ tryPositions(i += 1);
+ } else {
+ hasVisiblePosition = true;
+ }
+ }
+ }
-var LINK = '.' + PREFIX + '-show-password, .' + PREFIX + '-show-multipassword';
+ tryPositions(0); // if we can't find a position we compress it and try again
-function toggle(event) {
- event.preventDefault();
- toggleFormInput(this);
-}
+ if (!hasVisiblePosition) {
+ element.classList.add(ADJUST_WIDTH_CLASS);
-module.exports = behavior(_defineProperty({}, CLICK, _defineProperty({}, LINK, toggle)));
+ if (attempt <= maxAttempts) {
+ // eslint-disable-next-line no-param-reassign
+ findBestPosition(element, attempt += 1);
+ }
+ }
+ }
-},{"../config":26,"../events":27,"../utils/behavior":32,"../utils/toggle-form-input":37}],23:[function(require,module,exports){
-'use strict';
+ switch (position) {
+ case "top":
+ positionTop(tooltipBody);
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+ if (!isElementInViewport(tooltipBody)) {
+ findBestPosition(tooltipBody);
+ }
-var ignore = require('receptor/ignore');
-var behavior = require('../utils/behavior');
-var select = require('../utils/select');
+ break;
-var _require = require('../events'),
- CLICK = _require.CLICK;
+ case "bottom":
+ positionBottom(tooltipBody);
-var BUTTON = '.js-search-button';
-var FORM = '.js-search-form';
-var INPUT = '[type=search]';
-var CONTEXT = 'header'; // XXX
+ if (!isElementInViewport(tooltipBody)) {
+ findBestPosition(tooltipBody);
+ }
-var lastButton = void 0;
+ break;
-var getForm = function getForm(button) {
- var context = button.closest(CONTEXT);
- return context ? context.querySelector(FORM) : document.querySelector(FORM);
-};
+ case "right":
+ positionRight(tooltipBody);
-var toggleSearch = function toggleSearch(button, active) {
- var form = getForm(button);
+ if (!isElementInViewport(tooltipBody)) {
+ findBestPosition(tooltipBody);
+ }
- if (!form) {
- throw new Error('No ' + FORM + ' found for search toggle in ' + CONTEXT + '!');
- }
+ break;
- /* eslint-disable no-param-reassign */
- button.hidden = active;
- form.hidden = !active;
- /* eslint-enable */
+ case "left":
+ positionLeft(tooltipBody);
- if (!active) {
- return;
- }
+ if (!isElementInViewport(tooltipBody)) {
+ findBestPosition(tooltipBody);
+ }
- var input = form.querySelector(INPUT);
+ break;
- if (input) {
- input.focus();
+ default:
+ // skip default case
+ break;
}
- // when the user clicks _outside_ of the form w/ignore(): hide the
- // search, then remove the listener
- var listener = ignore(form, function () {
- if (lastButton) {
- hideSearch.call(lastButton); // eslint-disable-line no-use-before-define
- }
+ /**
+ * Actually show the tooltip. The VISIBLE_CLASS
+ * will change the opacity to 1
+ */
- document.body.removeEventListener(CLICK, listener);
- });
- // Normally we would just run this code without a timeout, but
- // IE11 and Edge will actually call the listener *immediately* because
- // they are currently handling this exact type of event, so we'll
- // make sure the browser is done handling the current click event,
- // if any, before we attach the listener.
setTimeout(function () {
- document.body.addEventListener(CLICK, listener);
- }, 0);
+ tooltipBody.classList.add(VISIBLE_CLASS);
+ }, 20);
};
+/**
+ * Removes all the properties to show and position the tooltip,
+ * and resets the tooltip position to the original intention
+ * in case the window is resized or the element is moved through
+ * DOM maniulation.
+ * @param {HTMLElement} tooltipBody - The body of the tooltip
+ */
-function showSearch() {
- toggleSearch(this, true);
- lastButton = this;
-}
-function hideSearch() {
- toggleSearch(this, false);
- lastButton = undefined;
-}
+var hideToolTip = function hideToolTip(tooltipBody) {
+ tooltipBody.classList.remove(VISIBLE_CLASS);
+ tooltipBody.classList.remove(SET_CLASS);
+ tooltipBody.classList.remove(ADJUST_WIDTH_CLASS);
+ tooltipBody.setAttribute("aria-hidden", "true");
+};
+/**
+ * Setup the tooltip component
+ * @param {HTMLElement} tooltipTrigger The element that creates the tooltip
+ */
-var search = behavior(_defineProperty({}, CLICK, _defineProperty({}, BUTTON, showSearch)), {
- init: function init(target) {
- select(BUTTON, target).forEach(function (button) {
- toggleSearch(button, false);
- });
- },
- teardown: function teardown() {
- // forget the last button clicked
- lastButton = undefined;
- }
-});
-module.exports = search;
+var setUpAttributes = function setUpAttributes(tooltipTrigger) {
+ var tooltipID = "tooltip-".concat(Math.floor(Math.random() * 900000) + 100000);
+ var tooltipContent = tooltipTrigger.getAttribute("title");
+ var wrapper = document.createElement("span");
+ var tooltipBody = document.createElement("span");
+ var position = tooltipTrigger.getAttribute("data-position") ? tooltipTrigger.getAttribute("data-position") : "top";
+ var additionalClasses = tooltipTrigger.getAttribute("data-classes"); // Set up tooltip attributes
-},{"../events":27,"../utils/behavior":32,"../utils/select":35,"receptor/ignore":12}],24:[function(require,module,exports){
-'use strict';
+ tooltipTrigger.setAttribute("aria-describedby", tooltipID);
+ tooltipTrigger.setAttribute("tabindex", "0");
+ tooltipTrigger.setAttribute("title", "");
+ tooltipTrigger.classList.remove(TOOLTIP_CLASS);
+ tooltipTrigger.classList.add(TOOLTIP_TRIGGER_CLASS); // insert wrapper before el in the DOM tree
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+ tooltipTrigger.parentNode.insertBefore(wrapper, tooltipTrigger); // set up the wrapper
-var once = require('receptor/once');
-var behavior = require('../utils/behavior');
+ wrapper.appendChild(tooltipTrigger);
+ wrapper.classList.add(TOOLTIP_CLASS);
+ wrapper.appendChild(tooltipBody); // Apply additional class names to wrapper element
-var _require = require('../events'),
- CLICK = _require.CLICK;
+ if (additionalClasses) {
+ var classesArray = additionalClasses.split(" ");
+ classesArray.forEach(function (classname) {
+ return wrapper.classList.add(classname);
+ });
+ } // set up the tooltip body
-var _require2 = require('../config'),
- PREFIX = _require2.prefix;
-var LINK = '.' + PREFIX + '-skipnav[href^="#"], .' + PREFIX + '-footer__return-to-top [href^="#"]';
-var MAINCONTENT = 'main-content';
+ tooltipBody.classList.add(TOOLTIP_BODY_CLASS);
+ tooltipBody.setAttribute("id", tooltipID);
+ tooltipBody.setAttribute("role", "tooltip");
+ tooltipBody.setAttribute("aria-hidden", "true"); // place the text in the tooltip
-function setTabindex() {
- // NB: we know because of the selector we're delegating to below that the
- // href already begins with '#'
- var id = this.getAttribute('href');
- var target = document.getElementById(id === '#' ? MAINCONTENT : id.slice(1));
+ tooltipBody.innerHTML = tooltipContent;
+ return {
+ tooltipBody: tooltipBody,
+ position: position,
+ tooltipContent: tooltipContent,
+ wrapper: wrapper
+ };
+}; // Setup our function to run on various events
- if (target) {
- target.style.outline = '0';
- target.setAttribute('tabindex', 0);
- target.focus();
- target.addEventListener('blur', once(function () {
- target.setAttribute('tabindex', -1);
- }));
- } else {
- // throw an error?
+
+var tooltip = behavior({}, {
+ init: function init(root) {
+ select(TOOLTIP, root).forEach(function (tooltipTrigger) {
+ var _setUpAttributes = setUpAttributes(tooltipTrigger),
+ tooltipBody = _setUpAttributes.tooltipBody,
+ position = _setUpAttributes.position,
+ tooltipContent = _setUpAttributes.tooltipContent,
+ wrapper = _setUpAttributes.wrapper;
+
+ if (tooltipContent) {
+ // Listeners for showing and hiding the tooltip
+ addListenerMulti(tooltipTrigger, "mouseenter focus", function () {
+ showToolTip(tooltipBody, tooltipTrigger, position, wrapper);
+ return false;
+ }); // Keydown here prevents tooltips from being read twice by
+ // screen reader. also allows excape key to close it
+ // (along with any other.)
+
+ addListenerMulti(tooltipTrigger, "mouseleave blur keydown", function () {
+ hideToolTip(tooltipBody);
+ return false;
+ });
+ } else {// throw error or let other tooltips on page function?
+ }
+ });
}
-}
+});
+module.exports = tooltip;
-module.exports = behavior(_defineProperty({}, CLICK, _defineProperty({}, LINK, setTabindex)));
+},{"../config":35,"../utils/behavior":44,"../utils/is-in-viewport":46,"../utils/select":49}],34:[function(require,module,exports){
+"use strict";
-},{"../config":26,"../events":27,"../utils/behavior":32,"receptor/once":15}],25:[function(require,module,exports){
-'use strict';
+var behavior = require("../utils/behavior");
-var behavior = require('../utils/behavior');
-var validate = require('../utils/validate-input');
+var validate = require("../utils/validate-input");
function change() {
validate(this);
}
var validator = behavior({
- 'keyup change': {
- 'input[data-validation-element]': change
+ "keyup change": {
+ "input[data-validation-element]": change
}
});
-
module.exports = validator;
-},{"../utils/behavior":32,"../utils/validate-input":39}],26:[function(require,module,exports){
-'use strict';
+},{"../utils/behavior":44,"../utils/validate-input":53}],35:[function(require,module,exports){
+"use strict";
module.exports = {
- prefix: 'usa'
+ prefix: "usa"
};
-},{}],27:[function(require,module,exports){
-'use strict';
+},{}],36:[function(require,module,exports){
+"use strict";
module.exports = {
// This used to be conditionally dependent on whether the
@@ -1756,14 +5916,37 @@ module.exports = {
// touch and clicks. This meant the conditional effectively dropped
// support for the user's mouse, frustrating users who preferred
// it on those systems.
- CLICK: 'click'
+ CLICK: "click"
};
-},{}],28:[function(require,module,exports){
-'use strict';
+},{}],37:[function(require,module,exports){
+"use strict";
+
+/* eslint-disable consistent-return */
+
+/* eslint-disable func-names */
+(function () {
+ if (typeof window.CustomEvent === "function") return false;
+
+ function CustomEvent(event, _params) {
+ var params = _params || {
+ bubbles: false,
+ cancelable: false,
+ detail: null
+ };
+ var evt = document.createEvent("CustomEvent");
+ evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);
+ return evt;
+ }
+
+ window.CustomEvent = CustomEvent;
+})();
+
+},{}],38:[function(require,module,exports){
+"use strict";
var elproto = window.HTMLElement.prototype;
-var HIDDEN = 'hidden';
+var HIDDEN = "hidden";
if (!(HIDDEN in elproto)) {
Object.defineProperty(elproto, HIDDEN, {
@@ -1772,7 +5955,7 @@ if (!(HIDDEN in elproto)) {
},
set: function set(value) {
if (value) {
- this.setAttribute(HIDDEN, '');
+ this.setAttribute(HIDDEN, "");
} else {
this.removeAttribute(HIDDEN);
}
@@ -1780,42 +5963,207 @@ if (!(HIDDEN in elproto)) {
});
}
-},{}],29:[function(require,module,exports){
-'use strict';
+},{}],39:[function(require,module,exports){
+"use strict";
// polyfills HTMLElement.prototype.classList and DOMTokenList
-require('classlist-polyfill');
-// polyfills HTMLElement.prototype.hidden
-require('./element-hidden');
+require("classlist-polyfill"); // polyfills HTMLElement.prototype.hidden
-},{"./element-hidden":28,"classlist-polyfill":1}],30:[function(require,module,exports){
-'use strict';
-var domready = require('domready');
+require("./element-hidden"); // polyfills Number.isNaN()
+
+
+require("./number-is-nan"); // polyfills CustomEvent
+
+
+require("./custom-event"); // polyfills svg4everybody
+
+
+require("./svg4everybody");
+
+},{"./custom-event":37,"./element-hidden":38,"./number-is-nan":40,"./svg4everybody":41,"classlist-polyfill":1}],40:[function(require,module,exports){
+"use strict";
+
+Number.isNaN = Number.isNaN || function isNaN(input) {
+ // eslint-disable-next-line no-self-compare
+ return typeof input === "number" && input !== input;
+};
+
+},{}],41:[function(require,module,exports){
+"use strict";
+
+/* eslint-disable */
+!function (factory) {
+ module.exports = factory();
+}(function () {
+ /*! svg4everybody v2.1.9 | github.com/jonathantneal/svg4everybody */
+ function embed(parent, svg, target, use) {
+ // if the target exists
+ if (target) {
+ // create a document fragment to hold the contents of the target
+ var fragment = document.createDocumentFragment(),
+ viewBox = !svg.hasAttribute("viewBox") && target.getAttribute("viewBox"); // conditionally set the viewBox on the svg
+
+ viewBox && svg.setAttribute("viewBox", viewBox); // copy the contents of the clone into the fragment
+
+ for ( // clone the target
+ var clone = document.importNode ? document.importNode(target, !0) : target.cloneNode(!0), g = document.createElementNS(svg.namespaceURI || "http://www.w3.org/2000/svg", "g"); clone.childNodes.length;) {
+ g.appendChild(clone.firstChild);
+ }
+
+ if (use) {
+ for (var i = 0; use.attributes.length > i; i++) {
+ var attr = use.attributes[i];
+ "xlink:href" !== attr.name && "href" !== attr.name && g.setAttribute(attr.name, attr.value);
+ }
+ }
+
+ fragment.appendChild(g), // append the fragment into the svg
+ parent.appendChild(fragment);
+ }
+ }
+
+ function loadreadystatechange(xhr, use) {
+ // listen to changes in the request
+ xhr.onreadystatechange = function () {
+ // if the request is ready
+ if (4 === xhr.readyState) {
+ // get the cached html document
+ var cachedDocument = xhr._cachedDocument; // ensure the cached html document based on the xhr response
+
+ cachedDocument || (cachedDocument = xhr._cachedDocument = document.implementation.createHTMLDocument(""), cachedDocument.body.innerHTML = xhr.responseText, // ensure domains are the same, otherwise we'll have issues appending the
+ // element in IE 11
+ cachedDocument.domain !== document.domain && (cachedDocument.domain = document.domain), xhr._cachedTarget = {}), // clear the xhr embeds list and embed each item
+ xhr._embeds.splice(0).map(function (item) {
+ // get the cached target
+ var target = xhr._cachedTarget[item.id]; // ensure the cached target
+
+ target || (target = xhr._cachedTarget[item.id] = cachedDocument.getElementById(item.id)), // embed the target into the svg
+ embed(item.parent, item.svg, target, use);
+ });
+ }
+ }, // test the ready state change immediately
+ xhr.onreadystatechange();
+ }
+
+ function svg4everybody(rawopts) {
+ function oninterval() {
+ // if all