diff options
Diffstat (limited to 'html/matt-chat/uswds/js')
| -rw-r--r-- | html/matt-chat/uswds/js/uswds-init.js | 24 | ||||
| -rw-r--r-- | html/matt-chat/uswds/js/uswds-init.min.js | 2 | ||||
| -rw-r--r-- | html/matt-chat/uswds/js/uswds-init.min.js.map | 1 | ||||
| -rw-r--r-- | html/matt-chat/uswds/js/uswds.js | 7137 | ||||
| -rw-r--r-- | html/matt-chat/uswds/js/uswds.min.js | 84 | ||||
| -rw-r--r-- | html/matt-chat/uswds/js/uswds.min.js.map | 1 |
6 files changed, 7249 insertions, 0 deletions
diff --git a/html/matt-chat/uswds/js/uswds-init.js b/html/matt-chat/uswds/js/uswds-init.js new file mode 100644 index 0000000..014c68d --- /dev/null +++ b/html/matt-chat/uswds/js/uswds-init.js @@ -0,0 +1,24 @@ +/* eslint-disable no-var */ +(function uswdsInit() { + "use strict"; + + var loadingClass = "usa-js-loading"; + var fallback; + + document.documentElement.classList.add(loadingClass); + function revertClass() { + document.documentElement.classList.remove(loadingClass); + } + + fallback = setTimeout(revertClass, 8000); + + function verifyLoaded() { + if (window.uswdsPresent) { + clearTimeout(fallback); + revertClass(); + window.removeEventListener("load", verifyLoaded, true); + } + } + + window.addEventListener("load", verifyLoaded, true); +})(); diff --git a/html/matt-chat/uswds/js/uswds-init.min.js b/html/matt-chat/uswds/js/uswds-init.min.js new file mode 100644 index 0000000..4ec10dd --- /dev/null +++ b/html/matt-chat/uswds/js/uswds-init.min.js @@ -0,0 +1,2 @@ +(()=>{var n,e="usa-js-loading";function t(){document.documentElement.classList.remove(e)}document.documentElement.classList.add(e),n=setTimeout(t,8e3),window.addEventListener("load",function e(){window.uswdsPresent&&(clearTimeout(n),t(),window.removeEventListener("load",e,!0))},!0)})(); +//# sourceMappingURL=uswds-init.min.js.map diff --git a/html/matt-chat/uswds/js/uswds-init.min.js.map b/html/matt-chat/uswds/js/uswds-init.min.js.map new file mode 100644 index 0000000..d41540e --- /dev/null +++ b/html/matt-chat/uswds/js/uswds-init.min.js.map @@ -0,0 +1 @@ +{"version":3,"file":"uswds-init.min.js","sources":["uswds-init.js"],"sourcesContent":["/* eslint-disable no-var */\n(function uswdsInit() {\n \"use strict\";\n\n var loadingClass = \"usa-js-loading\";\n var fallback;\n\n document.documentElement.classList.add(loadingClass);\n function revertClass() {\n document.documentElement.classList.remove(loadingClass);\n }\n\n fallback = setTimeout(revertClass, 8000);\n\n function verifyLoaded() {\n if (window.uswdsPresent) {\n clearTimeout(fallback);\n revertClass();\n window.removeEventListener(\"load\", verifyLoaded, true);\n }\n }\n\n window.addEventListener(\"load\", verifyLoaded, true);\n})();\n"],"names":["fallback","loadingClass","revertClass","document","documentElement","classList","remove","add","setTimeout","window","addEventListener","verifyLoaded","uswdsPresent","clearTimeout","removeEventListener"],"mappings":"CACA,KAGE,IACIA,EADAC,EAAe,iBAInB,SAASC,IACPC,SAASC,gBAAgBC,UAAUC,OAAOL,CAAY,CACxD,CAHAE,SAASC,gBAAgBC,UAAUE,IAAIN,CAAY,EAKnDD,EAAWQ,WAAWN,EAAa,GAAI,EAUvCO,OAAOC,iBAAiB,OARxB,SAASC,IACHF,OAAOG,eACTC,aAAab,CAAQ,EACrBE,EAAY,EACZO,OAAOK,oBAAoB,OAAQH,EAAc,CAAA,CAAI,EAEzD,EAE8C,CAAA,CAAI,CACnD,GAAE"} \ No newline at end of file diff --git a/html/matt-chat/uswds/js/uswds.js b/html/matt-chat/uswds/js/uswds.js new file mode 100644 index 0000000..bbd8309 --- /dev/null +++ b/html/matt-chat/uswds/js/uswds.js @@ -0,0 +1,7137 @@ +(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){ +"use strict"; + +// element-closest | CC0-1.0 | github.com/jonathantneal/closest + +(function (ElementProto) { + if (typeof ElementProto.matches !== 'function') { + ElementProto.matches = ElementProto.msMatchesSelector || ElementProto.mozMatchesSelector || ElementProto.webkitMatchesSelector || function matches(selector) { + var element = this; + var elements = (element.document || element.ownerDocument).querySelectorAll(selector); + var index = 0; + while (elements[index] && elements[index] !== element) { + ++index; + } + return Boolean(elements[index]); + }; + } + if (typeof ElementProto.closest !== 'function') { + ElementProto.closest = function closest(selector) { + var element = this; + while (element && element.nodeType === 1) { + if (element.matches(selector)) { + return element; + } + element = element.parentNode; + } + return null; + }; + } +})(window.Element.prototype); + +},{}],2:[function(require,module,exports){ +"use strict"; + +/* global define, KeyboardEvent, module */ + +(function () { + var keyboardeventKeyPolyfill = { + polyfill: polyfill, + keys: { + 3: 'Cancel', + 6: 'Help', + 8: 'Backspace', + 9: 'Tab', + 12: 'Clear', + 13: 'Enter', + 16: 'Shift', + 17: 'Control', + 18: 'Alt', + 19: 'Pause', + 20: 'CapsLock', + 27: 'Escape', + 28: 'Convert', + 29: 'NonConvert', + 30: 'Accept', + 31: 'ModeChange', + 32: ' ', + 33: 'PageUp', + 34: 'PageDown', + 35: 'End', + 36: 'Home', + 37: 'ArrowLeft', + 38: 'ArrowUp', + 39: 'ArrowRight', + 40: 'ArrowDown', + 41: 'Select', + 42: 'Print', + 43: 'Execute', + 44: 'PrintScreen', + 45: 'Insert', + 46: 'Delete', + 48: ['0', ')'], + 49: ['1', '!'], + 50: ['2', '@'], + 51: ['3', '#'], + 52: ['4', '$'], + 53: ['5', '%'], + 54: ['6', '^'], + 55: ['7', '&'], + 56: ['8', '*'], + 57: ['9', '('], + 91: 'OS', + 93: 'ContextMenu', + 144: 'NumLock', + 145: 'ScrollLock', + 181: 'VolumeMute', + 182: 'VolumeDown', + 183: 'VolumeUp', + 186: [';', ':'], + 187: ['=', '+'], + 188: [',', '<'], + 189: ['-', '_'], + 190: ['.', '>'], + 191: ['/', '?'], + 192: ['`', '~'], + 219: ['[', '{'], + 220: ['\\', '|'], + 221: [']', '}'], + 222: ["'", '"'], + 224: 'Meta', + 225: 'AltGraph', + 246: 'Attn', + 247: 'CrSel', + 248: 'ExSel', + 249: 'EraseEof', + 250: 'Play', + 251: 'ZoomOut' + } + }; + + // Function keys (F1-24). + var i; + for (i = 1; i < 25; i++) { + keyboardeventKeyPolyfill.keys[111 + i] = 'F' + i; + } + + // Printable ASCII characters. + var letter = ''; + for (i = 65; i < 91; i++) { + letter = String.fromCharCode(i); + keyboardeventKeyPolyfill.keys[i] = [letter.toLowerCase(), letter.toUpperCase()]; + } + function polyfill() { + if (!('KeyboardEvent' in window) || 'key' in KeyboardEvent.prototype) { + return false; + } + + // Polyfill `key` on `KeyboardEvent`. + var proto = { + get: function (x) { + var key = keyboardeventKeyPolyfill.keys[this.which || this.keyCode]; + if (Array.isArray(key)) { + key = key[+this.shiftKey]; + } + return key; + } + }; + Object.defineProperty(KeyboardEvent.prototype, 'key', proto); + return proto; + } + if (typeof define === 'function' && define.amd) { + define('keyboardevent-key-polyfill', keyboardeventKeyPolyfill); + } else if (typeof exports !== 'undefined' && typeof module !== 'undefined') { + module.exports = keyboardeventKeyPolyfill; + } else if (window) { + window.keyboardeventKeyPolyfill = keyboardeventKeyPolyfill; + } +})(); + +},{}],3:[function(require,module,exports){ +/* +object-assign +(c) Sindre Sorhus +@license MIT +*/ + +'use strict'; + +/* eslint-disable no-unused-vars */ +var getOwnPropertySymbols = Object.getOwnPropertySymbols; +var hasOwnProperty = Object.prototype.hasOwnProperty; +var propIsEnumerable = Object.prototype.propertyIsEnumerable; +function toObject(val) { + if (val === null || val === undefined) { + throw new TypeError('Object.assign cannot be called with null or undefined'); + } + return Object(val); +} +function shouldUseNative() { + try { + if (!Object.assign) { + return false; + } + + // Detect buggy property enumeration order in older V8 versions. + + // https://bugs.chromium.org/p/v8/issues/detail?id=4118 + var test1 = new String('abc'); // eslint-disable-line no-new-wrappers + test1[5] = 'de'; + if (Object.getOwnPropertyNames(test1)[0] === '5') { + return false; + } + + // https://bugs.chromium.org/p/v8/issues/detail?id=3056 + var test2 = {}; + for (var i = 0; i < 10; i++) { + test2['_' + String.fromCharCode(i)] = i; + } + var order2 = Object.getOwnPropertyNames(test2).map(function (n) { + return test2[n]; + }); + if (order2.join('') !== '0123456789') { + return false; + } + + // https://bugs.chromium.org/p/v8/issues/detail?id=3056 + var test3 = {}; + 'abcdefghijklmnopqrst'.split('').forEach(function (letter) { + test3[letter] = letter; + }); + if (Object.keys(Object.assign({}, test3)).join('') !== 'abcdefghijklmnopqrst') { + return false; + } + return true; + } catch (err) { + // We don't expect any of the above to throw, but better to be safe. + return false; + } +} +module.exports = shouldUseNative() ? Object.assign : function (target, source) { + var from; + var to = toObject(target); + var symbols; + for (var s = 1; s < arguments.length; s++) { + from = Object(arguments[s]); + for (var key in from) { + if (hasOwnProperty.call(from, key)) { + to[key] = from[key]; + } + } + if (getOwnPropertySymbols) { + symbols = getOwnPropertySymbols(from); + for (var i = 0; i < symbols.length; i++) { + if (propIsEnumerable.call(from, symbols[i])) { + to[symbols[i]] = from[symbols[i]]; + } + } + } + } + return to; +}; + +},{}],4:[function(require,module,exports){ +"use strict"; + +const assign = require('object-assign'); +const delegate = require('../delegate'); +const delegateAll = require('../delegateAll'); +const DELEGATE_PATTERN = /^(.+):delegate\((.+)\)$/; +const SPACE = ' '; +const getListeners = function (type, handler) { + var match = type.match(DELEGATE_PATTERN); + var selector; + if (match) { + type = match[1]; + selector = match[2]; + } + var options; + if (typeof handler === 'object') { + options = { + capture: popKey(handler, 'capture'), + passive: popKey(handler, 'passive') + }; + } + var listener = { + selector: selector, + delegate: typeof handler === 'object' ? delegateAll(handler) : selector ? delegate(selector, handler) : handler, + options: options + }; + if (type.indexOf(SPACE) > -1) { + return type.split(SPACE).map(function (_type) { + return assign({ + type: _type + }, listener); + }); + } else { + listener.type = type; + return [listener]; + } +}; +var popKey = function (obj, key) { + var value = obj[key]; + delete obj[key]; + return value; +}; +module.exports = function behavior(events, props) { + const listeners = Object.keys(events).reduce(function (memo, type) { + var listeners = getListeners(type, events[type]); + return memo.concat(listeners); + }, []); + return assign({ + add: function addBehavior(element) { + listeners.forEach(function (listener) { + element.addEventListener(listener.type, listener.delegate, listener.options); + }); + }, + remove: function removeBehavior(element) { + listeners.forEach(function (listener) { + element.removeEventListener(listener.type, listener.delegate, listener.options); + }); + } + }, props); +}; + +},{"../delegate":6,"../delegateAll":7,"object-assign":3}],5:[function(require,module,exports){ +"use strict"; + +module.exports = function compose(functions) { + return function (e) { + return functions.some(function (fn) { + return fn.call(this, e) === false; + }, this); + }; +}; + +},{}],6:[function(require,module,exports){ +"use strict"; + +// polyfill Element.prototype.closest +require('element-closest'); +module.exports = function delegate(selector, fn) { + return function delegation(event) { + var target = event.target.closest(selector); + if (target) { + return fn.call(target, event); + } + }; +}; + +},{"element-closest":1}],7:[function(require,module,exports){ +"use strict"; + +const delegate = require('../delegate'); +const compose = require('../compose'); +const SPLAT = '*'; +module.exports = function delegateAll(selectors) { + const keys = Object.keys(selectors); + + // XXX optimization: if there is only one handler and it applies to + // all elements (the "*" CSS selector), then just return that + // handler + if (keys.length === 1 && keys[0] === SPLAT) { + return selectors[SPLAT]; + } + const delegates = keys.reduce(function (memo, selector) { + memo.push(delegate(selector, selectors[selector])); + return memo; + }, []); + return compose(delegates); +}; + +},{"../compose":5,"../delegate":6}],8:[function(require,module,exports){ +"use strict"; + +module.exports = function ignore(element, fn) { + return function ignorance(e) { + if (element !== e.target && !element.contains(e.target)) { + return fn.call(this, e); + } + }; +}; + +},{}],9:[function(require,module,exports){ +"use strict"; + +module.exports = { + behavior: require('./behavior'), + delegate: require('./delegate'), + delegateAll: require('./delegateAll'), + ignore: require('./ignore'), + keymap: require('./keymap') +}; + +},{"./behavior":4,"./delegate":6,"./delegateAll":7,"./ignore":8,"./keymap":10}],10:[function(require,module,exports){ +"use strict"; + +require('keyboardevent-key-polyfill'); + +// these are the only relevant modifiers supported on all platforms, +// according to MDN: +// <https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/getModifierState> +const MODIFIERS = { + 'Alt': 'altKey', + 'Control': 'ctrlKey', + 'Ctrl': 'ctrlKey', + 'Shift': 'shiftKey' +}; +const MODIFIER_SEPARATOR = '+'; +const getEventKey = function (event, hasModifiers) { + var key = event.key; + if (hasModifiers) { + for (var modifier in MODIFIERS) { + if (event[MODIFIERS[modifier]] === true) { + key = [modifier, key].join(MODIFIER_SEPARATOR); + } + } + } + return key; +}; +module.exports = function keymap(keys) { + const hasModifiers = Object.keys(keys).some(function (key) { + return key.indexOf(MODIFIER_SEPARATOR) > -1; + }); + return function (event) { + var key = getEventKey(event, hasModifiers); + return [key, key.toLowerCase()].reduce(function (result, _key) { + if (_key in keys) { + result = keys[key].call(this, event); + } + return result; + }, undefined); + }; +}; +module.exports.MODIFIERS = MODIFIERS; + +},{"keyboardevent-key-polyfill":2}],11:[function(require,module,exports){ +"use strict"; + +module.exports = function once(listener, options) { + var wrapped = function wrappedOnce(e) { + e.currentTarget.removeEventListener(e.type, wrapped, options); + return listener.call(this, e); + }; + return wrapped; +}; + +},{}],12:[function(require,module,exports){ +'use strict'; + +var RE_TRIM = /(^\s+)|(\s+$)/g; +var RE_SPLIT = /\s+/; +var trim = String.prototype.trim ? function (str) { + return str.trim(); +} : function (str) { + return str.replace(RE_TRIM, ''); +}; +var queryById = function (id) { + return this.querySelector('[id="' + id.replace(/"/g, '\\"') + '"]'); +}; +module.exports = function resolveIds(ids, doc) { + if (typeof ids !== 'string') { + throw new Error('Expected a string but got ' + typeof ids); + } + if (!doc) { + doc = window.document; + } + var getElementById = doc.getElementById ? doc.getElementById.bind(doc) : queryById.bind(doc); + ids = trim(ids).split(RE_SPLIT); + + // XXX we can short-circuit here because trimming and splitting a + // string of just whitespace produces an array containing a single, + // empty string + if (ids.length === 1 && ids[0] === '') { + return []; + } + return ids.map(function (id) { + var el = getElementById(id); + if (!el) { + throw new Error('no element with id: "' + id + '"'); + } + return el; + }); +}; + +},{}],13:[function(require,module,exports){ +"use strict"; + +const behavior = require("../../uswds-core/src/js/utils/behavior"); +const toggleFormInput = require("../../uswds-core/src/js/utils/toggle-form-input"); +const { + CLICK +} = require("../../uswds-core/src/js/events"); +const { + prefix: PREFIX +} = require("../../uswds-core/src/js/config"); +const LINK = `.${PREFIX}-show-password`; +function toggle(event) { + event.preventDefault(); + toggleFormInput(this); +} +module.exports = behavior({ + [CLICK]: { + [LINK]: toggle + } +}); + +},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/events":36,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/toggle-form-input":50}],14:[function(require,module,exports){ +"use strict"; + +const select = require("../../uswds-core/src/js/utils/select"); +const behavior = require("../../uswds-core/src/js/utils/behavior"); +const toggle = require("../../uswds-core/src/js/utils/toggle"); +const isElementInViewport = require("../../uswds-core/src/js/utils/is-in-viewport"); +const { + CLICK +} = require("../../uswds-core/src/js/events"); +const { + prefix: PREFIX +} = require("../../uswds-core/src/js/config"); +const ACCORDION = `.${PREFIX}-accordion, .${PREFIX}-accordion--bordered`; +const BANNER_BUTTON = `.${PREFIX}-banner__button`; +const BUTTON = `.${PREFIX}-accordion__button[aria-controls]:not(${BANNER_BUTTON})`; +const EXPANDED = "aria-expanded"; +const MULTISELECTABLE = "data-allow-multiple"; + +/** + * Get an Array of button elements belonging directly to the given + * accordion element. + * @param {HTMLElement} accordion + * @return {array<HTMLButtonElement>} + */ +const getAccordionButtons = accordion => { + const buttons = select(BUTTON, accordion); + return buttons.filter(button => button.closest(ACCORDION) === accordion); +}; + +/** + * Toggle a button's "pressed" state, optionally providing a target + * state. + * + * @param {HTMLButtonElement} button + * @param {boolean?} expanded If no state is provided, the current + * state will be toggled (from false to true, and vice-versa). + * @return {boolean} the resulting state + */ +const toggleButton = (button, expanded) => { + const accordion = button.closest(ACCORDION); + let safeExpanded = expanded; + if (!accordion) { + throw new Error(`${BUTTON} is missing outer ${ACCORDION}`); + } + safeExpanded = toggle(button, expanded); + + // XXX multiselectable is opt-in, to preserve legacy behavior + const multiselectable = accordion.hasAttribute(MULTISELECTABLE); + if (safeExpanded && !multiselectable) { + getAccordionButtons(accordion).forEach(other => { + if (other !== button) { + toggle(other, false); + } + }); + } +}; + +/** + * @param {HTMLButtonElement} button + * @return {boolean} true + */ +const showButton = button => toggleButton(button, true); + +/** + * @param {HTMLButtonElement} button + * @return {boolean} false + */ +const hideButton = button => toggleButton(button, false); +const accordion = behavior({ + [CLICK]: { + [BUTTON]() { + toggleButton(this); + if (this.getAttribute(EXPANDED) === "true") { + // We were just expanded, but if another accordion was also just + // collapsed, we may no longer be in the viewport. This ensures + // that we are still visible, so the user isn't confused. + if (!isElementInViewport(this)) this.scrollIntoView(); + } + } + } +}, { + init(root) { + select(BUTTON, root).forEach(button => { + const expanded = button.getAttribute(EXPANDED) === "true"; + toggleButton(button, expanded); + }); + }, + ACCORDION, + BUTTON, + show: showButton, + hide: hideButton, + toggle: toggleButton, + getButtons: getAccordionButtons +}); +module.exports = accordion; + +},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/events":36,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/is-in-viewport":43,"../../uswds-core/src/js/utils/select":48,"../../uswds-core/src/js/utils/toggle":51}],15:[function(require,module,exports){ +"use strict"; + +const behavior = require("../../uswds-core/src/js/utils/behavior"); +const select = require("../../uswds-core/src/js/utils/select"); +const { + CLICK +} = require("../../uswds-core/src/js/events"); +const { + prefix: PREFIX +} = require("../../uswds-core/src/js/config"); +const toggle = require("../../uswds-core/src/js/utils/toggle"); +const HEADER = `.${PREFIX}-banner__header`; +const EXPANDED_CLASS = `${PREFIX}-banner__header--expanded`; +const BANNER_BUTTON = `${HEADER} [aria-controls]`; + +/** + * Toggle Banner display and class. + * @param {Event} event + */ +const toggleBanner = function toggleEl(event) { + event.preventDefault(); + const trigger = event.target.closest(BANNER_BUTTON); + toggle(trigger); + this.closest(HEADER).classList.toggle(EXPANDED_CLASS); +}; +module.exports = behavior({ + [CLICK]: { + [BANNER_BUTTON]: toggleBanner + } +}, { + init(root) { + select(BANNER_BUTTON, root).forEach(button => { + const expanded = button.getAttribute(EXPANDED_CLASS) === "true"; + toggle(button, expanded); + }); + } +}); + +},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/events":36,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/select":48,"../../uswds-core/src/js/utils/toggle":51}],16:[function(require,module,exports){ +"use strict"; + +const keymap = require("receptor/keymap"); +const behavior = require("../../uswds-core/src/js/utils/behavior"); +const ANCHOR_BUTTON = `a[class*="usa-button"]`; +const toggleButton = event => { + event.preventDefault(); + event.target.click(); +}; +const anchorButton = behavior({ + keydown: { + [ANCHOR_BUTTON]: keymap({ + " ": toggleButton + }) + } +}); +module.exports = anchorButton; + +},{"../../uswds-core/src/js/utils/behavior":40,"receptor/keymap":10}],17:[function(require,module,exports){ +"use strict"; + +const select = require("../../uswds-core/src/js/utils/select"); +const behavior = require("../../uswds-core/src/js/utils/behavior"); +const debounce = require("../../uswds-core/src/js/utils/debounce"); +const { + prefix: PREFIX +} = require("../../uswds-core/src/js/config"); +const CHARACTER_COUNT_CLASS = `${PREFIX}-character-count`; +const CHARACTER_COUNT = `.${CHARACTER_COUNT_CLASS}`; +const FORM_GROUP_CLASS = `${PREFIX}-form-group`; +const FORM_GROUP_ERROR_CLASS = `${FORM_GROUP_CLASS}--error`; +const FORM_GROUP = `.${FORM_GROUP_CLASS}`; +const LABEL_CLASS = `${PREFIX}-label`; +const LABEL_ERROR_CLASS = `${LABEL_CLASS}--error`; +const INPUT = `.${PREFIX}-character-count__field`; +const INPUT_ERROR_CLASS = `${PREFIX}-input--error`; +const MESSAGE = `.${PREFIX}-character-count__message`; +const VALIDATION_MESSAGE = "The content is too long."; +const MESSAGE_INVALID_CLASS = `${PREFIX}-character-count__status--invalid`; +const STATUS_MESSAGE_CLASS = `${CHARACTER_COUNT_CLASS}__status`; +const STATUS_MESSAGE_SR_ONLY_CLASS = `${CHARACTER_COUNT_CLASS}__sr-status`; +const STATUS_MESSAGE = `.${STATUS_MESSAGE_CLASS}`; +const STATUS_MESSAGE_SR_ONLY = `.${STATUS_MESSAGE_SR_ONLY_CLASS}`; +const DEFAULT_STATUS_LABEL = `characters allowed`; + +/** + * Returns the root, form group, label, and message elements for an character count input + * + * @param {HTMLInputElement|HTMLTextAreaElement} inputEl The character count input element + * @returns {CharacterCountElements} elements The root form group, input ID, label, and message element. + */ +const getCharacterCountElements = inputEl => { + const characterCountEl = inputEl.closest(CHARACTER_COUNT); + if (!characterCountEl) { + throw new Error(`${INPUT} is missing outer ${CHARACTER_COUNT}`); + } + const formGroupEl = characterCountEl.querySelector(FORM_GROUP); + const inputID = inputEl.getAttribute("id"); + const labelEl = document.querySelector(`label[for=${inputID}]`); + const messageEl = characterCountEl.querySelector(MESSAGE); + if (!messageEl) { + throw new Error(`${CHARACTER_COUNT} is missing inner ${MESSAGE}`); + } + return { + characterCountEl, + formGroupEl, + inputID, + labelEl, + messageEl + }; +}; + +/** + * Move maxlength attribute to a data attribute on usa-character-count + * + * @param {HTMLInputElement|HTMLTextAreaElement} inputEl The character count input element + */ +const setDataLength = inputEl => { + const { + characterCountEl + } = getCharacterCountElements(inputEl); + const maxlength = inputEl.getAttribute("maxlength"); + if (!maxlength) return; + inputEl.removeAttribute("maxlength"); + characterCountEl.setAttribute("data-maxlength", maxlength); +}; + +/** + * Create and append status messages for visual and screen readers + * + * @param {HTMLDivElement} characterCountEl - Div with `.usa-character-count` class + * @description Create two status messages for number of characters left; + * one visual status and another for screen readers + */ +const createStatusMessages = characterCountEl => { + const statusMessage = document.createElement("div"); + const srStatusMessage = document.createElement("div"); + const maxLength = characterCountEl.dataset.maxlength; + const defaultMessage = `${maxLength} ${DEFAULT_STATUS_LABEL}`; + statusMessage.classList.add(`${STATUS_MESSAGE_CLASS}`, "usa-hint"); + srStatusMessage.classList.add(`${STATUS_MESSAGE_SR_ONLY_CLASS}`, "usa-sr-only"); + statusMessage.setAttribute("aria-hidden", true); + srStatusMessage.setAttribute("aria-live", "polite"); + statusMessage.textContent = defaultMessage; + srStatusMessage.textContent = defaultMessage; + characterCountEl.append(statusMessage, srStatusMessage); +}; + +/** + * Returns message with how many characters are left + * + * @param {number} currentLength - The number of characters used + * @param {number} maxLength - The total number of characters allowed + * @returns {string} A string description of how many characters are left + */ +const getCountMessage = (currentLength, maxLength) => { + let newMessage = ""; + if (currentLength === 0) { + newMessage = `${maxLength} ${DEFAULT_STATUS_LABEL}`; + } else { + const difference = Math.abs(maxLength - currentLength); + const characters = `character${difference === 1 ? "" : "s"}`; + const guidance = currentLength > maxLength ? "over limit" : "left"; + newMessage = `${difference} ${characters} ${guidance}`; + } + return newMessage; +}; + +/** + * Updates the character count status for screen readers after a 1000ms delay. + * + * @param {HTMLElement} msgEl - The screen reader status message element + * @param {string} statusMessage - A string of the current character status + */ +const srUpdateStatus = debounce((msgEl, statusMessage) => { + const srStatusMessage = msgEl; + srStatusMessage.textContent = statusMessage; +}, 1000); + +/** + * Update the character count component + * + * @description On input, it will update visual status, screenreader + * status and update input validation (if over character length) + * @param {HTMLInputElement|HTMLTextAreaElement} inputEl The character count input element + */ +const updateCountMessage = inputEl => { + const { + characterCountEl, + labelEl, + formGroupEl + } = getCharacterCountElements(inputEl); + const currentLength = inputEl.value.length; + const maxLength = parseInt(characterCountEl.getAttribute("data-maxlength"), 10); + const statusMessage = characterCountEl.querySelector(STATUS_MESSAGE); + const srStatusMessage = characterCountEl.querySelector(STATUS_MESSAGE_SR_ONLY); + const currentStatusMessage = getCountMessage(currentLength, maxLength); + if (!maxLength) return; + const isOverLimit = currentLength && currentLength > maxLength; + statusMessage.textContent = currentStatusMessage; + srUpdateStatus(srStatusMessage, currentStatusMessage); + if (isOverLimit && !inputEl.validationMessage) { + inputEl.setCustomValidity(VALIDATION_MESSAGE); + } + if (!isOverLimit && inputEl.validationMessage === VALIDATION_MESSAGE) { + inputEl.setCustomValidity(""); + } + if (formGroupEl) { + formGroupEl.classList.toggle(FORM_GROUP_ERROR_CLASS, isOverLimit); + } + if (labelEl) { + labelEl.classList.toggle(LABEL_ERROR_CLASS, isOverLimit); + } + inputEl.classList.toggle(INPUT_ERROR_CLASS, isOverLimit); + statusMessage.classList.toggle(MESSAGE_INVALID_CLASS, isOverLimit); +}; + +/** + * Initialize component + * + * @description On init this function will create elements and update any + * attributes so it can tell the user how many characters are left. + * @param {HTMLInputElement|HTMLTextAreaElement} inputEl the components input + */ +const enhanceCharacterCount = inputEl => { + const { + characterCountEl, + messageEl + } = getCharacterCountElements(inputEl); + + // Hide hint and remove aria-live for backwards compatibility + messageEl.classList.add("usa-sr-only"); + messageEl.removeAttribute("aria-live"); + setDataLength(inputEl); + createStatusMessages(characterCountEl); +}; +const characterCount = behavior({ + input: { + [INPUT]() { + updateCountMessage(this); + } + } +}, { + init(root) { + select(INPUT, root).forEach(input => enhanceCharacterCount(input)); + }, + FORM_GROUP_ERROR_CLASS, + LABEL_ERROR_CLASS, + INPUT_ERROR_CLASS, + MESSAGE_INVALID_CLASS, + VALIDATION_MESSAGE, + STATUS_MESSAGE_CLASS, + STATUS_MESSAGE_SR_ONLY_CLASS, + DEFAULT_STATUS_LABEL, + createStatusMessages, + getCountMessage, + updateCountMessage +}); +module.exports = characterCount; + +},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/debounce":41,"../../uswds-core/src/js/utils/select":48}],18:[function(require,module,exports){ +"use strict"; + +const keymap = require("receptor/keymap"); +const selectOrMatches = require("../../uswds-core/src/js/utils/select-or-matches"); +const behavior = require("../../uswds-core/src/js/utils/behavior"); +const Sanitizer = require("../../uswds-core/src/js/utils/sanitizer"); +const { + prefix: PREFIX +} = require("../../uswds-core/src/js/config"); +const { + CLICK +} = require("../../uswds-core/src/js/events"); +const COMBO_BOX_CLASS = `${PREFIX}-combo-box`; +const COMBO_BOX_PRISTINE_CLASS = `${COMBO_BOX_CLASS}--pristine`; +const SELECT_CLASS = `${COMBO_BOX_CLASS}__select`; +const INPUT_CLASS = `${COMBO_BOX_CLASS}__input`; +const CLEAR_INPUT_BUTTON_CLASS = `${COMBO_BOX_CLASS}__clear-input`; +const CLEAR_INPUT_BUTTON_WRAPPER_CLASS = `${CLEAR_INPUT_BUTTON_CLASS}__wrapper`; +const INPUT_BUTTON_SEPARATOR_CLASS = `${COMBO_BOX_CLASS}__input-button-separator`; +const TOGGLE_LIST_BUTTON_CLASS = `${COMBO_BOX_CLASS}__toggle-list`; +const TOGGLE_LIST_BUTTON_WRAPPER_CLASS = `${TOGGLE_LIST_BUTTON_CLASS}__wrapper`; +const LIST_CLASS = `${COMBO_BOX_CLASS}__list`; +const LIST_OPTION_CLASS = `${COMBO_BOX_CLASS}__list-option`; +const LIST_OPTION_FOCUSED_CLASS = `${LIST_OPTION_CLASS}--focused`; +const LIST_OPTION_SELECTED_CLASS = `${LIST_OPTION_CLASS}--selected`; +const STATUS_CLASS = `${COMBO_BOX_CLASS}__status`; +const COMBO_BOX = `.${COMBO_BOX_CLASS}`; +const SELECT = `.${SELECT_CLASS}`; +const INPUT = `.${INPUT_CLASS}`; +const CLEAR_INPUT_BUTTON = `.${CLEAR_INPUT_BUTTON_CLASS}`; +const TOGGLE_LIST_BUTTON = `.${TOGGLE_LIST_BUTTON_CLASS}`; +const LIST = `.${LIST_CLASS}`; +const LIST_OPTION = `.${LIST_OPTION_CLASS}`; +const LIST_OPTION_FOCUSED = `.${LIST_OPTION_FOCUSED_CLASS}`; +const LIST_OPTION_SELECTED = `.${LIST_OPTION_SELECTED_CLASS}`; +const STATUS = `.${STATUS_CLASS}`; +const DEFAULT_FILTER = ".*{{query}}.*"; +const noop = () => {}; + +/** + * set the value of the element and dispatch a change event + * + * @param {HTMLInputElement|HTMLSelectElement} el The element to update + * @param {string} value The new value of the element + */ +const changeElementValue = (el, value = "") => { + const elementToChange = el; + elementToChange.value = value; + const event = new CustomEvent("change", { + bubbles: true, + cancelable: true, + detail: { + value + } + }); + elementToChange.dispatchEvent(event); +}; + +/** + * The elements within the combo box. + * @typedef {Object} ComboBoxContext + * @property {HTMLElement} comboBoxEl + * @property {HTMLSelectElement} selectEl + * @property {HTMLInputElement} inputEl + * @property {HTMLUListElement} listEl + * @property {HTMLDivElement} statusEl + * @property {HTMLLIElement} focusedOptionEl + * @property {HTMLLIElement} selectedOptionEl + * @property {HTMLButtonElement} toggleListBtnEl + * @property {HTMLButtonElement} clearInputBtnEl + * @property {boolean} isPristine + * @property {boolean} disableFiltering + */ + +/** + * Get an object of elements belonging directly to the given + * combo box component. + * + * @param {HTMLElement} el the element within the combo box + * @returns {ComboBoxContext} elements + */ +const getComboBoxContext = el => { + const comboBoxEl = el.closest(COMBO_BOX); + if (!comboBoxEl) { + throw new Error(`Element is missing outer ${COMBO_BOX}`); + } + const selectEl = comboBoxEl.querySelector(SELECT); + const inputEl = comboBoxEl.querySelector(INPUT); + const listEl = comboBoxEl.querySelector(LIST); + const statusEl = comboBoxEl.querySelector(STATUS); + const focusedOptionEl = comboBoxEl.querySelector(LIST_OPTION_FOCUSED); + const selectedOptionEl = comboBoxEl.querySelector(LIST_OPTION_SELECTED); + const toggleListBtnEl = comboBoxEl.querySelector(TOGGLE_LIST_BUTTON); + const clearInputBtnEl = comboBoxEl.querySelector(CLEAR_INPUT_BUTTON); + const isPristine = comboBoxEl.classList.contains(COMBO_BOX_PRISTINE_CLASS); + const disableFiltering = comboBoxEl.dataset.disableFiltering === "true"; + return { + comboBoxEl, + selectEl, + inputEl, + listEl, + statusEl, + focusedOptionEl, + selectedOptionEl, + toggleListBtnEl, + clearInputBtnEl, + isPristine, + disableFiltering + }; +}; + +/** + * Disable the combo-box component + * + * @param {HTMLInputElement} el An element within the combo box component + */ +const disable = el => { + const { + inputEl, + toggleListBtnEl, + clearInputBtnEl + } = getComboBoxContext(el); + clearInputBtnEl.hidden = true; + clearInputBtnEl.disabled = true; + toggleListBtnEl.disabled = true; + inputEl.disabled = true; +}; + +/** + * Check for aria-disabled on initialization + * + * @param {HTMLInputElement} el An element within the combo box component + */ +const ariaDisable = el => { + const { + inputEl, + toggleListBtnEl, + clearInputBtnEl + } = getComboBoxContext(el); + clearInputBtnEl.hidden = true; + clearInputBtnEl.setAttribute("aria-disabled", true); + toggleListBtnEl.setAttribute("aria-disabled", true); + inputEl.setAttribute("aria-disabled", true); +}; + +/** + * Enable the combo-box component + * + * @param {HTMLInputElement} el An element within the combo box component + */ +const enable = el => { + const { + inputEl, + toggleListBtnEl, + clearInputBtnEl + } = getComboBoxContext(el); + clearInputBtnEl.hidden = false; + clearInputBtnEl.disabled = false; + toggleListBtnEl.disabled = false; + inputEl.disabled = false; +}; + +/** + * Enhance a select element into a combo box component. + * + * @param {HTMLElement} _comboBoxEl The initial element of the combo box component + */ +const enhanceComboBox = _comboBoxEl => { + const comboBoxEl = _comboBoxEl.closest(COMBO_BOX); + if (comboBoxEl.dataset.enhanced) return; + const selectEl = comboBoxEl.querySelector("select"); + if (!selectEl) { + throw new Error(`${COMBO_BOX} is missing inner select`); + } + const selectId = selectEl.id; + const selectLabel = document.querySelector(`label[for="${selectId}"]`); + const listId = `${selectId}--list`; + const listIdLabel = `${selectId}-label`; + const additionalAttributes = []; + const { + defaultValue + } = comboBoxEl.dataset; + const { + placeholder + } = comboBoxEl.dataset; + let selectedOption; + if (placeholder) { + additionalAttributes.push({ + placeholder + }); + } + if (defaultValue) { + for (let i = 0, len = selectEl.options.length; i < len; i += 1) { + const optionEl = selectEl.options[i]; + if (optionEl.value === defaultValue) { + selectedOption = optionEl; + break; + } + } + } + + /** + * Throw error if combobox is missing a label or label is missing + * `for` attribute. Otherwise, set the ID to match the <ul> aria-labelledby + */ + if (!selectLabel || !selectLabel.matches(`label[for="${selectId}"]`)) { + throw new Error(`${COMBO_BOX} for ${selectId} is either missing a label or a "for" attribute`); + } else { + selectLabel.setAttribute("id", listIdLabel); + } + selectLabel.setAttribute("id", listIdLabel); + selectEl.setAttribute("aria-hidden", "true"); + selectEl.setAttribute("tabindex", "-1"); + selectEl.classList.add("usa-sr-only", SELECT_CLASS); + selectEl.id = ""; + selectEl.value = ""; + ["required", "aria-label", "aria-labelledby"].forEach(name => { + if (selectEl.hasAttribute(name)) { + const value = selectEl.getAttribute(name); + additionalAttributes.push({ + [name]: value + }); + selectEl.removeAttribute(name); + } + }); + + // sanitize doesn't like functions in template literals + const input = document.createElement("input"); + input.setAttribute("id", selectId); + input.setAttribute("aria-owns", listId); + input.setAttribute("aria-controls", listId); + input.setAttribute("aria-autocomplete", "list"); + input.setAttribute("aria-expanded", "false"); + input.setAttribute("autocapitalize", "off"); + input.setAttribute("autocomplete", "off"); + input.setAttribute("class", INPUT_CLASS); + input.setAttribute("type", "text"); + input.setAttribute("role", "combobox"); + additionalAttributes.forEach(attr => Object.keys(attr).forEach(key => { + const value = Sanitizer.escapeHTML`${attr[key]}`; + input.setAttribute(key, value); + })); + comboBoxEl.insertAdjacentElement("beforeend", input); + comboBoxEl.insertAdjacentHTML("beforeend", Sanitizer.escapeHTML` + <span class="${CLEAR_INPUT_BUTTON_WRAPPER_CLASS}" tabindex="-1"> + <button type="button" class="${CLEAR_INPUT_BUTTON_CLASS}" aria-label="Clear the select contents"> </button> + </span> + <span class="${INPUT_BUTTON_SEPARATOR_CLASS}"> </span> + <span class="${TOGGLE_LIST_BUTTON_WRAPPER_CLASS}" tabindex="-1"> + <button type="button" tabindex="-1" class="${TOGGLE_LIST_BUTTON_CLASS}" aria-label="Toggle the dropdown list"> </button> + </span> + <ul + tabindex="-1" + id="${listId}" + class="${LIST_CLASS}" + role="listbox" + aria-labelledby="${listIdLabel}" + hidden> + </ul> + <div class="${STATUS_CLASS} usa-sr-only" role="status"></div>`); + if (selectedOption) { + const { + inputEl + } = getComboBoxContext(comboBoxEl); + changeElementValue(selectEl, selectedOption.value); + changeElementValue(inputEl, selectedOption.text); + comboBoxEl.classList.add(COMBO_BOX_PRISTINE_CLASS); + } + if (selectEl.disabled) { + disable(comboBoxEl); + selectEl.disabled = false; + } + if (selectEl.hasAttribute("aria-disabled")) { + ariaDisable(comboBoxEl); + selectEl.removeAttribute("aria-disabled"); + } + comboBoxEl.dataset.enhanced = "true"; +}; + +/** + * Manage the focused element within the list options when + * navigating via keyboard. + * + * @param {HTMLElement} el An anchor element within the combo box component + * @param {HTMLElement} nextEl An element within the combo box component + * @param {Object} options options + * @param {boolean} options.skipFocus skip focus of highlighted item + * @param {boolean} options.preventScroll should skip procedure to scroll to element + */ +const highlightOption = (el, nextEl, { + skipFocus, + preventScroll +} = {}) => { + const { + inputEl, + listEl, + focusedOptionEl + } = getComboBoxContext(el); + if (focusedOptionEl) { + focusedOptionEl.classList.remove(LIST_OPTION_FOCUSED_CLASS); + focusedOptionEl.setAttribute("tabIndex", "-1"); + } + if (nextEl) { + inputEl.setAttribute("aria-activedescendant", nextEl.id); + nextEl.setAttribute("tabIndex", "0"); + nextEl.classList.add(LIST_OPTION_FOCUSED_CLASS); + if (!preventScroll) { + const optionBottom = nextEl.offsetTop + nextEl.offsetHeight; + const currentBottom = listEl.scrollTop + listEl.offsetHeight; + if (optionBottom > currentBottom) { + listEl.scrollTop = optionBottom - listEl.offsetHeight; + } + if (nextEl.offsetTop < listEl.scrollTop) { + listEl.scrollTop = nextEl.offsetTop; + } + } + if (!skipFocus) { + nextEl.focus({ + preventScroll + }); + } + } else { + inputEl.setAttribute("aria-activedescendant", ""); + inputEl.focus(); + } +}; + +/** + * Generate a dynamic regular expression based off of a replaceable and possibly filtered value. + * + * @param {string} el An element within the combo box component + * @param {string} query The value to use in the regular expression + * @param {object} extras An object of regular expressions to replace and filter the query + */ +const generateDynamicRegExp = (filter, query = "", extras = {}) => { + const escapeRegExp = text => text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"); + let find = filter.replace(/{{(.*?)}}/g, (m, $1) => { + const key = $1.trim(); + const queryFilter = extras[key]; + if (key !== "query" && queryFilter) { + const matcher = new RegExp(queryFilter, "i"); + const matches = query.match(matcher); + if (matches) { + return escapeRegExp(matches[1]); + } + return ""; + } + return escapeRegExp(query); + }); + find = `^(?:${find})$`; + return new RegExp(find, "i"); +}; + +/** + * Display the option list of a combo box component. + * + * @param {HTMLElement} el An element within the combo box component + */ +const displayList = el => { + const { + comboBoxEl, + selectEl, + inputEl, + listEl, + statusEl, + isPristine, + disableFiltering + } = getComboBoxContext(el); + let selectedItemId; + let firstFoundId; + const listOptionBaseId = `${listEl.id}--option-`; + const inputValue = (inputEl.value || "").toLowerCase(); + const filter = comboBoxEl.dataset.filter || DEFAULT_FILTER; + const regex = generateDynamicRegExp(filter, inputValue, comboBoxEl.dataset); + let options = []; + const optionsStartsWith = []; + const optionsContains = []; + const optionList = [...selectEl.options]; + + /** + * Builds and sorts options array. + * + * Option param is passed through regex test before passing into this function. + * When filtering is enabled, the array will be sorted by options that start with the query, followed by + * options that contain the query. + * When filtering is disabled, all options will be included in the array unsorted. + * + * These array items will populate the list that is displayed to the user after a search query is entered. + * Array attributes are also used to set option IDs and aria-setsize attributes. + * + * @param {HTMLOptionElement} option - Option element from select array + */ + const buildOptionsArray = option => { + if (disableFiltering || isPristine) { + options.push(option); + return; + } + const matchStartsWith = option.text.toLowerCase().startsWith(inputValue); + if (matchStartsWith) { + optionsStartsWith.push(option); + } else { + optionsContains.push(option); + } + options = [...optionsStartsWith, ...optionsContains]; + }; + + /** + * Compares option text to query using generated regex filter. + * + * @param {HTMLOptionElement} option + * @returns {boolean} - True when option text matches user input query. + */ + const optionMatchesQuery = option => regex.test(option.text); + + /** + * Logic check to determine if options array needs to be updated. + * + * @param {HTMLOptionElement} option + * @returns {boolean} - True when option has value && if filtering is disabled, combo box has an active selection, + * there is no inputValue, or if option matches user query + */ + const arrayNeedsUpdate = option => option.value && (disableFiltering || isPristine || !inputValue || optionMatchesQuery(option)); + + /** + * Checks if firstFoundId should be assigned, which is then used to set itemToFocus. + * + * @param {HTMLOptionElement} option + * @return {boolean} - Returns true if filtering is disabled, no firstFoundId is assigned, and the option matches the query. + */ + const isFirstMatch = option => disableFiltering && !firstFoundId && optionMatchesQuery(option); + + /** + * Checks if isCurrentSelection should be assigned, which is then used to set itemToFocus. + * + * @param {HTMLOptionElement} option + * @returns {boolean} - Returns true if option.value matches selectEl.value. + */ + const isCurrentSelection = option => selectEl.value && option.value === selectEl.value; + + /** + * Update the array of options that should be displayed on the page. + * Assign an ID to each displayed option. + * Identify and assign the option that should receive focus. + */ + optionList.forEach(option => { + if (arrayNeedsUpdate(option)) { + buildOptionsArray(option); + const optionId = `${listOptionBaseId}${options.indexOf(option)}`; + if (isFirstMatch(option)) { + firstFoundId = optionId; + } + if (isCurrentSelection(option)) { + selectedItemId = optionId; + } + } + }); + const numOptions = options.length; + const optionHtml = options.map((option, index) => { + const optionId = `${listOptionBaseId}${index}`; + const classes = [LIST_OPTION_CLASS]; + let tabindex = "-1"; + let ariaSelected = "false"; + if (optionId === selectedItemId) { + classes.push(LIST_OPTION_SELECTED_CLASS, LIST_OPTION_FOCUSED_CLASS); + tabindex = "0"; + ariaSelected = "true"; + } + if (!selectedItemId && index === 0) { + classes.push(LIST_OPTION_FOCUSED_CLASS); + tabindex = "0"; + } + const li = document.createElement("li"); + li.setAttribute("aria-setsize", options.length); + li.setAttribute("aria-posinset", index + 1); + li.setAttribute("aria-selected", ariaSelected); + li.setAttribute("id", optionId); + li.setAttribute("class", classes.join(" ")); + li.setAttribute("tabindex", tabindex); + li.setAttribute("role", "option"); + li.setAttribute("data-value", option.value); + li.textContent = option.text; + return li; + }); + const noResults = document.createElement("li"); + noResults.setAttribute("class", `${LIST_OPTION_CLASS}--no-results`); + noResults.textContent = "No results found"; + listEl.hidden = false; + if (numOptions) { + listEl.innerHTML = ""; + optionHtml.forEach(item => listEl.insertAdjacentElement("beforeend", item)); + } else { + listEl.innerHTML = ""; + listEl.insertAdjacentElement("beforeend", noResults); + } + inputEl.setAttribute("aria-expanded", "true"); + statusEl.textContent = numOptions ? `${numOptions} result${numOptions > 1 ? "s" : ""} available.` : "No results."; + let itemToFocus; + if (isPristine && selectedItemId) { + itemToFocus = listEl.querySelector(`#${selectedItemId}`); + } else if (disableFiltering && firstFoundId) { + itemToFocus = listEl.querySelector(`#${firstFoundId}`); + } + if (itemToFocus) { + highlightOption(listEl, itemToFocus, { + skipFocus: true + }); + } +}; + +/** + * Hide the option list of a combo box component. + * + * @param {HTMLElement} el An element within the combo box component + */ +const hideList = el => { + const { + inputEl, + listEl, + statusEl, + focusedOptionEl + } = getComboBoxContext(el); + statusEl.innerHTML = ""; + inputEl.setAttribute("aria-expanded", "false"); + inputEl.setAttribute("aria-activedescendant", ""); + if (focusedOptionEl) { + focusedOptionEl.classList.remove(LIST_OPTION_FOCUSED_CLASS); + } + listEl.scrollTop = 0; + listEl.hidden = true; +}; + +/** + * Select an option list of the combo box component. + * + * @param {HTMLElement} listOptionEl The list option being selected + */ +const selectItem = listOptionEl => { + const { + comboBoxEl, + selectEl, + inputEl + } = getComboBoxContext(listOptionEl); + changeElementValue(selectEl, listOptionEl.dataset.value); + changeElementValue(inputEl, listOptionEl.textContent); + comboBoxEl.classList.add(COMBO_BOX_PRISTINE_CLASS); + hideList(comboBoxEl); + inputEl.focus(); +}; + +/** + * Clear the input of the combo box + * + * @param {HTMLButtonElement} clearButtonEl The clear input button + */ +const clearInput = clearButtonEl => { + const { + comboBoxEl, + listEl, + selectEl, + inputEl + } = getComboBoxContext(clearButtonEl); + const listShown = !listEl.hidden; + if (selectEl.value) changeElementValue(selectEl); + if (inputEl.value) changeElementValue(inputEl); + comboBoxEl.classList.remove(COMBO_BOX_PRISTINE_CLASS); + if (listShown) displayList(comboBoxEl); + inputEl.focus(); +}; + +/** + * Reset the select based off of currently set select value + * + * @param {HTMLElement} el An element within the combo box component + */ +const resetSelection = el => { + const { + comboBoxEl, + selectEl, + inputEl + } = getComboBoxContext(el); + const selectValue = selectEl.value; + const inputValue = (inputEl.value || "").toLowerCase(); + if (selectValue) { + for (let i = 0, len = selectEl.options.length; i < len; i += 1) { + const optionEl = selectEl.options[i]; + if (optionEl.value === selectValue) { + if (inputValue !== optionEl.text) { + changeElementValue(inputEl, optionEl.text); + } + comboBoxEl.classList.add(COMBO_BOX_PRISTINE_CLASS); + return; + } + } + } + if (inputValue) { + changeElementValue(inputEl); + } +}; + +/** + * Select an option list of the combo box component based off of + * having a current focused list option or + * having test that completely matches a list option. + * Otherwise it clears the input and select. + * + * @param {HTMLElement} el An element within the combo box component + */ +const completeSelection = el => { + const { + comboBoxEl, + selectEl, + inputEl, + statusEl + } = getComboBoxContext(el); + statusEl.textContent = ""; + const inputValue = (inputEl.value || "").toLowerCase(); + if (inputValue) { + for (let i = 0, len = selectEl.options.length; i < len; i += 1) { + const optionEl = selectEl.options[i]; + if (optionEl.text.toLowerCase() === inputValue) { + changeElementValue(selectEl, optionEl.value); + changeElementValue(inputEl, optionEl.text); + comboBoxEl.classList.add(COMBO_BOX_PRISTINE_CLASS); + return; + } + } + } + resetSelection(comboBoxEl); +}; + +/** + * Handle the escape event within the combo box component. + * + * @param {KeyboardEvent} event An event within the combo box component + */ +const handleEscape = event => { + const { + comboBoxEl, + inputEl + } = getComboBoxContext(event.target); + hideList(comboBoxEl); + resetSelection(comboBoxEl); + inputEl.focus(); +}; + +/** + * Handle the down event within the combo box component. + * + * @param {KeyboardEvent} event An event within the combo box component + */ +const handleDownFromInput = event => { + const { + comboBoxEl, + listEl + } = getComboBoxContext(event.target); + if (listEl.hidden) { + displayList(comboBoxEl); + } + const nextOptionEl = listEl.querySelector(LIST_OPTION_FOCUSED) || listEl.querySelector(LIST_OPTION); + if (nextOptionEl) { + highlightOption(comboBoxEl, nextOptionEl); + } + event.preventDefault(); +}; + +/** + * Handle the enter event from an input element within the combo box component. + * + * @param {KeyboardEvent} event An event within the combo box component + */ +const handleEnterFromInput = event => { + const { + comboBoxEl, + listEl + } = getComboBoxContext(event.target); + const listShown = !listEl.hidden; + completeSelection(comboBoxEl); + if (listShown) { + hideList(comboBoxEl); + } + event.preventDefault(); +}; + +/** + * Handle the down event within the combo box component. + * + * @param {KeyboardEvent} event An event within the combo box component + */ +const handleDownFromListOption = event => { + const focusedOptionEl = event.target; + const nextOptionEl = focusedOptionEl.nextSibling; + if (nextOptionEl) { + highlightOption(focusedOptionEl, nextOptionEl); + } + event.preventDefault(); +}; + +/** + * Handle the space event from an list option element within the combo box component. + * + * @param {KeyboardEvent} event An event within the combo box component + */ +const handleSpaceFromListOption = event => { + selectItem(event.target); + event.preventDefault(); +}; + +/** + * Handle the enter event from list option within the combo box component. + * + * @param {KeyboardEvent} event An event within the combo box component + */ +const handleEnterFromListOption = event => { + selectItem(event.target); + event.preventDefault(); +}; + +/** + * Handle the up event from list option within the combo box component. + * + * @param {KeyboardEvent} event An event within the combo box component + */ +const handleUpFromListOption = event => { + const { + comboBoxEl, + listEl, + focusedOptionEl + } = getComboBoxContext(event.target); + const nextOptionEl = focusedOptionEl && focusedOptionEl.previousSibling; + const listShown = !listEl.hidden; + highlightOption(comboBoxEl, nextOptionEl); + if (listShown) { + event.preventDefault(); + } + if (!nextOptionEl) { + hideList(comboBoxEl); + } +}; + +/** + * Select list option on the mouseover event. + * + * @param {MouseEvent} event The mouseover event + * @param {HTMLLIElement} listOptionEl An element within the combo box component + */ +const handleMouseover = listOptionEl => { + const isCurrentlyFocused = listOptionEl.classList.contains(LIST_OPTION_FOCUSED_CLASS); + if (isCurrentlyFocused) return; + highlightOption(listOptionEl, listOptionEl, { + preventScroll: true + }); +}; + +/** + * Toggle the list when the button is clicked + * + * @param {HTMLElement} el An element within the combo box component + */ +const toggleList = el => { + const { + comboBoxEl, + listEl, + inputEl + } = getComboBoxContext(el); + if (listEl.hidden) { + displayList(comboBoxEl); + } else { + hideList(comboBoxEl); + } + inputEl.focus(); +}; + +/** + * Handle click from input + * + * @param {HTMLInputElement} el An element within the combo box component + */ +const handleClickFromInput = el => { + const { + comboBoxEl, + listEl + } = getComboBoxContext(el); + if (listEl.hidden) { + displayList(comboBoxEl); + } +}; +const comboBox = behavior({ + [CLICK]: { + [INPUT]() { + if (this.disabled) return; + handleClickFromInput(this); + }, + [TOGGLE_LIST_BUTTON]() { + if (this.disabled) return; + toggleList(this); + }, + [LIST_OPTION]() { + if (this.disabled) return; + selectItem(this); + }, + [CLEAR_INPUT_BUTTON]() { + if (this.disabled) return; + clearInput(this); + } + }, + focusout: { + [COMBO_BOX](event) { + if (!this.contains(event.relatedTarget)) { + resetSelection(this); + hideList(this); + } + } + }, + keydown: { + [COMBO_BOX]: keymap({ + Escape: handleEscape + }), + [INPUT]: keymap({ + Enter: handleEnterFromInput, + ArrowDown: handleDownFromInput, + Down: handleDownFromInput + }), + [LIST_OPTION]: keymap({ + ArrowUp: handleUpFromListOption, + Up: handleUpFromListOption, + ArrowDown: handleDownFromListOption, + Down: handleDownFromListOption, + Enter: handleEnterFromListOption, + " ": handleSpaceFromListOption, + "Shift+Tab": noop + }) + }, + input: { + [INPUT]() { + const comboBoxEl = this.closest(COMBO_BOX); + comboBoxEl.classList.remove(COMBO_BOX_PRISTINE_CLASS); + displayList(this); + } + }, + mouseover: { + [LIST_OPTION]() { + handleMouseover(this); + } + } +}, { + init(root) { + selectOrMatches(COMBO_BOX, root).forEach(comboBoxEl => { + enhanceComboBox(comboBoxEl); + }); + }, + getComboBoxContext, + enhanceComboBox, + generateDynamicRegExp, + disable, + enable, + displayList, + hideList, + COMBO_BOX_CLASS +}); +module.exports = comboBox; + +},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/events":36,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/sanitizer":45,"../../uswds-core/src/js/utils/select-or-matches":47,"receptor/keymap":10}],19:[function(require,module,exports){ +"use strict"; + +const keymap = require("receptor/keymap"); +const behavior = require("../../uswds-core/src/js/utils/behavior"); +const select = require("../../uswds-core/src/js/utils/select"); +const selectOrMatches = require("../../uswds-core/src/js/utils/select-or-matches"); +const { + prefix: PREFIX +} = require("../../uswds-core/src/js/config"); +const { + CLICK +} = require("../../uswds-core/src/js/events"); +const activeElement = require("../../uswds-core/src/js/utils/active-element"); +const isIosDevice = require("../../uswds-core/src/js/utils/is-ios-device"); +const Sanitizer = require("../../uswds-core/src/js/utils/sanitizer"); +const DATE_PICKER_CLASS = `${PREFIX}-date-picker`; +const DATE_PICKER_WRAPPER_CLASS = `${DATE_PICKER_CLASS}__wrapper`; +const DATE_PICKER_INITIALIZED_CLASS = `${DATE_PICKER_CLASS}--initialized`; +const DATE_PICKER_ACTIVE_CLASS = `${DATE_PICKER_CLASS}--active`; +const DATE_PICKER_INTERNAL_INPUT_CLASS = `${DATE_PICKER_CLASS}__internal-input`; +const DATE_PICKER_EXTERNAL_INPUT_CLASS = `${DATE_PICKER_CLASS}__external-input`; +const DATE_PICKER_BUTTON_CLASS = `${DATE_PICKER_CLASS}__button`; +const DATE_PICKER_CALENDAR_CLASS = `${DATE_PICKER_CLASS}__calendar`; +const DATE_PICKER_STATUS_CLASS = `${DATE_PICKER_CLASS}__status`; +const CALENDAR_DATE_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__date`; +const CALENDAR_DATE_FOCUSED_CLASS = `${CALENDAR_DATE_CLASS}--focused`; +const CALENDAR_DATE_SELECTED_CLASS = `${CALENDAR_DATE_CLASS}--selected`; +const CALENDAR_DATE_PREVIOUS_MONTH_CLASS = `${CALENDAR_DATE_CLASS}--previous-month`; +const CALENDAR_DATE_CURRENT_MONTH_CLASS = `${CALENDAR_DATE_CLASS}--current-month`; +const CALENDAR_DATE_NEXT_MONTH_CLASS = `${CALENDAR_DATE_CLASS}--next-month`; +const CALENDAR_DATE_RANGE_DATE_CLASS = `${CALENDAR_DATE_CLASS}--range-date`; +const CALENDAR_DATE_TODAY_CLASS = `${CALENDAR_DATE_CLASS}--today`; +const CALENDAR_DATE_RANGE_DATE_START_CLASS = `${CALENDAR_DATE_CLASS}--range-date-start`; +const CALENDAR_DATE_RANGE_DATE_END_CLASS = `${CALENDAR_DATE_CLASS}--range-date-end`; +const CALENDAR_DATE_WITHIN_RANGE_CLASS = `${CALENDAR_DATE_CLASS}--within-range`; +const CALENDAR_PREVIOUS_YEAR_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__previous-year`; +const CALENDAR_PREVIOUS_MONTH_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__previous-month`; +const CALENDAR_NEXT_YEAR_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__next-year`; +const CALENDAR_NEXT_MONTH_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__next-month`; +const CALENDAR_MONTH_SELECTION_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__month-selection`; +const CALENDAR_YEAR_SELECTION_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__year-selection`; +const CALENDAR_MONTH_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__month`; +const CALENDAR_MONTH_FOCUSED_CLASS = `${CALENDAR_MONTH_CLASS}--focused`; +const CALENDAR_MONTH_SELECTED_CLASS = `${CALENDAR_MONTH_CLASS}--selected`; +const CALENDAR_YEAR_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__year`; +const CALENDAR_YEAR_FOCUSED_CLASS = `${CALENDAR_YEAR_CLASS}--focused`; +const CALENDAR_YEAR_SELECTED_CLASS = `${CALENDAR_YEAR_CLASS}--selected`; +const CALENDAR_PREVIOUS_YEAR_CHUNK_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__previous-year-chunk`; +const CALENDAR_NEXT_YEAR_CHUNK_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__next-year-chunk`; +const CALENDAR_DATE_PICKER_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__date-picker`; +const CALENDAR_MONTH_PICKER_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__month-picker`; +const CALENDAR_YEAR_PICKER_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__year-picker`; +const CALENDAR_TABLE_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__table`; +const CALENDAR_ROW_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__row`; +const CALENDAR_CELL_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__cell`; +const CALENDAR_CELL_CENTER_ITEMS_CLASS = `${CALENDAR_CELL_CLASS}--center-items`; +const CALENDAR_MONTH_LABEL_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__month-label`; +const CALENDAR_DAY_OF_WEEK_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__day-of-week`; +const DATE_PICKER = `.${DATE_PICKER_CLASS}`; +const DATE_PICKER_BUTTON = `.${DATE_PICKER_BUTTON_CLASS}`; +const DATE_PICKER_INTERNAL_INPUT = `.${DATE_PICKER_INTERNAL_INPUT_CLASS}`; +const DATE_PICKER_EXTERNAL_INPUT = `.${DATE_PICKER_EXTERNAL_INPUT_CLASS}`; +const DATE_PICKER_CALENDAR = `.${DATE_PICKER_CALENDAR_CLASS}`; +const DATE_PICKER_STATUS = `.${DATE_PICKER_STATUS_CLASS}`; +const CALENDAR_DATE = `.${CALENDAR_DATE_CLASS}`; +const CALENDAR_DATE_FOCUSED = `.${CALENDAR_DATE_FOCUSED_CLASS}`; +const CALENDAR_DATE_CURRENT_MONTH = `.${CALENDAR_DATE_CURRENT_MONTH_CLASS}`; +const CALENDAR_PREVIOUS_YEAR = `.${CALENDAR_PREVIOUS_YEAR_CLASS}`; +const CALENDAR_PREVIOUS_MONTH = `.${CALENDAR_PREVIOUS_MONTH_CLASS}`; +const CALENDAR_NEXT_YEAR = `.${CALENDAR_NEXT_YEAR_CLASS}`; +const CALENDAR_NEXT_MONTH = `.${CALENDAR_NEXT_MONTH_CLASS}`; +const CALENDAR_YEAR_SELECTION = `.${CALENDAR_YEAR_SELECTION_CLASS}`; +const CALENDAR_MONTH_SELECTION = `.${CALENDAR_MONTH_SELECTION_CLASS}`; +const CALENDAR_MONTH = `.${CALENDAR_MONTH_CLASS}`; +const CALENDAR_YEAR = `.${CALENDAR_YEAR_CLASS}`; +const CALENDAR_PREVIOUS_YEAR_CHUNK = `.${CALENDAR_PREVIOUS_YEAR_CHUNK_CLASS}`; +const CALENDAR_NEXT_YEAR_CHUNK = `.${CALENDAR_NEXT_YEAR_CHUNK_CLASS}`; +const CALENDAR_DATE_PICKER = `.${CALENDAR_DATE_PICKER_CLASS}`; +const CALENDAR_MONTH_PICKER = `.${CALENDAR_MONTH_PICKER_CLASS}`; +const CALENDAR_YEAR_PICKER = `.${CALENDAR_YEAR_PICKER_CLASS}`; +const CALENDAR_MONTH_FOCUSED = `.${CALENDAR_MONTH_FOCUSED_CLASS}`; +const CALENDAR_YEAR_FOCUSED = `.${CALENDAR_YEAR_FOCUSED_CLASS}`; +const VALIDATION_MESSAGE = "Please enter a valid date"; +const MONTH_LABELS = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]; +const DAY_OF_WEEK_LABELS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]; +const ENTER_KEYCODE = 13; +const YEAR_CHUNK = 12; +const DEFAULT_MIN_DATE = "0000-01-01"; +const DEFAULT_EXTERNAL_DATE_FORMAT = "MM/DD/YYYY"; +const INTERNAL_DATE_FORMAT = "YYYY-MM-DD"; +const NOT_DISABLED_SELECTOR = ":not([disabled])"; +const processFocusableSelectors = (...selectors) => selectors.map(query => query + NOT_DISABLED_SELECTOR).join(", "); +const DATE_PICKER_FOCUSABLE = processFocusableSelectors(CALENDAR_PREVIOUS_YEAR, CALENDAR_PREVIOUS_MONTH, CALENDAR_YEAR_SELECTION, CALENDAR_MONTH_SELECTION, CALENDAR_NEXT_YEAR, CALENDAR_NEXT_MONTH, CALENDAR_DATE_FOCUSED); +const MONTH_PICKER_FOCUSABLE = processFocusableSelectors(CALENDAR_MONTH_FOCUSED); +const YEAR_PICKER_FOCUSABLE = processFocusableSelectors(CALENDAR_PREVIOUS_YEAR_CHUNK, CALENDAR_NEXT_YEAR_CHUNK, CALENDAR_YEAR_FOCUSED); + +// #region Date Manipulation Functions + +/** + * Keep date within month. Month would only be over by 1 to 3 days + * + * @param {Date} dateToCheck the date object to check + * @param {number} month the correct month + * @returns {Date} the date, corrected if needed + */ +const keepDateWithinMonth = (dateToCheck, month) => { + if (month !== dateToCheck.getMonth()) { + dateToCheck.setDate(0); + } + return dateToCheck; +}; + +/** + * Set date from month day year + * + * @param {number} year the year to set + * @param {number} month the month to set (zero-indexed) + * @param {number} date the date to set + * @returns {Date} the set date + */ +const setDate = (year, month, date) => { + const newDate = new Date(0); + newDate.setFullYear(year, month, date); + return newDate; +}; + +/** + * todays date + * + * @returns {Date} todays date + */ +const today = () => { + const newDate = new Date(); + const day = newDate.getDate(); + const month = newDate.getMonth(); + const year = newDate.getFullYear(); + return setDate(year, month, day); +}; + +/** + * Set date to first day of the month + * + * @param {number} date the date to adjust + * @returns {Date} the adjusted date + */ +const startOfMonth = date => { + const newDate = new Date(0); + newDate.setFullYear(date.getFullYear(), date.getMonth(), 1); + return newDate; +}; + +/** + * Set date to last day of the month + * + * @param {number} date the date to adjust + * @returns {Date} the adjusted date + */ +const lastDayOfMonth = date => { + const newDate = new Date(0); + newDate.setFullYear(date.getFullYear(), date.getMonth() + 1, 0); + return newDate; +}; + +/** + * Add days to date + * + * @param {Date} _date the date to adjust + * @param {number} numDays the difference in days + * @returns {Date} the adjusted date + */ +const addDays = (_date, numDays) => { + const newDate = new Date(_date.getTime()); + newDate.setDate(newDate.getDate() + numDays); + return newDate; +}; + +/** + * Subtract days from date + * + * @param {Date} _date the date to adjust + * @param {number} numDays the difference in days + * @returns {Date} the adjusted date + */ +const subDays = (_date, numDays) => addDays(_date, -numDays); + +/** + * Add weeks to date + * + * @param {Date} _date the date to adjust + * @param {number} numWeeks the difference in weeks + * @returns {Date} the adjusted date + */ +const addWeeks = (_date, numWeeks) => addDays(_date, numWeeks * 7); + +/** + * Subtract weeks from date + * + * @param {Date} _date the date to adjust + * @param {number} numWeeks the difference in weeks + * @returns {Date} the adjusted date + */ +const subWeeks = (_date, numWeeks) => addWeeks(_date, -numWeeks); + +/** + * Set date to the start of the week (Sunday) + * + * @param {Date} _date the date to adjust + * @returns {Date} the adjusted date + */ +const startOfWeek = _date => { + const dayOfWeek = _date.getDay(); + return subDays(_date, dayOfWeek); +}; + +/** + * Set date to the end of the week (Saturday) + * + * @param {Date} _date the date to adjust + * @param {number} numWeeks the difference in weeks + * @returns {Date} the adjusted date + */ +const endOfWeek = _date => { + const dayOfWeek = _date.getDay(); + return addDays(_date, 6 - dayOfWeek); +}; + +/** + * Add months to date and keep date within month + * + * @param {Date} _date the date to adjust + * @param {number} numMonths the difference in months + * @returns {Date} the adjusted date + */ +const addMonths = (_date, numMonths) => { + const newDate = new Date(_date.getTime()); + const dateMonth = (newDate.getMonth() + 12 + numMonths) % 12; + newDate.setMonth(newDate.getMonth() + numMonths); + keepDateWithinMonth(newDate, dateMonth); + return newDate; +}; + +/** + * Subtract months from date + * + * @param {Date} _date the date to adjust + * @param {number} numMonths the difference in months + * @returns {Date} the adjusted date + */ +const subMonths = (_date, numMonths) => addMonths(_date, -numMonths); + +/** + * Add years to date and keep date within month + * + * @param {Date} _date the date to adjust + * @param {number} numYears the difference in years + * @returns {Date} the adjusted date + */ +const addYears = (_date, numYears) => addMonths(_date, numYears * 12); + +/** + * Subtract years from date + * + * @param {Date} _date the date to adjust + * @param {number} numYears the difference in years + * @returns {Date} the adjusted date + */ +const subYears = (_date, numYears) => addYears(_date, -numYears); + +/** + * Set months of date + * + * @param {Date} _date the date to adjust + * @param {number} month zero-indexed month to set + * @returns {Date} the adjusted date + */ +const setMonth = (_date, month) => { + const newDate = new Date(_date.getTime()); + newDate.setMonth(month); + keepDateWithinMonth(newDate, month); + return newDate; +}; + +/** + * Set year of date + * + * @param {Date} _date the date to adjust + * @param {number} year the year to set + * @returns {Date} the adjusted date + */ +const setYear = (_date, year) => { + const newDate = new Date(_date.getTime()); + const month = newDate.getMonth(); + newDate.setFullYear(year); + keepDateWithinMonth(newDate, month); + return newDate; +}; + +/** + * Return the earliest date + * + * @param {Date} dateA date to compare + * @param {Date} dateB date to compare + * @returns {Date} the earliest date + */ +const min = (dateA, dateB) => { + let newDate = dateA; + if (dateB < dateA) { + newDate = dateB; + } + return new Date(newDate.getTime()); +}; + +/** + * Return the latest date + * + * @param {Date} dateA date to compare + * @param {Date} dateB date to compare + * @returns {Date} the latest date + */ +const max = (dateA, dateB) => { + let newDate = dateA; + if (dateB > dateA) { + newDate = dateB; + } + return new Date(newDate.getTime()); +}; + +/** + * Check if dates are the in the same year + * + * @param {Date} dateA date to compare + * @param {Date} dateB date to compare + * @returns {boolean} are dates in the same year + */ +const isSameYear = (dateA, dateB) => dateA && dateB && dateA.getFullYear() === dateB.getFullYear(); + +/** + * Check if dates are the in the same month + * + * @param {Date} dateA date to compare + * @param {Date} dateB date to compare + * @returns {boolean} are dates in the same month + */ +const isSameMonth = (dateA, dateB) => isSameYear(dateA, dateB) && dateA.getMonth() === dateB.getMonth(); + +/** + * Check if dates are the same date + * + * @param {Date} dateA the date to compare + * @param {Date} dateA the date to compare + * @returns {boolean} are dates the same date + */ +const isSameDay = (dateA, dateB) => isSameMonth(dateA, dateB) && dateA.getDate() === dateB.getDate(); + +/** + * return a new date within minimum and maximum date + * + * @param {Date} date date to check + * @param {Date} minDate minimum date to allow + * @param {Date} maxDate maximum date to allow + * @returns {Date} the date between min and max + */ +const keepDateBetweenMinAndMax = (date, minDate, maxDate) => { + let newDate = date; + if (date < minDate) { + newDate = minDate; + } else if (maxDate && date > maxDate) { + newDate = maxDate; + } + return new Date(newDate.getTime()); +}; + +/** + * Check if dates is valid. + * + * @param {Date} date date to check + * @param {Date} minDate minimum date to allow + * @param {Date} maxDate maximum date to allow + * @return {boolean} is there a day within the month within min and max dates + */ +const isDateWithinMinAndMax = (date, minDate, maxDate) => date >= minDate && (!maxDate || date <= maxDate); + +/** + * Check if dates month is invalid. + * + * @param {Date} date date to check + * @param {Date} minDate minimum date to allow + * @param {Date} maxDate maximum date to allow + * @return {boolean} is the month outside min or max dates + */ +const isDatesMonthOutsideMinOrMax = (date, minDate, maxDate) => lastDayOfMonth(date) < minDate || maxDate && startOfMonth(date) > maxDate; + +/** + * Check if dates year is invalid. + * + * @param {Date} date date to check + * @param {Date} minDate minimum date to allow + * @param {Date} maxDate maximum date to allow + * @return {boolean} is the month outside min or max dates + */ +const isDatesYearOutsideMinOrMax = (date, minDate, maxDate) => lastDayOfMonth(setMonth(date, 11)) < minDate || maxDate && startOfMonth(setMonth(date, 0)) > maxDate; + +/** + * @typedef {Object} DateRangeContext + * @property {Date} rangeStartDate + * @property {Date} rangeEndDate + * @property {Date} withinRangeStartDate + * @property {Date} withinRangeEndDate + */ + +/** + * Set the start, end, and within range values for date range variants. + + * @param {Date} date - Date that concludes the date range. + * @param {Date} rangeDate - Range date data attribute value of the date picker component. + * @returns {DateRangeContext} - Dates for range selection. + */ +const setRangeDates = (date, rangeDate) => { + const rangeConclusionDate = date; + const rangeStartDate = rangeDate && min(rangeConclusionDate, rangeDate); + const rangeEndDate = rangeDate && max(rangeConclusionDate, rangeDate); + const withinRangeStartDate = rangeDate && addDays(rangeStartDate, 1); + const withinRangeEndDate = rangeDate && subDays(rangeEndDate, 1); + return { + rangeStartDate, + rangeEndDate, + withinRangeStartDate, + withinRangeEndDate + }; +}; + +/** + * Parse a date with format M-D-YY + * + * @param {string} dateString the date string to parse + * @param {string} dateFormat the format of the date string + * @param {boolean} adjustDate should the date be adjusted + * @returns {Date} the parsed date + */ +const parseDateString = (dateString, dateFormat = INTERNAL_DATE_FORMAT, adjustDate = false) => { + let date; + let month; + let day; + let year; + let parsed; + if (dateString) { + let monthStr; + let dayStr; + let yearStr; + if (dateFormat === DEFAULT_EXTERNAL_DATE_FORMAT) { + [monthStr, dayStr, yearStr] = dateString.split("/"); + } else { + [yearStr, monthStr, dayStr] = dateString.split("-"); + } + if (yearStr) { + parsed = parseInt(yearStr, 10); + if (!Number.isNaN(parsed)) { + year = parsed; + if (adjustDate) { + year = Math.max(0, year); + if (yearStr.length < 3) { + const currentYear = today().getFullYear(); + const currentYearStub = currentYear - currentYear % 10 ** yearStr.length; + year = currentYearStub + parsed; + } + } + } + } + if (monthStr) { + parsed = parseInt(monthStr, 10); + if (!Number.isNaN(parsed)) { + month = parsed; + if (adjustDate) { + month = Math.max(1, month); + month = Math.min(12, month); + } + } + } + if (month && dayStr && year != null) { + parsed = parseInt(dayStr, 10); + if (!Number.isNaN(parsed)) { + day = parsed; + if (adjustDate) { + const lastDayOfTheMonth = setDate(year, month, 0).getDate(); + day = Math.max(1, day); + day = Math.min(lastDayOfTheMonth, day); + } + } + } + if (month && day && year != null) { + date = setDate(year, month - 1, day); + } + } + return date; +}; + +/** + * Format a date to format MM-DD-YYYY + * + * @param {Date} date the date to format + * @param {string} dateFormat the format of the date string + * @returns {string} the formatted date string + */ +const formatDate = (date, dateFormat = INTERNAL_DATE_FORMAT) => { + const padZeros = (value, length) => `0000${value}`.slice(-length); + const month = date.getMonth() + 1; + const day = date.getDate(); + const year = date.getFullYear(); + if (dateFormat === DEFAULT_EXTERNAL_DATE_FORMAT) { + return [padZeros(month, 2), padZeros(day, 2), padZeros(year, 4)].join("/"); + } + return [padZeros(year, 4), padZeros(month, 2), padZeros(day, 2)].join("-"); +}; + +// #endregion Date Manipulation Functions + +/** + * Create a grid string from an array of html strings + * + * @param {string[]} htmlArray the array of html items + * @param {number} rowSize the length of a row + * @returns {string} the grid string + */ +const listToGridHtml = (htmlArray, rowSize) => { + const grid = []; + let row = []; + let i = 0; + while (i < htmlArray.length) { + row = []; + const tr = document.createElement("tr"); + while (i < htmlArray.length && row.length < rowSize) { + const td = document.createElement("td"); + td.insertAdjacentElement("beforeend", htmlArray[i]); + row.push(td); + i += 1; + } + row.forEach(element => { + tr.insertAdjacentElement("beforeend", element); + }); + grid.push(tr); + } + return grid; +}; +const createTableBody = grid => { + const tableBody = document.createElement("tbody"); + grid.forEach(element => { + tableBody.insertAdjacentElement("beforeend", element); + }); + return tableBody; +}; + +/** + * set the value of the element and dispatch a change event + * + * @param {HTMLInputElement} el The element to update + * @param {string} value The new value of the element + */ +const changeElementValue = (el, value = "") => { + const elementToChange = el; + elementToChange.value = value; + const event = new CustomEvent("change", { + bubbles: true, + cancelable: true, + detail: { + value + } + }); + elementToChange.dispatchEvent(event); +}; + +/** + * The properties and elements within the date picker. + * @typedef {Object} DatePickerContext + * @property {HTMLDivElement} calendarEl + * @property {HTMLElement} datePickerEl + * @property {HTMLInputElement} internalInputEl + * @property {HTMLInputElement} externalInputEl + * @property {HTMLDivElement} statusEl + * @property {HTMLDivElement} firstYearChunkEl + * @property {Date} calendarDate + * @property {Date} minDate + * @property {Date} maxDate + * @property {Date} selectedDate + * @property {Date} rangeDate + * @property {Date} defaultDate + */ + +/** + * Get an object of the properties and elements belonging directly to the given + * date picker component. + * + * @param {HTMLElement} el the element within the date picker + * @returns {DatePickerContext} elements + */ +const getDatePickerContext = el => { + const datePickerEl = el.closest(DATE_PICKER); + if (!datePickerEl) { + throw new Error(`Element is missing outer ${DATE_PICKER}`); + } + const internalInputEl = datePickerEl.querySelector(DATE_PICKER_INTERNAL_INPUT); + const externalInputEl = datePickerEl.querySelector(DATE_PICKER_EXTERNAL_INPUT); + const calendarEl = datePickerEl.querySelector(DATE_PICKER_CALENDAR); + const toggleBtnEl = datePickerEl.querySelector(DATE_PICKER_BUTTON); + const statusEl = datePickerEl.querySelector(DATE_PICKER_STATUS); + const firstYearChunkEl = datePickerEl.querySelector(CALENDAR_YEAR); + const inputDate = parseDateString(externalInputEl.value, DEFAULT_EXTERNAL_DATE_FORMAT, true); + const selectedDate = parseDateString(internalInputEl.value); + const calendarDate = parseDateString(calendarEl.dataset.value); + const minDate = parseDateString(datePickerEl.dataset.minDate); + const maxDate = parseDateString(datePickerEl.dataset.maxDate); + const rangeDate = parseDateString(datePickerEl.dataset.rangeDate); + const defaultDate = parseDateString(datePickerEl.dataset.defaultDate); + if (minDate && maxDate && minDate > maxDate) { + throw new Error("Minimum date cannot be after maximum date"); + } + return { + calendarDate, + minDate, + toggleBtnEl, + selectedDate, + maxDate, + firstYearChunkEl, + datePickerEl, + inputDate, + internalInputEl, + externalInputEl, + calendarEl, + rangeDate, + defaultDate, + statusEl + }; +}; + +/** + * Disable the date picker component + * + * @param {HTMLElement} el An element within the date picker component + */ +const disable = el => { + const { + externalInputEl, + toggleBtnEl + } = getDatePickerContext(el); + toggleBtnEl.disabled = true; + externalInputEl.disabled = true; +}; + +/** + * Add the readonly attribute to input element and the aria-disabled attribute to the toggle calendar button and external input elements. + * + * @param {HTMLElement} el - The date picker element + */ +const ariaDisable = el => { + const { + externalInputEl, + toggleBtnEl + } = getDatePickerContext(el); + toggleBtnEl.setAttribute("aria-disabled", true); + externalInputEl.setAttribute("aria-disabled", true); + externalInputEl.setAttribute("readonly", ""); +}; + +/** + * Enable the date picker component + * + * @param {HTMLElement} el An element within the date picker component + */ +const enable = el => { + const { + externalInputEl, + toggleBtnEl + } = getDatePickerContext(el); + toggleBtnEl.disabled = false; + toggleBtnEl.removeAttribute("aria-disabled"); + externalInputEl.disabled = false; + externalInputEl.removeAttribute("aria-disabled"); + externalInputEl.removeAttribute("readonly"); +}; + +// #region Validation + +/** + * Validate the value in the input as a valid date of format M/D/YYYY + * + * @param {HTMLElement} el An element within the date picker component + */ +const isDateInputInvalid = el => { + const { + externalInputEl, + minDate, + maxDate + } = getDatePickerContext(el); + const dateString = externalInputEl.value; + let isInvalid = false; + if (dateString) { + isInvalid = true; + const dateStringParts = dateString.split("/"); + const [month, day, year] = dateStringParts.map(str => { + let value; + const parsed = parseInt(str, 10); + if (!Number.isNaN(parsed)) value = parsed; + return value; + }); + if (month && day && year != null) { + const checkDate = setDate(year, month - 1, day); + if (checkDate.getMonth() === month - 1 && checkDate.getDate() === day && checkDate.getFullYear() === year && dateStringParts[2].length === 4 && isDateWithinMinAndMax(checkDate, minDate, maxDate)) { + isInvalid = false; + } + } + } + return isInvalid; +}; + +/** + * Validate the value in the input as a valid date of format M/D/YYYY + * + * @param {HTMLElement} el An element within the date picker component + */ +const validateDateInput = el => { + const { + externalInputEl + } = getDatePickerContext(el); + const isInvalid = isDateInputInvalid(externalInputEl); + if (isInvalid && !externalInputEl.validationMessage) { + externalInputEl.setCustomValidity(VALIDATION_MESSAGE); + } + if (!isInvalid && externalInputEl.validationMessage === VALIDATION_MESSAGE) { + externalInputEl.setCustomValidity(""); + } +}; + +// #endregion Validation + +/** + * Enable the date picker component + * + * @param {HTMLElement} el An element within the date picker component + */ +const reconcileInputValues = el => { + const { + internalInputEl, + inputDate + } = getDatePickerContext(el); + let newValue = ""; + if (inputDate && !isDateInputInvalid(el)) { + newValue = formatDate(inputDate); + } + if (internalInputEl.value !== newValue) { + changeElementValue(internalInputEl, newValue); + } +}; + +/** + * Select the value of the date picker inputs. + * + * @param {HTMLButtonElement} el An element within the date picker component + * @param {string} dateString The date string to update in YYYY-MM-DD format + */ +const setCalendarValue = (el, dateString) => { + const parsedDate = parseDateString(dateString); + if (parsedDate) { + const formattedDate = formatDate(parsedDate, DEFAULT_EXTERNAL_DATE_FORMAT); + const { + datePickerEl, + internalInputEl, + externalInputEl + } = getDatePickerContext(el); + changeElementValue(internalInputEl, dateString); + changeElementValue(externalInputEl, formattedDate); + validateDateInput(datePickerEl); + } +}; + +/** + * Enhance an input with the date picker elements + * + * @param {HTMLElement} el The initial wrapping element of the date picker component + */ +const enhanceDatePicker = el => { + const datePickerEl = el.closest(DATE_PICKER); + const { + defaultValue + } = datePickerEl.dataset; + const internalInputEl = datePickerEl.querySelector(`input`); + if (!internalInputEl) { + throw new Error(`${DATE_PICKER} is missing inner input`); + } + if (internalInputEl.value) { + internalInputEl.value = ""; + } + const minDate = parseDateString(datePickerEl.dataset.minDate || internalInputEl.getAttribute("min")); + datePickerEl.dataset.minDate = minDate ? formatDate(minDate) : DEFAULT_MIN_DATE; + const maxDate = parseDateString(datePickerEl.dataset.maxDate || internalInputEl.getAttribute("max")); + if (maxDate) { + datePickerEl.dataset.maxDate = formatDate(maxDate); + } + const calendarWrapper = document.createElement("div"); + calendarWrapper.classList.add(DATE_PICKER_WRAPPER_CLASS); + const externalInputEl = internalInputEl.cloneNode(); + externalInputEl.classList.add(DATE_PICKER_EXTERNAL_INPUT_CLASS); + externalInputEl.type = "text"; + calendarWrapper.appendChild(externalInputEl); + calendarWrapper.insertAdjacentHTML("beforeend", Sanitizer.escapeHTML` + <button type="button" class="${DATE_PICKER_BUTTON_CLASS}" aria-haspopup="true" aria-label="Toggle calendar"></button> + <div class="${DATE_PICKER_CALENDAR_CLASS}" role="application" hidden></div> + <div class="usa-sr-only ${DATE_PICKER_STATUS_CLASS}" role="status" aria-live="polite"></div>`); + internalInputEl.setAttribute("aria-hidden", "true"); + internalInputEl.setAttribute("tabindex", "-1"); + internalInputEl.style.display = "none"; + internalInputEl.classList.add(DATE_PICKER_INTERNAL_INPUT_CLASS); + internalInputEl.removeAttribute("id"); + internalInputEl.removeAttribute("name"); + internalInputEl.required = false; + datePickerEl.appendChild(calendarWrapper); + datePickerEl.classList.add(DATE_PICKER_INITIALIZED_CLASS); + if (defaultValue) { + setCalendarValue(datePickerEl, defaultValue); + } + if (internalInputEl.disabled) { + disable(datePickerEl); + internalInputEl.disabled = false; + } + if (internalInputEl.hasAttribute("aria-disabled")) { + ariaDisable(datePickerEl); + internalInputEl.removeAttribute("aria-disabled"); + } +}; + +// #region Calendar - Date Selection View + +/** + * render the calendar. + * + * @param {HTMLElement} el An element within the date picker component + * @param {Date} _dateToDisplay a date to render on the calendar + * @returns {HTMLElement} a reference to the new calendar element + */ +const renderCalendar = (el, _dateToDisplay) => { + const { + datePickerEl, + calendarEl, + statusEl, + selectedDate, + maxDate, + minDate, + rangeDate + } = getDatePickerContext(el); + const todaysDate = today(); + let dateToDisplay = _dateToDisplay || todaysDate; + const calendarWasHidden = calendarEl.hidden; + const focusedDate = addDays(dateToDisplay, 0); + const focusedMonth = dateToDisplay.getMonth(); + const focusedYear = dateToDisplay.getFullYear(); + const prevMonth = subMonths(dateToDisplay, 1); + const nextMonth = addMonths(dateToDisplay, 1); + const currentFormattedDate = formatDate(dateToDisplay); + const firstOfMonth = startOfMonth(dateToDisplay); + const prevButtonsDisabled = isSameMonth(dateToDisplay, minDate); + const nextButtonsDisabled = isSameMonth(dateToDisplay, maxDate); + const { + rangeStartDate, + rangeEndDate, + withinRangeStartDate, + withinRangeEndDate + } = setRangeDates(selectedDate || dateToDisplay, rangeDate); + const monthLabel = MONTH_LABELS[focusedMonth]; + const generateDateHtml = dateToRender => { + const classes = [CALENDAR_DATE_CLASS]; + const day = dateToRender.getDate(); + const month = dateToRender.getMonth(); + const year = dateToRender.getFullYear(); + const dayOfWeek = dateToRender.getDay(); + const formattedDate = formatDate(dateToRender); + let tabindex = "-1"; + const isDisabled = !isDateWithinMinAndMax(dateToRender, minDate, maxDate); + const isSelected = isSameDay(dateToRender, selectedDate); + if (isSameMonth(dateToRender, prevMonth)) { + classes.push(CALENDAR_DATE_PREVIOUS_MONTH_CLASS); + } + if (isSameMonth(dateToRender, focusedDate)) { + classes.push(CALENDAR_DATE_CURRENT_MONTH_CLASS); + } + if (isSameMonth(dateToRender, nextMonth)) { + classes.push(CALENDAR_DATE_NEXT_MONTH_CLASS); + } + if (isSelected) { + classes.push(CALENDAR_DATE_SELECTED_CLASS); + } + if (isSameDay(dateToRender, todaysDate)) { + classes.push(CALENDAR_DATE_TODAY_CLASS); + } + if (rangeDate) { + if (isSameDay(dateToRender, rangeDate)) { + classes.push(CALENDAR_DATE_RANGE_DATE_CLASS); + } + if (isSameDay(dateToRender, rangeStartDate)) { + classes.push(CALENDAR_DATE_RANGE_DATE_START_CLASS); + } + if (isSameDay(dateToRender, rangeEndDate)) { + classes.push(CALENDAR_DATE_RANGE_DATE_END_CLASS); + } + if (isDateWithinMinAndMax(dateToRender, withinRangeStartDate, withinRangeEndDate)) { + classes.push(CALENDAR_DATE_WITHIN_RANGE_CLASS); + } + } + if (isSameDay(dateToRender, focusedDate)) { + tabindex = "0"; + classes.push(CALENDAR_DATE_FOCUSED_CLASS); + } + const monthStr = MONTH_LABELS[month]; + const dayStr = DAY_OF_WEEK_LABELS[dayOfWeek]; + const btn = document.createElement("button"); + btn.setAttribute("type", "button"); + btn.setAttribute("tabindex", tabindex); + btn.setAttribute("class", classes.join(" ")); + btn.setAttribute("data-day", day); + btn.setAttribute("data-month", month + 1); + btn.setAttribute("data-year", year); + btn.setAttribute("data-value", formattedDate); + btn.setAttribute("aria-label", Sanitizer.escapeHTML`${day} ${monthStr} ${year} ${dayStr}`); + btn.setAttribute("aria-selected", isSelected ? "true" : "false"); + if (isDisabled === true) { + btn.disabled = true; + } + btn.textContent = day; + return btn; + }; + + // set date to first rendered day + dateToDisplay = startOfWeek(firstOfMonth); + const days = []; + while (days.length < 28 || dateToDisplay.getMonth() === focusedMonth || days.length % 7 !== 0) { + days.push(generateDateHtml(dateToDisplay)); + dateToDisplay = addDays(dateToDisplay, 1); + } + const datesGrid = listToGridHtml(days, 7); + const newCalendar = calendarEl.cloneNode(); + newCalendar.dataset.value = currentFormattedDate; + newCalendar.style.top = `${datePickerEl.offsetHeight}px`; + newCalendar.hidden = false; + newCalendar.innerHTML = Sanitizer.escapeHTML` + <div tabindex="-1" class="${CALENDAR_DATE_PICKER_CLASS}"> + <div class="${CALENDAR_ROW_CLASS}"> + <div class="${CALENDAR_CELL_CLASS} ${CALENDAR_CELL_CENTER_ITEMS_CLASS}"> + <button + type="button" + class="${CALENDAR_PREVIOUS_YEAR_CLASS}" + aria-label="Navigate back one year" + ${prevButtonsDisabled ? `disabled="disabled"` : ""} + ></button> + </div> + <div class="${CALENDAR_CELL_CLASS} ${CALENDAR_CELL_CENTER_ITEMS_CLASS}"> + <button + type="button" + class="${CALENDAR_PREVIOUS_MONTH_CLASS}" + aria-label="Navigate back one month" + ${prevButtonsDisabled ? `disabled="disabled"` : ""} + ></button> + </div> + <div class="${CALENDAR_CELL_CLASS} ${CALENDAR_MONTH_LABEL_CLASS}"> + <button + type="button" + class="${CALENDAR_MONTH_SELECTION_CLASS}" aria-label="${monthLabel}. Select month" + >${monthLabel}</button> + <button + type="button" + class="${CALENDAR_YEAR_SELECTION_CLASS}" aria-label="${focusedYear}. Select year" + >${focusedYear}</button> + </div> + <div class="${CALENDAR_CELL_CLASS} ${CALENDAR_CELL_CENTER_ITEMS_CLASS}"> + <button + type="button" + class="${CALENDAR_NEXT_MONTH_CLASS}" + aria-label="Navigate forward one month" + ${nextButtonsDisabled ? `disabled="disabled"` : ""} + ></button> + </div> + <div class="${CALENDAR_CELL_CLASS} ${CALENDAR_CELL_CENTER_ITEMS_CLASS}"> + <button + type="button" + class="${CALENDAR_NEXT_YEAR_CLASS}" + aria-label="Navigate forward one year" + ${nextButtonsDisabled ? `disabled="disabled"` : ""} + ></button> + </div> + </div> + </div> + `; + const table = document.createElement("table"); + table.setAttribute("class", CALENDAR_TABLE_CLASS); + const tableHead = document.createElement("thead"); + table.insertAdjacentElement("beforeend", tableHead); + const tableHeadRow = document.createElement("tr"); + tableHead.insertAdjacentElement("beforeend", tableHeadRow); + const daysOfWeek = { + Sunday: "S", + Monday: "M", + Tuesday: "T", + Wednesday: "W", + Thursday: "Th", + Friday: "Fr", + Saturday: "S" + }; + Object.keys(daysOfWeek).forEach(key => { + const th = document.createElement("th"); + th.setAttribute("class", CALENDAR_DAY_OF_WEEK_CLASS); + th.setAttribute("scope", "col"); + th.setAttribute("aria-label", key); + th.textContent = daysOfWeek[key]; + tableHeadRow.insertAdjacentElement("beforeend", th); + }); + const tableBody = createTableBody(datesGrid); + table.insertAdjacentElement("beforeend", tableBody); + + // Container for Years, Months, and Days + const datePickerCalendarContainer = newCalendar.querySelector(CALENDAR_DATE_PICKER); + datePickerCalendarContainer.insertAdjacentElement("beforeend", table); + calendarEl.parentNode.replaceChild(newCalendar, calendarEl); + datePickerEl.classList.add(DATE_PICKER_ACTIVE_CLASS); + const statuses = []; + if (isSameDay(selectedDate, focusedDate)) { + statuses.push("Selected date"); + } + if (calendarWasHidden) { + statuses.push("You can navigate by day using left and right arrows", "Weeks by using up and down arrows", "Months by using page up and page down keys", "Years by using shift plus page up and shift plus page down", "Home and end keys navigate to the beginning and end of a week"); + statusEl.textContent = ""; + } else { + statuses.push(`${monthLabel} ${focusedYear}`); + } + statusEl.textContent = statuses.join(". "); + return newCalendar; +}; + +/** + * Navigate back one year and display the calendar. + * + * @param {HTMLButtonElement} _buttonEl An element within the date picker component + */ +const displayPreviousYear = _buttonEl => { + if (_buttonEl.disabled) return; + const { + calendarEl, + calendarDate, + minDate, + maxDate + } = getDatePickerContext(_buttonEl); + let date = subYears(calendarDate, 1); + date = keepDateBetweenMinAndMax(date, minDate, maxDate); + const newCalendar = renderCalendar(calendarEl, date); + let nextToFocus = newCalendar.querySelector(CALENDAR_PREVIOUS_YEAR); + if (nextToFocus.disabled) { + nextToFocus = newCalendar.querySelector(CALENDAR_DATE_PICKER); + } + nextToFocus.focus(); +}; + +/** + * Navigate back one month and display the calendar. + * + * @param {HTMLButtonElement} _buttonEl An element within the date picker component + */ +const displayPreviousMonth = _buttonEl => { + if (_buttonEl.disabled) return; + const { + calendarEl, + calendarDate, + minDate, + maxDate + } = getDatePickerContext(_buttonEl); + let date = subMonths(calendarDate, 1); + date = keepDateBetweenMinAndMax(date, minDate, maxDate); + const newCalendar = renderCalendar(calendarEl, date); + let nextToFocus = newCalendar.querySelector(CALENDAR_PREVIOUS_MONTH); + if (nextToFocus.disabled) { + nextToFocus = newCalendar.querySelector(CALENDAR_DATE_PICKER); + } + nextToFocus.focus(); +}; + +/** + * Navigate forward one month and display the calendar. + * + * @param {HTMLButtonElement} _buttonEl An element within the date picker component + */ +const displayNextMonth = _buttonEl => { + if (_buttonEl.disabled) return; + const { + calendarEl, + calendarDate, + minDate, + maxDate + } = getDatePickerContext(_buttonEl); + let date = addMonths(calendarDate, 1); + date = keepDateBetweenMinAndMax(date, minDate, maxDate); + const newCalendar = renderCalendar(calendarEl, date); + let nextToFocus = newCalendar.querySelector(CALENDAR_NEXT_MONTH); + if (nextToFocus.disabled) { + nextToFocus = newCalendar.querySelector(CALENDAR_DATE_PICKER); + } + nextToFocus.focus(); +}; + +/** + * Navigate forward one year and display the calendar. + * + * @param {HTMLButtonElement} _buttonEl An element within the date picker component + */ +const displayNextYear = _buttonEl => { + if (_buttonEl.disabled) return; + const { + calendarEl, + calendarDate, + minDate, + maxDate + } = getDatePickerContext(_buttonEl); + let date = addYears(calendarDate, 1); + date = keepDateBetweenMinAndMax(date, minDate, maxDate); + const newCalendar = renderCalendar(calendarEl, date); + let nextToFocus = newCalendar.querySelector(CALENDAR_NEXT_YEAR); + if (nextToFocus.disabled) { + nextToFocus = newCalendar.querySelector(CALENDAR_DATE_PICKER); + } + nextToFocus.focus(); +}; + +/** + * Hide the calendar of a date picker component. + * + * @param {HTMLElement} el An element within the date picker component + */ +const hideCalendar = el => { + const { + datePickerEl, + calendarEl, + statusEl + } = getDatePickerContext(el); + datePickerEl.classList.remove(DATE_PICKER_ACTIVE_CLASS); + calendarEl.hidden = true; + statusEl.textContent = ""; +}; + +/** + * Select a date within the date picker component. + * + * @param {HTMLButtonElement} calendarDateEl A date element within the date picker component + */ +const selectDate = calendarDateEl => { + if (calendarDateEl.disabled) return; + const { + datePickerEl, + externalInputEl + } = getDatePickerContext(calendarDateEl); + setCalendarValue(calendarDateEl, calendarDateEl.dataset.value); + hideCalendar(datePickerEl); + externalInputEl.focus(); +}; + +/** + * Toggle the calendar. + * + * @param {HTMLButtonElement} el An element within the date picker component + */ +const toggleCalendar = el => { + if (el.disabled || el.hasAttribute("aria-disabled")) return; + const { + calendarEl, + inputDate, + minDate, + maxDate, + defaultDate + } = getDatePickerContext(el); + if (calendarEl.hidden) { + const dateToDisplay = keepDateBetweenMinAndMax(inputDate || defaultDate || today(), minDate, maxDate); + const newCalendar = renderCalendar(calendarEl, dateToDisplay); + newCalendar.querySelector(CALENDAR_DATE_FOCUSED).focus(); + } else { + hideCalendar(el); + } +}; + +/** + * Update the calendar when visible. + * + * @param {HTMLElement} el an element within the date picker + */ +const updateCalendarIfVisible = el => { + const { + calendarEl, + inputDate, + minDate, + maxDate + } = getDatePickerContext(el); + const calendarShown = !calendarEl.hidden; + if (calendarShown && inputDate) { + const dateToDisplay = keepDateBetweenMinAndMax(inputDate, minDate, maxDate); + renderCalendar(calendarEl, dateToDisplay); + } +}; + +// #endregion Calendar - Date Selection View + +// #region Calendar - Month Selection View +/** + * Display the month selection screen in the date picker. + * + * @param {HTMLButtonElement} el An element within the date picker component + * @returns {HTMLElement} a reference to the new calendar element + */ +const displayMonthSelection = (el, monthToDisplay) => { + const { + calendarEl, + statusEl, + calendarDate, + minDate, + maxDate + } = getDatePickerContext(el); + const selectedMonth = calendarDate.getMonth(); + const focusedMonth = monthToDisplay == null ? selectedMonth : monthToDisplay; + const months = MONTH_LABELS.map((month, index) => { + const monthToCheck = setMonth(calendarDate, index); + const isDisabled = isDatesMonthOutsideMinOrMax(monthToCheck, minDate, maxDate); + let tabindex = "-1"; + const classes = [CALENDAR_MONTH_CLASS]; + const isSelected = index === selectedMonth; + if (index === focusedMonth) { + tabindex = "0"; + classes.push(CALENDAR_MONTH_FOCUSED_CLASS); + } + if (isSelected) { + classes.push(CALENDAR_MONTH_SELECTED_CLASS); + } + const btn = document.createElement("button"); + btn.setAttribute("type", "button"); + btn.setAttribute("tabindex", tabindex); + btn.setAttribute("class", classes.join(" ")); + btn.setAttribute("data-value", index); + btn.setAttribute("data-label", month); + btn.setAttribute("aria-selected", isSelected ? "true" : "false"); + if (isDisabled === true) { + btn.disabled = true; + } + btn.textContent = month; + return btn; + }); + const monthsHtml = document.createElement("div"); + monthsHtml.setAttribute("tabindex", "-1"); + monthsHtml.setAttribute("class", CALENDAR_MONTH_PICKER_CLASS); + const table = document.createElement("table"); + table.setAttribute("class", CALENDAR_TABLE_CLASS); + table.setAttribute("role", "presentation"); + const monthsGrid = listToGridHtml(months, 3); + const tableBody = createTableBody(monthsGrid); + table.insertAdjacentElement("beforeend", tableBody); + monthsHtml.insertAdjacentElement("beforeend", table); + const newCalendar = calendarEl.cloneNode(); + newCalendar.insertAdjacentElement("beforeend", monthsHtml); + calendarEl.parentNode.replaceChild(newCalendar, calendarEl); + statusEl.textContent = "Select a month."; + return newCalendar; +}; + +/** + * Select a month in the date picker component. + * + * @param {HTMLButtonElement} monthEl An month element within the date picker component + */ +const selectMonth = monthEl => { + if (monthEl.disabled) return; + const { + calendarEl, + calendarDate, + minDate, + maxDate + } = getDatePickerContext(monthEl); + const selectedMonth = parseInt(monthEl.dataset.value, 10); + let date = setMonth(calendarDate, selectedMonth); + date = keepDateBetweenMinAndMax(date, minDate, maxDate); + const newCalendar = renderCalendar(calendarEl, date); + newCalendar.querySelector(CALENDAR_DATE_FOCUSED).focus(); +}; + +// #endregion Calendar - Month Selection View + +// #region Calendar - Year Selection View + +/** + * Display the year selection screen in the date picker. + * + * @param {HTMLButtonElement} el An element within the date picker component + * @param {number} yearToDisplay year to display in year selection + * @returns {HTMLElement} a reference to the new calendar element + */ +const displayYearSelection = (el, yearToDisplay) => { + const { + calendarEl, + statusEl, + calendarDate, + minDate, + maxDate + } = getDatePickerContext(el); + const selectedYear = calendarDate.getFullYear(); + const focusedYear = yearToDisplay == null ? selectedYear : yearToDisplay; + let yearToChunk = focusedYear; + yearToChunk -= yearToChunk % YEAR_CHUNK; + yearToChunk = Math.max(0, yearToChunk); + const prevYearChunkDisabled = isDatesYearOutsideMinOrMax(setYear(calendarDate, yearToChunk - 1), minDate, maxDate); + const nextYearChunkDisabled = isDatesYearOutsideMinOrMax(setYear(calendarDate, yearToChunk + YEAR_CHUNK), minDate, maxDate); + const years = []; + let yearIndex = yearToChunk; + while (years.length < YEAR_CHUNK) { + const isDisabled = isDatesYearOutsideMinOrMax(setYear(calendarDate, yearIndex), minDate, maxDate); + let tabindex = "-1"; + const classes = [CALENDAR_YEAR_CLASS]; + const isSelected = yearIndex === selectedYear; + if (yearIndex === focusedYear) { + tabindex = "0"; + classes.push(CALENDAR_YEAR_FOCUSED_CLASS); + } + if (isSelected) { + classes.push(CALENDAR_YEAR_SELECTED_CLASS); + } + const btn = document.createElement("button"); + btn.setAttribute("type", "button"); + btn.setAttribute("tabindex", tabindex); + btn.setAttribute("class", classes.join(" ")); + btn.setAttribute("data-value", yearIndex); + btn.setAttribute("aria-selected", isSelected ? "true" : "false"); + if (isDisabled === true) { + btn.disabled = true; + } + btn.textContent = yearIndex; + years.push(btn); + yearIndex += 1; + } + const newCalendar = calendarEl.cloneNode(); + + // create the years calendar wrapper + const yearsCalendarWrapper = document.createElement("div"); + yearsCalendarWrapper.setAttribute("tabindex", "-1"); + yearsCalendarWrapper.setAttribute("class", CALENDAR_YEAR_PICKER_CLASS); + + // create table parent + const yearsTableParent = document.createElement("table"); + yearsTableParent.setAttribute("class", CALENDAR_TABLE_CLASS); + + // create table body and table row + const yearsHTMLTableBody = document.createElement("tbody"); + const yearsHTMLTableBodyRow = document.createElement("tr"); + + // create previous button + const previousYearsBtn = document.createElement("button"); + previousYearsBtn.setAttribute("type", "button"); + previousYearsBtn.setAttribute("class", CALENDAR_PREVIOUS_YEAR_CHUNK_CLASS); + previousYearsBtn.setAttribute("aria-label", `Navigate back ${YEAR_CHUNK} years`); + if (prevYearChunkDisabled === true) { + previousYearsBtn.disabled = true; + } + previousYearsBtn.innerHTML = Sanitizer.escapeHTML` `; + + // create next button + const nextYearsBtn = document.createElement("button"); + nextYearsBtn.setAttribute("type", "button"); + nextYearsBtn.setAttribute("class", CALENDAR_NEXT_YEAR_CHUNK_CLASS); + nextYearsBtn.setAttribute("aria-label", `Navigate forward ${YEAR_CHUNK} years`); + if (nextYearChunkDisabled === true) { + nextYearsBtn.disabled = true; + } + nextYearsBtn.innerHTML = Sanitizer.escapeHTML` `; + + // create the actual years table + const yearsTable = document.createElement("table"); + yearsTable.setAttribute("class", CALENDAR_TABLE_CLASS); + yearsTable.setAttribute("role", "presentation"); + + // create the years child table + const yearsGrid = listToGridHtml(years, 3); + const yearsTableBody = createTableBody(yearsGrid); + + // append the grid to the years child table + yearsTable.insertAdjacentElement("beforeend", yearsTableBody); + + // create the prev button td and append the prev button + const yearsHTMLTableBodyDetailPrev = document.createElement("td"); + yearsHTMLTableBodyDetailPrev.insertAdjacentElement("beforeend", previousYearsBtn); + + // create the years td and append the years child table + const yearsHTMLTableBodyYearsDetail = document.createElement("td"); + yearsHTMLTableBodyYearsDetail.setAttribute("colspan", "3"); + yearsHTMLTableBodyYearsDetail.insertAdjacentElement("beforeend", yearsTable); + + // create the next button td and append the next button + const yearsHTMLTableBodyDetailNext = document.createElement("td"); + yearsHTMLTableBodyDetailNext.insertAdjacentElement("beforeend", nextYearsBtn); + + // append the three td to the years child table row + yearsHTMLTableBodyRow.insertAdjacentElement("beforeend", yearsHTMLTableBodyDetailPrev); + yearsHTMLTableBodyRow.insertAdjacentElement("beforeend", yearsHTMLTableBodyYearsDetail); + yearsHTMLTableBodyRow.insertAdjacentElement("beforeend", yearsHTMLTableBodyDetailNext); + + // append the table row to the years child table body + yearsHTMLTableBody.insertAdjacentElement("beforeend", yearsHTMLTableBodyRow); + + // append the years table body to the years parent table + yearsTableParent.insertAdjacentElement("beforeend", yearsHTMLTableBody); + + // append the parent table to the calendar wrapper + yearsCalendarWrapper.insertAdjacentElement("beforeend", yearsTableParent); + + // append the years calender to the new calendar + newCalendar.insertAdjacentElement("beforeend", yearsCalendarWrapper); + + // replace calendar + calendarEl.parentNode.replaceChild(newCalendar, calendarEl); + statusEl.textContent = Sanitizer.escapeHTML`Showing years ${yearToChunk} to ${yearToChunk + YEAR_CHUNK - 1}. Select a year.`; + return newCalendar; +}; + +/** + * Navigate back by years and display the year selection screen. + * + * @param {HTMLButtonElement} el An element within the date picker component + */ +const displayPreviousYearChunk = el => { + if (el.disabled) return; + const { + calendarEl, + calendarDate, + minDate, + maxDate + } = getDatePickerContext(el); + const yearEl = calendarEl.querySelector(CALENDAR_YEAR_FOCUSED); + const selectedYear = parseInt(yearEl.textContent, 10); + let adjustedYear = selectedYear - YEAR_CHUNK; + adjustedYear = Math.max(0, adjustedYear); + const date = setYear(calendarDate, adjustedYear); + const cappedDate = keepDateBetweenMinAndMax(date, minDate, maxDate); + const newCalendar = displayYearSelection(calendarEl, cappedDate.getFullYear()); + let nextToFocus = newCalendar.querySelector(CALENDAR_PREVIOUS_YEAR_CHUNK); + if (nextToFocus.disabled) { + nextToFocus = newCalendar.querySelector(CALENDAR_YEAR_PICKER); + } + nextToFocus.focus(); +}; + +/** + * Navigate forward by years and display the year selection screen. + * + * @param {HTMLButtonElement} el An element within the date picker component + */ +const displayNextYearChunk = el => { + if (el.disabled) return; + const { + calendarEl, + calendarDate, + minDate, + maxDate + } = getDatePickerContext(el); + const yearEl = calendarEl.querySelector(CALENDAR_YEAR_FOCUSED); + const selectedYear = parseInt(yearEl.textContent, 10); + let adjustedYear = selectedYear + YEAR_CHUNK; + adjustedYear = Math.max(0, adjustedYear); + const date = setYear(calendarDate, adjustedYear); + const cappedDate = keepDateBetweenMinAndMax(date, minDate, maxDate); + const newCalendar = displayYearSelection(calendarEl, cappedDate.getFullYear()); + let nextToFocus = newCalendar.querySelector(CALENDAR_NEXT_YEAR_CHUNK); + if (nextToFocus.disabled) { + nextToFocus = newCalendar.querySelector(CALENDAR_YEAR_PICKER); + } + nextToFocus.focus(); +}; + +/** + * Select a year in the date picker component. + * + * @param {HTMLButtonElement} yearEl A year element within the date picker component + */ +const selectYear = yearEl => { + if (yearEl.disabled) return; + const { + calendarEl, + calendarDate, + minDate, + maxDate + } = getDatePickerContext(yearEl); + const selectedYear = parseInt(yearEl.innerHTML, 10); + let date = setYear(calendarDate, selectedYear); + date = keepDateBetweenMinAndMax(date, minDate, maxDate); + const newCalendar = renderCalendar(calendarEl, date); + newCalendar.querySelector(CALENDAR_DATE_FOCUSED).focus(); +}; + +// #endregion Calendar - Year Selection View + +// #region Calendar Event Handling + +/** + * Hide the calendar. + * + * @param {KeyboardEvent} event the keydown event + */ +const handleEscapeFromCalendar = event => { + const { + datePickerEl, + externalInputEl + } = getDatePickerContext(event.target); + hideCalendar(datePickerEl); + externalInputEl.focus(); + event.preventDefault(); +}; + +// #endregion Calendar Event Handling + +// #region Calendar Date Event Handling + +/** + * Adjust the date and display the calendar if needed. + * + * @param {function} adjustDateFn function that returns the adjusted date + */ +const adjustCalendar = adjustDateFn => event => { + const { + calendarEl, + calendarDate, + minDate, + maxDate + } = getDatePickerContext(event.target); + const date = adjustDateFn(calendarDate); + const cappedDate = keepDateBetweenMinAndMax(date, minDate, maxDate); + if (!isSameDay(calendarDate, cappedDate)) { + const newCalendar = renderCalendar(calendarEl, cappedDate); + newCalendar.querySelector(CALENDAR_DATE_FOCUSED).focus(); + } + event.preventDefault(); +}; + +/** + * Navigate back one week and display the calendar. + * + * @param {KeyboardEvent} event the keydown event + */ +const handleUpFromDate = adjustCalendar(date => subWeeks(date, 1)); + +/** + * Navigate forward one week and display the calendar. + * + * @param {KeyboardEvent} event the keydown event + */ +const handleDownFromDate = adjustCalendar(date => addWeeks(date, 1)); + +/** + * Navigate back one day and display the calendar. + * + * @param {KeyboardEvent} event the keydown event + */ +const handleLeftFromDate = adjustCalendar(date => subDays(date, 1)); + +/** + * Navigate forward one day and display the calendar. + * + * @param {KeyboardEvent} event the keydown event + */ +const handleRightFromDate = adjustCalendar(date => addDays(date, 1)); + +/** + * Navigate to the start of the week and display the calendar. + * + * @param {KeyboardEvent} event the keydown event + */ +const handleHomeFromDate = adjustCalendar(date => startOfWeek(date)); + +/** + * Navigate to the end of the week and display the calendar. + * + * @param {KeyboardEvent} event the keydown event + */ +const handleEndFromDate = adjustCalendar(date => endOfWeek(date)); + +/** + * Navigate forward one month and display the calendar. + * + * @param {KeyboardEvent} event the keydown event + */ +const handlePageDownFromDate = adjustCalendar(date => addMonths(date, 1)); + +/** + * Navigate back one month and display the calendar. + * + * @param {KeyboardEvent} event the keydown event + */ +const handlePageUpFromDate = adjustCalendar(date => subMonths(date, 1)); + +/** + * Navigate forward one year and display the calendar. + * + * @param {KeyboardEvent} event the keydown event + */ +const handleShiftPageDownFromDate = adjustCalendar(date => addYears(date, 1)); + +/** + * Navigate back one year and display the calendar. + * + * @param {KeyboardEvent} event the keydown event + */ +const handleShiftPageUpFromDate = adjustCalendar(date => subYears(date, 1)); + +/** + * Set range date classes without re-rendering the calendar. Called when date button is hovered. + * Returns early if the date hovered is disabled or if there is already a selected date. + * + * @param {HTMLElement} dateEl - Calendar date button within the date picker component. + */ + +const handleMouseoverFromDate = dateEl => { + if (dateEl.disabled) return; + const hoverDate = parseDateString(dateEl.dataset.value); + const { + calendarEl, + selectedDate, + rangeDate + } = getDatePickerContext(dateEl); + if (selectedDate) return; + const { + withinRangeStartDate, + withinRangeEndDate + } = setRangeDates(hoverDate, rangeDate); + const dateButtons = calendarEl.querySelectorAll(`.${CALENDAR_DATE_CURRENT_MONTH_CLASS}`); + dateButtons.forEach(button => { + const buttonDate = parseDateString(button.dataset.value); + if (isDateWithinMinAndMax(buttonDate, withinRangeStartDate, withinRangeEndDate)) { + button.classList.add(CALENDAR_DATE_WITHIN_RANGE_CLASS); + } else { + button.classList.remove(CALENDAR_DATE_WITHIN_RANGE_CLASS); + } + }); +}; + +// #endregion Calendar Date Event Handling + +// #region Calendar Month Event Handling + +/** + * Adjust the month and display the month selection screen if needed. + * + * @param {function} adjustMonthFn function that returns the adjusted month + */ +const adjustMonthSelectionScreen = adjustMonthFn => event => { + const monthEl = event.target; + const selectedMonth = parseInt(monthEl.dataset.value, 10); + const { + calendarEl, + calendarDate, + minDate, + maxDate + } = getDatePickerContext(monthEl); + const currentDate = setMonth(calendarDate, selectedMonth); + let adjustedMonth = adjustMonthFn(selectedMonth); + adjustedMonth = Math.max(0, Math.min(11, adjustedMonth)); + const date = setMonth(calendarDate, adjustedMonth); + const cappedDate = keepDateBetweenMinAndMax(date, minDate, maxDate); + if (!isSameMonth(currentDate, cappedDate)) { + const newCalendar = displayMonthSelection(calendarEl, cappedDate.getMonth()); + newCalendar.querySelector(CALENDAR_MONTH_FOCUSED).focus(); + } + event.preventDefault(); +}; + +/** + * Navigate back three months and display the month selection screen. + * + * @param {KeyboardEvent} event the keydown event + */ +const handleUpFromMonth = adjustMonthSelectionScreen(month => month - 3); + +/** + * Navigate forward three months and display the month selection screen. + * + * @param {KeyboardEvent} event the keydown event + */ +const handleDownFromMonth = adjustMonthSelectionScreen(month => month + 3); + +/** + * Navigate back one month and display the month selection screen. + * + * @param {KeyboardEvent} event the keydown event + */ +const handleLeftFromMonth = adjustMonthSelectionScreen(month => month - 1); + +/** + * Navigate forward one month and display the month selection screen. + * + * @param {KeyboardEvent} event the keydown event + */ +const handleRightFromMonth = adjustMonthSelectionScreen(month => month + 1); + +/** + * Navigate to the start of the row of months and display the month selection screen. + * + * @param {KeyboardEvent} event the keydown event + */ +const handleHomeFromMonth = adjustMonthSelectionScreen(month => month - month % 3); + +/** + * Navigate to the end of the row of months and display the month selection screen. + * + * @param {KeyboardEvent} event the keydown event + */ +const handleEndFromMonth = adjustMonthSelectionScreen(month => month + 2 - month % 3); + +/** + * Navigate to the last month (December) and display the month selection screen. + * + * @param {KeyboardEvent} event the keydown event + */ +const handlePageDownFromMonth = adjustMonthSelectionScreen(() => 11); + +/** + * Navigate to the first month (January) and display the month selection screen. + * + * @param {KeyboardEvent} event the keydown event + */ +const handlePageUpFromMonth = adjustMonthSelectionScreen(() => 0); + +// #endregion Calendar Month Event Handling + +// #region Calendar Year Event Handling + +/** + * Adjust the year and display the year selection screen if needed. + * + * @param {function} adjustYearFn function that returns the adjusted year + */ +const adjustYearSelectionScreen = adjustYearFn => event => { + const yearEl = event.target; + const selectedYear = parseInt(yearEl.dataset.value, 10); + const { + calendarEl, + calendarDate, + minDate, + maxDate + } = getDatePickerContext(yearEl); + const currentDate = setYear(calendarDate, selectedYear); + let adjustedYear = adjustYearFn(selectedYear); + adjustedYear = Math.max(0, adjustedYear); + const date = setYear(calendarDate, adjustedYear); + const cappedDate = keepDateBetweenMinAndMax(date, minDate, maxDate); + if (!isSameYear(currentDate, cappedDate)) { + const newCalendar = displayYearSelection(calendarEl, cappedDate.getFullYear()); + newCalendar.querySelector(CALENDAR_YEAR_FOCUSED).focus(); + } + event.preventDefault(); +}; + +/** + * Navigate back three years and display the year selection screen. + * + * @param {KeyboardEvent} event the keydown event + */ +const handleUpFromYear = adjustYearSelectionScreen(year => year - 3); + +/** + * Navigate forward three years and display the year selection screen. + * + * @param {KeyboardEvent} event the keydown event + */ +const handleDownFromYear = adjustYearSelectionScreen(year => year + 3); + +/** + * Navigate back one year and display the year selection screen. + * + * @param {KeyboardEvent} event the keydown event + */ +const handleLeftFromYear = adjustYearSelectionScreen(year => year - 1); + +/** + * Navigate forward one year and display the year selection screen. + * + * @param {KeyboardEvent} event the keydown event + */ +const handleRightFromYear = adjustYearSelectionScreen(year => year + 1); + +/** + * Navigate to the start of the row of years and display the year selection screen. + * + * @param {KeyboardEvent} event the keydown event + */ +const handleHomeFromYear = adjustYearSelectionScreen(year => year - year % 3); + +/** + * Navigate to the end of the row of years and display the year selection screen. + * + * @param {KeyboardEvent} event the keydown event + */ +const handleEndFromYear = adjustYearSelectionScreen(year => year + 2 - year % 3); + +/** + * Navigate to back 12 years and display the year selection screen. + * + * @param {KeyboardEvent} event the keydown event + */ +const handlePageUpFromYear = adjustYearSelectionScreen(year => year - YEAR_CHUNK); + +/** + * Navigate forward 12 years and display the year selection screen. + * + * @param {KeyboardEvent} event the keydown event + */ +const handlePageDownFromYear = adjustYearSelectionScreen(year => year + YEAR_CHUNK); + +// #endregion Calendar Year Event Handling + +// #region Focus Handling Event Handling + +const tabHandler = focusable => { + const getFocusableContext = el => { + const { + calendarEl + } = getDatePickerContext(el); + const focusableElements = select(focusable, calendarEl); + const firstTabIndex = 0; + const lastTabIndex = focusableElements.length - 1; + const firstTabStop = focusableElements[firstTabIndex]; + const lastTabStop = focusableElements[lastTabIndex]; + const focusIndex = focusableElements.indexOf(activeElement()); + const isLastTab = focusIndex === lastTabIndex; + const isFirstTab = focusIndex === firstTabIndex; + const isNotFound = focusIndex === -1; + return { + focusableElements, + isNotFound, + firstTabStop, + isFirstTab, + lastTabStop, + isLastTab + }; + }; + return { + tabAhead(event) { + const { + firstTabStop, + isLastTab, + isNotFound + } = getFocusableContext(event.target); + if (isLastTab || isNotFound) { + event.preventDefault(); + firstTabStop.focus(); + } + }, + tabBack(event) { + const { + lastTabStop, + isFirstTab, + isNotFound + } = getFocusableContext(event.target); + if (isFirstTab || isNotFound) { + event.preventDefault(); + lastTabStop.focus(); + } + } + }; +}; +const datePickerTabEventHandler = tabHandler(DATE_PICKER_FOCUSABLE); +const monthPickerTabEventHandler = tabHandler(MONTH_PICKER_FOCUSABLE); +const yearPickerTabEventHandler = tabHandler(YEAR_PICKER_FOCUSABLE); + +// #endregion Focus Handling Event Handling + +// #region Date Picker Event Delegation Registration / Component + +const datePickerEvents = { + [CLICK]: { + [DATE_PICKER_BUTTON]() { + toggleCalendar(this); + }, + [CALENDAR_DATE]() { + selectDate(this); + }, + [CALENDAR_MONTH]() { + selectMonth(this); + }, + [CALENDAR_YEAR]() { + selectYear(this); + }, + [CALENDAR_PREVIOUS_MONTH]() { + displayPreviousMonth(this); + }, + [CALENDAR_NEXT_MONTH]() { + displayNextMonth(this); + }, + [CALENDAR_PREVIOUS_YEAR]() { + displayPreviousYear(this); + }, + [CALENDAR_NEXT_YEAR]() { + displayNextYear(this); + }, + [CALENDAR_PREVIOUS_YEAR_CHUNK]() { + displayPreviousYearChunk(this); + }, + [CALENDAR_NEXT_YEAR_CHUNK]() { + displayNextYearChunk(this); + }, + [CALENDAR_MONTH_SELECTION]() { + const newCalendar = displayMonthSelection(this); + newCalendar.querySelector(CALENDAR_MONTH_FOCUSED).focus(); + }, + [CALENDAR_YEAR_SELECTION]() { + const newCalendar = displayYearSelection(this); + newCalendar.querySelector(CALENDAR_YEAR_FOCUSED).focus(); + } + }, + keyup: { + [DATE_PICKER_CALENDAR](event) { + const keydown = this.dataset.keydownKeyCode; + if (`${event.keyCode}` !== keydown) { + event.preventDefault(); + } + } + }, + keydown: { + [DATE_PICKER_EXTERNAL_INPUT](event) { + if (event.keyCode === ENTER_KEYCODE) { + validateDateInput(this); + } + }, + [CALENDAR_DATE]: keymap({ + Up: handleUpFromDate, + ArrowUp: handleUpFromDate, + Down: handleDownFromDate, + ArrowDown: handleDownFromDate, + Left: handleLeftFromDate, + ArrowLeft: handleLeftFromDate, + Right: handleRightFromDate, + ArrowRight: handleRightFromDate, + Home: handleHomeFromDate, + End: handleEndFromDate, + PageDown: handlePageDownFromDate, + PageUp: handlePageUpFromDate, + "Shift+PageDown": handleShiftPageDownFromDate, + "Shift+PageUp": handleShiftPageUpFromDate, + Tab: datePickerTabEventHandler.tabAhead + }), + [CALENDAR_DATE_PICKER]: keymap({ + Tab: datePickerTabEventHandler.tabAhead, + "Shift+Tab": datePickerTabEventHandler.tabBack + }), + [CALENDAR_MONTH]: keymap({ + Up: handleUpFromMonth, + ArrowUp: handleUpFromMonth, + Down: handleDownFromMonth, + ArrowDown: handleDownFromMonth, + Left: handleLeftFromMonth, + ArrowLeft: handleLeftFromMonth, + Right: handleRightFromMonth, + ArrowRight: handleRightFromMonth, + Home: handleHomeFromMonth, + End: handleEndFromMonth, + PageDown: handlePageDownFromMonth, + PageUp: handlePageUpFromMonth + }), + [CALENDAR_MONTH_PICKER]: keymap({ + Tab: monthPickerTabEventHandler.tabAhead, + "Shift+Tab": monthPickerTabEventHandler.tabBack + }), + [CALENDAR_YEAR]: keymap({ + Up: handleUpFromYear, + ArrowUp: handleUpFromYear, + Down: handleDownFromYear, + ArrowDown: handleDownFromYear, + Left: handleLeftFromYear, + ArrowLeft: handleLeftFromYear, + Right: handleRightFromYear, + ArrowRight: handleRightFromYear, + Home: handleHomeFromYear, + End: handleEndFromYear, + PageDown: handlePageDownFromYear, + PageUp: handlePageUpFromYear + }), + [CALENDAR_YEAR_PICKER]: keymap({ + Tab: yearPickerTabEventHandler.tabAhead, + "Shift+Tab": yearPickerTabEventHandler.tabBack + }), + [DATE_PICKER_CALENDAR](event) { + this.dataset.keydownKeyCode = event.keyCode; + }, + [DATE_PICKER](event) { + const keyMap = keymap({ + Escape: handleEscapeFromCalendar + }); + keyMap(event); + } + }, + focusout: { + [DATE_PICKER_EXTERNAL_INPUT]() { + validateDateInput(this); + }, + [DATE_PICKER](event) { + if (!this.contains(event.relatedTarget)) { + hideCalendar(this); + } + } + }, + input: { + [DATE_PICKER_EXTERNAL_INPUT]() { + reconcileInputValues(this); + updateCalendarIfVisible(this); + } + } +}; +if (!isIosDevice()) { + datePickerEvents.mouseover = { + [CALENDAR_DATE_CURRENT_MONTH]() { + handleMouseoverFromDate(this); + } + }; +} +const datePicker = behavior(datePickerEvents, { + init(root) { + selectOrMatches(DATE_PICKER, root).forEach(datePickerEl => { + enhanceDatePicker(datePickerEl); + }); + }, + getDatePickerContext, + disable, + ariaDisable, + enable, + isDateInputInvalid, + setCalendarValue, + validateDateInput, + renderCalendar, + updateCalendarIfVisible +}); + +// #endregion Date Picker Event Delegation Registration / Component + +module.exports = datePicker; + +},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/events":36,"../../uswds-core/src/js/utils/active-element":39,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/is-ios-device":44,"../../uswds-core/src/js/utils/sanitizer":45,"../../uswds-core/src/js/utils/select":48,"../../uswds-core/src/js/utils/select-or-matches":47,"receptor/keymap":10}],20:[function(require,module,exports){ +"use strict"; + +const behavior = require("../../uswds-core/src/js/utils/behavior"); +const select = require("../../uswds-core/src/js/utils/select"); +const selectOrMatches = require("../../uswds-core/src/js/utils/select-or-matches"); +const { + prefix: PREFIX +} = require("../../uswds-core/src/js/config"); +const { + getDatePickerContext, + isDateInputInvalid, + updateCalendarIfVisible +} = require("../../usa-date-picker/src/index"); +const DATE_PICKER_CLASS = `${PREFIX}-date-picker`; +const DATE_RANGE_PICKER_CLASS = `${PREFIX}-date-range-picker`; +const DATE_RANGE_PICKER_RANGE_START_CLASS = `${DATE_RANGE_PICKER_CLASS}__range-start`; +const DATE_RANGE_PICKER_RANGE_END_CLASS = `${DATE_RANGE_PICKER_CLASS}__range-end`; +const DATE_PICKER = `.${DATE_PICKER_CLASS}`; +const DATE_RANGE_PICKER = `.${DATE_RANGE_PICKER_CLASS}`; +const DATE_RANGE_PICKER_RANGE_START = `.${DATE_RANGE_PICKER_RANGE_START_CLASS}`; +const DATE_RANGE_PICKER_RANGE_END = `.${DATE_RANGE_PICKER_RANGE_END_CLASS}`; +const DEFAULT_MIN_DATE = "0000-01-01"; + +/** + * The properties and elements within the date range picker. + * @typedef {Object} DateRangePickerContext + * @property {HTMLElement} dateRangePickerEl + * @property {HTMLElement} rangeStartEl + * @property {HTMLElement} rangeEndEl + */ + +/** + * Get an object of the properties and elements belonging directly to the given + * date picker component. + * + * @param {HTMLElement} el the element within the date picker + * @returns {DateRangePickerContext} elements + */ +const getDateRangePickerContext = el => { + const dateRangePickerEl = el.closest(DATE_RANGE_PICKER); + if (!dateRangePickerEl) { + throw new Error(`Element is missing outer ${DATE_RANGE_PICKER}`); + } + const rangeStartEl = dateRangePickerEl.querySelector(DATE_RANGE_PICKER_RANGE_START); + const rangeEndEl = dateRangePickerEl.querySelector(DATE_RANGE_PICKER_RANGE_END); + return { + dateRangePickerEl, + rangeStartEl, + rangeEndEl + }; +}; + +/** + * handle update from range start date picker + * + * @param {HTMLElement} el an element within the date range picker + */ +const handleRangeStartUpdate = el => { + const { + dateRangePickerEl, + rangeStartEl, + rangeEndEl + } = getDateRangePickerContext(el); + const { + internalInputEl + } = getDatePickerContext(rangeStartEl); + const updatedDate = internalInputEl.value; + if (updatedDate && !isDateInputInvalid(internalInputEl)) { + rangeEndEl.dataset.minDate = updatedDate; + rangeEndEl.dataset.rangeDate = updatedDate; + rangeEndEl.dataset.defaultDate = updatedDate; + } else { + rangeEndEl.dataset.minDate = dateRangePickerEl.dataset.minDate || ""; + rangeEndEl.dataset.rangeDate = ""; + rangeEndEl.dataset.defaultDate = ""; + } + updateCalendarIfVisible(rangeEndEl); +}; + +/** + * handle update from range start date picker + * + * @param {HTMLElement} el an element within the date range picker + */ +const handleRangeEndUpdate = el => { + const { + dateRangePickerEl, + rangeStartEl, + rangeEndEl + } = getDateRangePickerContext(el); + const { + internalInputEl + } = getDatePickerContext(rangeEndEl); + const updatedDate = internalInputEl.value; + if (updatedDate && !isDateInputInvalid(internalInputEl)) { + rangeStartEl.dataset.maxDate = updatedDate; + rangeStartEl.dataset.rangeDate = updatedDate; + rangeStartEl.dataset.defaultDate = updatedDate; + } else { + rangeStartEl.dataset.maxDate = dateRangePickerEl.dataset.maxDate || ""; + rangeStartEl.dataset.rangeDate = ""; + rangeStartEl.dataset.defaultDate = ""; + } + updateCalendarIfVisible(rangeStartEl); +}; + +/** + * Enhance an input with the date picker elements + * + * @param {HTMLElement} el The initial wrapping element of the date range picker component + */ +const enhanceDateRangePicker = el => { + const dateRangePickerEl = el.closest(DATE_RANGE_PICKER); + const [rangeStart, rangeEnd] = select(DATE_PICKER, dateRangePickerEl); + if (!rangeStart) { + throw new Error(`${DATE_RANGE_PICKER} is missing inner two '${DATE_PICKER}' elements`); + } + if (!rangeEnd) { + throw new Error(`${DATE_RANGE_PICKER} is missing second '${DATE_PICKER}' element`); + } + rangeStart.classList.add(DATE_RANGE_PICKER_RANGE_START_CLASS); + rangeEnd.classList.add(DATE_RANGE_PICKER_RANGE_END_CLASS); + if (!dateRangePickerEl.dataset.minDate) { + dateRangePickerEl.dataset.minDate = DEFAULT_MIN_DATE; + } + const { + minDate + } = dateRangePickerEl.dataset; + rangeStart.dataset.minDate = minDate; + rangeEnd.dataset.minDate = minDate; + const { + maxDate + } = dateRangePickerEl.dataset; + if (maxDate) { + rangeStart.dataset.maxDate = maxDate; + rangeEnd.dataset.maxDate = maxDate; + } + handleRangeStartUpdate(dateRangePickerEl); + handleRangeEndUpdate(dateRangePickerEl); +}; +const dateRangePicker = behavior({ + "input change": { + [DATE_RANGE_PICKER_RANGE_START]() { + handleRangeStartUpdate(this); + }, + [DATE_RANGE_PICKER_RANGE_END]() { + handleRangeEndUpdate(this); + } + } +}, { + init(root) { + selectOrMatches(DATE_RANGE_PICKER, root).forEach(dateRangePickerEl => { + enhanceDateRangePicker(dateRangePickerEl); + }); + } +}); +module.exports = dateRangePicker; + +},{"../../usa-date-picker/src/index":19,"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/select":48,"../../uswds-core/src/js/utils/select-or-matches":47}],21:[function(require,module,exports){ +"use strict"; + +const selectOrMatches = require("../../uswds-core/src/js/utils/select-or-matches"); +const behavior = require("../../uswds-core/src/js/utils/behavior"); +const Sanitizer = require("../../uswds-core/src/js/utils/sanitizer"); +const { + prefix: PREFIX +} = require("../../uswds-core/src/js/config"); +const DROPZONE_CLASS = `${PREFIX}-file-input`; +const DROPZONE = `.${DROPZONE_CLASS}`; +const INPUT_CLASS = `${PREFIX}-file-input__input`; +const TARGET_CLASS = `${PREFIX}-file-input__target`; +const INPUT = `.${INPUT_CLASS}`; +const BOX_CLASS = `${PREFIX}-file-input__box`; +const INSTRUCTIONS_CLASS = `${PREFIX}-file-input__instructions`; +const PREVIEW_CLASS = `${PREFIX}-file-input__preview`; +const PREVIEW_HEADING_CLASS = `${PREFIX}-file-input__preview-heading`; +const DISABLED_CLASS = `${PREFIX}-file-input--disabled`; +const CHOOSE_CLASS = `${PREFIX}-file-input__choose`; +const ACCEPTED_FILE_MESSAGE_CLASS = `${PREFIX}-file-input__accepted-files-message`; +const DRAG_TEXT_CLASS = `${PREFIX}-file-input__drag-text`; +const DRAG_CLASS = `${PREFIX}-file-input--drag`; +const LOADING_CLASS = "is-loading"; +const INVALID_FILE_CLASS = "has-invalid-file"; +const GENERIC_PREVIEW_CLASS_NAME = `${PREFIX}-file-input__preview-image`; +const GENERIC_PREVIEW_CLASS = `${GENERIC_PREVIEW_CLASS_NAME}--generic`; +const PDF_PREVIEW_CLASS = `${GENERIC_PREVIEW_CLASS_NAME}--pdf`; +const WORD_PREVIEW_CLASS = `${GENERIC_PREVIEW_CLASS_NAME}--word`; +const VIDEO_PREVIEW_CLASS = `${GENERIC_PREVIEW_CLASS_NAME}--video`; +const EXCEL_PREVIEW_CLASS = `${GENERIC_PREVIEW_CLASS_NAME}--excel`; +const SR_ONLY_CLASS = `${PREFIX}-sr-only`; +const SPACER_GIF = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7"; +const DEFAULT_ERROR_LABEL_TEXT = "Error: This is not a valid file type."; +let TYPE_IS_VALID = Boolean(true); // logic gate for change listener +let DEFAULT_ARIA_LABEL_TEXT = ""; +let DEFAULT_FILE_STATUS_TEXT = ""; + +/** + * The properties and elements within the file input. + * @typedef {Object} FileInputContext + * @property {HTMLDivElement} dropZoneEl + * @property {HTMLInputElement} inputEl + */ + +/** + * Get an object of the properties and elements belonging directly to the given + * file input component. + * + * @param {HTMLElement} el the element within the file input + * @returns {FileInputContext} elements + */ +const getFileInputContext = el => { + const dropZoneEl = el.closest(DROPZONE); + if (!dropZoneEl) { + throw new Error(`Element is missing outer ${DROPZONE}`); + } + const inputEl = dropZoneEl.querySelector(INPUT); + return { + dropZoneEl, + inputEl + }; +}; + +/** + * Disable the file input component + * + * @param {HTMLElement} el An element within the file input component + */ +const disable = el => { + const { + dropZoneEl, + inputEl + } = getFileInputContext(el); + inputEl.disabled = true; + dropZoneEl.classList.add(DISABLED_CLASS); +}; + +/** + * Set aria-disabled attribute to file input component + * + * @param {HTMLElement} el An element within the file input component + */ +const ariaDisable = el => { + const { + dropZoneEl + } = getFileInputContext(el); + dropZoneEl.classList.add(DISABLED_CLASS); +}; + +/** + * Enable the file input component + * + * @param {HTMLElement} el An element within the file input component + */ +const enable = el => { + const { + dropZoneEl, + inputEl + } = getFileInputContext(el); + inputEl.disabled = false; + dropZoneEl.classList.remove(DISABLED_CLASS); + dropZoneEl.removeAttribute("aria-disabled"); +}; + +/** + * + * @param {String} s special characters + * @returns {String} replaces specified values + */ +const replaceName = s => { + const c = s.charCodeAt(0); + if (c === 32) return "-"; + if (c >= 65 && c <= 90) return `img_${s.toLowerCase()}`; + return `__${("000", c.toString(16)).slice(-4)}`; +}; + +/** + * Creates an ID name for each file that strips all invalid characters. + * @param {String} name - name of the file added to file input (searchvalue) + * @returns {String} same characters as the name with invalid chars removed (newvalue) + */ +const makeSafeForID = name => name.replace(/[^a-z0-9]/g, replaceName); + +// Takes a generated safe ID and creates a unique ID. +const createUniqueID = name => `${name}-${Math.floor(Date.now().toString() / 1000)}`; + +/** + * Determines if the singular or plural item label should be used + * Determination is based on the presence of the `multiple` attribute + * + * @param {HTMLInputElement} fileInputEl - The input element. + * @returns {HTMLDivElement} The singular or plural version of "item" + */ +const getItemsLabel = fileInputEl => { + const acceptsMultiple = fileInputEl.hasAttribute("multiple"); + const itemsLabel = acceptsMultiple ? "files" : "file"; + return itemsLabel; +}; + +/** + * Scaffold the file input component with a parent wrapper and + * Create a target area overlay for drag and drop functionality + * + * @param {HTMLInputElement} fileInputEl - The input element. + * @returns {HTMLDivElement} The drag and drop target area. + */ +const createTargetArea = fileInputEl => { + const fileInputParent = document.createElement("div"); + const dropTarget = document.createElement("div"); + const box = document.createElement("div"); + + // Adds class names and other attributes + fileInputEl.classList.remove(DROPZONE_CLASS); + fileInputEl.classList.add(INPUT_CLASS); + fileInputParent.classList.add(DROPZONE_CLASS); + box.classList.add(BOX_CLASS); + dropTarget.classList.add(TARGET_CLASS); + + // Adds child elements to the DOM + dropTarget.prepend(box); + fileInputEl.parentNode.insertBefore(dropTarget, fileInputEl); + fileInputEl.parentNode.insertBefore(fileInputParent, dropTarget); + dropTarget.appendChild(fileInputEl); + fileInputParent.appendChild(dropTarget); + return dropTarget; +}; + +/** + * Build the visible element with default interaction instructions. + * + * @param {HTMLInputElement} fileInputEl - The input element. + * @returns {HTMLDivElement} The container for visible interaction instructions. + */ +const createVisibleInstructions = fileInputEl => { + const fileInputParent = fileInputEl.closest(DROPZONE); + const itemsLabel = getItemsLabel(fileInputEl); + const instructions = document.createElement("div"); + const dragText = `Drag ${itemsLabel} here or`; + const chooseText = "choose from folder"; + + // Create instructions text for aria-label + DEFAULT_ARIA_LABEL_TEXT = `${dragText} ${chooseText}`; + + // Adds class names and other attributes + instructions.classList.add(INSTRUCTIONS_CLASS); + instructions.setAttribute("aria-hidden", "true"); + + // Add initial instructions for input usage + fileInputEl.setAttribute("aria-label", DEFAULT_ARIA_LABEL_TEXT); + instructions.innerHTML = Sanitizer.escapeHTML`<span class="${DRAG_TEXT_CLASS}">${dragText}</span> <span class="${CHOOSE_CLASS}">${chooseText}</span>`; + + // Add the instructions element to the DOM + fileInputEl.parentNode.insertBefore(instructions, fileInputEl); + + // IE11 and Edge do not support drop files on file inputs, so we've removed text that indicates that + if (/rv:11.0/i.test(navigator.userAgent) || /Edge\/\d./i.test(navigator.userAgent)) { + fileInputParent.querySelector(`.${DRAG_TEXT_CLASS}`).outerHTML = ""; + } + return instructions; +}; + +/** + * Build a screen reader-only message element that contains file status updates and + * Create and set the default file status message + * + * @param {HTMLInputElement} fileInputEl - The input element. + */ +const createSROnlyStatus = fileInputEl => { + const statusEl = document.createElement("div"); + const itemsLabel = getItemsLabel(fileInputEl); + const fileInputParent = fileInputEl.closest(DROPZONE); + const fileInputTarget = fileInputEl.closest(`.${TARGET_CLASS}`); + DEFAULT_FILE_STATUS_TEXT = `No ${itemsLabel} selected.`; + + // Adds class names and other attributes + statusEl.classList.add(SR_ONLY_CLASS); + statusEl.setAttribute("aria-live", "polite"); + + // Add initial file status message + statusEl.textContent = DEFAULT_FILE_STATUS_TEXT; + + // Add the status element to the DOM + fileInputParent.insertBefore(statusEl, fileInputTarget); +}; + +/** + * Scaffold the component with all required elements + * + * @param {HTMLInputElement} fileInputEl - The original input element. + */ +const enhanceFileInput = fileInputEl => { + const isInputDisabled = fileInputEl.hasAttribute("aria-disabled") || fileInputEl.hasAttribute("disabled"); + const dropTarget = createTargetArea(fileInputEl); + const instructions = createVisibleInstructions(fileInputEl); + const { + dropZoneEl + } = getFileInputContext(fileInputEl); + if (isInputDisabled) { + dropZoneEl.classList.add(DISABLED_CLASS); + } else { + createSROnlyStatus(fileInputEl); + } + return { + instructions, + dropTarget + }; +}; + +/** + * Removes image previews + * We want to start with a clean list every time files are added to the file input + * + * @param {HTMLDivElement} dropTarget - The drag and drop target area. + * @param {HTMLDivElement} instructions - The container for visible interaction instructions. + */ +const removeOldPreviews = (dropTarget, instructions) => { + const filePreviews = dropTarget.querySelectorAll(`.${PREVIEW_CLASS}`); + const currentPreviewHeading = dropTarget.querySelector(`.${PREVIEW_HEADING_CLASS}`); + const currentErrorMessage = dropTarget.querySelector(`.${ACCEPTED_FILE_MESSAGE_CLASS}`); + + /** + * finds the parent of the passed node and removes the child + * @param {HTMLElement} node + */ + const removeImages = node => { + node.parentNode.removeChild(node); + }; + + // Remove the heading above the previews + if (currentPreviewHeading) { + currentPreviewHeading.outerHTML = ""; + } + + // Remove existing error messages + if (currentErrorMessage) { + currentErrorMessage.outerHTML = ""; + dropTarget.classList.remove(INVALID_FILE_CLASS); + } + + // Get rid of existing previews if they exist, show instructions + if (filePreviews !== null) { + if (instructions) { + instructions.removeAttribute("hidden"); + } + Array.prototype.forEach.call(filePreviews, removeImages); + } +}; + +/** + * Update the screen reader-only status message after interaction + * + * @param {HTMLDivElement} statusElement - The screen reader-only container for file status updates. + * @param {Object} fileNames - The selected files found in the fileList object. + * @param {Array} fileStore - The array of uploaded file names created from the fileNames object. + */ +const updateStatusMessage = (statusElement, fileNames, fileStore) => { + const statusEl = statusElement; + let statusMessage = DEFAULT_FILE_STATUS_TEXT; + + // If files added, update the status message with file name(s) + if (fileNames.length === 1) { + statusMessage = `You have selected the file: ${fileStore}`; + } else if (fileNames.length > 1) { + statusMessage = `You have selected ${fileNames.length} files: ${fileStore.join(", ")}`; + } + + // Add delay to encourage screen reader readout + setTimeout(() => { + statusEl.textContent = statusMessage; + }, 1000); +}; + +/** + * Show the preview heading, hide the initial instructions and + * Update the aria-label with new instructions text + * + * @param {HTMLInputElement} fileInputEl - The input element. + * @param {Object} fileNames - The selected files found in the fileList object. + */ +const addPreviewHeading = (fileInputEl, fileNames) => { + const filePreviewsHeading = document.createElement("div"); + const dropTarget = fileInputEl.closest(`.${TARGET_CLASS}`); + const instructions = dropTarget.querySelector(`.${INSTRUCTIONS_CLASS}`); + let changeItemText = "Change file"; + let previewHeadingText = ""; + if (fileNames.length === 1) { + previewHeadingText = Sanitizer.escapeHTML`Selected file <span class="usa-file-input__choose">${changeItemText}</span>`; + } else if (fileNames.length > 1) { + changeItemText = "Change files"; + previewHeadingText = Sanitizer.escapeHTML`${fileNames.length} files selected <span class="usa-file-input__choose">${changeItemText}</span>`; + } + + // Hides null state content and sets preview heading + instructions.setAttribute("hidden", "true"); + filePreviewsHeading.classList.add(PREVIEW_HEADING_CLASS); + filePreviewsHeading.innerHTML = previewHeadingText; + dropTarget.insertBefore(filePreviewsHeading, instructions); + + // Update aria label to match the visible action text + fileInputEl.setAttribute("aria-label", changeItemText); +}; + +/** Add an error listener to the image preview to set a fallback image + * @param {HTMLImageElement} previewImage - The image element + * @param {String} fallbackClass - The CSS class of the fallback image + */ +const setPreviewFallback = (previewImage, fallbackClass) => { + previewImage.addEventListener("error", () => { + const localPreviewImage = previewImage; // to avoid no-param-reassign from ESLint + localPreviewImage.src = SPACER_GIF; + localPreviewImage.classList.add(fallbackClass); + }, { + once: true + }); +}; + +/** + * When new files are applied to file input, this function generates previews + * and removes old ones. + * + * @param {event} e + * @param {HTMLInputElement} fileInputEl - The input element. + * @param {HTMLDivElement} instructions - The container for visible interaction instructions. + * @param {HTMLDivElement} dropTarget - The drag and drop target area. + */ + +const handleChange = (e, fileInputEl, instructions, dropTarget) => { + const fileNames = e.target.files; + const inputParent = dropTarget.closest(`.${DROPZONE_CLASS}`); + const statusElement = inputParent.querySelector(`.${SR_ONLY_CLASS}`); + const fileStore = []; + + // First, get rid of existing previews + removeOldPreviews(dropTarget, instructions); + + // Then, iterate through files list and create previews + for (let i = 0; i < fileNames.length; i += 1) { + const reader = new FileReader(); + const fileName = fileNames[i].name; + let imageId; + + // Push updated file names into the store array + fileStore.push(fileName); + + // Starts with a loading image while preview is created + reader.onloadstart = function createLoadingImage() { + imageId = createUniqueID(makeSafeForID(fileName)); + instructions.insertAdjacentHTML("afterend", Sanitizer.escapeHTML`<div class="${PREVIEW_CLASS}" aria-hidden="true"> + <img id="${imageId}" src="${SPACER_GIF}" alt="" class="${GENERIC_PREVIEW_CLASS_NAME} ${LOADING_CLASS}"/>${fileName} + <div>`); + }; + + // 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() { + const previewImage = document.getElementById(imageId); + const fileExtension = fileName.split(".").pop(); + if (fileExtension === "pdf") { + setPreviewFallback(previewImage, PDF_PREVIEW_CLASS); + } else if (fileExtension === "doc" || fileExtension === "docx" || fileExtension === "pages") { + setPreviewFallback(previewImage, WORD_PREVIEW_CLASS); + } else if (fileExtension === "xls" || fileExtension === "xlsx" || fileExtension === "numbers") { + setPreviewFallback(previewImage, EXCEL_PREVIEW_CLASS); + } else if (fileExtension === "mov" || fileExtension === "mp4") { + setPreviewFallback(previewImage, VIDEO_PREVIEW_CLASS); + } else { + setPreviewFallback(previewImage, GENERIC_PREVIEW_CLASS); + } + + // Removes loader and displays preview + previewImage.classList.remove(LOADING_CLASS); + previewImage.src = reader.result; + }; + if (fileNames[i]) { + reader.readAsDataURL(fileNames[i]); + } + } + if (fileNames.length === 0) { + // Reset input aria-label with default message + fileInputEl.setAttribute("aria-label", DEFAULT_ARIA_LABEL_TEXT); + } else { + addPreviewHeading(fileInputEl, fileNames); + } + updateStatusMessage(statusElement, fileNames, fileStore); +}; + +/** + * When using an Accept attribute, invalid files will be hidden from + * file browser, but they can still be dragged to the input. This + * function prevents them from being dragged and removes error states + * when correct files are added. + * + * @param {event} e + * @param {HTMLInputElement} fileInputEl - The input element. + * @param {HTMLDivElement} instructions - The container for visible interaction instructions. + * @param {HTMLDivElement} dropTarget - The drag and drop target area. + */ +const preventInvalidFiles = (e, fileInputEl, instructions, dropTarget) => { + const acceptedFilesAttr = fileInputEl.getAttribute("accept"); + dropTarget.classList.remove(INVALID_FILE_CLASS); + + /** + * We can probably move away from this once IE11 support stops, and replace + * with a simple es `.includes` + * check if element is in array + * check if 1 or more alphabets are in string + * if element is present return the position value and -1 otherwise + * @param {Object} file + * @param {String} value + * @returns {Boolean} + */ + const isIncluded = (file, value) => { + let returnValue = false; + const pos = file.indexOf(value); + if (pos >= 0) { + returnValue = true; + } + return returnValue; + }; + + // Runs if only specific files are accepted + if (acceptedFilesAttr) { + const acceptedFiles = acceptedFilesAttr.split(","); + const errorMessage = document.createElement("div"); + const userErrorText = fileInputEl.dataset.errormessage; + const errorMessageText = userErrorText || DEFAULT_ERROR_LABEL_TEXT; + errorMessage.setAttribute("aria-hidden", true); + + // If multiple files are dragged, this iterates through them and look for any files that are not accepted. + let allFilesAllowed = true; + const scannedFiles = e.target.files || e.dataTransfer.files; + for (let i = 0; i < scannedFiles.length; i += 1) { + const file = scannedFiles[i]; + if (allFilesAllowed) { + for (let j = 0; j < acceptedFiles.length; j += 1) { + const fileType = acceptedFiles[j]; + allFilesAllowed = file.name.indexOf(fileType) > 0 || isIncluded(file.type, fileType.replace(/\*/g, "")); + if (allFilesAllowed) { + TYPE_IS_VALID = true; + break; + } + } + } else break; + } + + // If dragged files are not accepted, this removes them from the value of the input and creates and error state + if (!allFilesAllowed) { + removeOldPreviews(dropTarget, instructions); + fileInputEl.value = ""; // eslint-disable-line no-param-reassign + errorMessage.textContent = errorMessageText; + dropTarget.insertBefore(errorMessage, fileInputEl); + const ariaLabelText = `${errorMessageText} ${DEFAULT_ARIA_LABEL_TEXT}`; + fileInputEl.setAttribute("aria-label", ariaLabelText); + errorMessage.classList.add(ACCEPTED_FILE_MESSAGE_CLASS); + dropTarget.classList.add(INVALID_FILE_CLASS); + TYPE_IS_VALID = false; + e.preventDefault(); + e.stopPropagation(); + } + } +}; + +/** + * 1. passes through gate for preventing invalid files + * 2. handles updates if file is valid + * + * @param {event} event + * @param {HTMLInputElement} fileInputEl - The input element. + * @param {HTMLDivElement} instructions - The container for visible interaction instructions. + * @param {HTMLDivElement} dropTarget - The drag and drop target area. + */ +const handleUpload = (event, fileInputEl, instructions, dropTarget) => { + preventInvalidFiles(event, fileInputEl, instructions, dropTarget); + if (TYPE_IS_VALID === true) { + handleChange(event, fileInputEl, instructions, dropTarget); + } +}; +const fileInput = behavior({}, { + init(root) { + selectOrMatches(DROPZONE, root).forEach(fileInputEl => { + const { + instructions, + dropTarget + } = enhanceFileInput(fileInputEl); + 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() { + this.classList.remove(DRAG_CLASS); + }, false); + fileInputEl.addEventListener("change", e => handleUpload(e, fileInputEl, instructions, dropTarget), false); + }); + }, + teardown(root) { + selectOrMatches(INPUT, root).forEach(fileInputEl => { + const fileInputTopElement = fileInputEl.parentElement.parentElement; + fileInputTopElement.parentElement.replaceChild(fileInputEl, fileInputTopElement); + // eslint-disable-next-line no-param-reassign + fileInputEl.className = DROPZONE_CLASS; + }); + }, + getFileInputContext, + disable, + ariaDisable, + enable +}); +module.exports = fileInput; + +},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/sanitizer":45,"../../uswds-core/src/js/utils/select-or-matches":47}],22:[function(require,module,exports){ +"use strict"; + +const behavior = require("../../uswds-core/src/js/utils/behavior"); +const { + CLICK +} = require("../../uswds-core/src/js/events"); +const { + prefix: PREFIX +} = require("../../uswds-core/src/js/config"); +const SCOPE = `.${PREFIX}-footer--big`; +const NAV = `${SCOPE} nav`; +const BUTTON = `${NAV} .${PREFIX}-footer__primary-link`; +const HIDE_MAX_WIDTH = 480; + +/** + * Expands selected footer menu panel, while collapsing others + */ +function showPanel() { + if (window.innerWidth < HIDE_MAX_WIDTH) { + const isOpen = this.getAttribute("aria-expanded") === "true"; + const thisFooter = this.closest(SCOPE); + + // Close all other menus + thisFooter.querySelectorAll(BUTTON).forEach(button => { + button.setAttribute("aria-expanded", false); + }); + this.setAttribute("aria-expanded", !isOpen); + } +} + +/** + * Swaps the <h4> element for a <button> element (and vice-versa) and sets id + * of menu list + * + * @param {Boolean} isMobile - If the footer is in mobile configuration + */ +function toggleHtmlTag(isMobile) { + const bigFooter = document.querySelector(SCOPE); + if (!bigFooter) { + return; + } + const primaryLinks = bigFooter.querySelectorAll(BUTTON); + primaryLinks.forEach(currentElement => { + const currentElementClasses = currentElement.getAttribute("class"); + const preservedHtmlTag = currentElement.getAttribute("data-tag") || currentElement.tagName; + const newElementType = isMobile ? "button" : preservedHtmlTag; + + // Create the new element + const newElement = document.createElement(newElementType); + newElement.setAttribute("class", currentElementClasses); + newElement.classList.toggle(`${PREFIX}-footer__primary-link--button`, isMobile); + newElement.textContent = currentElement.textContent; + if (isMobile) { + newElement.setAttribute("data-tag", currentElement.tagName); + const menuId = `${PREFIX}-footer-menu-list-${Math.floor(Math.random() * 100000)}`; + newElement.setAttribute("aria-controls", menuId); + newElement.setAttribute("aria-expanded", "false"); + currentElement.nextElementSibling.setAttribute("id", menuId); + newElement.setAttribute("type", "button"); + } + + // Insert the new element and delete the old + currentElement.after(newElement); + currentElement.remove(); + }); +} +const resize = event => { + toggleHtmlTag(event.matches); +}; +module.exports = behavior({ + [CLICK]: { + [BUTTON]: showPanel + } +}, { + // export for use elsewhere + HIDE_MAX_WIDTH, + init() { + toggleHtmlTag(window.innerWidth < HIDE_MAX_WIDTH); + this.mediaQueryList = window.matchMedia(`(max-width: ${HIDE_MAX_WIDTH - 0.1}px)`); + this.mediaQueryList.addListener(resize); + }, + teardown() { + this.mediaQueryList.removeListener(resize); + } +}); + +},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/events":36,"../../uswds-core/src/js/utils/behavior":40}],23:[function(require,module,exports){ +"use strict"; + +const keymap = require("receptor/keymap"); +const behavior = require("../../uswds-core/src/js/utils/behavior"); +const select = require("../../uswds-core/src/js/utils/select"); +const toggle = require("../../uswds-core/src/js/utils/toggle"); +const FocusTrap = require("../../uswds-core/src/js/utils/focus-trap"); +const accordion = require("../../usa-accordion/src/index"); +const ScrollBarWidth = require("../../uswds-core/src/js/utils/scrollbar-width"); +const { + CLICK +} = require("../../uswds-core/src/js/events"); +const { + prefix: PREFIX +} = require("../../uswds-core/src/js/config"); +const BODY = "body"; +const HEADER = `.${PREFIX}-header`; +const NAV = `.${PREFIX}-nav`; +const NAV_CONTAINER = `.${PREFIX}-nav-container`; +const NAV_PRIMARY = `.${PREFIX}-nav__primary`; +const NAV_PRIMARY_ITEM = `.${PREFIX}-nav__primary-item`; +const NAV_CONTROL = `button.${PREFIX}-nav__link`; +const NAV_LINKS = `${NAV} a`; +const NON_NAV_HIDDEN_ATTRIBUTE = `data-nav-hidden`; +const OPENERS = `.${PREFIX}-menu-btn`; +const CLOSE_BUTTON = `.${PREFIX}-nav__close`; +const OVERLAY = `.${PREFIX}-overlay`; +const CLOSERS = `${CLOSE_BUTTON}, .${PREFIX}-overlay`; +const TOGGLES = [NAV, OVERLAY].join(", "); +const NON_NAV_ELEMENTS = `body *:not(${HEADER}, ${NAV_CONTAINER}, ${NAV}, ${NAV} *):not([aria-hidden])`; +const NON_NAV_HIDDEN = `[${NON_NAV_HIDDEN_ATTRIBUTE}]`; +const ACTIVE_CLASS = "usa-js-mobile-nav--active"; +const VISIBLE_CLASS = "is-visible"; +let navigation; +let navActive; +let nonNavElements; +const isActive = () => document.body.classList.contains(ACTIVE_CLASS); +// Detect Safari +// Note: Chrome also reports the Safari userAgent so this specifically excludes Chrome. +const isSafari = navigator.userAgent.includes("Safari") && !navigator.userAgent.includes("Chrome"); +const SCROLLBAR_WIDTH = ScrollBarWidth(); +const INITIAL_PADDING = window.getComputedStyle(document.body).getPropertyValue("padding-right"); +const TEMPORARY_PADDING = `${parseInt(INITIAL_PADDING.replace(/px/, ""), 10) + parseInt(SCROLLBAR_WIDTH.replace(/px/, ""), 10)}px`; +const hideNonNavItems = () => { + const headerParent = document.querySelector(`${HEADER}`).parentNode; + nonNavElements = document.querySelectorAll(NON_NAV_ELEMENTS); + nonNavElements.forEach(nonNavElement => { + if (nonNavElement !== headerParent) { + nonNavElement.setAttribute("aria-hidden", true); + nonNavElement.setAttribute(NON_NAV_HIDDEN_ATTRIBUTE, ""); + } + }); +}; +const showNonNavItems = () => { + nonNavElements = document.querySelectorAll(NON_NAV_HIDDEN); + if (!nonNavElements) { + return; + } + + // Remove aria-hidden from non-header elements + nonNavElements.forEach(nonNavElement => { + nonNavElement.removeAttribute("aria-hidden"); + nonNavElement.removeAttribute(NON_NAV_HIDDEN_ATTRIBUTE); + }); +}; + +// Toggle all non-header elements #3527. +const toggleNonNavItems = active => { + if (active) { + hideNonNavItems(); + } else { + showNonNavItems(); + } +}; + +/** + * Detect Safari and add body class for a Safari-only CSS bug fix. + * More details in https://github.com/uswds/uswds/pull/5443 + */ +const addSafariClass = () => { + if (isSafari) { + document.body.classList.add("is-safari"); + } +}; + +/** + * Set the value for the --scrolltop CSS var when the mobile menu is open. + * This allows the CSS to lock the current scroll position in Safari + * when overflow-y is set to scroll. + * More details in https://github.com/uswds/uswds/pull/5443 + */ +const setSafariScrollPosition = body => { + const currentScrollPosition = `-${window.scrollY}px`; + if (isSafari) { + body.style.setProperty("--scrolltop", currentScrollPosition); + } +}; +const toggleNav = active => { + const { + body + } = document; + const safeActive = typeof active === "boolean" ? active : !isActive(); + setSafariScrollPosition(body); + body.classList.toggle(ACTIVE_CLASS, safeActive); + select(TOGGLES).forEach(el => el.classList.toggle(VISIBLE_CLASS, safeActive)); + navigation.focusTrap.update(safeActive); + const closeButton = body.querySelector(CLOSE_BUTTON); + const menuButton = document.querySelector(OPENERS); + body.style.paddingRight = body.style.paddingRight === TEMPORARY_PADDING ? INITIAL_PADDING : TEMPORARY_PADDING; + toggleNonNavItems(safeActive); + if (safeActive && closeButton) { + // The mobile nav was just activated. Focus on the close button, which is + // just before all the nav elements in the tab order. + closeButton.focus(); + } else if (!safeActive && menuButton && getComputedStyle(menuButton).display !== "none") { + // The mobile nav was just deactivated. 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; +}; +const resize = () => { + const 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); + } +}; +const onMenuClose = () => navigation.toggleNav.call(navigation, false); +const hideActiveNavDropdown = () => { + if (!navActive) { + return; + } + toggle(navActive, false); + navActive = null; +}; +const focusNavButton = event => { + const parentNavItem = event.target.closest(NAV_PRIMARY_ITEM); + + // Only shift focus if within dropdown + if (!event.target.matches(NAV_CONTROL)) { + const navControl = parentNavItem.querySelector(NAV_CONTROL); + if (navControl) { + navControl.focus(); + } + } +}; +const handleEscape = event => { + hideActiveNavDropdown(); + focusNavButton(event); +}; +navigation = behavior({ + [CLICK]: { + [NAV_CONTROL]() { + // If another nav is open, close it + if (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) { + navActive = this; + toggle(navActive, true); + } + + // Do this so the event handler on the body doesn't fire + return false; + }, + [BODY]: hideActiveNavDropdown, + [OPENERS]: toggleNav, + [CLOSERS]: toggleNav, + [NAV_LINKS]() { + // 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. + const acc = this.closest(accordion.ACCORDION); + if (acc) { + accordion.getButtons(acc).forEach(btn => accordion.hide(btn)); + } + + // If the mobile navigation menu is active, we want to hide it. + if (isActive()) { + navigation.toggleNav.call(navigation, false); + } + } + }, + keydown: { + [NAV_PRIMARY]: keymap({ + Escape: handleEscape + }) + }, + focusout: { + [NAV_PRIMARY](event) { + const nav = event.target.closest(NAV_PRIMARY); + if (!nav.contains(event.relatedTarget)) { + hideActiveNavDropdown(); + } + } + } +}, { + init(root) { + const trapContainer = root.matches(NAV) ? root : root.querySelector(NAV); + if (trapContainer) { + navigation.focusTrap = FocusTrap(trapContainer, { + Escape: onMenuClose + }); + } + addSafariClass(); + resize(); + window.addEventListener("resize", resize, false); + }, + teardown() { + window.removeEventListener("resize", resize, false); + navActive = false; + }, + focusTrap: null, + toggleNav +}); +module.exports = navigation; + +},{"../../usa-accordion/src/index":14,"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/events":36,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/focus-trap":42,"../../uswds-core/src/js/utils/scrollbar-width":46,"../../uswds-core/src/js/utils/select":48,"../../uswds-core/src/js/utils/toggle":51,"receptor/keymap":10}],24:[function(require,module,exports){ +"use strict"; + +const once = require("receptor/once"); +const keymap = require("receptor/keymap"); +const selectOrMatches = require("../../uswds-core/src/js/utils/select-or-matches"); +const behavior = require("../../uswds-core/src/js/utils/behavior"); +const { + prefix: PREFIX +} = require("../../uswds-core/src/js/config"); +const { + CLICK +} = require("../../uswds-core/src/js/events"); +const Sanitizer = require("../../uswds-core/src/js/utils/sanitizer"); +const CURRENT_CLASS = `${PREFIX}-current`; +const IN_PAGE_NAV_HEADINGS = "h2 h3"; +const IN_PAGE_NAV_VALID_HEADINGS = ["h1", "h2", "h3", "h4", "h5", "h6"]; +const IN_PAGE_NAV_TITLE_TEXT = "On this page"; +const IN_PAGE_NAV_TITLE_HEADING_LEVEL = "h4"; +const IN_PAGE_NAV_SCROLL_OFFSET = 0; +const IN_PAGE_NAV_ROOT_MARGIN = "0px 0px 0px 0px"; +const IN_PAGE_NAV_THRESHOLD = "1"; +const IN_PAGE_NAV_CLASS = `${PREFIX}-in-page-nav`; +const IN_PAGE_NAV_ANCHOR_CLASS = `${PREFIX}-anchor`; +const IN_PAGE_NAV_NAV_CLASS = `${IN_PAGE_NAV_CLASS}__nav`; +const IN_PAGE_NAV_LIST_CLASS = `${IN_PAGE_NAV_CLASS}__list`; +const IN_PAGE_NAV_ITEM_CLASS = `${IN_PAGE_NAV_CLASS}__item`; +const IN_PAGE_NAV_PRIMARY_ITEM_CLASS = `${IN_PAGE_NAV_ITEM_CLASS}--primary`; +const IN_PAGE_NAV_LINK_CLASS = `${IN_PAGE_NAV_CLASS}__link`; +const IN_PAGE_NAV_TITLE_CLASS = `${IN_PAGE_NAV_CLASS}__heading`; +const MAIN_ELEMENT = "main"; + +/** + * Set the active link state for the currently observed section + * + * @param {HTMLElement} el An element within the in-page nav component + */ +const setActive = el => { + const allLinks = document.querySelectorAll(`.${IN_PAGE_NAV_LINK_CLASS}`); + el.map(i => { + if (i.isIntersecting === true && i.intersectionRatio >= 1) { + allLinks.forEach(link => link.classList.remove(CURRENT_CLASS)); + document.querySelector(`a[href="#${i.target.id}"]`).classList.add(CURRENT_CLASS); + return true; + } + return false; + }); +}; + +/** + * Return an array of the designated heading types found in the designated content region. + * Throw an error if an invalid header element is designated. + * + * @param {HTMLElement} selectedContentRegion The content region the component should pull headers from + * @param {String} selectedHeadingTypes The list of heading types that should be included in the nav list + * + * @return {Array} - An array of designated heading types from the designated content region + */ +const createSectionHeadingsArray = (selectedContentRegion, selectedHeadingTypes) => { + // Convert designated headings list to an array + const selectedHeadingTypesArray = selectedHeadingTypes.indexOf(" ") ? selectedHeadingTypes.split(" ") : selectedHeadingTypes; + const contentRegion = document.querySelector(selectedContentRegion); + selectedHeadingTypesArray.forEach(headingType => { + if (!IN_PAGE_NAV_VALID_HEADINGS.includes(headingType)) { + throw new Error(`In-page navigation: data-heading-elements attribute defined with an invalid heading type: "${headingType}". + Define the attribute with one or more of the following: "${IN_PAGE_NAV_VALID_HEADINGS}". + Do not use commas or other punctuation in the attribute definition.`); + } + }); + const sectionHeadingsArray = Array.from(contentRegion.querySelectorAll(selectedHeadingTypesArray)); + return sectionHeadingsArray; +}; + +/** + * Return an array of the visible headings from sectionHeadingsArray. + * This function removes headings that are hidden with display:none or visibility:none style rules. + * These items will be added to the component nav list. + * + * @param {HTMLElement} selectedContentRegion The content region the component should pull headers from + * @param {String} selectedHeadingTypes The list of heading types that should be included in the nav list + * + * @return {Array} - An array of visible headings from the designated content region + */ +const getVisibleSectionHeadings = (selectedContentRegion, selectedHeadingTypes) => { + const sectionHeadings = createSectionHeadingsArray(selectedContentRegion, selectedHeadingTypes); + + // Find all headings with hidden styling and remove them from the array + const visibleSectionHeadings = sectionHeadings.filter(heading => { + const headingStyle = window.getComputedStyle(heading); + const visibleHeading = headingStyle.getPropertyValue("display") !== "none" && headingStyle.getPropertyValue("visibility") !== "hidden"; + return visibleHeading; + }); + return visibleSectionHeadings; +}; + +/** + * Return the highest-level header tag included in the link list + * + * @param {HTMLElement} sectionHeadings The array of headings selected for inclusion in the link list + * + * @return {tagName} - The tag name for the highest level of header in the link list + */ + +const getTopLevelHeading = sectionHeadings => { + const topHeading = sectionHeadings[0].tagName.toLowerCase(); + return topHeading; +}; + +/** + * Return a node list of section anchor tags + * + * @return {HTMLElement[]} - An array of DOM nodes + */ +const getSectionAnchors = () => { + const sectionAnchors = document.querySelectorAll(`.${IN_PAGE_NAV_ANCHOR_CLASS}`); + return sectionAnchors; +}; + +/** + * Generates a unique ID for the given heading element. + * + * @param {HTMLHeadingElement} heading + * + * @return {string} - Unique ID + */ +const getHeadingId = heading => { + const baseId = heading.textContent.toLowerCase() + // Replace non-alphanumeric characters with dashes + .replace(/[^a-z\d]/g, "-") + // Replace a sequence of two or more dashes with a single dash + .replace(/-{2,}/g, "-") + // Trim leading or trailing dash (there should only ever be one) + .replace(/^-|-$/g, ""); + let id; + let suffix = 0; + do { + id = baseId; + + // To avoid conflicts with existing IDs on the page, loop and append an + // incremented suffix until a unique ID is found. + suffix += 1; + if (suffix > 1) { + id += `-${suffix}`; + } + } while (document.getElementById(id)); + return id; +}; + +/** + * Return a section id/anchor hash without the number sign + * + * @return {String} - Id value with the number sign removed + */ +const getSectionId = value => { + let id; + + // Check if value is an event or element and get the cleaned up id + if (value && value.nodeType === 1) { + id = value.getAttribute("href").replace("#", ""); + } else { + id = value.target.hash.replace("#", ""); + } + return id; +}; + +/** + * Scroll smoothly to a section based on the passed in element + * + * @param {HTMLElement} - Id value with the number sign removed + */ +const handleScrollToSection = el => { + const inPageNavEl = document.querySelector(`.${IN_PAGE_NAV_CLASS}`); + const inPageNavScrollOffset = inPageNavEl.dataset.scrollOffset || IN_PAGE_NAV_SCROLL_OFFSET; + window.scroll({ + behavior: "smooth", + top: el.offsetTop - inPageNavScrollOffset, + block: "start" + }); + if (window.location.hash.slice(1) !== el.id) { + window.history.pushState(null, "", `#${el.id}`); + } +}; + +/** + * Scrolls the page to the section corresponding to the current hash fragment, if one exists. + */ +const scrollToCurrentSection = () => { + const hashFragment = window.location.hash.slice(1); + if (hashFragment) { + const anchorTag = document.getElementById(hashFragment); + if (anchorTag) { + handleScrollToSection(anchorTag); + } + } +}; + +/** + * Create the in-page navigation component + * + * @param {HTMLElement} inPageNavEl The in-page nav element + */ +const createInPageNav = inPageNavEl => { + const inPageNavTitleText = Sanitizer.escapeHTML`${inPageNavEl.dataset.titleText || IN_PAGE_NAV_TITLE_TEXT}`; + const inPageNavTitleHeadingLevel = Sanitizer.escapeHTML`${inPageNavEl.dataset.titleHeadingLevel || IN_PAGE_NAV_TITLE_HEADING_LEVEL}`; + const inPageNavRootMargin = Sanitizer.escapeHTML`${inPageNavEl.dataset.rootMargin || IN_PAGE_NAV_ROOT_MARGIN}`; + const inPageNavThreshold = Sanitizer.escapeHTML`${inPageNavEl.dataset.threshold || IN_PAGE_NAV_THRESHOLD}`; + const inPageNavContentSelector = Sanitizer.escapeHTML`${inPageNavEl.dataset.mainContentSelector || MAIN_ELEMENT}`; + const inPageNavHeadingSelector = Sanitizer.escapeHTML`${inPageNavEl.dataset.headingElements || IN_PAGE_NAV_HEADINGS}`; + const options = { + root: null, + rootMargin: inPageNavRootMargin, + threshold: [inPageNavThreshold] + }; + const sectionHeadings = getVisibleSectionHeadings(inPageNavContentSelector, inPageNavHeadingSelector); + const inPageNav = document.createElement("nav"); + inPageNav.setAttribute("aria-label", inPageNavTitleText); + inPageNav.classList.add(IN_PAGE_NAV_NAV_CLASS); + const inPageNavTitle = document.createElement(inPageNavTitleHeadingLevel); + inPageNavTitle.classList.add(IN_PAGE_NAV_TITLE_CLASS); + inPageNavTitle.setAttribute("tabindex", "0"); + inPageNavTitle.textContent = inPageNavTitleText; + inPageNav.appendChild(inPageNavTitle); + const inPageNavList = document.createElement("ul"); + inPageNavList.classList.add(IN_PAGE_NAV_LIST_CLASS); + inPageNav.appendChild(inPageNavList); + sectionHeadings.forEach(el => { + const listItem = document.createElement("li"); + const navLinks = document.createElement("a"); + const anchorTag = document.createElement("a"); + const textContentOfLink = el.textContent; + const tag = el.tagName.toLowerCase(); + const topHeadingLevel = getTopLevelHeading(sectionHeadings); + const headingId = getHeadingId(el); + listItem.classList.add(IN_PAGE_NAV_ITEM_CLASS); + if (tag === topHeadingLevel) { + listItem.classList.add(IN_PAGE_NAV_PRIMARY_ITEM_CLASS); + } + navLinks.setAttribute("href", `#${headingId}`); + navLinks.setAttribute("class", IN_PAGE_NAV_LINK_CLASS); + navLinks.textContent = textContentOfLink; + anchorTag.setAttribute("id", headingId); + anchorTag.setAttribute("class", IN_PAGE_NAV_ANCHOR_CLASS); + el.insertAdjacentElement("afterbegin", anchorTag); + inPageNavList.appendChild(listItem); + listItem.appendChild(navLinks); + }); + inPageNavEl.appendChild(inPageNav); + const anchorTags = getSectionAnchors(); + const observeSections = new window.IntersectionObserver(setActive, options); + anchorTags.forEach(tag => { + observeSections.observe(tag); + }); +}; + +/** + * Handle click from link + * + * @param {HTMLElement} el An element within the in-page nav component + */ +const handleClickFromLink = el => { + const elementToScrollTo = document.getElementById(el.hash.slice(1)); + handleScrollToSection(elementToScrollTo); +}; + +/** + * Handle the enter event from a link within the in-page nav component + * + * @param {KeyboardEvent} event An event within the in-page nav component + */ +const handleEnterFromLink = event => { + const id = getSectionId(event); + const targetAnchor = document.getElementById(id); + const target = targetAnchor.parentElement; + if (target) { + target.setAttribute("tabindex", 0); + target.focus(); + target.addEventListener("blur", once(() => { + target.setAttribute("tabindex", -1); + })); + } else { + // throw an error? + } + handleScrollToSection(targetAnchor); +}; +const inPageNavigation = behavior({ + [CLICK]: { + [`.${IN_PAGE_NAV_LINK_CLASS}`](event) { + event.preventDefault(); + if (this.disabled) return; + handleClickFromLink(this); + } + }, + keydown: { + [`.${IN_PAGE_NAV_LINK_CLASS}`]: keymap({ + Enter: handleEnterFromLink + }) + } +}, { + init(root) { + selectOrMatches(`.${IN_PAGE_NAV_CLASS}`, root).forEach(inPageNavEl => { + createInPageNav(inPageNavEl); + scrollToCurrentSection(); + }); + } +}); +module.exports = inPageNavigation; + +},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/events":36,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/sanitizer":45,"../../uswds-core/src/js/utils/select-or-matches":47,"receptor/keymap":10,"receptor/once":11}],25:[function(require,module,exports){ +"use strict"; + +const selectOrMatches = require("../../uswds-core/src/js/utils/select-or-matches"); +const behavior = require("../../uswds-core/src/js/utils/behavior"); +const { + prefix: PREFIX +} = require("../../uswds-core/src/js/config"); +const MASKED_CLASS = `${PREFIX}-masked`; +const MASKED = `.${MASKED_CLASS}`; +const MASK = `${PREFIX}-input-mask`; +const MASK_CONTENT = `${MASK}--content`; +const PLACEHOLDER = "placeholder"; + +// User defined Values +const maskedNumber = "_#dDmMyY9"; +const maskedLetter = "A"; + +// replaces each masked input with a shell containing the input and it's mask. +const createMaskedInputShell = input => { + const placeholder = input.getAttribute(`${PLACEHOLDER}`); + if (placeholder) { + input.setAttribute("maxlength", placeholder.length); + input.setAttribute("data-placeholder", placeholder); + input.removeAttribute(`${PLACEHOLDER}`); + } else { + return; + } + const shell = document.createElement("span"); + shell.classList.add(MASK); + shell.setAttribute("data-mask", placeholder); + const content = document.createElement("span"); + content.classList.add(MASK_CONTENT); + content.setAttribute("aria-hidden", "true"); + content.id = `${input.id}Mask`; + content.textContent = placeholder; + shell.appendChild(content); + input.parentNode.insertBefore(shell, input); + shell.appendChild(input); +}; +const setValueOfMask = el => { + const { + value + } = el; + const placeholderVal = `${el.dataset.placeholder.substr(value.length)}`; + const theIEl = document.createElement("i"); + theIEl.textContent = value; + return [theIEl, placeholderVal]; +}; +const strippedValue = (isCharsetPresent, value) => isCharsetPresent ? value.replace(/\W/g, "") : value.replace(/\D/g, ""); +const isInteger = value => !Number.isNaN(parseInt(value, 10)); +const isLetter = value => value ? value.match(/[A-Z]/i) : false; +const handleCurrentValue = el => { + const isCharsetPresent = el.dataset.charset; + const placeholder = isCharsetPresent || el.dataset.placeholder; + const { + value + } = el; + const len = placeholder.length; + let newValue = ""; + let i; + let charIndex; + const strippedVal = strippedValue(isCharsetPresent, value); + for (i = 0, charIndex = 0; i < len; i += 1) { + const isInt = isInteger(strippedVal[charIndex]); + const isLet = isLetter(strippedVal[charIndex]); + const matchesNumber = maskedNumber.indexOf(placeholder[i]) >= 0; + const matchesLetter = maskedLetter.indexOf(placeholder[i]) >= 0; + if (matchesNumber && isInt || isCharsetPresent && matchesLetter && isLet) { + newValue += strippedVal[charIndex]; + charIndex += 1; + } else if (!isCharsetPresent && !isInt && matchesNumber || isCharsetPresent && (matchesLetter && !isLet || matchesNumber && !isInt)) { + return newValue; + } else { + newValue += placeholder[i]; + } + // break if no characters left and the pattern is non-special character + if (strippedVal[charIndex] === undefined) { + break; + } + } + return newValue; +}; +const handleValueChange = el => { + const inputEl = el; + const id = inputEl.getAttribute("id"); + inputEl.value = handleCurrentValue(inputEl); + const maskVal = setValueOfMask(el); + const maskEl = document.getElementById(`${id}Mask`); + maskEl.textContent = ""; + maskEl.replaceChildren(maskVal[0], maskVal[1]); +}; +const inputMaskEvents = { + keyup: { + [MASKED]() { + handleValueChange(this); + } + } +}; +const inputMask = behavior(inputMaskEvents, { + init(root) { + selectOrMatches(MASKED, root).forEach(maskedInput => { + createMaskedInputShell(maskedInput); + }); + } +}); +module.exports = inputMask; + +},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/select-or-matches":47}],26:[function(require,module,exports){ +"use strict"; + +const keymap = require("receptor/keymap"); +const behavior = require("../../uswds-core/src/js/utils/behavior"); +const toggle = require("../../uswds-core/src/js/utils/toggle"); +const FocusTrap = require("../../uswds-core/src/js/utils/focus-trap"); +const accordion = require("../../usa-accordion/src/index"); +const { + CLICK +} = require("../../uswds-core/src/js/events"); +const { + prefix: PREFIX +} = require("../../uswds-core/src/js/config"); +const BODY = "body"; +const LANGUAGE = `.${PREFIX}-language`; +const LANGUAGE_SUB = `.${PREFIX}-language__submenu`; +const LANGUAGE_PRIMARY = `.${PREFIX}-language__primary`; +const LANGUAGE_PRIMARY_ITEM = `.${PREFIX}-language__primary-item`; +const LANGUAGE_CONTROL = `button.${PREFIX}-language__link`; +const LANGUAGE_LINKS = `${LANGUAGE} a`; +let languageSelector; +let languageActive; +const onLanguageClose = () => languageSelector.toggleLanguage.call(languageSelector, false); +const hideActiveLanguageDropdown = () => { + if (!languageActive) { + return; + } + toggle(languageActive, false); + languageActive = null; +}; +const focusLanguageButton = event => { + const parentLanguageItem = event.target.closest(LANGUAGE_PRIMARY_ITEM); + if (!event.target.matches(LANGUAGE_CONTROL)) { + parentLanguageItem.querySelector(LANGUAGE_CONTROL).focus(); + } +}; +const handleEscape = event => { + hideActiveLanguageDropdown(); + focusLanguageButton(event); +}; +languageSelector = behavior({ + [CLICK]: { + [LANGUAGE_CONTROL]() { + if (languageActive !== this) { + hideActiveLanguageDropdown(); + } + if (languageActive === this) { + hideActiveLanguageDropdown(); + return false; + } + if (!languageActive) { + languageActive = this; + toggle(languageActive, true); + } + return false; + }, + [BODY]: hideActiveLanguageDropdown, + [LANGUAGE_LINKS]() { + const acc = this.closest(accordion.ACCORDION); + if (acc) { + accordion.getButtons(acc).forEach(btn => accordion.hide(btn)); + } + } + }, + keydown: { + [LANGUAGE_PRIMARY]: keymap({ + Escape: handleEscape + }) + }, + focusout: { + [LANGUAGE_PRIMARY](event) { + const language = event.target.closest(LANGUAGE_PRIMARY); + if (!language.contains(event.relatedTarget)) { + hideActiveLanguageDropdown(); + } + } + } +}, { + init(root) { + const trapContainer = root.matches(LANGUAGE_SUB) ? root : root.querySelector(LANGUAGE_SUB); + if (trapContainer) { + languageSelector.focusTrap = FocusTrap(trapContainer, { + Escape: onLanguageClose + }); + } + }, + teardown() { + languageActive = false; + }, + focusTrap: null +}); +module.exports = languageSelector; + +},{"../../usa-accordion/src/index":14,"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/events":36,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/focus-trap":42,"../../uswds-core/src/js/utils/toggle":51,"receptor/keymap":10}],27:[function(require,module,exports){ +"use strict"; + +const selectOrMatches = require("../../uswds-core/src/js/utils/select-or-matches"); +const FocusTrap = require("../../uswds-core/src/js/utils/focus-trap"); +const ScrollBarWidth = require("../../uswds-core/src/js/utils/scrollbar-width"); +const behavior = require("../../uswds-core/src/js/utils/behavior"); +const { + prefix: PREFIX +} = require("../../uswds-core/src/js/config"); +const MODAL_CLASSNAME = `${PREFIX}-modal`; +const OVERLAY_CLASSNAME = `${MODAL_CLASSNAME}-overlay`; +const WRAPPER_CLASSNAME = `${MODAL_CLASSNAME}-wrapper`; +const OPENER_ATTRIBUTE = "data-open-modal"; +const CLOSER_ATTRIBUTE = "data-close-modal"; +const FORCE_ACTION_ATTRIBUTE = "data-force-action"; +const NON_MODAL_HIDDEN_ATTRIBUTE = `data-modal-hidden`; +const MODAL = `.${MODAL_CLASSNAME}`; +const INITIAL_FOCUS = `.${WRAPPER_CLASSNAME} *[data-focus]`; +const CLOSE_BUTTON = `${WRAPPER_CLASSNAME} *[${CLOSER_ATTRIBUTE}]`; +const OPENERS = `*[${OPENER_ATTRIBUTE}][aria-controls]`; +const CLOSERS = `${CLOSE_BUTTON}, .${OVERLAY_CLASSNAME}:not([${FORCE_ACTION_ATTRIBUTE}])`; +const NON_MODALS = `body > *:not(.${WRAPPER_CLASSNAME}):not([aria-hidden])`; +const NON_MODALS_HIDDEN = `[${NON_MODAL_HIDDEN_ATTRIBUTE}]`; +const ACTIVE_CLASS = "usa-js-modal--active"; +const PREVENT_CLICK_CLASS = "usa-js-no-click"; +const VISIBLE_CLASS = "is-visible"; +const HIDDEN_CLASS = "is-hidden"; +let modal; +let INITIAL_BODY_PADDING; +let TEMPORARY_BODY_PADDING; +const isActive = () => document.body.classList.contains(ACTIVE_CLASS); +const SCROLLBAR_WIDTH = ScrollBarWidth(); + +/** + * Closes modal when bound to a button and pressed. + */ +const onMenuClose = () => { + modal.toggleModal.call(modal, false); +}; + +/** + * Set the value for temporary body padding that will be applied when the modal is open. + * Value is created by checking for initial body padding and adding the width of the scrollbar. + */ +const setTemporaryBodyPadding = () => { + INITIAL_BODY_PADDING = window.getComputedStyle(document.body).getPropertyValue("padding-right"); + TEMPORARY_BODY_PADDING = `${parseInt(INITIAL_BODY_PADDING.replace(/px/, ""), 10) + parseInt(SCROLLBAR_WIDTH.replace(/px/, ""), 10)}px`; +}; + +/** + * Toggle the visibility of a modal window + * + * @param {KeyboardEvent} event the keydown event. + * @returns {boolean} safeActive if mobile is open. + */ +function toggleModal(event) { + let originalOpener; + let clickedElement = event.target; + const { + body + } = document; + const safeActive = !isActive(); + const modalId = clickedElement ? clickedElement.getAttribute("aria-controls") : document.querySelector(`.${WRAPPER_CLASSNAME}.${VISIBLE_CLASS}`); + const targetModal = safeActive ? document.getElementById(modalId) : document.querySelector(`.${WRAPPER_CLASSNAME}.${VISIBLE_CLASS}`); + + // if there is no modal we return early + if (!targetModal) { + return false; + } + const openFocusEl = targetModal.querySelector(INITIAL_FOCUS) ? targetModal.querySelector(INITIAL_FOCUS) : targetModal.querySelector(`.${MODAL_CLASSNAME}`); + const returnFocus = document.getElementById(targetModal.getAttribute("data-opener")); + const menuButton = body.querySelector(OPENERS); + const 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-${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(`.${MODAL_CLASSNAME}`)) { + if (clickedElement.hasAttribute(CLOSER_ATTRIBUTE) || clickedElement.closest(`[${CLOSER_ATTRIBUTE}]`)) { + // do nothing. move on. + } else { + return false; + } + } + } + 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); + } + + // Temporarily increase body padding to include the width of the scrollbar. + // This accounts for the content shift when the scrollbar is removed on modal open. + if (body.style.paddingRight === TEMPORARY_BODY_PADDING) { + body.style.removeProperty("padding-right"); + } else { + body.style.paddingRight = TEMPORARY_BODY_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 + document.querySelectorAll(NON_MODALS).forEach(nonModal => { + nonModal.setAttribute("aria-hidden", "true"); + nonModal.setAttribute(NON_MODAL_HIDDEN_ATTRIBUTE, ""); + }); + } else if (!safeActive && menuButton && returnFocus) { + // The modal window is closed. + // Non-modals now accesible to screen reader + document.querySelectorAll(NON_MODALS_HIDDEN).forEach(nonModal => { + nonModal.removeAttribute("aria-hidden"); + nonModal.removeAttribute(NON_MODAL_HIDDEN_ATTRIBUTE); + }); + + // Focus is returned to the opener + returnFocus.focus(); + modal.focusTrap.update(safeActive); + } + return safeActive; +} + +/** + * Creates a placeholder with data attributes for cleanup function. + * The cleanup function uses this placeholder to easily restore the original Modal HTML on teardown. + * + * @param {HTMLDivElement} baseComponent - Modal HTML from the DOM. + * @returns {HTMLDivElement} Placeholder used for cleanup function. + */ +const createPlaceHolder = baseComponent => { + const modalID = baseComponent.getAttribute("id"); + const originalLocationPlaceHolder = document.createElement("div"); + const modalAttributes = Array.from(baseComponent.attributes); + setTemporaryBodyPadding(); + originalLocationPlaceHolder.setAttribute(`data-placeholder-for`, modalID); + originalLocationPlaceHolder.style.display = "none"; + originalLocationPlaceHolder.setAttribute("aria-hidden", "true"); + modalAttributes.forEach(attribute => { + originalLocationPlaceHolder.setAttribute(`data-original-${attribute.name}`, attribute.value); + }); + return originalLocationPlaceHolder; +}; + +/** + * Moves necessary attributes from Modal HTML to wrapper element. + * + * @param {HTMLDivElement} baseComponent - Modal HTML in the DOM. + * @param {HTMLDivElement} modalContentWrapper - Modal component wrapper element. + * @returns Modal wrapper with correct attributes. + */ +const setModalAttributes = (baseComponent, modalContentWrapper) => { + const modalID = baseComponent.getAttribute("id"); + const ariaLabelledBy = baseComponent.getAttribute("aria-labelledby"); + const ariaDescribedBy = baseComponent.getAttribute("aria-describedby"); + const forceUserAction = baseComponent.hasAttribute(FORCE_ACTION_ATTRIBUTE); + if (!ariaLabelledBy) throw new Error(`${modalID} is missing aria-labelledby attribute`); + if (!ariaDescribedBy) throw new Error(`${modalID} is missing aria-desribedby attribute`); + + // Set attributes + modalContentWrapper.setAttribute("role", "dialog"); + modalContentWrapper.setAttribute("id", modalID); + modalContentWrapper.setAttribute("aria-labelledby", ariaLabelledBy); + modalContentWrapper.setAttribute("aria-describedby", ariaDescribedBy); + if (forceUserAction) { + modalContentWrapper.setAttribute(FORCE_ACTION_ATTRIBUTE, forceUserAction); + } + + // Add aria-controls + const modalClosers = modalContentWrapper.querySelectorAll(CLOSERS); + modalClosers.forEach(el => { + el.setAttribute("aria-controls", modalID); + }); + + // Update the base element HTML + baseComponent.removeAttribute("id"); + baseComponent.removeAttribute("aria-labelledby"); + baseComponent.removeAttribute("aria-describedby"); + baseComponent.setAttribute("tabindex", "-1"); + return modalContentWrapper; +}; + +/** + * Creates a hidden modal content wrapper. + * Rebuilds the original Modal HTML in the new wrapper and adds a page overlay. + * Then moves original Modal HTML attributes to the new wrapper. + * + * @param {HTMLDivElement} baseComponent - Original Modal HTML in the DOM. + * @returns Modal component - Modal wrapper w/ nested Overlay and Modal Content. + */ +const rebuildModal = baseComponent => { + const modalContent = baseComponent; + const modalContentWrapper = document.createElement("div"); + const overlayDiv = document.createElement("div"); + + // Add classes + modalContentWrapper.classList.add(HIDDEN_CLASS, WRAPPER_CLASSNAME); + overlayDiv.classList.add(OVERLAY_CLASSNAME); + + // Rebuild the modal element + modalContentWrapper.append(overlayDiv); + overlayDiv.append(modalContent); + + // Add attributes + setModalAttributes(modalContent, modalContentWrapper); + return modalContentWrapper; +}; + +/** + * Builds modal window from base HTML and appends to the end of the DOM. + * + * @param {HTMLDivElement} baseComponent - The modal div element in the DOM. + */ +const setUpModal = baseComponent => { + const modalID = baseComponent.getAttribute("id"); + if (!modalID) { + throw new Error(`Modal markup is missing ID`); + } + + // Create placeholder where modal is for cleanup + const originalLocationPlaceHolder = createPlaceHolder(baseComponent); + baseComponent.after(originalLocationPlaceHolder); + + // Build modal component + const modalComponent = rebuildModal(baseComponent); + + // 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(modalComponent); +}; + +/** + * Removes dynamically created Modal and Wrapper elements and restores original Modal HTML. + * + * @param {HTMLDivElement} baseComponent - The modal div element in the DOM. + */ +const cleanUpModal = baseComponent => { + const modalContent = baseComponent; + const modalContentWrapper = modalContent.parentElement.parentElement; + const modalID = modalContentWrapper.getAttribute("id"); + + // if there is no modalID, return early + if (!modalID) { + return; + } + const originalLocationPlaceHolder = document.querySelector(`[data-placeholder-for="${modalID}"]`); + if (originalLocationPlaceHolder) { + const modalAttributes = Array.from(originalLocationPlaceHolder.attributes); + modalAttributes.forEach(attribute => { + if (attribute.name.startsWith("data-original-")) { + // data-original- is 14 long + modalContent.setAttribute(attribute.name.substr(14), attribute.value); + } + }); + originalLocationPlaceHolder.after(modalContent); + originalLocationPlaceHolder.parentElement.removeChild(originalLocationPlaceHolder); + } + modalContentWrapper.parentElement.removeChild(modalContentWrapper); +}; +modal = behavior({}, { + init(root) { + selectOrMatches(MODAL, root).forEach(modalWindow => { + const modalId = modalWindow.id; + setUpModal(modalWindow); + + // Query all openers and closers including the overlay + selectOrMatches(`[aria-controls="${modalId}"]`, document).forEach(modalTrigger => { + // If modalTrigger is an anchor... + if (modalTrigger.nodeName === "A") { + // Turn anchor links into buttons for screen readers + modalTrigger.setAttribute("role", "button"); + + // Prevent modal triggers from acting like links + modalTrigger.addEventListener("click", 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. + // modalTrigger.setAttribute("aria-haspopup", "dialog"); + + modalTrigger.addEventListener("click", toggleModal); + }); + }); + }, + teardown(root) { + selectOrMatches(MODAL, root).forEach(modalWindow => { + const modalId = modalWindow.id; + cleanUpModal(modalWindow); + selectOrMatches(`[aria-controls="${modalId}"]`, document).forEach(modalTrigger => modalTrigger.removeEventListener("click", toggleModal)); + }); + }, + focusTrap: null, + toggleModal +}); +module.exports = modal; + +},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/focus-trap":42,"../../uswds-core/src/js/utils/scrollbar-width":46,"../../uswds-core/src/js/utils/select-or-matches":47}],28:[function(require,module,exports){ +"use strict"; + +const selectOrMatches = require("../../uswds-core/src/js/utils/select-or-matches"); +const behavior = require("../../uswds-core/src/js/utils/behavior"); +const { + prefix: PREFIX +} = require("../../uswds-core/src/js/config"); +const RANGE_CLASSNAME = `${PREFIX}-range`; +const RANGE = `.${RANGE_CLASSNAME}`; + +/** + * Update range callout for screen readers using the optional data attributes. + * + * Get optional data attributes, construct and appends aria-valuetext attribute. + * + * @example + * + * <input id="usa-range" class="usa-range" type="range" min="0" max="100" step="10" value="20" data-text-unit="degrees"> + * + * Callout returns "20 degrees of 100." + * + * <input id="usa-range" class="usa-range" type="range" min="0" max="100" step="10" value="20" data-text-preposition="de"> + * + * Callout returns "20 de 100." + * + * @param {HTMLInputElement} targetRange - The range slider input element + */ +const updateCallout = targetRange => { + const rangeSlider = targetRange; + const defaultPrep = "of"; + const optionalPrep = rangeSlider.dataset.textPreposition; + const prep = optionalPrep || defaultPrep; + const unit = rangeSlider.dataset.textUnit; + const val = rangeSlider.value; + // Note: 100 is the max attribute's native default value on range inputs + // Reference: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/range#validation + const max = rangeSlider.getAttribute("max") || 100; + let callout; + if (unit) { + callout = `${val} ${unit} ${prep} ${max}`; + } else { + callout = `${val} ${prep} ${max}`; + } + rangeSlider.setAttribute("aria-valuetext", callout); +}; +const rangeEvents = { + change: { + [RANGE]() { + updateCallout(this); + } + } +}; +const range = behavior(rangeEvents, { + init(root) { + selectOrMatches(RANGE, root).forEach(rangeSlider => { + updateCallout(rangeSlider); + }); + }, + updateCallout +}); +module.exports = range; + +},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/select-or-matches":47}],29:[function(require,module,exports){ +"use strict"; + +const ignore = require("receptor/ignore"); +const behavior = require("../../uswds-core/src/js/utils/behavior"); +const select = require("../../uswds-core/src/js/utils/select"); +const { + CLICK +} = require("../../uswds-core/src/js/events"); +const BUTTON = ".js-search-button"; +const FORM = ".js-search-form"; +const INPUT = "[type=search]"; +const CONTEXT = "header"; // XXX + +let lastButton; +const getForm = button => { + const context = button.closest(CONTEXT); + return context ? context.querySelector(FORM) : document.querySelector(FORM); +}; +const toggleSearch = (button, active) => { + const form = getForm(button); + if (!form) { + throw new Error(`No ${FORM} found for search toggle in ${CONTEXT}!`); + } + + /* eslint-disable no-param-reassign */ + button.hidden = active; + form.hidden = !active; + /* eslint-enable */ + + if (!active) { + return; + } + const 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 + const listener = ignore(form, () => { + 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(() => { + document.body.addEventListener(CLICK, listener); + }, 0); +}; +function showSearch() { + toggleSearch(this, true); + lastButton = this; +} +function hideSearch() { + toggleSearch(this, false); + lastButton = undefined; +} +const search = behavior({ + [CLICK]: { + [BUTTON]: showSearch + } +}, { + init(target) { + select(BUTTON, target).forEach(button => { + toggleSearch(button, false); + }); + }, + teardown() { + // forget the last button clicked + lastButton = undefined; + } +}); +module.exports = search; + +},{"../../uswds-core/src/js/events":36,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/select":48,"receptor/ignore":8}],30:[function(require,module,exports){ +"use strict"; + +const once = require("receptor/once"); +const behavior = require("../../uswds-core/src/js/utils/behavior"); +const { + CLICK +} = require("../../uswds-core/src/js/events"); +const { + prefix: PREFIX +} = require("../../uswds-core/src/js/config"); +const LINK = `.${PREFIX}-skipnav[href^="#"], .${PREFIX}-footer__return-to-top [href^="#"]`; +const MAINCONTENT = "main-content"; +function setTabindex() { + // NB: we know because of the selector we're delegating to below that the + // href already begins with '#' + const id = encodeURI(this.getAttribute("href")); + const target = document.getElementById(id === "#" ? MAINCONTENT : id.slice(1)); + if (target) { + target.style.outline = "0"; + target.setAttribute("tabindex", 0); + target.focus(); + target.addEventListener("blur", once(() => { + target.setAttribute("tabindex", -1); + })); + } else { + // throw an error? + } +} +module.exports = behavior({ + [CLICK]: { + [LINK]: setTabindex + } +}); + +},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/events":36,"../../uswds-core/src/js/utils/behavior":40,"receptor/once":11}],31:[function(require,module,exports){ +"use strict"; + +const select = require("../../uswds-core/src/js/utils/select"); +const behavior = require("../../uswds-core/src/js/utils/behavior"); +const { + CLICK +} = require("../../uswds-core/src/js/events"); +const { + prefix: PREFIX +} = require("../../uswds-core/src/js/config"); +const Sanitizer = require("../../uswds-core/src/js/utils/sanitizer"); +const TABLE = `.${PREFIX}-table`; +const SORTED = "aria-sort"; +const ASCENDING = "ascending"; +const DESCENDING = "descending"; +const SORT_OVERRIDE = "data-sort-value"; +const SORT_BUTTON_CLASS = `${PREFIX}-table__header__button`; +const SORT_BUTTON = `.${SORT_BUTTON_CLASS}`; +const SORTABLE_HEADER = `th[data-sortable]`; +const ANNOUNCEMENT_REGION = `.${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<HTMLTableRowElement>} tr + * @return {boolean} + */ +const getCellValue = (tr, index) => 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} + */ +const compareFunction = (index, isAscending) => (thisRow, nextRow) => { + // get values to compare from data attribute or cell content + const value1 = getCellValue(isAscending ? thisRow : nextRow, index); + const 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<HTMLTableHeaderCellElement>} + */ +const getColumnHeaders = table => { + const headers = select(SORTABLE_HEADER, table); + return headers.filter(header => 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 + */ +const updateSortLabel = header => { + const headerName = header.innerText; + const sortedAscending = header.getAttribute(SORTED) === ASCENDING; + const isSorted = header.getAttribute(SORTED) === ASCENDING || header.getAttribute(SORTED) === DESCENDING || false; + const headerLabel = `${headerName}, sortable column, currently ${isSorted ? `${sortedAscending ? `sorted ${ASCENDING}` : `sorted ${DESCENDING}`}` : "unsorted"}`; + const headerButtonLabel = `Click to sort by ${headerName} in ${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 + */ +const 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 + */ +const sortRows = (header, isAscending) => { + header.setAttribute(SORTED, isAscending === true ? DESCENDING : ASCENDING); + updateSortLabel(header); + const 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 + const allRows = [].slice.call(tbody.querySelectorAll("tr")); + const allHeaders = [].slice.call(header.parentNode.children); + const thisHeaderIndex = allHeaders.indexOf(header); + allRows.sort(compareFunction(thisHeaderIndex, !isAscending)).forEach(tr => { + [].slice.call(tr.children).forEach(td => 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 + */ + +const updateLiveRegion = (table, sortedHeader) => { + const caption = table.querySelector("caption").innerText; + const sortedAscending = sortedHeader.getAttribute(SORTED) === ASCENDING; + const headerLabel = sortedHeader.innerText; + const liveRegion = table.nextElementSibling; + if (liveRegion && liveRegion.matches(ANNOUNCEMENT_REGION)) { + const sortAnnouncement = `The table named "${caption}" is now sorted by ${headerLabel} in ${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). + */ +const toggleSort = (header, isAscending) => { + const table = header.closest(TABLE); + let safeAscending = isAscending; + if (typeof safeAscending !== "boolean") { + safeAscending = header.getAttribute(SORTED) === ASCENDING; + } + if (!table) { + throw new Error(`${SORTABLE_HEADER} is missing outer ${TABLE}`); + } + safeAscending = sortRows(header, isAscending); + if (safeAscending) { + getColumnHeaders(table).forEach(otherHeader => { + if (otherHeader !== header) { + unsetSort(otherHeader); + } + }); + updateLiveRegion(table, header); + } +}; + +/** + ** Inserts a button with icon inside a sortable header + * @param {HTMLTableHeaderCellElement} header + */ + +const createHeaderButton = header => { + const buttonEl = document.createElement("button"); + buttonEl.setAttribute("tabindex", "0"); + buttonEl.classList.add(SORT_BUTTON_CLASS); + // ICON_SOURCE + buttonEl.innerHTML = Sanitizer.escapeHTML` + <svg class="${PREFIX}-icon" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"> + <g class="descending" fill="transparent"> + <path d="M17 17L15.59 15.59L12.9999 18.17V2H10.9999V18.17L8.41 15.58L7 17L11.9999 22L17 17Z" /> + </g> + <g class="ascending" fill="transparent"> + <path transform="rotate(180, 12, 12)" d="M17 17L15.59 15.59L12.9999 18.17V2H10.9999V18.17L8.41 15.58L7 17L11.9999 22L17 17Z" /> + </g> + <g class="unsorted" fill="transparent"> + <polygon points="15.17 15 13 17.17 13 6.83 15.17 9 16.58 7.59 12 3 7.41 7.59 8.83 9 11 6.83 11 17.17 8.83 15 7.42 16.41 12 21 16.59 16.41 15.17 15"/> + </g> + </svg> + `; + header.appendChild(buttonEl); + updateSortLabel(header); +}; +const table = behavior({ + [CLICK]: { + [SORT_BUTTON](event) { + event.preventDefault(); + toggleSort(event.target.closest(SORTABLE_HEADER), event.target.closest(SORTABLE_HEADER).getAttribute(SORTED) === ASCENDING); + } + } +}, { + init(root) { + const sortableHeaders = select(SORTABLE_HEADER, root); + sortableHeaders.forEach(header => createHeaderButton(header)); + const firstSorted = sortableHeaders.filter(header => header.getAttribute(SORTED) === ASCENDING || header.getAttribute(SORTED) === DESCENDING)[0]; + if (typeof firstSorted === "undefined") { + // no sortable headers found + return; + } + const sortDir = firstSorted.getAttribute(SORTED); + if (sortDir === ASCENDING) { + toggleSort(firstSorted, true); + } else if (sortDir === DESCENDING) { + toggleSort(firstSorted, false); + } + }, + TABLE, + SORTABLE_HEADER, + SORT_BUTTON +}); +module.exports = table; + +},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/events":36,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/sanitizer":45,"../../uswds-core/src/js/utils/select":48}],32:[function(require,module,exports){ +"use strict"; + +const behavior = require("../../uswds-core/src/js/utils/behavior"); +const selectOrMatches = require("../../uswds-core/src/js/utils/select-or-matches"); +const { + prefix: PREFIX +} = require("../../uswds-core/src/js/config"); +const { + COMBO_BOX_CLASS, + enhanceComboBox +} = require("../../usa-combo-box/src/index"); +const TIME_PICKER_CLASS = `${PREFIX}-time-picker`; +const TIME_PICKER = `.${TIME_PICKER_CLASS}`; +const MAX_TIME = 60 * 24 - 1; +const MIN_TIME = 0; +const DEFAULT_STEP = 30; +const MIN_STEP = 1; +const 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 + */ +const parseTimeString = timeStr => { + let minutes; + if (timeStr) { + const [hours, mins] = timeStr.split(":").map(str => { + let value; + const parsed = parseInt(str, 10); + if (!Number.isNaN(parsed)) value = parsed; + return value; + }); + 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 + */ +const transformTimePicker = el => { + const timePickerEl = el.closest(TIME_PICKER); + const initialInputEl = timePickerEl.querySelector(`input`); + if (!initialInputEl) { + throw new Error(`${TIME_PICKER} is missing inner input`); + } + const selectEl = document.createElement("select"); + ["id", "name", "required", "aria-label", "aria-labelledby", "disabled", "aria-disabled"].forEach(name => { + if (initialInputEl.hasAttribute(name)) { + const value = initialInputEl.getAttribute(name); + selectEl.setAttribute(name, value); + initialInputEl.removeAttribute(name); + } + }); + const padZeros = (value, length) => `0000${value}`.slice(-length); + const getTimeContext = minutes => { + const minute = minutes % 60; + const hour24 = Math.floor(minutes / 60); + const hour12 = hour24 % 12 || 12; + const ampm = hour24 < 12 ? "am" : "pm"; + return { + minute, + hour24, + hour12, + ampm + }; + }; + const minTime = Math.max(MIN_TIME, parseTimeString(timePickerEl.dataset.minTime) || MIN_TIME); + const maxTime = Math.min(MAX_TIME, parseTimeString(timePickerEl.dataset.maxTime) || MAX_TIME); + const step = Math.floor(Math.max(MIN_STEP, timePickerEl.dataset.step || DEFAULT_STEP)); + let defaultValue; + for (let time = minTime; time <= maxTime; time += step) { + const { + minute, + hour24, + hour12, + ampm + } = getTimeContext(time); + const option = document.createElement("option"); + option.value = `${padZeros(hour24, 2)}:${padZeros(minute, 2)}`; + option.text = `${hour12}:${padZeros(minute, 2)}${ampm}`; + if (option.text === initialInputEl.value) { + defaultValue = option.value; + } + selectEl.appendChild(option); + } + timePickerEl.classList.add(COMBO_BOX_CLASS); + + // combo box properties + Object.keys(FILTER_DATASET).forEach(key => { + timePickerEl.dataset[key] = FILTER_DATASET[key]; + }); + timePickerEl.dataset.disableFiltering = "true"; + timePickerEl.dataset.defaultValue = defaultValue; + timePickerEl.appendChild(selectEl); + initialInputEl.remove(); +}; +const timePicker = behavior({}, { + init(root) { + selectOrMatches(TIME_PICKER, root).forEach(timePickerEl => { + transformTimePicker(timePickerEl); + enhanceComboBox(timePickerEl); + }); + }, + FILTER_DATASET +}); +module.exports = timePicker; + +},{"../../usa-combo-box/src/index":18,"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/select-or-matches":47}],33:[function(require,module,exports){ +"use strict"; + +// Tooltips +const keymap = require("receptor/keymap"); +const selectOrMatches = require("../../uswds-core/src/js/utils/select-or-matches"); +const behavior = require("../../uswds-core/src/js/utils/behavior"); +const { + prefix: PREFIX +} = require("../../uswds-core/src/js/config"); +const isElementInViewport = require("../../uswds-core/src/js/utils/is-in-viewport"); +const BODY = "body"; +const TOOLTIP = `.${PREFIX}-tooltip`; +const TOOLTIP_TRIGGER = `.${PREFIX}-tooltip__trigger`; +const TOOLTIP_TRIGGER_CLASS = `${PREFIX}-tooltip__trigger`; +const TOOLTIP_CLASS = `${PREFIX}-tooltip`; +const TOOLTIP_BODY_CLASS = `${PREFIX}-tooltip__body`; +const SET_CLASS = "is-set"; +const VISIBLE_CLASS = "is-visible"; +const TRIANGLE_SIZE = 5; +const ADJUST_WIDTH_CLASS = `${PREFIX}-tooltip__body--wrap`; + +/** + * + * @param {DOMElement} trigger - The tooltip trigger + * @returns {object} Elements for initialized tooltip; includes trigger, wrapper, and body + */ +const getTooltipElements = trigger => { + const wrapper = trigger.parentNode; + const body = wrapper.querySelector(`.${TOOLTIP_BODY_CLASS}`); + return { + trigger, + wrapper, + body + }; +}; + +/** + * Shows the tooltip + * @param {HTMLElement} tooltipTrigger - the element that initializes the tooltip + */ +const 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" + */ + const setPositionClass = setPos => { + tooltipBody.classList.remove(`${TOOLTIP_BODY_CLASS}--top`); + tooltipBody.classList.remove(`${TOOLTIP_BODY_CLASS}--bottom`); + tooltipBody.classList.remove(`${TOOLTIP_BODY_CLASS}--right`); + tooltipBody.classList.remove(`${TOOLTIP_BODY_CLASS}--left`); + tooltipBody.classList.add(`${TOOLTIP_BODY_CLASS}--${setPos}`); + }; + + /** + * Removes old positioning styles. This allows + * re-positioning to change without inheriting other + * dynamic styles + * + * @param {HTMLElement} e - this is the tooltip body + */ + const 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 + */ + + const offsetMargin = (target, propertyValue) => 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 + */ + const calculateMarginOffset = (marginPosition, tooltipBodyOffset, trigger) => { + const offset = offsetMargin(trigger, `margin-${marginPosition}`) > 0 ? tooltipBodyOffset - offsetMargin(trigger, `margin-${marginPosition}`) : tooltipBodyOffset; + return offset; + }; + + /** + * Positions tooltip at the top + * @param {HTMLElement} e - this is the tooltip body + */ + const positionTop = e => { + resetPositionStyles(e); // ensures we start from the same point + // get details on the elements object with + + const topMargin = calculateMarginOffset("top", e.offsetHeight, tooltipTrigger); + const leftMargin = calculateMarginOffset("left", e.offsetWidth, tooltipTrigger); + setPositionClass("top"); + e.style.left = `50%`; // center the element + e.style.top = `-${TRIANGLE_SIZE}px`; // consider the pseudo element + // apply our margins based on the offset + e.style.margin = `-${topMargin}px 0 0 -${leftMargin / 2}px`; + }; + + /** + * Positions tooltip at the bottom + * @param {HTMLElement} e - this is the tooltip body + */ + const positionBottom = e => { + resetPositionStyles(e); + const leftMargin = calculateMarginOffset("left", e.offsetWidth, tooltipTrigger); + setPositionClass("bottom"); + e.style.left = `50%`; + e.style.margin = `${TRIANGLE_SIZE}px 0 0 -${leftMargin / 2}px`; + }; + + /** + * Positions tooltip at the right + * @param {HTMLElement} e - this is the tooltip body + */ + const positionRight = e => { + resetPositionStyles(e); + const topMargin = calculateMarginOffset("top", e.offsetHeight, tooltipTrigger); + setPositionClass("right"); + e.style.top = `50%`; + e.style.left = `${tooltipTrigger.offsetLeft + tooltipTrigger.offsetWidth + TRIANGLE_SIZE}px`; + e.style.margin = `-${topMargin / 2}px 0 0 0`; + }; + + /** + * Positions tooltip at the right + * @param {HTMLElement} e - this is the tooltip body + */ + const positionLeft = e => { + resetPositionStyles(e); + const topMargin = calculateMarginOffset("top", e.offsetHeight, tooltipTrigger); + + // we have to check for some utility margins + const leftMargin = calculateMarginOffset("left", tooltipTrigger.offsetLeft > e.offsetWidth ? tooltipTrigger.offsetLeft - e.offsetWidth : e.offsetWidth, tooltipTrigger); + setPositionClass("left"); + e.style.top = `50%`; + e.style.left = `-${TRIANGLE_SIZE}px`; + e.style.margin = `-${topMargin / 2}px 0 0 ${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) + */ + + const maxAttempts = 2; + function findBestPosition(element, attempt = 1) { + // create array of optional positions + const positions = [positionTop, positionBottom, positionRight, positionLeft]; + let hasVisiblePosition = false; + + // we take a recursive approach + function tryPositions(i) { + if (i < positions.length) { + const pos = positions[i]; + pos(element); + if (!isElementInViewport(element)) { + // eslint-disable-next-line no-param-reassign + tryPositions(i += 1); + } else { + hasVisiblePosition = true; + } + } + } + tryPositions(0); + // if we can't find a position we compress it and try again + if (!hasVisiblePosition) { + element.classList.add(ADJUST_WIDTH_CLASS); + if (attempt <= maxAttempts) { + // eslint-disable-next-line no-param-reassign + findBestPosition(element, attempt += 1); + } + } + } + switch (position) { + case "top": + positionTop(tooltipBody); + if (!isElementInViewport(tooltipBody)) { + findBestPosition(tooltipBody); + } + break; + case "bottom": + positionBottom(tooltipBody); + if (!isElementInViewport(tooltipBody)) { + findBestPosition(tooltipBody); + } + break; + case "right": + positionRight(tooltipBody); + if (!isElementInViewport(tooltipBody)) { + findBestPosition(tooltipBody); + } + break; + case "left": + positionLeft(tooltipBody); + if (!isElementInViewport(tooltipBody)) { + findBestPosition(tooltipBody); + } + break; + default: + // skip default case + break; + } + + /** + * Actually show the tooltip. The VISIBLE_CLASS + * will change the opacity to 1 + */ + setTimeout(() => { + 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 manipulation. + * @param {HTMLElement} tooltipBody - The body of the tooltip + */ +const 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 + */ +const setUpAttributes = tooltipTrigger => { + const tooltipID = `tooltip-${Math.floor(Math.random() * 900000) + 100000}`; + const tooltipContent = tooltipTrigger.getAttribute("title"); + const wrapper = document.createElement("span"); + const tooltipBody = document.createElement("span"); + const additionalClasses = tooltipTrigger.getAttribute("data-classes"); + let position = tooltipTrigger.getAttribute("data-position"); + + // Apply default position if not set as attribute + if (!position) { + position = "top"; + tooltipTrigger.setAttribute("data-position", position); + } + + // Set up tooltip attributes + tooltipTrigger.setAttribute("aria-describedby", tooltipID); + tooltipTrigger.setAttribute("tabindex", "0"); + tooltipTrigger.removeAttribute("title"); + tooltipTrigger.classList.remove(TOOLTIP_CLASS); + tooltipTrigger.classList.add(TOOLTIP_TRIGGER_CLASS); + + // insert wrapper before el in the DOM tree + tooltipTrigger.parentNode.insertBefore(wrapper, tooltipTrigger); + + // set up the wrapper + wrapper.appendChild(tooltipTrigger); + wrapper.classList.add(TOOLTIP_CLASS); + wrapper.appendChild(tooltipBody); + + // Apply additional class names to wrapper element + if (additionalClasses) { + const classesArray = additionalClasses.split(" "); + classesArray.forEach(classname => wrapper.classList.add(classname)); + } + + // set up the tooltip body + 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 + tooltipBody.textContent = tooltipContent; + return { + tooltipBody, + position, + tooltipContent, + wrapper + }; +}; + +/** + * Hide all active tooltips when escape key is pressed. + */ + +const handleEscape = () => { + const activeTooltips = selectOrMatches(`.${TOOLTIP_BODY_CLASS}.${SET_CLASS}`); + if (!activeTooltips) { + return; + } + activeTooltips.forEach(activeTooltip => hideToolTip(activeTooltip)); +}; + +// Setup our function to run on various events +const tooltip = behavior({ + "mouseover focusin": { + [TOOLTIP](e) { + const trigger = e.target; + const elementType = trigger.nodeName; + + // Initialize tooltip if it hasn't already + if (elementType === "BUTTON" && trigger.hasAttribute("title")) { + setUpAttributes(trigger); + } + }, + [TOOLTIP_TRIGGER](e) { + const { + trigger, + body + } = getTooltipElements(e.target); + showToolTip(body, trigger, trigger.dataset.position); + } + }, + focusout: { + [TOOLTIP_TRIGGER](e) { + const { + body + } = getTooltipElements(e.target); + hideToolTip(body); + } + }, + keydown: { + [BODY]: keymap({ + Escape: handleEscape + }) + } +}, { + init(root) { + selectOrMatches(TOOLTIP, root).forEach(tooltipTrigger => { + setUpAttributes(tooltipTrigger); + const { + body, + wrapper + } = getTooltipElements(tooltipTrigger); + wrapper.addEventListener("mouseleave", () => hideToolTip(body)); + }); + }, + teardown(root) { + selectOrMatches(TOOLTIP, root).forEach(tooltipWrapper => { + tooltipWrapper.removeEventListener("mouseleave", hideToolTip); + }); + }, + setup: setUpAttributes, + getTooltipElements, + show: showToolTip, + hide: hideToolTip +}); +module.exports = tooltip; + +},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/is-in-viewport":43,"../../uswds-core/src/js/utils/select-or-matches":47,"receptor/keymap":10}],34:[function(require,module,exports){ +"use strict"; + +const behavior = require("../../uswds-core/src/js/utils/behavior"); +const validate = require("../../uswds-core/src/js/utils/validate-input"); +const { + prefix: PREFIX +} = require("../../uswds-core/src/js/config"); +const selectOrMatches = require("../../uswds-core/src/js/utils/select-or-matches"); +const VALIDATE_INPUT = "input[data-validation-element],textarea[data-validation-element]"; +const CHECKLIST_ITEM = `.${PREFIX}-checklist__item`; + +// Trigger validation on input change +const handleChange = el => validate(el); + +// Create container to hold aria readout +const createStatusElement = input => { + const validationContainer = input.parentNode; + const inputID = input.getAttribute("id"); + const statusSummaryID = `${inputID}-sr-summary`; + input.setAttribute("aria-describedby", statusSummaryID); + const statusSummaryContainer = document.createElement("span"); + statusSummaryContainer.setAttribute("data-validation-status", ""); + statusSummaryContainer.classList.add("usa-sr-only"); + statusSummaryContainer.setAttribute("aria-live", "polite"); + statusSummaryContainer.setAttribute("aria-atomic", true); + statusSummaryContainer.setAttribute("id", statusSummaryID); + validationContainer.append(statusSummaryContainer); +}; + +// Set up checklist items with initial aria-label (incomplete) values +const createInitialStatus = input => { + const validationContainer = input.parentNode; + const checklistItems = validationContainer.querySelectorAll(CHECKLIST_ITEM); + const validationElement = input.getAttribute("data-validation-element"); + input.setAttribute("aria-controls", validationElement); + checklistItems.forEach(listItem => { + let currentStatus = "status incomplete"; + if (input.hasAttribute("data-validation-incomplete")) { + currentStatus = input.getAttribute("data-validation-incomplete"); + } + const itemStatus = `${listItem.textContent} ${currentStatus} `; + listItem.setAttribute("aria-label", itemStatus); + }); +}; +const enhanceValidation = input => { + createStatusElement(input); + createInitialStatus(input); +}; +const validator = behavior({ + "input change": { + [VALIDATE_INPUT](event) { + handleChange(event.target); + } + } +}, { + init(root) { + selectOrMatches(VALIDATE_INPUT, root).forEach(input => enhanceValidation(input)); + } +}); +module.exports = validator; + +},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/select-or-matches":47,"../../uswds-core/src/js/utils/validate-input":52}],35:[function(require,module,exports){ +"use strict"; + +module.exports = { + prefix: "usa" +}; + +},{}],36:[function(require,module,exports){ +"use strict"; + +module.exports = { + // This used to be conditionally dependent on whether the + // browser supported touch events; if it did, `CLICK` was set to + // `touchstart`. However, this had downsides: + // + // * It pre-empted mobile browsers' default behavior of detecting + // whether a touch turned into a scroll, thereby preventing + // users from using some of our components as scroll surfaces. + // + // * Some devices, such as the Microsoft Surface Pro, support *both* + // 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" +}; + +},{}],37:[function(require,module,exports){ +"use strict"; + +const accordion = require("../../../usa-accordion/src/index"); +const banner = require("../../../usa-banner/src/index"); +const button = require("../../../usa-button/src/index"); +const characterCount = require("../../../usa-character-count/src/index"); +const comboBox = require("../../../usa-combo-box/src/index"); +const datePicker = require("../../../usa-date-picker/src/index"); +const dateRangePicker = require("../../../usa-date-range-picker/src/index"); +const fileInput = require("../../../usa-file-input/src/index"); +const footer = require("../../../usa-footer/src/index"); +const inPageNavigation = require("../../../usa-in-page-navigation/src/index"); +const inputMask = require("../../../usa-input-mask/src/index"); +const languageSelector = require("../../../usa-language-selector/src/index"); +const modal = require("../../../usa-modal/src/index"); +const navigation = require("../../../usa-header/src/index"); +const password = require("../../../_usa-password/src/index"); +const range = require("../../../usa-range/src/index"); +const search = require("../../../usa-search/src/index"); +const skipnav = require("../../../usa-skipnav/src/index"); +const table = require("../../../usa-table/src/index"); +const timePicker = require("../../../usa-time-picker/src/index"); +const tooltip = require("../../../usa-tooltip/src/index"); +const validator = require("../../../usa-validation/src/index"); +module.exports = { + accordion, + banner, + button, + characterCount, + comboBox, + datePicker, + dateRangePicker, + fileInput, + footer, + inPageNavigation, + inputMask, + languageSelector, + modal, + navigation, + password, + range, + search, + skipnav, + table, + timePicker, + tooltip, + validator +}; + +},{"../../../_usa-password/src/index":13,"../../../usa-accordion/src/index":14,"../../../usa-banner/src/index":15,"../../../usa-button/src/index":16,"../../../usa-character-count/src/index":17,"../../../usa-combo-box/src/index":18,"../../../usa-date-picker/src/index":19,"../../../usa-date-range-picker/src/index":20,"../../../usa-file-input/src/index":21,"../../../usa-footer/src/index":22,"../../../usa-header/src/index":23,"../../../usa-in-page-navigation/src/index":24,"../../../usa-input-mask/src/index":25,"../../../usa-language-selector/src/index":26,"../../../usa-modal/src/index":27,"../../../usa-range/src/index":28,"../../../usa-search/src/index":29,"../../../usa-skipnav/src/index":30,"../../../usa-table/src/index":31,"../../../usa-time-picker/src/index":32,"../../../usa-tooltip/src/index":33,"../../../usa-validation/src/index":34}],38:[function(require,module,exports){ +"use strict"; + +window.uswdsPresent = true; // GLOBAL variable to indicate that the uswds.js has loaded in the DOM. + +const uswds = require("./config"); +const components = require("./index"); +uswds.components = components; +const initComponents = () => { + const target = document.body; + Object.keys(components).forEach(key => { + const behavior = components[key]; + behavior.on(target); + }); +}; +if (document.readyState === "loading") { + document.addEventListener("DOMContentLoaded", initComponents, { + once: true + }); +} else { + initComponents(); +} +exports.default = uswds; +exports.initComponents = initComponents; + +},{"./config":35,"./index":37}],39:[function(require,module,exports){ +"use strict"; + +module.exports = (htmlDocument = document) => htmlDocument.activeElement; + +},{}],40:[function(require,module,exports){ +"use strict"; + +const Behavior = require("receptor/behavior"); + +/** + * @name sequence + * @param {...Function} seq an array of functions + * @return { closure } callHooks + */ +// We use a named function here because we want it to inherit its lexical scope +// from the behavior props object, not from the module +const sequence = (...seq) => function callHooks(target = document.body) { + seq.forEach(method => { + if (typeof this[method] === "function") { + this[method].call(this, target); + } + }); +}; + +/** + * @name behavior + * @param {object} events + * @param {object?} props + * @return {receptor.behavior} + */ +module.exports = (events, props) => Behavior(events, { + on: sequence("init", "add"), + off: sequence("teardown", "remove"), + ...props +}); + +},{"receptor/behavior":4}],41:[function(require,module,exports){ +"use strict"; + +/** + * Call a function every X amount of milliseconds. + * + * @param {Function} callback - A callback function to be debounced + * @param {number} delay - Milliseconds to wait before calling function + * @returns {Function} A debounced function + * @example const updateStatus = debounce((string) => console.log(string), 2000) + */ + +module.exports = function debounce(callback, delay = 500) { + let timer = null; + return (...args) => { + window.clearTimeout(timer); + timer = window.setTimeout(() => { + callback.apply(this, args); + }, delay); + }; +}; + +},{}],42:[function(require,module,exports){ +"use strict"; + +const { + keymap +} = require("receptor"); +const behavior = require("./behavior"); +const select = require("./select"); +const activeElement = require("./active-element"); +const FOCUSABLE = 'a[href], area[href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), button:not([disabled]), iframe, object, embed, [tabindex="0"], [contenteditable]'; +const tabHandler = context => { + const focusableElements = select(FOCUSABLE, context); + const firstTabStop = focusableElements[0]; + const lastTabStop = focusableElements[focusableElements.length - 1]; + + // Special rules for when the user is tabbing forward from the last focusable element, + // or when tabbing backwards from the first focusable element + function tabAhead(event) { + if (activeElement() === lastTabStop) { + event.preventDefault(); + firstTabStop.focus(); + } + } + function tabBack(event) { + if (activeElement() === firstTabStop) { + event.preventDefault(); + lastTabStop.focus(); + } + // This checks if you want to set the initial focus to a container + // instead of an element within, and the user tabs back. + // Then we set the focus to the first + else if (!focusableElements.includes(activeElement())) { + event.preventDefault(); + firstTabStop.focus(); + } + } + return { + firstTabStop, + lastTabStop, + tabAhead, + tabBack + }; +}; +module.exports = (context, additionalKeyBindings = {}) => { + const tabEventHandler = tabHandler(context); + const bindings = additionalKeyBindings; + const { + Esc, + Escape + } = bindings; + if (Escape && !Esc) bindings.Esc = Escape; + + // TODO: In the future, loop over additional keybindings and pass an array + // of functions, if necessary, to the map keys. Then people implementing + // the focus trap could pass callbacks to fire when tabbing + const keyMappings = keymap({ + Tab: tabEventHandler.tabAhead, + "Shift+Tab": tabEventHandler.tabBack, + ...additionalKeyBindings + }); + const focusTrap = behavior({ + keydown: keyMappings + }, { + init() { + // TODO: is this desireable behavior? Should the trap always do this by default or should + // the component getting decorated handle this? + if (tabEventHandler.firstTabStop) { + tabEventHandler.firstTabStop.focus(); + } + }, + update(isActive) { + if (isActive) { + this.on(); + } else { + this.off(); + } + } + }); + return focusTrap; +}; + +},{"./active-element":39,"./behavior":40,"./select":48,"receptor":9}],43:[function(require,module,exports){ +"use strict"; + +// https://stackoverflow.com/a/7557433 +function isElementInViewport(el, win = window, docEl = document.documentElement) { + const rect = el.getBoundingClientRect(); + return rect.top >= 0 && rect.left >= 0 && rect.bottom <= (win.innerHeight || docEl.clientHeight) && rect.right <= (win.innerWidth || docEl.clientWidth); +} +module.exports = isElementInViewport; + +},{}],44:[function(require,module,exports){ +"use strict"; + +// iOS detection from: http://stackoverflow.com/a/9039885/177710 +function isIosDevice() { + return typeof navigator !== "undefined" && (navigator.userAgent.match(/(iPod|iPhone|iPad)/g) || navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1) && !window.MSStream; +} +module.exports = isIosDevice; + +},{}],45:[function(require,module,exports){ +"use strict"; + +/* eslint-disable */ +/* globals define, module */ + +/** + * A simple library to help you escape HTML using template strings. + * + * It's the counterpart to our eslint "no-unsafe-innerhtml" plugin that helps us + * avoid unsafe coding practices. + * A full write-up of the Hows and Whys are documented + * for developers at + * https://developer.mozilla.org/en-US/Firefox_OS/Security/Security_Automation + * with additional background information and design docs at + * https://wiki.mozilla.org/User:Fbraun/Gaia/SafeinnerHTMLRoadmap + * + */ + +!function (factory) { + module.exports = factory(); +}(function () { + "use strict"; + + var Sanitizer = { + _entity: /[&<>"'/]/g, + _entities: { + "&": "&", + "<": "<", + ">": ">", + '"': """, + "'": "'", + "/": "/" + }, + getEntity: function (s) { + return Sanitizer._entities[s]; + }, + /** + * Escapes HTML for all values in a tagged template string. + */ + escapeHTML: function (strings) { + var result = ""; + for (var i = 0; i < strings.length; i++) { + result += strings[i]; + if (i + 1 < arguments.length) { + var value = arguments[i + 1] || ""; + result += String(value).replace(Sanitizer._entity, Sanitizer.getEntity); + } + } + return result; + }, + /** + * Escapes HTML and returns a wrapped object to be used during DOM insertion + */ + createSafeHTML: function (strings) { + var _len = arguments.length; + var values = new Array(_len > 1 ? _len - 1 : 0); + for (var _key = 1; _key < _len; _key++) { + values[_key - 1] = arguments[_key]; + } + var escaped = Sanitizer.escapeHTML.apply(Sanitizer, [strings].concat(values)); + return { + __html: escaped, + toString: function () { + return "[object WrappedHTMLObject]"; + }, + info: "This is a wrapped HTML object. See https://developer.mozilla.or" + "g/en-US/Firefox_OS/Security/Security_Automation for more." + }; + }, + /** + * Unwrap safe HTML created by createSafeHTML or a custom replacement that + * underwent security review. + */ + unwrapSafeHTML: function () { + var _len = arguments.length; + var htmlObjects = new Array(_len); + for (var _key = 0; _key < _len; _key++) { + htmlObjects[_key] = arguments[_key]; + } + var markupList = htmlObjects.map(function (obj) { + return obj.__html; + }); + return markupList.join(""); + } + }; + return Sanitizer; +}); + +},{}],46:[function(require,module,exports){ +"use strict"; + +module.exports = function getScrollbarWidth() { + // Creating invisible container + const outer = document.createElement("div"); + outer.style.visibility = "hidden"; + outer.style.overflow = "scroll"; // forcing scrollbar to appear + outer.style.msOverflowStyle = "scrollbar"; // needed for WinJS apps + document.body.appendChild(outer); + + // Creating inner element and placing it in the container + const inner = document.createElement("div"); + outer.appendChild(inner); + + // Calculating difference between container's full width and the child width + const scrollbarWidth = `${outer.offsetWidth - inner.offsetWidth}px`; + + // Removing temporary elements from the DOM + outer.parentNode.removeChild(outer); + return scrollbarWidth; +}; + +},{}],47:[function(require,module,exports){ +"use strict"; + +const select = require("./select"); +/** + * @name isElement + * @desc returns whether or not the given argument is a DOM element. + * @param {any} value + * @return {boolean} + */ +const isElement = value => value && typeof value === "object" && value.nodeType === 1; + +/** + * @name selectOrMatches + * @desc selects elements from the DOM by class selector or ID selector. + * @param {string} selector - The selector to traverse the DOM with. + * @param {Document|HTMLElement?} context - The context to traverse the DOM + * in. If not provided, it defaults to the document. + * @return {HTMLElement[]} - An array of DOM nodes or an empty array. + */ +module.exports = (selector, context) => { + const selection = select(selector, context); + if (typeof selector !== "string") { + return selection; + } + if (isElement(context) && context.matches(selector)) { + selection.push(context); + } + return selection; +}; + +},{"./select":48}],48:[function(require,module,exports){ +"use strict"; + +/** + * @name isElement + * @desc returns whether or not the given argument is a DOM element. + * @param {any} value + * @return {boolean} + */ +const isElement = value => value && typeof value === "object" && value.nodeType === 1; + +/** + * @name select + * @desc selects elements from the DOM by class selector or ID selector. + * @param {string} selector - The selector to traverse the DOM with. + * @param {Document|HTMLElement?} context - The context to traverse the DOM + * in. If not provided, it defaults to the document. + * @return {HTMLElement[]} - An array of DOM nodes or an empty array. + */ +module.exports = (selector, context) => { + if (typeof selector !== "string") { + return []; + } + if (!context || !isElement(context)) { + context = window.document; // eslint-disable-line no-param-reassign + } + const selection = context.querySelectorAll(selector); + return Array.prototype.slice.call(selection); +}; + +},{}],49:[function(require,module,exports){ +"use strict"; + +/** + * Flips given INPUT elements between masked (hiding the field value) and unmasked + * @param {Array.HTMLElement} fields - An array of INPUT elements + * @param {Boolean} mask - Whether the mask should be applied, hiding the field value + */ +module.exports = (field, mask) => { + field.setAttribute("autocapitalize", "off"); + field.setAttribute("autocorrect", "off"); + field.setAttribute("type", mask ? "password" : "text"); +}; + +},{}],50:[function(require,module,exports){ +"use strict"; + +const resolveIdRefs = require("resolve-id-refs"); +const toggleFieldMask = require("./toggle-field-mask"); +const CONTROLS = "aria-controls"; +const PRESSED = "aria-pressed"; +const SHOW_ATTR = "data-show-text"; +const HIDE_ATTR = "data-hide-text"; + +/** + * Replace the word "Show" (or "show") with "Hide" (or "hide") in a string. + * @param {string} showText + * @return {strong} hideText + */ +const getHideText = showText => showText.replace(/\bShow\b/i, show => `${show[0] === "S" ? "H" : "h"}ide`); + +/** + * Component that decorates an HTML element with the ability to toggle the + * masked state of an input field (like a password) when clicked. + * The ids of the fields to be masked will be pulled directly from the button's + * `aria-controls` attribute. + * + * @param {HTMLElement} el Parent element containing the fields to be masked + * @return {boolean} + */ +module.exports = el => { + // this is the *target* state: + // * if the element has the attr and it's !== "true", pressed is true + // * otherwise, pressed is false + const pressed = el.hasAttribute(PRESSED) && el.getAttribute(PRESSED) !== "true"; + const fields = resolveIdRefs(el.getAttribute(CONTROLS)); + fields.forEach(field => toggleFieldMask(field, pressed)); + if (!el.hasAttribute(SHOW_ATTR)) { + el.setAttribute(SHOW_ATTR, el.textContent); + } + const showText = el.getAttribute(SHOW_ATTR); + const hideText = el.getAttribute(HIDE_ATTR) || getHideText(showText); + el.textContent = pressed ? showText : hideText; // eslint-disable-line no-param-reassign + el.setAttribute(PRESSED, pressed); + return pressed; +}; + +},{"./toggle-field-mask":49,"resolve-id-refs":12}],51:[function(require,module,exports){ +"use strict"; + +const EXPANDED = "aria-expanded"; +const CONTROLS = "aria-controls"; +const HIDDEN = "hidden"; +module.exports = (button, expanded) => { + let safeExpanded = expanded; + if (typeof safeExpanded !== "boolean") { + safeExpanded = button.getAttribute(EXPANDED) === "false"; + } + button.setAttribute(EXPANDED, safeExpanded); + const id = button.getAttribute(CONTROLS); + const controls = document.getElementById(id); + if (!controls) { + throw new Error(`No toggle target found with id: "${id}"`); + } + if (safeExpanded) { + controls.removeAttribute(HIDDEN); + } else { + controls.setAttribute(HIDDEN, ""); + } + return safeExpanded; +}; + +},{}],52:[function(require,module,exports){ +"use strict"; + +const debounce = require("./debounce"); +const { + prefix: PREFIX +} = require("../config"); +const CHECKED_CLASS = `${PREFIX}-checklist__item--checked`; +module.exports = function validate(el) { + const id = el.dataset.validationElement; + const checkList = id.charAt(0) === "#" ? document.querySelector(id) : document.getElementById(id); + if (!checkList) { + throw new Error(`No validation element found with id: "${id}"`); + } + let statusSummary = ""; + Object.entries(el.dataset).forEach(([key, value]) => { + if (key.startsWith("validate")) { + const validatorName = key.substr("validate".length).toLowerCase(); + const validatorPattern = new RegExp(value); + const validatorSelector = `[data-validator="${validatorName}"]`; + const validatorCheckbox = checkList.querySelector(validatorSelector); + const validatorParent = el.parentNode; + const statusSummaryContainer = validatorParent.querySelector(`[data-validation-status]`); + const checked = validatorPattern.test(el.value); + validatorCheckbox.classList.toggle(CHECKED_CLASS, checked); + if (!validatorCheckbox) { + throw new Error(`No validator checkbox found for: "${validatorName}"`); + } + + // Create status reports for checklist items + const statusComplete = el.dataset.validationComplete || "status complete"; + const statusIncomplete = el.dataset.validationIncomplete || "status incomplete"; + let checkboxContent = `${validatorCheckbox.textContent} `; + if (validatorCheckbox.classList.contains(CHECKED_CLASS)) { + checkboxContent += statusComplete; + } else { + checkboxContent += statusIncomplete; + } + + // move status updates to aria-label on checklist item + validatorCheckbox.setAttribute("aria-label", checkboxContent); + + // Create a summary of status for all checklist items + statusSummary += `${checkboxContent}. `; + + // Add summary to screen reader summary container, after a delay + const srUpdateStatus = debounce(() => { + statusSummaryContainer.textContent = statusSummary; + }, 1000); + srUpdateStatus(); + } + }); +}; + +},{"../config":35,"./debounce":41}]},{},[38]) +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","node_modules/element-closest/element-closest.js","node_modules/keyboardevent-key-polyfill/index.js","node_modules/object-assign/index.js","node_modules/receptor/behavior/index.js","node_modules/receptor/compose/index.js","node_modules/receptor/delegate/index.js","node_modules/receptor/delegateAll/index.js","node_modules/receptor/ignore/index.js","node_modules/receptor/index.js","node_modules/receptor/keymap/index.js","node_modules/receptor/once/index.js","node_modules/resolve-id-refs/index.js","packages/_usa-password/src/index.js","packages/usa-accordion/src/index.js","packages/usa-banner/src/index.js","packages/usa-button/src/index.js","packages/usa-character-count/src/index.js","packages/usa-combo-box/src/index.js","packages/usa-date-picker/src/index.js","packages/usa-date-range-picker/src/index.js","packages/usa-file-input/src/index.js","packages/usa-footer/src/index.js","packages/usa-header/src/index.js","packages/usa-in-page-navigation/src/index.js","packages/usa-input-mask/src/index.js","packages/usa-language-selector/src/index.js","packages/usa-modal/src/index.js","packages/usa-range/src/index.js","packages/usa-search/src/index.js","packages/usa-skipnav/src/index.js","packages/usa-table/src/index.js","packages/usa-time-picker/src/index.js","packages/usa-tooltip/src/index.js","packages/usa-validation/src/index.js","packages/uswds-core/src/js/config.js","packages/uswds-core/src/js/events.js","packages/uswds-core/src/js/index.js","packages/uswds-core/src/js/start.js","packages/uswds-core/src/js/utils/active-element.js","packages/uswds-core/src/js/utils/behavior.js","packages/uswds-core/src/js/utils/debounce.js","packages/uswds-core/src/js/utils/focus-trap.js","packages/uswds-core/src/js/utils/is-in-viewport.js","packages/uswds-core/src/js/utils/is-ios-device.js","packages/uswds-core/src/js/utils/sanitizer.js","packages/uswds-core/src/js/utils/scrollbar-width.js","packages/uswds-core/src/js/utils/select-or-matches.js","packages/uswds-core/src/js/utils/select.js","packages/uswds-core/src/js/utils/toggle-field-mask.js","packages/uswds-core/src/js/utils/toggle-form-input.js","packages/uswds-core/src/js/utils/toggle.js","packages/uswds-core/src/js/utils/validate-input.js"],"names":[],"mappings":"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","file":"generated.js","sourceRoot":"","sourcesContent":["(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()","// element-closest | CC0-1.0 | github.com/jonathantneal/closest\n\n(function (ElementProto) {\n\tif (typeof ElementProto.matches !== 'function') {\n\t\tElementProto.matches = ElementProto.msMatchesSelector || ElementProto.mozMatchesSelector || ElementProto.webkitMatchesSelector || function matches(selector) {\n\t\t\tvar element = this;\n\t\t\tvar elements = (element.document || element.ownerDocument).querySelectorAll(selector);\n\t\t\tvar index = 0;\n\n\t\t\twhile (elements[index] && elements[index] !== element) {\n\t\t\t\t++index;\n\t\t\t}\n\n\t\t\treturn Boolean(elements[index]);\n\t\t};\n\t}\n\n\tif (typeof ElementProto.closest !== 'function') {\n\t\tElementProto.closest = function closest(selector) {\n\t\t\tvar element = this;\n\n\t\t\twhile (element && element.nodeType === 1) {\n\t\t\t\tif (element.matches(selector)) {\n\t\t\t\t\treturn element;\n\t\t\t\t}\n\n\t\t\t\telement = element.parentNode;\n\t\t\t}\n\n\t\t\treturn null;\n\t\t};\n\t}\n})(window.Element.prototype);\n","/* global define, KeyboardEvent, module */\n\n(function () {\n\n  var keyboardeventKeyPolyfill = {\n    polyfill: polyfill,\n    keys: {\n      3: 'Cancel',\n      6: 'Help',\n      8: 'Backspace',\n      9: 'Tab',\n      12: 'Clear',\n      13: 'Enter',\n      16: 'Shift',\n      17: 'Control',\n      18: 'Alt',\n      19: 'Pause',\n      20: 'CapsLock',\n      27: 'Escape',\n      28: 'Convert',\n      29: 'NonConvert',\n      30: 'Accept',\n      31: 'ModeChange',\n      32: ' ',\n      33: 'PageUp',\n      34: 'PageDown',\n      35: 'End',\n      36: 'Home',\n      37: 'ArrowLeft',\n      38: 'ArrowUp',\n      39: 'ArrowRight',\n      40: 'ArrowDown',\n      41: 'Select',\n      42: 'Print',\n      43: 'Execute',\n      44: 'PrintScreen',\n      45: 'Insert',\n      46: 'Delete',\n      48: ['0', ')'],\n      49: ['1', '!'],\n      50: ['2', '@'],\n      51: ['3', '#'],\n      52: ['4', '$'],\n      53: ['5', '%'],\n      54: ['6', '^'],\n      55: ['7', '&'],\n      56: ['8', '*'],\n      57: ['9', '('],\n      91: 'OS',\n      93: 'ContextMenu',\n      144: 'NumLock',\n      145: 'ScrollLock',\n      181: 'VolumeMute',\n      182: 'VolumeDown',\n      183: 'VolumeUp',\n      186: [';', ':'],\n      187: ['=', '+'],\n      188: [',', '<'],\n      189: ['-', '_'],\n      190: ['.', '>'],\n      191: ['/', '?'],\n      192: ['`', '~'],\n      219: ['[', '{'],\n      220: ['\\\\', '|'],\n      221: [']', '}'],\n      222: [\"'\", '\"'],\n      224: 'Meta',\n      225: 'AltGraph',\n      246: 'Attn',\n      247: 'CrSel',\n      248: 'ExSel',\n      249: 'EraseEof',\n      250: 'Play',\n      251: 'ZoomOut'\n    }\n  };\n\n  // Function keys (F1-24).\n  var i;\n  for (i = 1; i < 25; i++) {\n    keyboardeventKeyPolyfill.keys[111 + i] = 'F' + i;\n  }\n\n  // Printable ASCII characters.\n  var letter = '';\n  for (i = 65; i < 91; i++) {\n    letter = String.fromCharCode(i);\n    keyboardeventKeyPolyfill.keys[i] = [letter.toLowerCase(), letter.toUpperCase()];\n  }\n\n  function polyfill () {\n    if (!('KeyboardEvent' in window) ||\n        'key' in KeyboardEvent.prototype) {\n      return false;\n    }\n\n    // Polyfill `key` on `KeyboardEvent`.\n    var proto = {\n      get: function (x) {\n        var key = keyboardeventKeyPolyfill.keys[this.which || this.keyCode];\n\n        if (Array.isArray(key)) {\n          key = key[+this.shiftKey];\n        }\n\n        return key;\n      }\n    };\n    Object.defineProperty(KeyboardEvent.prototype, 'key', proto);\n    return proto;\n  }\n\n  if (typeof define === 'function' && define.amd) {\n    define('keyboardevent-key-polyfill', keyboardeventKeyPolyfill);\n  } else if (typeof exports !== 'undefined' && typeof module !== 'undefined') {\n    module.exports = keyboardeventKeyPolyfill;\n  } else if (window) {\n    window.keyboardeventKeyPolyfill = keyboardeventKeyPolyfill;\n  }\n\n})();\n","/*\nobject-assign\n(c) Sindre Sorhus\n@license MIT\n*/\n\n'use strict';\n/* eslint-disable no-unused-vars */\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nfunction toObject(val) {\n\tif (val === null || val === undefined) {\n\t\tthrow new TypeError('Object.assign cannot be called with null or undefined');\n\t}\n\n\treturn Object(val);\n}\n\nfunction shouldUseNative() {\n\ttry {\n\t\tif (!Object.assign) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Detect buggy property enumeration order in older V8 versions.\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=4118\n\t\tvar test1 = new String('abc');  // eslint-disable-line no-new-wrappers\n\t\ttest1[5] = 'de';\n\t\tif (Object.getOwnPropertyNames(test1)[0] === '5') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test2 = {};\n\t\tfor (var i = 0; i < 10; i++) {\n\t\t\ttest2['_' + String.fromCharCode(i)] = i;\n\t\t}\n\t\tvar order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n\t\t\treturn test2[n];\n\t\t});\n\t\tif (order2.join('') !== '0123456789') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test3 = {};\n\t\t'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n\t\t\ttest3[letter] = letter;\n\t\t});\n\t\tif (Object.keys(Object.assign({}, test3)).join('') !==\n\t\t\t\t'abcdefghijklmnopqrst') {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t} catch (err) {\n\t\t// We don't expect any of the above to throw, but better to be safe.\n\t\treturn false;\n\t}\n}\n\nmodule.exports = shouldUseNative() ? Object.assign : function (target, source) {\n\tvar from;\n\tvar to = toObject(target);\n\tvar symbols;\n\n\tfor (var s = 1; s < arguments.length; s++) {\n\t\tfrom = Object(arguments[s]);\n\n\t\tfor (var key in from) {\n\t\t\tif (hasOwnProperty.call(from, key)) {\n\t\t\t\tto[key] = from[key];\n\t\t\t}\n\t\t}\n\n\t\tif (getOwnPropertySymbols) {\n\t\t\tsymbols = getOwnPropertySymbols(from);\n\t\t\tfor (var i = 0; i < symbols.length; i++) {\n\t\t\t\tif (propIsEnumerable.call(from, symbols[i])) {\n\t\t\t\t\tto[symbols[i]] = from[symbols[i]];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn to;\n};\n","const assign = require('object-assign');\nconst delegate = require('../delegate');\nconst delegateAll = require('../delegateAll');\n\nconst DELEGATE_PATTERN = /^(.+):delegate\\((.+)\\)$/;\nconst SPACE = ' ';\n\nconst getListeners = function(type, handler) {\n  var match = type.match(DELEGATE_PATTERN);\n  var selector;\n  if (match) {\n    type = match[1];\n    selector = match[2];\n  }\n\n  var options;\n  if (typeof handler === 'object') {\n    options = {\n      capture: popKey(handler, 'capture'),\n      passive: popKey(handler, 'passive')\n    };\n  }\n\n  var listener = {\n    selector: selector,\n    delegate: (typeof handler === 'object')\n      ? delegateAll(handler)\n      : selector\n        ? delegate(selector, handler)\n        : handler,\n    options: options\n  };\n\n  if (type.indexOf(SPACE) > -1) {\n    return type.split(SPACE).map(function(_type) {\n      return assign({type: _type}, listener);\n    });\n  } else {\n    listener.type = type;\n    return [listener];\n  }\n};\n\nvar popKey = function(obj, key) {\n  var value = obj[key];\n  delete obj[key];\n  return value;\n};\n\nmodule.exports = function behavior(events, props) {\n  const listeners = Object.keys(events)\n    .reduce(function(memo, type) {\n      var listeners = getListeners(type, events[type]);\n      return memo.concat(listeners);\n    }, []);\n\n  return assign({\n    add: function addBehavior(element) {\n      listeners.forEach(function(listener) {\n        element.addEventListener(\n          listener.type,\n          listener.delegate,\n          listener.options\n        );\n      });\n    },\n    remove: function removeBehavior(element) {\n      listeners.forEach(function(listener) {\n        element.removeEventListener(\n          listener.type,\n          listener.delegate,\n          listener.options\n        );\n      });\n    }\n  }, props);\n};\n","module.exports = function compose(functions) {\n  return function(e) {\n    return functions.some(function(fn) {\n      return fn.call(this, e) === false;\n    }, this);\n  };\n};\n","// polyfill Element.prototype.closest\nrequire('element-closest');\n\nmodule.exports = function delegate(selector, fn) {\n  return function delegation(event) {\n    var target = event.target.closest(selector);\n    if (target) {\n      return fn.call(target, event);\n    }\n  }\n};\n","const delegate = require('../delegate');\nconst compose = require('../compose');\n\nconst SPLAT = '*';\n\nmodule.exports = function delegateAll(selectors) {\n  const keys = Object.keys(selectors)\n\n  // XXX optimization: if there is only one handler and it applies to\n  // all elements (the \"*\" CSS selector), then just return that\n  // handler\n  if (keys.length === 1 && keys[0] === SPLAT) {\n    return selectors[SPLAT];\n  }\n\n  const delegates = keys.reduce(function(memo, selector) {\n    memo.push(delegate(selector, selectors[selector]));\n    return memo;\n  }, []);\n  return compose(delegates);\n};\n","module.exports = function ignore(element, fn) {\n  return function ignorance(e) {\n    if (element !== e.target && !element.contains(e.target)) {\n      return fn.call(this, e);\n    }\n  };\n};\n","module.exports = {\n  behavior:     require('./behavior'),\n  delegate:     require('./delegate'),\n  delegateAll:  require('./delegateAll'),\n  ignore:       require('./ignore'),\n  keymap:       require('./keymap'),\n};\n","require('keyboardevent-key-polyfill');\n\n// these are the only relevant modifiers supported on all platforms,\n// according to MDN:\n// <https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/getModifierState>\nconst MODIFIERS = {\n  'Alt':      'altKey',\n  'Control':  'ctrlKey',\n  'Ctrl':     'ctrlKey',\n  'Shift':    'shiftKey'\n};\n\nconst MODIFIER_SEPARATOR = '+';\n\nconst getEventKey = function(event, hasModifiers) {\n  var key = event.key;\n  if (hasModifiers) {\n    for (var modifier in MODIFIERS) {\n      if (event[MODIFIERS[modifier]] === true) {\n        key = [modifier, key].join(MODIFIER_SEPARATOR);\n      }\n    }\n  }\n  return key;\n};\n\nmodule.exports = function keymap(keys) {\n  const hasModifiers = Object.keys(keys).some(function(key) {\n    return key.indexOf(MODIFIER_SEPARATOR) > -1;\n  });\n  return function(event) {\n    var key = getEventKey(event, hasModifiers);\n    return [key, key.toLowerCase()]\n      .reduce(function(result, _key) {\n        if (_key in keys) {\n          result = keys[key].call(this, event);\n        }\n        return result;\n      }, undefined);\n  };\n};\n\nmodule.exports.MODIFIERS = MODIFIERS;\n","module.exports = function once(listener, options) {\n  var wrapped = function wrappedOnce(e) {\n    e.currentTarget.removeEventListener(e.type, wrapped, options);\n    return listener.call(this, e);\n  };\n  return wrapped;\n};\n\n","'use strict';\n\nvar RE_TRIM = /(^\\s+)|(\\s+$)/g;\nvar RE_SPLIT = /\\s+/;\n\nvar trim = String.prototype.trim\n  ? function(str) { return str.trim(); }\n  : function(str) { return str.replace(RE_TRIM, ''); };\n\nvar queryById = function(id) {\n  return this.querySelector('[id=\"' + id.replace(/\"/g, '\\\\\"') + '\"]');\n};\n\nmodule.exports = function resolveIds(ids, doc) {\n  if (typeof ids !== 'string') {\n    throw new Error('Expected a string but got ' + (typeof ids));\n  }\n\n  if (!doc) {\n    doc = window.document;\n  }\n\n  var getElementById = doc.getElementById\n    ? doc.getElementById.bind(doc)\n    : queryById.bind(doc);\n\n  ids = trim(ids).split(RE_SPLIT);\n\n  // XXX we can short-circuit here because trimming and splitting a\n  // string of just whitespace produces an array containing a single,\n  // empty string\n  if (ids.length === 1 && ids[0] === '') {\n    return [];\n  }\n\n  return ids\n    .map(function(id) {\n      var el = getElementById(id);\n      if (!el) {\n        throw new Error('no element with id: \"' + id + '\"');\n      }\n      return el;\n    });\n};\n","const behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst toggleFormInput = require(\"../../uswds-core/src/js/utils/toggle-form-input\");\n\nconst { CLICK } = require(\"../../uswds-core/src/js/events\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\n\nconst LINK = `.${PREFIX}-show-password`;\n\nfunction toggle(event) {\n  event.preventDefault();\n  toggleFormInput(this);\n}\n\nmodule.exports = behavior({\n  [CLICK]: {\n    [LINK]: toggle,\n  },\n});\n","const select = require(\"../../uswds-core/src/js/utils/select\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst toggle = require(\"../../uswds-core/src/js/utils/toggle\");\nconst isElementInViewport = require(\"../../uswds-core/src/js/utils/is-in-viewport\");\nconst { CLICK } = require(\"../../uswds-core/src/js/events\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\n\nconst ACCORDION = `.${PREFIX}-accordion, .${PREFIX}-accordion--bordered`;\nconst BANNER_BUTTON = `.${PREFIX}-banner__button`;\nconst BUTTON = `.${PREFIX}-accordion__button[aria-controls]:not(${BANNER_BUTTON})`;\nconst EXPANDED = \"aria-expanded\";\nconst MULTISELECTABLE = \"data-allow-multiple\";\n\n/**\n * Get an Array of button elements belonging directly to the given\n * accordion element.\n * @param {HTMLElement} accordion\n * @return {array<HTMLButtonElement>}\n */\nconst getAccordionButtons = (accordion) => {\n  const buttons = select(BUTTON, accordion);\n\n  return buttons.filter((button) => button.closest(ACCORDION) === accordion);\n};\n\n/**\n * Toggle a button's \"pressed\" state, optionally providing a target\n * state.\n *\n * @param {HTMLButtonElement} button\n * @param {boolean?} expanded If no state is provided, the current\n * state will be toggled (from false to true, and vice-versa).\n * @return {boolean} the resulting state\n */\nconst toggleButton = (button, expanded) => {\n  const accordion = button.closest(ACCORDION);\n  let safeExpanded = expanded;\n\n  if (!accordion) {\n    throw new Error(`${BUTTON} is missing outer ${ACCORDION}`);\n  }\n\n  safeExpanded = toggle(button, expanded);\n\n  // XXX multiselectable is opt-in, to preserve legacy behavior\n  const multiselectable = accordion.hasAttribute(MULTISELECTABLE);\n\n  if (safeExpanded && !multiselectable) {\n    getAccordionButtons(accordion).forEach((other) => {\n      if (other !== button) {\n        toggle(other, false);\n      }\n    });\n  }\n};\n\n/**\n * @param {HTMLButtonElement} button\n * @return {boolean} true\n */\nconst showButton = (button) => toggleButton(button, true);\n\n/**\n * @param {HTMLButtonElement} button\n * @return {boolean} false\n */\nconst hideButton = (button) => toggleButton(button, false);\n\nconst accordion = behavior(\n  {\n    [CLICK]: {\n      [BUTTON]() {\n        toggleButton(this);\n\n        if (this.getAttribute(EXPANDED) === \"true\") {\n          // We were just expanded, but if another accordion was also just\n          // collapsed, we may no longer be in the viewport. This ensures\n          // that we are still visible, so the user isn't confused.\n          if (!isElementInViewport(this)) this.scrollIntoView();\n        }\n      },\n    },\n  },\n  {\n    init(root) {\n      select(BUTTON, root).forEach((button) => {\n        const expanded = button.getAttribute(EXPANDED) === \"true\";\n        toggleButton(button, expanded);\n      });\n    },\n    ACCORDION,\n    BUTTON,\n    show: showButton,\n    hide: hideButton,\n    toggle: toggleButton,\n    getButtons: getAccordionButtons,\n  },\n);\n\nmodule.exports = accordion;\n","const behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst select = require(\"../../uswds-core/src/js/utils/select\");\nconst { CLICK } = require(\"../../uswds-core/src/js/events\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\nconst toggle = require(\"../../uswds-core/src/js/utils/toggle\");\n\nconst HEADER = `.${PREFIX}-banner__header`;\nconst EXPANDED_CLASS = `${PREFIX}-banner__header--expanded`;\nconst BANNER_BUTTON = `${HEADER} [aria-controls]`;\n\n/**\n * Toggle Banner display and class.\n * @param {Event} event\n */\nconst toggleBanner = function toggleEl(event) {\n  event.preventDefault();\n  const trigger = event.target.closest(BANNER_BUTTON);\n\n  toggle(trigger);\n  this.closest(HEADER).classList.toggle(EXPANDED_CLASS);\n};\n\nmodule.exports = behavior(\n  {\n    [CLICK]: {\n      [BANNER_BUTTON]: toggleBanner,\n    },\n  },\n  {\n    init(root) {\n      select(BANNER_BUTTON, root).forEach((button) => {\n        const expanded = button.getAttribute(EXPANDED_CLASS) === \"true\";\n        toggle(button, expanded);\n      });\n    },\n  },\n);\n","const keymap = require(\"receptor/keymap\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\n\nconst ANCHOR_BUTTON = `a[class*=\"usa-button\"]`;\n\nconst toggleButton = (event) => {\n  event.preventDefault();\n  event.target.click();\n};\n\nconst anchorButton = behavior({\n  keydown: {\n    [ANCHOR_BUTTON]: keymap({\n      \" \": toggleButton,\n    }),\n  },\n});\n\nmodule.exports = anchorButton;\n","const select = require(\"../../uswds-core/src/js/utils/select\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst debounce = require(\"../../uswds-core/src/js/utils/debounce\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\n\nconst CHARACTER_COUNT_CLASS = `${PREFIX}-character-count`;\nconst CHARACTER_COUNT = `.${CHARACTER_COUNT_CLASS}`;\nconst FORM_GROUP_CLASS = `${PREFIX}-form-group`;\nconst FORM_GROUP_ERROR_CLASS = `${FORM_GROUP_CLASS}--error`;\nconst FORM_GROUP = `.${FORM_GROUP_CLASS}`;\nconst LABEL_CLASS = `${PREFIX}-label`;\nconst LABEL_ERROR_CLASS = `${LABEL_CLASS}--error`;\nconst INPUT = `.${PREFIX}-character-count__field`;\nconst INPUT_ERROR_CLASS = `${PREFIX}-input--error`;\nconst MESSAGE = `.${PREFIX}-character-count__message`;\nconst VALIDATION_MESSAGE = \"The content is too long.\";\nconst MESSAGE_INVALID_CLASS = `${PREFIX}-character-count__status--invalid`;\nconst STATUS_MESSAGE_CLASS = `${CHARACTER_COUNT_CLASS}__status`;\nconst STATUS_MESSAGE_SR_ONLY_CLASS = `${CHARACTER_COUNT_CLASS}__sr-status`;\nconst STATUS_MESSAGE = `.${STATUS_MESSAGE_CLASS}`;\nconst STATUS_MESSAGE_SR_ONLY = `.${STATUS_MESSAGE_SR_ONLY_CLASS}`;\nconst DEFAULT_STATUS_LABEL = `characters allowed`;\n\n/**\n * Returns the root, form group, label, and message elements for an character count input\n *\n * @param {HTMLInputElement|HTMLTextAreaElement} inputEl The character count input element\n * @returns {CharacterCountElements} elements The root form group, input ID, label, and message element.\n */\nconst getCharacterCountElements = (inputEl) => {\n  const characterCountEl = inputEl.closest(CHARACTER_COUNT);\n\n  if (!characterCountEl) {\n    throw new Error(`${INPUT} is missing outer ${CHARACTER_COUNT}`);\n  }\n\n  const formGroupEl = characterCountEl.querySelector(FORM_GROUP);\n\n  const inputID = inputEl.getAttribute(\"id\");\n  const labelEl = document.querySelector(`label[for=${inputID}]`);\n\n  const messageEl = characterCountEl.querySelector(MESSAGE);\n\n  if (!messageEl) {\n    throw new Error(`${CHARACTER_COUNT} is missing inner ${MESSAGE}`);\n  }\n\n  return { characterCountEl, formGroupEl, inputID, labelEl, messageEl };\n};\n\n/**\n * Move maxlength attribute to a data attribute on usa-character-count\n *\n * @param {HTMLInputElement|HTMLTextAreaElement} inputEl The character count input element\n */\nconst setDataLength = (inputEl) => {\n  const { characterCountEl } = getCharacterCountElements(inputEl);\n\n  const maxlength = inputEl.getAttribute(\"maxlength\");\n\n  if (!maxlength) return;\n\n  inputEl.removeAttribute(\"maxlength\");\n  characterCountEl.setAttribute(\"data-maxlength\", maxlength);\n};\n\n/**\n * Create and append status messages for visual and screen readers\n *\n * @param {HTMLDivElement} characterCountEl - Div with `.usa-character-count` class\n * @description  Create two status messages for number of characters left;\n * one visual status and another for screen readers\n */\nconst createStatusMessages = (characterCountEl) => {\n  const statusMessage = document.createElement(\"div\");\n  const srStatusMessage = document.createElement(\"div\");\n  const maxLength = characterCountEl.dataset.maxlength;\n  const defaultMessage = `${maxLength} ${DEFAULT_STATUS_LABEL}`;\n\n  statusMessage.classList.add(`${STATUS_MESSAGE_CLASS}`, \"usa-hint\");\n  srStatusMessage.classList.add(\n    `${STATUS_MESSAGE_SR_ONLY_CLASS}`,\n    \"usa-sr-only\",\n  );\n\n  statusMessage.setAttribute(\"aria-hidden\", true);\n  srStatusMessage.setAttribute(\"aria-live\", \"polite\");\n\n  statusMessage.textContent = defaultMessage;\n  srStatusMessage.textContent = defaultMessage;\n\n  characterCountEl.append(statusMessage, srStatusMessage);\n};\n\n/**\n * Returns message with how many characters are left\n *\n * @param {number} currentLength - The number of characters used\n * @param {number} maxLength - The total number of characters allowed\n * @returns {string} A string description of how many characters are left\n */\nconst getCountMessage = (currentLength, maxLength) => {\n  let newMessage = \"\";\n\n  if (currentLength === 0) {\n    newMessage = `${maxLength} ${DEFAULT_STATUS_LABEL}`;\n  } else {\n    const difference = Math.abs(maxLength - currentLength);\n    const characters = `character${difference === 1 ? \"\" : \"s\"}`;\n    const guidance = currentLength > maxLength ? \"over limit\" : \"left\";\n\n    newMessage = `${difference} ${characters} ${guidance}`;\n  }\n\n  return newMessage;\n};\n\n/**\n * Updates the character count status for screen readers after a 1000ms delay.\n *\n * @param {HTMLElement} msgEl - The screen reader status message element\n * @param {string} statusMessage - A string of the current character status\n */\nconst srUpdateStatus = debounce((msgEl, statusMessage) => {\n  const srStatusMessage = msgEl;\n  srStatusMessage.textContent = statusMessage;\n}, 1000);\n\n/**\n * Update the character count component\n *\n * @description On input, it will update visual status, screenreader\n * status and update input validation (if over character length)\n * @param {HTMLInputElement|HTMLTextAreaElement} inputEl The character count input element\n */\nconst updateCountMessage = (inputEl) => {\n  const { characterCountEl, labelEl, formGroupEl } =\n    getCharacterCountElements(inputEl);\n  const currentLength = inputEl.value.length;\n  const maxLength = parseInt(\n    characterCountEl.getAttribute(\"data-maxlength\"),\n    10,\n  );\n  const statusMessage = characterCountEl.querySelector(STATUS_MESSAGE);\n  const srStatusMessage = characterCountEl.querySelector(\n    STATUS_MESSAGE_SR_ONLY,\n  );\n  const currentStatusMessage = getCountMessage(currentLength, maxLength);\n\n  if (!maxLength) return;\n\n  const isOverLimit = currentLength && currentLength > maxLength;\n\n  statusMessage.textContent = currentStatusMessage;\n  srUpdateStatus(srStatusMessage, currentStatusMessage);\n\n  if (isOverLimit && !inputEl.validationMessage) {\n    inputEl.setCustomValidity(VALIDATION_MESSAGE);\n  }\n\n  if (!isOverLimit && inputEl.validationMessage === VALIDATION_MESSAGE) {\n    inputEl.setCustomValidity(\"\");\n  }\n\n  if (formGroupEl) {\n    formGroupEl.classList.toggle(FORM_GROUP_ERROR_CLASS, isOverLimit);\n  }\n\n  if (labelEl) {\n    labelEl.classList.toggle(LABEL_ERROR_CLASS, isOverLimit);\n  }\n\n  inputEl.classList.toggle(INPUT_ERROR_CLASS, isOverLimit);\n  statusMessage.classList.toggle(MESSAGE_INVALID_CLASS, isOverLimit);\n};\n\n/**\n * Initialize component\n *\n * @description On init this function will create elements and update any\n * attributes so it can tell the user how many characters are left.\n * @param  {HTMLInputElement|HTMLTextAreaElement} inputEl the components input\n */\nconst enhanceCharacterCount = (inputEl) => {\n  const { characterCountEl, messageEl } = getCharacterCountElements(inputEl);\n\n  // Hide hint and remove aria-live for backwards compatibility\n  messageEl.classList.add(\"usa-sr-only\");\n  messageEl.removeAttribute(\"aria-live\");\n\n  setDataLength(inputEl);\n  createStatusMessages(characterCountEl);\n};\n\nconst characterCount = behavior(\n  {\n    input: {\n      [INPUT]() {\n        updateCountMessage(this);\n      },\n    },\n  },\n  {\n    init(root) {\n      select(INPUT, root).forEach((input) => enhanceCharacterCount(input));\n    },\n    FORM_GROUP_ERROR_CLASS,\n    LABEL_ERROR_CLASS,\n    INPUT_ERROR_CLASS,\n    MESSAGE_INVALID_CLASS,\n    VALIDATION_MESSAGE,\n    STATUS_MESSAGE_CLASS,\n    STATUS_MESSAGE_SR_ONLY_CLASS,\n    DEFAULT_STATUS_LABEL,\n    createStatusMessages,\n    getCountMessage,\n    updateCountMessage,\n  },\n);\n\nmodule.exports = characterCount;\n","const keymap = require(\"receptor/keymap\");\nconst selectOrMatches = require(\"../../uswds-core/src/js/utils/select-or-matches\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst Sanitizer = require(\"../../uswds-core/src/js/utils/sanitizer\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\nconst { CLICK } = require(\"../../uswds-core/src/js/events\");\n\nconst COMBO_BOX_CLASS = `${PREFIX}-combo-box`;\nconst COMBO_BOX_PRISTINE_CLASS = `${COMBO_BOX_CLASS}--pristine`;\nconst SELECT_CLASS = `${COMBO_BOX_CLASS}__select`;\nconst INPUT_CLASS = `${COMBO_BOX_CLASS}__input`;\nconst CLEAR_INPUT_BUTTON_CLASS = `${COMBO_BOX_CLASS}__clear-input`;\nconst CLEAR_INPUT_BUTTON_WRAPPER_CLASS = `${CLEAR_INPUT_BUTTON_CLASS}__wrapper`;\nconst INPUT_BUTTON_SEPARATOR_CLASS = `${COMBO_BOX_CLASS}__input-button-separator`;\nconst TOGGLE_LIST_BUTTON_CLASS = `${COMBO_BOX_CLASS}__toggle-list`;\nconst TOGGLE_LIST_BUTTON_WRAPPER_CLASS = `${TOGGLE_LIST_BUTTON_CLASS}__wrapper`;\nconst LIST_CLASS = `${COMBO_BOX_CLASS}__list`;\nconst LIST_OPTION_CLASS = `${COMBO_BOX_CLASS}__list-option`;\nconst LIST_OPTION_FOCUSED_CLASS = `${LIST_OPTION_CLASS}--focused`;\nconst LIST_OPTION_SELECTED_CLASS = `${LIST_OPTION_CLASS}--selected`;\nconst STATUS_CLASS = `${COMBO_BOX_CLASS}__status`;\n\nconst COMBO_BOX = `.${COMBO_BOX_CLASS}`;\nconst SELECT = `.${SELECT_CLASS}`;\nconst INPUT = `.${INPUT_CLASS}`;\nconst CLEAR_INPUT_BUTTON = `.${CLEAR_INPUT_BUTTON_CLASS}`;\nconst TOGGLE_LIST_BUTTON = `.${TOGGLE_LIST_BUTTON_CLASS}`;\nconst LIST = `.${LIST_CLASS}`;\nconst LIST_OPTION = `.${LIST_OPTION_CLASS}`;\nconst LIST_OPTION_FOCUSED = `.${LIST_OPTION_FOCUSED_CLASS}`;\nconst LIST_OPTION_SELECTED = `.${LIST_OPTION_SELECTED_CLASS}`;\nconst STATUS = `.${STATUS_CLASS}`;\n\nconst DEFAULT_FILTER = \".*{{query}}.*\";\n\nconst noop = () => {};\n\n/**\n * set the value of the element and dispatch a change event\n *\n * @param {HTMLInputElement|HTMLSelectElement} el The element to update\n * @param {string} value The new value of the element\n */\nconst changeElementValue = (el, value = \"\") => {\n  const elementToChange = el;\n  elementToChange.value = value;\n\n  const event = new CustomEvent(\"change\", {\n    bubbles: true,\n    cancelable: true,\n    detail: { value },\n  });\n  elementToChange.dispatchEvent(event);\n};\n\n/**\n * The elements within the combo box.\n * @typedef {Object} ComboBoxContext\n * @property {HTMLElement} comboBoxEl\n * @property {HTMLSelectElement} selectEl\n * @property {HTMLInputElement} inputEl\n * @property {HTMLUListElement} listEl\n * @property {HTMLDivElement} statusEl\n * @property {HTMLLIElement} focusedOptionEl\n * @property {HTMLLIElement} selectedOptionEl\n * @property {HTMLButtonElement} toggleListBtnEl\n * @property {HTMLButtonElement} clearInputBtnEl\n * @property {boolean} isPristine\n * @property {boolean} disableFiltering\n */\n\n/**\n * Get an object of elements belonging directly to the given\n * combo box component.\n *\n * @param {HTMLElement} el the element within the combo box\n * @returns {ComboBoxContext} elements\n */\nconst getComboBoxContext = (el) => {\n  const comboBoxEl = el.closest(COMBO_BOX);\n\n  if (!comboBoxEl) {\n    throw new Error(`Element is missing outer ${COMBO_BOX}`);\n  }\n\n  const selectEl = comboBoxEl.querySelector(SELECT);\n  const inputEl = comboBoxEl.querySelector(INPUT);\n  const listEl = comboBoxEl.querySelector(LIST);\n  const statusEl = comboBoxEl.querySelector(STATUS);\n  const focusedOptionEl = comboBoxEl.querySelector(LIST_OPTION_FOCUSED);\n  const selectedOptionEl = comboBoxEl.querySelector(LIST_OPTION_SELECTED);\n  const toggleListBtnEl = comboBoxEl.querySelector(TOGGLE_LIST_BUTTON);\n  const clearInputBtnEl = comboBoxEl.querySelector(CLEAR_INPUT_BUTTON);\n\n  const isPristine = comboBoxEl.classList.contains(COMBO_BOX_PRISTINE_CLASS);\n  const disableFiltering = comboBoxEl.dataset.disableFiltering === \"true\";\n\n  return {\n    comboBoxEl,\n    selectEl,\n    inputEl,\n    listEl,\n    statusEl,\n    focusedOptionEl,\n    selectedOptionEl,\n    toggleListBtnEl,\n    clearInputBtnEl,\n    isPristine,\n    disableFiltering,\n  };\n};\n\n/**\n * Disable the combo-box component\n *\n * @param {HTMLInputElement} el An element within the combo box component\n */\nconst disable = (el) => {\n  const { inputEl, toggleListBtnEl, clearInputBtnEl } = getComboBoxContext(el);\n\n  clearInputBtnEl.hidden = true;\n  clearInputBtnEl.disabled = true;\n  toggleListBtnEl.disabled = true;\n  inputEl.disabled = true;\n};\n\n/**\n * Check for aria-disabled on initialization\n *\n * @param {HTMLInputElement} el An element within the combo box component\n */\nconst ariaDisable = (el) => {\n  const { inputEl, toggleListBtnEl, clearInputBtnEl } = getComboBoxContext(el);\n\n  clearInputBtnEl.hidden = true;\n  clearInputBtnEl.setAttribute(\"aria-disabled\", true);\n  toggleListBtnEl.setAttribute(\"aria-disabled\", true);\n  inputEl.setAttribute(\"aria-disabled\", true);\n};\n\n/**\n * Enable the combo-box component\n *\n * @param {HTMLInputElement} el An element within the combo box component\n */\nconst enable = (el) => {\n  const { inputEl, toggleListBtnEl, clearInputBtnEl } = getComboBoxContext(el);\n\n  clearInputBtnEl.hidden = false;\n  clearInputBtnEl.disabled = false;\n  toggleListBtnEl.disabled = false;\n  inputEl.disabled = false;\n};\n\n/**\n * Enhance a select element into a combo box component.\n *\n * @param {HTMLElement} _comboBoxEl The initial element of the combo box component\n */\nconst enhanceComboBox = (_comboBoxEl) => {\n  const comboBoxEl = _comboBoxEl.closest(COMBO_BOX);\n\n  if (comboBoxEl.dataset.enhanced) return;\n\n  const selectEl = comboBoxEl.querySelector(\"select\");\n\n  if (!selectEl) {\n    throw new Error(`${COMBO_BOX} is missing inner select`);\n  }\n\n  const selectId = selectEl.id;\n  const selectLabel = document.querySelector(`label[for=\"${selectId}\"]`);\n  const listId = `${selectId}--list`;\n  const listIdLabel = `${selectId}-label`;\n  const additionalAttributes = [];\n  const { defaultValue } = comboBoxEl.dataset;\n  const { placeholder } = comboBoxEl.dataset;\n  let selectedOption;\n\n  if (placeholder) {\n    additionalAttributes.push({ placeholder });\n  }\n\n  if (defaultValue) {\n    for (let i = 0, len = selectEl.options.length; i < len; i += 1) {\n      const optionEl = selectEl.options[i];\n\n      if (optionEl.value === defaultValue) {\n        selectedOption = optionEl;\n        break;\n      }\n    }\n  }\n\n  /**\n   * Throw error if combobox is missing a label or label is missing\n   * `for` attribute. Otherwise, set the ID to match the <ul> aria-labelledby\n   */\n  if (!selectLabel || !selectLabel.matches(`label[for=\"${selectId}\"]`)) {\n    throw new Error(\n      `${COMBO_BOX} for ${selectId} is either missing a label or a \"for\" attribute`,\n    );\n  } else {\n    selectLabel.setAttribute(\"id\", listIdLabel);\n  }\n\n  selectLabel.setAttribute(\"id\", listIdLabel);\n  selectEl.setAttribute(\"aria-hidden\", \"true\");\n  selectEl.setAttribute(\"tabindex\", \"-1\");\n  selectEl.classList.add(\"usa-sr-only\", SELECT_CLASS);\n  selectEl.id = \"\";\n  selectEl.value = \"\";\n\n  [\"required\", \"aria-label\", \"aria-labelledby\"].forEach((name) => {\n    if (selectEl.hasAttribute(name)) {\n      const value = selectEl.getAttribute(name);\n      additionalAttributes.push({ [name]: value });\n      selectEl.removeAttribute(name);\n    }\n  });\n\n  // sanitize doesn't like functions in template literals\n  const input = document.createElement(\"input\");\n  input.setAttribute(\"id\", selectId);\n  input.setAttribute(\"aria-owns\", listId);\n  input.setAttribute(\"aria-controls\", listId);\n  input.setAttribute(\"aria-autocomplete\", \"list\");\n  input.setAttribute(\"aria-expanded\", \"false\");\n  input.setAttribute(\"autocapitalize\", \"off\");\n  input.setAttribute(\"autocomplete\", \"off\");\n  input.setAttribute(\"class\", INPUT_CLASS);\n  input.setAttribute(\"type\", \"text\");\n  input.setAttribute(\"role\", \"combobox\");\n  additionalAttributes.forEach((attr) =>\n    Object.keys(attr).forEach((key) => {\n      const value = Sanitizer.escapeHTML`${attr[key]}`;\n      input.setAttribute(key, value);\n    }),\n  );\n\n  comboBoxEl.insertAdjacentElement(\"beforeend\", input);\n\n  comboBoxEl.insertAdjacentHTML(\n    \"beforeend\",\n    Sanitizer.escapeHTML`\n    <span class=\"${CLEAR_INPUT_BUTTON_WRAPPER_CLASS}\" tabindex=\"-1\">\n        <button type=\"button\" class=\"${CLEAR_INPUT_BUTTON_CLASS}\" aria-label=\"Clear the select contents\">&nbsp;</button>\n      </span>\n      <span class=\"${INPUT_BUTTON_SEPARATOR_CLASS}\">&nbsp;</span>\n      <span class=\"${TOGGLE_LIST_BUTTON_WRAPPER_CLASS}\" tabindex=\"-1\">\n        <button type=\"button\" tabindex=\"-1\" class=\"${TOGGLE_LIST_BUTTON_CLASS}\" aria-label=\"Toggle the dropdown list\">&nbsp;</button>\n      </span>\n      <ul\n        tabindex=\"-1\"\n        id=\"${listId}\"\n        class=\"${LIST_CLASS}\"\n        role=\"listbox\"\n        aria-labelledby=\"${listIdLabel}\"\n        hidden>\n      </ul>\n      <div class=\"${STATUS_CLASS} usa-sr-only\" role=\"status\"></div>`,\n  );\n\n  if (selectedOption) {\n    const { inputEl } = getComboBoxContext(comboBoxEl);\n    changeElementValue(selectEl, selectedOption.value);\n    changeElementValue(inputEl, selectedOption.text);\n    comboBoxEl.classList.add(COMBO_BOX_PRISTINE_CLASS);\n  }\n\n  if (selectEl.disabled) {\n    disable(comboBoxEl);\n    selectEl.disabled = false;\n  }\n\n  if (selectEl.hasAttribute(\"aria-disabled\")) {\n    ariaDisable(comboBoxEl);\n    selectEl.removeAttribute(\"aria-disabled\");\n  }\n\n  comboBoxEl.dataset.enhanced = \"true\";\n};\n\n/**\n * Manage the focused element within the list options when\n * navigating via keyboard.\n *\n * @param {HTMLElement} el An anchor element within the combo box component\n * @param {HTMLElement} nextEl An element within the combo box component\n * @param {Object} options options\n * @param {boolean} options.skipFocus skip focus of highlighted item\n * @param {boolean} options.preventScroll should skip procedure to scroll to element\n */\nconst highlightOption = (el, nextEl, { skipFocus, preventScroll } = {}) => {\n  const { inputEl, listEl, focusedOptionEl } = getComboBoxContext(el);\n\n  if (focusedOptionEl) {\n    focusedOptionEl.classList.remove(LIST_OPTION_FOCUSED_CLASS);\n    focusedOptionEl.setAttribute(\"tabIndex\", \"-1\");\n  }\n\n  if (nextEl) {\n    inputEl.setAttribute(\"aria-activedescendant\", nextEl.id);\n    nextEl.setAttribute(\"tabIndex\", \"0\");\n    nextEl.classList.add(LIST_OPTION_FOCUSED_CLASS);\n\n    if (!preventScroll) {\n      const optionBottom = nextEl.offsetTop + nextEl.offsetHeight;\n      const currentBottom = listEl.scrollTop + listEl.offsetHeight;\n\n      if (optionBottom > currentBottom) {\n        listEl.scrollTop = optionBottom - listEl.offsetHeight;\n      }\n\n      if (nextEl.offsetTop < listEl.scrollTop) {\n        listEl.scrollTop = nextEl.offsetTop;\n      }\n    }\n\n    if (!skipFocus) {\n      nextEl.focus({ preventScroll });\n    }\n  } else {\n    inputEl.setAttribute(\"aria-activedescendant\", \"\");\n    inputEl.focus();\n  }\n};\n\n/**\n * Generate a dynamic regular expression based off of a replaceable and possibly filtered value.\n *\n * @param {string} el An element within the combo box component\n * @param {string} query The value to use in the regular expression\n * @param {object} extras An object of regular expressions to replace and filter the query\n */\nconst generateDynamicRegExp = (filter, query = \"\", extras = {}) => {\n  const escapeRegExp = (text) =>\n    text.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, \"\\\\$&\");\n\n  let find = filter.replace(/{{(.*?)}}/g, (m, $1) => {\n    const key = $1.trim();\n    const queryFilter = extras[key];\n    if (key !== \"query\" && queryFilter) {\n      const matcher = new RegExp(queryFilter, \"i\");\n      const matches = query.match(matcher);\n\n      if (matches) {\n        return escapeRegExp(matches[1]);\n      }\n\n      return \"\";\n    }\n    return escapeRegExp(query);\n  });\n\n  find = `^(?:${find})$`;\n\n  return new RegExp(find, \"i\");\n};\n\n/**\n * Display the option list of a combo box component.\n *\n * @param {HTMLElement} el An element within the combo box component\n */\nconst displayList = (el) => {\n  const {\n    comboBoxEl,\n    selectEl,\n    inputEl,\n    listEl,\n    statusEl,\n    isPristine,\n    disableFiltering,\n  } = getComboBoxContext(el);\n  let selectedItemId;\n  let firstFoundId;\n\n  const listOptionBaseId = `${listEl.id}--option-`;\n\n  const inputValue = (inputEl.value || \"\").toLowerCase();\n  const filter = comboBoxEl.dataset.filter || DEFAULT_FILTER;\n  const regex = generateDynamicRegExp(filter, inputValue, comboBoxEl.dataset);\n\n  let options = [];\n  const optionsStartsWith = [];\n  const optionsContains = [];\n  const optionList = [...selectEl.options];\n\n  /**\n   * Builds and sorts options array.\n   *\n   * Option param is passed through regex test before passing into this function.\n   * When filtering is enabled, the array will be sorted by options that start with the query, followed by\n   * options that contain the query.\n   * When filtering is disabled, all options will be included in the array unsorted.\n   *\n   * These array items will populate the list that is displayed to the user after a search query is entered.\n   * Array attributes are also used to set option IDs and aria-setsize attributes.\n   *\n   * @param {HTMLOptionElement} option - Option element from select array\n   */\n  const buildOptionsArray = (option) => {\n    if (disableFiltering || isPristine) {\n      options.push(option);\n      return;\n    }\n\n    const matchStartsWith = option.text.toLowerCase().startsWith(inputValue);\n\n    if (matchStartsWith) {\n      optionsStartsWith.push(option);\n    } else {\n      optionsContains.push(option);\n    }\n\n    options = [...optionsStartsWith, ...optionsContains];\n  };\n\n  /**\n   * Compares option text to query using generated regex filter.\n   *\n   * @param {HTMLOptionElement} option\n   * @returns {boolean} - True when option text matches user input query.\n   */\n  const optionMatchesQuery = (option) => regex.test(option.text);\n\n  /**\n   * Logic check to determine if options array needs to be updated.\n   *\n   * @param {HTMLOptionElement} option\n   * @returns {boolean} - True when option has value && if filtering is disabled, combo box has an active selection,\n   * there is no inputValue, or if option matches user query\n   */\n  const arrayNeedsUpdate = (option) =>\n    option.value &&\n    (disableFiltering ||\n      isPristine ||\n      !inputValue ||\n      optionMatchesQuery(option));\n\n  /**\n   * Checks if firstFoundId should be assigned, which is then used to set itemToFocus.\n   *\n   * @param {HTMLOptionElement} option\n   * @return {boolean} - Returns true if filtering is disabled, no firstFoundId is assigned, and the option matches the query.\n   */\n  const isFirstMatch = (option) =>\n    disableFiltering && !firstFoundId && optionMatchesQuery(option);\n\n  /**\n   * Checks if isCurrentSelection should be assigned, which is then used to set itemToFocus.\n   *\n   * @param {HTMLOptionElement} option\n   * @returns {boolean} - Returns true if option.value matches selectEl.value.\n   */\n  const isCurrentSelection = (option) =>\n    selectEl.value && option.value === selectEl.value;\n\n  /**\n   * Update the array of options that should be displayed on the page.\n   * Assign an ID to each displayed option.\n   * Identify and assign the option that should receive focus.\n   */\n  optionList.forEach((option) => {\n    if (arrayNeedsUpdate(option)) {\n      buildOptionsArray(option);\n\n      const optionId = `${listOptionBaseId}${options.indexOf(option)}`;\n\n      if (isFirstMatch(option)) {\n        firstFoundId = optionId;\n      }\n\n      if (isCurrentSelection(option)) {\n        selectedItemId = optionId;\n      }\n    }\n  });\n\n  const numOptions = options.length;\n  const optionHtml = options.map((option, index) => {\n    const optionId = `${listOptionBaseId}${index}`;\n    const classes = [LIST_OPTION_CLASS];\n    let tabindex = \"-1\";\n    let ariaSelected = \"false\";\n\n    if (optionId === selectedItemId) {\n      classes.push(LIST_OPTION_SELECTED_CLASS, LIST_OPTION_FOCUSED_CLASS);\n      tabindex = \"0\";\n      ariaSelected = \"true\";\n    }\n\n    if (!selectedItemId && index === 0) {\n      classes.push(LIST_OPTION_FOCUSED_CLASS);\n      tabindex = \"0\";\n    }\n\n    const li = document.createElement(\"li\");\n\n    li.setAttribute(\"aria-setsize\", options.length);\n    li.setAttribute(\"aria-posinset\", index + 1);\n    li.setAttribute(\"aria-selected\", ariaSelected);\n    li.setAttribute(\"id\", optionId);\n    li.setAttribute(\"class\", classes.join(\" \"));\n    li.setAttribute(\"tabindex\", tabindex);\n    li.setAttribute(\"role\", \"option\");\n    li.setAttribute(\"data-value\", option.value);\n    li.textContent = option.text;\n\n    return li;\n  });\n\n  const noResults = document.createElement(\"li\");\n  noResults.setAttribute(\"class\", `${LIST_OPTION_CLASS}--no-results`);\n  noResults.textContent = \"No results found\";\n\n  listEl.hidden = false;\n\n  if (numOptions) {\n    listEl.innerHTML = \"\";\n    optionHtml.forEach((item) =>\n      listEl.insertAdjacentElement(\"beforeend\", item),\n    );\n  } else {\n    listEl.innerHTML = \"\";\n    listEl.insertAdjacentElement(\"beforeend\", noResults);\n  }\n\n  inputEl.setAttribute(\"aria-expanded\", \"true\");\n\n  statusEl.textContent = numOptions\n    ? `${numOptions} result${numOptions > 1 ? \"s\" : \"\"} available.`\n    : \"No results.\";\n\n  let itemToFocus;\n\n  if (isPristine && selectedItemId) {\n    itemToFocus = listEl.querySelector(`#${selectedItemId}`);\n  } else if (disableFiltering && firstFoundId) {\n    itemToFocus = listEl.querySelector(`#${firstFoundId}`);\n  }\n\n  if (itemToFocus) {\n    highlightOption(listEl, itemToFocus, {\n      skipFocus: true,\n    });\n  }\n};\n\n/**\n * Hide the option list of a combo box component.\n *\n * @param {HTMLElement} el An element within the combo box component\n */\nconst hideList = (el) => {\n  const { inputEl, listEl, statusEl, focusedOptionEl } = getComboBoxContext(el);\n\n  statusEl.innerHTML = \"\";\n\n  inputEl.setAttribute(\"aria-expanded\", \"false\");\n  inputEl.setAttribute(\"aria-activedescendant\", \"\");\n\n  if (focusedOptionEl) {\n    focusedOptionEl.classList.remove(LIST_OPTION_FOCUSED_CLASS);\n  }\n\n  listEl.scrollTop = 0;\n  listEl.hidden = true;\n};\n\n/**\n * Select an option list of the combo box component.\n *\n * @param {HTMLElement} listOptionEl The list option being selected\n */\nconst selectItem = (listOptionEl) => {\n  const { comboBoxEl, selectEl, inputEl } = getComboBoxContext(listOptionEl);\n\n  changeElementValue(selectEl, listOptionEl.dataset.value);\n  changeElementValue(inputEl, listOptionEl.textContent);\n  comboBoxEl.classList.add(COMBO_BOX_PRISTINE_CLASS);\n  hideList(comboBoxEl);\n  inputEl.focus();\n};\n\n/**\n * Clear the input of the combo box\n *\n * @param {HTMLButtonElement} clearButtonEl The clear input button\n */\nconst clearInput = (clearButtonEl) => {\n  const { comboBoxEl, listEl, selectEl, inputEl } =\n    getComboBoxContext(clearButtonEl);\n  const listShown = !listEl.hidden;\n\n  if (selectEl.value) changeElementValue(selectEl);\n  if (inputEl.value) changeElementValue(inputEl);\n  comboBoxEl.classList.remove(COMBO_BOX_PRISTINE_CLASS);\n\n  if (listShown) displayList(comboBoxEl);\n  inputEl.focus();\n};\n\n/**\n * Reset the select based off of currently set select value\n *\n * @param {HTMLElement} el An element within the combo box component\n */\nconst resetSelection = (el) => {\n  const { comboBoxEl, selectEl, inputEl } = getComboBoxContext(el);\n\n  const selectValue = selectEl.value;\n  const inputValue = (inputEl.value || \"\").toLowerCase();\n\n  if (selectValue) {\n    for (let i = 0, len = selectEl.options.length; i < len; i += 1) {\n      const optionEl = selectEl.options[i];\n      if (optionEl.value === selectValue) {\n        if (inputValue !== optionEl.text) {\n          changeElementValue(inputEl, optionEl.text);\n        }\n        comboBoxEl.classList.add(COMBO_BOX_PRISTINE_CLASS);\n        return;\n      }\n    }\n  }\n\n  if (inputValue) {\n    changeElementValue(inputEl);\n  }\n};\n\n/**\n * Select an option list of the combo box component based off of\n * having a current focused list option or\n * having test that completely matches a list option.\n * Otherwise it clears the input and select.\n *\n * @param {HTMLElement} el An element within the combo box component\n */\nconst completeSelection = (el) => {\n  const { comboBoxEl, selectEl, inputEl, statusEl } = getComboBoxContext(el);\n\n  statusEl.textContent = \"\";\n\n  const inputValue = (inputEl.value || \"\").toLowerCase();\n\n  if (inputValue) {\n    for (let i = 0, len = selectEl.options.length; i < len; i += 1) {\n      const optionEl = selectEl.options[i];\n      if (optionEl.text.toLowerCase() === inputValue) {\n        changeElementValue(selectEl, optionEl.value);\n        changeElementValue(inputEl, optionEl.text);\n        comboBoxEl.classList.add(COMBO_BOX_PRISTINE_CLASS);\n        return;\n      }\n    }\n  }\n\n  resetSelection(comboBoxEl);\n};\n\n/**\n * Handle the escape event within the combo box component.\n *\n * @param {KeyboardEvent} event An event within the combo box component\n */\nconst handleEscape = (event) => {\n  const { comboBoxEl, inputEl } = getComboBoxContext(event.target);\n\n  hideList(comboBoxEl);\n  resetSelection(comboBoxEl);\n  inputEl.focus();\n};\n\n/**\n * Handle the down event within the combo box component.\n *\n * @param {KeyboardEvent} event An event within the combo box component\n */\nconst handleDownFromInput = (event) => {\n  const { comboBoxEl, listEl } = getComboBoxContext(event.target);\n\n  if (listEl.hidden) {\n    displayList(comboBoxEl);\n  }\n\n  const nextOptionEl =\n    listEl.querySelector(LIST_OPTION_FOCUSED) ||\n    listEl.querySelector(LIST_OPTION);\n\n  if (nextOptionEl) {\n    highlightOption(comboBoxEl, nextOptionEl);\n  }\n\n  event.preventDefault();\n};\n\n/**\n * Handle the enter event from an input element within the combo box component.\n *\n * @param {KeyboardEvent} event An event within the combo box component\n */\nconst handleEnterFromInput = (event) => {\n  const { comboBoxEl, listEl } = getComboBoxContext(event.target);\n  const listShown = !listEl.hidden;\n\n  completeSelection(comboBoxEl);\n\n  if (listShown) {\n    hideList(comboBoxEl);\n  }\n\n  event.preventDefault();\n};\n\n/**\n * Handle the down event within the combo box component.\n *\n * @param {KeyboardEvent} event An event within the combo box component\n */\nconst handleDownFromListOption = (event) => {\n  const focusedOptionEl = event.target;\n  const nextOptionEl = focusedOptionEl.nextSibling;\n\n  if (nextOptionEl) {\n    highlightOption(focusedOptionEl, nextOptionEl);\n  }\n\n  event.preventDefault();\n};\n\n/**\n * Handle the space event from an list option element within the combo box component.\n *\n * @param {KeyboardEvent} event An event within the combo box component\n */\nconst handleSpaceFromListOption = (event) => {\n  selectItem(event.target);\n  event.preventDefault();\n};\n\n/**\n * Handle the enter event from list option within the combo box component.\n *\n * @param {KeyboardEvent} event An event within the combo box component\n */\nconst handleEnterFromListOption = (event) => {\n  selectItem(event.target);\n  event.preventDefault();\n};\n\n/**\n * Handle the up event from list option within the combo box component.\n *\n * @param {KeyboardEvent} event An event within the combo box component\n */\nconst handleUpFromListOption = (event) => {\n  const { comboBoxEl, listEl, focusedOptionEl } = getComboBoxContext(\n    event.target,\n  );\n  const nextOptionEl = focusedOptionEl && focusedOptionEl.previousSibling;\n  const listShown = !listEl.hidden;\n\n  highlightOption(comboBoxEl, nextOptionEl);\n\n  if (listShown) {\n    event.preventDefault();\n  }\n\n  if (!nextOptionEl) {\n    hideList(comboBoxEl);\n  }\n};\n\n/**\n * Select list option on the mouseover event.\n *\n * @param {MouseEvent} event The mouseover event\n * @param {HTMLLIElement} listOptionEl An element within the combo box component\n */\nconst handleMouseover = (listOptionEl) => {\n  const isCurrentlyFocused = listOptionEl.classList.contains(\n    LIST_OPTION_FOCUSED_CLASS,\n  );\n\n  if (isCurrentlyFocused) return;\n\n  highlightOption(listOptionEl, listOptionEl, {\n    preventScroll: true,\n  });\n};\n\n/**\n * Toggle the list when the button is clicked\n *\n * @param {HTMLElement} el An element within the combo box component\n */\nconst toggleList = (el) => {\n  const { comboBoxEl, listEl, inputEl } = getComboBoxContext(el);\n\n  if (listEl.hidden) {\n    displayList(comboBoxEl);\n  } else {\n    hideList(comboBoxEl);\n  }\n\n  inputEl.focus();\n};\n\n/**\n * Handle click from input\n *\n * @param {HTMLInputElement} el An element within the combo box component\n */\nconst handleClickFromInput = (el) => {\n  const { comboBoxEl, listEl } = getComboBoxContext(el);\n\n  if (listEl.hidden) {\n    displayList(comboBoxEl);\n  }\n};\n\nconst comboBox = behavior(\n  {\n    [CLICK]: {\n      [INPUT]() {\n        if (this.disabled) return;\n        handleClickFromInput(this);\n      },\n      [TOGGLE_LIST_BUTTON]() {\n        if (this.disabled) return;\n        toggleList(this);\n      },\n      [LIST_OPTION]() {\n        if (this.disabled) return;\n        selectItem(this);\n      },\n      [CLEAR_INPUT_BUTTON]() {\n        if (this.disabled) return;\n        clearInput(this);\n      },\n    },\n    focusout: {\n      [COMBO_BOX](event) {\n        if (!this.contains(event.relatedTarget)) {\n          resetSelection(this);\n          hideList(this);\n        }\n      },\n    },\n    keydown: {\n      [COMBO_BOX]: keymap({\n        Escape: handleEscape,\n      }),\n      [INPUT]: keymap({\n        Enter: handleEnterFromInput,\n        ArrowDown: handleDownFromInput,\n        Down: handleDownFromInput,\n      }),\n      [LIST_OPTION]: keymap({\n        ArrowUp: handleUpFromListOption,\n        Up: handleUpFromListOption,\n        ArrowDown: handleDownFromListOption,\n        Down: handleDownFromListOption,\n        Enter: handleEnterFromListOption,\n        \" \": handleSpaceFromListOption,\n        \"Shift+Tab\": noop,\n      }),\n    },\n    input: {\n      [INPUT]() {\n        const comboBoxEl = this.closest(COMBO_BOX);\n        comboBoxEl.classList.remove(COMBO_BOX_PRISTINE_CLASS);\n        displayList(this);\n      },\n    },\n    mouseover: {\n      [LIST_OPTION]() {\n        handleMouseover(this);\n      },\n    },\n  },\n  {\n    init(root) {\n      selectOrMatches(COMBO_BOX, root).forEach((comboBoxEl) => {\n        enhanceComboBox(comboBoxEl);\n      });\n    },\n    getComboBoxContext,\n    enhanceComboBox,\n    generateDynamicRegExp,\n    disable,\n    enable,\n    displayList,\n    hideList,\n    COMBO_BOX_CLASS,\n  },\n);\n\nmodule.exports = comboBox;\n","const keymap = require(\"receptor/keymap\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst select = require(\"../../uswds-core/src/js/utils/select\");\nconst selectOrMatches = require(\"../../uswds-core/src/js/utils/select-or-matches\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\nconst { CLICK } = require(\"../../uswds-core/src/js/events\");\nconst activeElement = require(\"../../uswds-core/src/js/utils/active-element\");\nconst isIosDevice = require(\"../../uswds-core/src/js/utils/is-ios-device\");\nconst Sanitizer = require(\"../../uswds-core/src/js/utils/sanitizer\");\n\nconst DATE_PICKER_CLASS = `${PREFIX}-date-picker`;\nconst DATE_PICKER_WRAPPER_CLASS = `${DATE_PICKER_CLASS}__wrapper`;\nconst DATE_PICKER_INITIALIZED_CLASS = `${DATE_PICKER_CLASS}--initialized`;\nconst DATE_PICKER_ACTIVE_CLASS = `${DATE_PICKER_CLASS}--active`;\nconst DATE_PICKER_INTERNAL_INPUT_CLASS = `${DATE_PICKER_CLASS}__internal-input`;\nconst DATE_PICKER_EXTERNAL_INPUT_CLASS = `${DATE_PICKER_CLASS}__external-input`;\nconst DATE_PICKER_BUTTON_CLASS = `${DATE_PICKER_CLASS}__button`;\nconst DATE_PICKER_CALENDAR_CLASS = `${DATE_PICKER_CLASS}__calendar`;\nconst DATE_PICKER_STATUS_CLASS = `${DATE_PICKER_CLASS}__status`;\nconst CALENDAR_DATE_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__date`;\n\nconst CALENDAR_DATE_FOCUSED_CLASS = `${CALENDAR_DATE_CLASS}--focused`;\nconst CALENDAR_DATE_SELECTED_CLASS = `${CALENDAR_DATE_CLASS}--selected`;\nconst CALENDAR_DATE_PREVIOUS_MONTH_CLASS = `${CALENDAR_DATE_CLASS}--previous-month`;\nconst CALENDAR_DATE_CURRENT_MONTH_CLASS = `${CALENDAR_DATE_CLASS}--current-month`;\nconst CALENDAR_DATE_NEXT_MONTH_CLASS = `${CALENDAR_DATE_CLASS}--next-month`;\nconst CALENDAR_DATE_RANGE_DATE_CLASS = `${CALENDAR_DATE_CLASS}--range-date`;\nconst CALENDAR_DATE_TODAY_CLASS = `${CALENDAR_DATE_CLASS}--today`;\nconst CALENDAR_DATE_RANGE_DATE_START_CLASS = `${CALENDAR_DATE_CLASS}--range-date-start`;\nconst CALENDAR_DATE_RANGE_DATE_END_CLASS = `${CALENDAR_DATE_CLASS}--range-date-end`;\nconst CALENDAR_DATE_WITHIN_RANGE_CLASS = `${CALENDAR_DATE_CLASS}--within-range`;\nconst CALENDAR_PREVIOUS_YEAR_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__previous-year`;\nconst CALENDAR_PREVIOUS_MONTH_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__previous-month`;\nconst CALENDAR_NEXT_YEAR_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__next-year`;\nconst CALENDAR_NEXT_MONTH_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__next-month`;\nconst CALENDAR_MONTH_SELECTION_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__month-selection`;\nconst CALENDAR_YEAR_SELECTION_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__year-selection`;\nconst CALENDAR_MONTH_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__month`;\nconst CALENDAR_MONTH_FOCUSED_CLASS = `${CALENDAR_MONTH_CLASS}--focused`;\nconst CALENDAR_MONTH_SELECTED_CLASS = `${CALENDAR_MONTH_CLASS}--selected`;\nconst CALENDAR_YEAR_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__year`;\nconst CALENDAR_YEAR_FOCUSED_CLASS = `${CALENDAR_YEAR_CLASS}--focused`;\nconst CALENDAR_YEAR_SELECTED_CLASS = `${CALENDAR_YEAR_CLASS}--selected`;\nconst CALENDAR_PREVIOUS_YEAR_CHUNK_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__previous-year-chunk`;\nconst CALENDAR_NEXT_YEAR_CHUNK_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__next-year-chunk`;\nconst CALENDAR_DATE_PICKER_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__date-picker`;\nconst CALENDAR_MONTH_PICKER_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__month-picker`;\nconst CALENDAR_YEAR_PICKER_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__year-picker`;\nconst CALENDAR_TABLE_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__table`;\nconst CALENDAR_ROW_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__row`;\nconst CALENDAR_CELL_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__cell`;\nconst CALENDAR_CELL_CENTER_ITEMS_CLASS = `${CALENDAR_CELL_CLASS}--center-items`;\nconst CALENDAR_MONTH_LABEL_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__month-label`;\nconst CALENDAR_DAY_OF_WEEK_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__day-of-week`;\n\nconst DATE_PICKER = `.${DATE_PICKER_CLASS}`;\nconst DATE_PICKER_BUTTON = `.${DATE_PICKER_BUTTON_CLASS}`;\nconst DATE_PICKER_INTERNAL_INPUT = `.${DATE_PICKER_INTERNAL_INPUT_CLASS}`;\nconst DATE_PICKER_EXTERNAL_INPUT = `.${DATE_PICKER_EXTERNAL_INPUT_CLASS}`;\nconst DATE_PICKER_CALENDAR = `.${DATE_PICKER_CALENDAR_CLASS}`;\nconst DATE_PICKER_STATUS = `.${DATE_PICKER_STATUS_CLASS}`;\nconst CALENDAR_DATE = `.${CALENDAR_DATE_CLASS}`;\nconst CALENDAR_DATE_FOCUSED = `.${CALENDAR_DATE_FOCUSED_CLASS}`;\nconst CALENDAR_DATE_CURRENT_MONTH = `.${CALENDAR_DATE_CURRENT_MONTH_CLASS}`;\nconst CALENDAR_PREVIOUS_YEAR = `.${CALENDAR_PREVIOUS_YEAR_CLASS}`;\nconst CALENDAR_PREVIOUS_MONTH = `.${CALENDAR_PREVIOUS_MONTH_CLASS}`;\nconst CALENDAR_NEXT_YEAR = `.${CALENDAR_NEXT_YEAR_CLASS}`;\nconst CALENDAR_NEXT_MONTH = `.${CALENDAR_NEXT_MONTH_CLASS}`;\nconst CALENDAR_YEAR_SELECTION = `.${CALENDAR_YEAR_SELECTION_CLASS}`;\nconst CALENDAR_MONTH_SELECTION = `.${CALENDAR_MONTH_SELECTION_CLASS}`;\nconst CALENDAR_MONTH = `.${CALENDAR_MONTH_CLASS}`;\nconst CALENDAR_YEAR = `.${CALENDAR_YEAR_CLASS}`;\nconst CALENDAR_PREVIOUS_YEAR_CHUNK = `.${CALENDAR_PREVIOUS_YEAR_CHUNK_CLASS}`;\nconst CALENDAR_NEXT_YEAR_CHUNK = `.${CALENDAR_NEXT_YEAR_CHUNK_CLASS}`;\nconst CALENDAR_DATE_PICKER = `.${CALENDAR_DATE_PICKER_CLASS}`;\nconst CALENDAR_MONTH_PICKER = `.${CALENDAR_MONTH_PICKER_CLASS}`;\nconst CALENDAR_YEAR_PICKER = `.${CALENDAR_YEAR_PICKER_CLASS}`;\nconst CALENDAR_MONTH_FOCUSED = `.${CALENDAR_MONTH_FOCUSED_CLASS}`;\nconst CALENDAR_YEAR_FOCUSED = `.${CALENDAR_YEAR_FOCUSED_CLASS}`;\n\nconst VALIDATION_MESSAGE = \"Please enter a valid date\";\n\nconst MONTH_LABELS = [\n  \"January\",\n  \"February\",\n  \"March\",\n  \"April\",\n  \"May\",\n  \"June\",\n  \"July\",\n  \"August\",\n  \"September\",\n  \"October\",\n  \"November\",\n  \"December\",\n];\n\nconst DAY_OF_WEEK_LABELS = [\n  \"Sunday\",\n  \"Monday\",\n  \"Tuesday\",\n  \"Wednesday\",\n  \"Thursday\",\n  \"Friday\",\n  \"Saturday\",\n];\n\nconst ENTER_KEYCODE = 13;\n\nconst YEAR_CHUNK = 12;\n\nconst DEFAULT_MIN_DATE = \"0000-01-01\";\nconst DEFAULT_EXTERNAL_DATE_FORMAT = \"MM/DD/YYYY\";\nconst INTERNAL_DATE_FORMAT = \"YYYY-MM-DD\";\n\nconst NOT_DISABLED_SELECTOR = \":not([disabled])\";\n\nconst processFocusableSelectors = (...selectors) =>\n  selectors.map((query) => query + NOT_DISABLED_SELECTOR).join(\", \");\n\nconst DATE_PICKER_FOCUSABLE = processFocusableSelectors(\n  CALENDAR_PREVIOUS_YEAR,\n  CALENDAR_PREVIOUS_MONTH,\n  CALENDAR_YEAR_SELECTION,\n  CALENDAR_MONTH_SELECTION,\n  CALENDAR_NEXT_YEAR,\n  CALENDAR_NEXT_MONTH,\n  CALENDAR_DATE_FOCUSED,\n);\n\nconst MONTH_PICKER_FOCUSABLE = processFocusableSelectors(\n  CALENDAR_MONTH_FOCUSED,\n);\n\nconst YEAR_PICKER_FOCUSABLE = processFocusableSelectors(\n  CALENDAR_PREVIOUS_YEAR_CHUNK,\n  CALENDAR_NEXT_YEAR_CHUNK,\n  CALENDAR_YEAR_FOCUSED,\n);\n\n// #region Date Manipulation Functions\n\n/**\n * Keep date within month. Month would only be over by 1 to 3 days\n *\n * @param {Date} dateToCheck the date object to check\n * @param {number} month the correct month\n * @returns {Date} the date, corrected if needed\n */\nconst keepDateWithinMonth = (dateToCheck, month) => {\n  if (month !== dateToCheck.getMonth()) {\n    dateToCheck.setDate(0);\n  }\n\n  return dateToCheck;\n};\n\n/**\n * Set date from month day year\n *\n * @param {number} year the year to set\n * @param {number} month the month to set (zero-indexed)\n * @param {number} date the date to set\n * @returns {Date} the set date\n */\nconst setDate = (year, month, date) => {\n  const newDate = new Date(0);\n  newDate.setFullYear(year, month, date);\n  return newDate;\n};\n\n/**\n * todays date\n *\n * @returns {Date} todays date\n */\nconst today = () => {\n  const newDate = new Date();\n  const day = newDate.getDate();\n  const month = newDate.getMonth();\n  const year = newDate.getFullYear();\n  return setDate(year, month, day);\n};\n\n/**\n * Set date to first day of the month\n *\n * @param {number} date the date to adjust\n * @returns {Date} the adjusted date\n */\nconst startOfMonth = (date) => {\n  const newDate = new Date(0);\n  newDate.setFullYear(date.getFullYear(), date.getMonth(), 1);\n  return newDate;\n};\n\n/**\n * Set date to last day of the month\n *\n * @param {number} date the date to adjust\n * @returns {Date} the adjusted date\n */\nconst lastDayOfMonth = (date) => {\n  const newDate = new Date(0);\n  newDate.setFullYear(date.getFullYear(), date.getMonth() + 1, 0);\n  return newDate;\n};\n\n/**\n * Add days to date\n *\n * @param {Date} _date the date to adjust\n * @param {number} numDays the difference in days\n * @returns {Date} the adjusted date\n */\nconst addDays = (_date, numDays) => {\n  const newDate = new Date(_date.getTime());\n  newDate.setDate(newDate.getDate() + numDays);\n  return newDate;\n};\n\n/**\n * Subtract days from date\n *\n * @param {Date} _date the date to adjust\n * @param {number} numDays the difference in days\n * @returns {Date} the adjusted date\n */\nconst subDays = (_date, numDays) => addDays(_date, -numDays);\n\n/**\n * Add weeks to date\n *\n * @param {Date} _date the date to adjust\n * @param {number} numWeeks the difference in weeks\n * @returns {Date} the adjusted date\n */\nconst addWeeks = (_date, numWeeks) => addDays(_date, numWeeks * 7);\n\n/**\n * Subtract weeks from date\n *\n * @param {Date} _date the date to adjust\n * @param {number} numWeeks the difference in weeks\n * @returns {Date} the adjusted date\n */\nconst subWeeks = (_date, numWeeks) => addWeeks(_date, -numWeeks);\n\n/**\n * Set date to the start of the week (Sunday)\n *\n * @param {Date} _date the date to adjust\n * @returns {Date} the adjusted date\n */\nconst startOfWeek = (_date) => {\n  const dayOfWeek = _date.getDay();\n  return subDays(_date, dayOfWeek);\n};\n\n/**\n * Set date to the end of the week (Saturday)\n *\n * @param {Date} _date the date to adjust\n * @param {number} numWeeks the difference in weeks\n * @returns {Date} the adjusted date\n */\nconst endOfWeek = (_date) => {\n  const dayOfWeek = _date.getDay();\n  return addDays(_date, 6 - dayOfWeek);\n};\n\n/**\n * Add months to date and keep date within month\n *\n * @param {Date} _date the date to adjust\n * @param {number} numMonths the difference in months\n * @returns {Date} the adjusted date\n */\nconst addMonths = (_date, numMonths) => {\n  const newDate = new Date(_date.getTime());\n\n  const dateMonth = (newDate.getMonth() + 12 + numMonths) % 12;\n  newDate.setMonth(newDate.getMonth() + numMonths);\n  keepDateWithinMonth(newDate, dateMonth);\n\n  return newDate;\n};\n\n/**\n * Subtract months from date\n *\n * @param {Date} _date the date to adjust\n * @param {number} numMonths the difference in months\n * @returns {Date} the adjusted date\n */\nconst subMonths = (_date, numMonths) => addMonths(_date, -numMonths);\n\n/**\n * Add years to date and keep date within month\n *\n * @param {Date} _date the date to adjust\n * @param {number} numYears the difference in years\n * @returns {Date} the adjusted date\n */\nconst addYears = (_date, numYears) => addMonths(_date, numYears * 12);\n\n/**\n * Subtract years from date\n *\n * @param {Date} _date the date to adjust\n * @param {number} numYears the difference in years\n * @returns {Date} the adjusted date\n */\nconst subYears = (_date, numYears) => addYears(_date, -numYears);\n\n/**\n * Set months of date\n *\n * @param {Date} _date the date to adjust\n * @param {number} month zero-indexed month to set\n * @returns {Date} the adjusted date\n */\nconst setMonth = (_date, month) => {\n  const newDate = new Date(_date.getTime());\n\n  newDate.setMonth(month);\n  keepDateWithinMonth(newDate, month);\n\n  return newDate;\n};\n\n/**\n * Set year of date\n *\n * @param {Date} _date the date to adjust\n * @param {number} year the year to set\n * @returns {Date} the adjusted date\n */\nconst setYear = (_date, year) => {\n  const newDate = new Date(_date.getTime());\n\n  const month = newDate.getMonth();\n  newDate.setFullYear(year);\n  keepDateWithinMonth(newDate, month);\n\n  return newDate;\n};\n\n/**\n * Return the earliest date\n *\n * @param {Date} dateA date to compare\n * @param {Date} dateB date to compare\n * @returns {Date} the earliest date\n */\nconst min = (dateA, dateB) => {\n  let newDate = dateA;\n\n  if (dateB < dateA) {\n    newDate = dateB;\n  }\n\n  return new Date(newDate.getTime());\n};\n\n/**\n * Return the latest date\n *\n * @param {Date} dateA date to compare\n * @param {Date} dateB date to compare\n * @returns {Date} the latest date\n */\nconst max = (dateA, dateB) => {\n  let newDate = dateA;\n\n  if (dateB > dateA) {\n    newDate = dateB;\n  }\n\n  return new Date(newDate.getTime());\n};\n\n/**\n * Check if dates are the in the same year\n *\n * @param {Date} dateA date to compare\n * @param {Date} dateB date to compare\n * @returns {boolean} are dates in the same year\n */\nconst isSameYear = (dateA, dateB) =>\n  dateA && dateB && dateA.getFullYear() === dateB.getFullYear();\n\n/**\n * Check if dates are the in the same month\n *\n * @param {Date} dateA date to compare\n * @param {Date} dateB date to compare\n * @returns {boolean} are dates in the same month\n */\nconst isSameMonth = (dateA, dateB) =>\n  isSameYear(dateA, dateB) && dateA.getMonth() === dateB.getMonth();\n\n/**\n * Check if dates are the same date\n *\n * @param {Date} dateA the date to compare\n * @param {Date} dateA the date to compare\n * @returns {boolean} are dates the same date\n */\nconst isSameDay = (dateA, dateB) =>\n  isSameMonth(dateA, dateB) && dateA.getDate() === dateB.getDate();\n\n/**\n * return a new date within minimum and maximum date\n *\n * @param {Date} date date to check\n * @param {Date} minDate minimum date to allow\n * @param {Date} maxDate maximum date to allow\n * @returns {Date} the date between min and max\n */\nconst keepDateBetweenMinAndMax = (date, minDate, maxDate) => {\n  let newDate = date;\n\n  if (date < minDate) {\n    newDate = minDate;\n  } else if (maxDate && date > maxDate) {\n    newDate = maxDate;\n  }\n\n  return new Date(newDate.getTime());\n};\n\n/**\n * Check if dates is valid.\n *\n * @param {Date} date date to check\n * @param {Date} minDate minimum date to allow\n * @param {Date} maxDate maximum date to allow\n * @return {boolean} is there a day within the month within min and max dates\n */\nconst isDateWithinMinAndMax = (date, minDate, maxDate) =>\n  date >= minDate && (!maxDate || date <= maxDate);\n\n/**\n * Check if dates month is invalid.\n *\n * @param {Date} date date to check\n * @param {Date} minDate minimum date to allow\n * @param {Date} maxDate maximum date to allow\n * @return {boolean} is the month outside min or max dates\n */\nconst isDatesMonthOutsideMinOrMax = (date, minDate, maxDate) =>\n  lastDayOfMonth(date) < minDate || (maxDate && startOfMonth(date) > maxDate);\n\n/**\n * Check if dates year is invalid.\n *\n * @param {Date} date date to check\n * @param {Date} minDate minimum date to allow\n * @param {Date} maxDate maximum date to allow\n * @return {boolean} is the month outside min or max dates\n */\nconst isDatesYearOutsideMinOrMax = (date, minDate, maxDate) =>\n  lastDayOfMonth(setMonth(date, 11)) < minDate ||\n  (maxDate && startOfMonth(setMonth(date, 0)) > maxDate);\n\n/**\n * @typedef {Object} DateRangeContext\n * @property {Date} rangeStartDate\n * @property {Date} rangeEndDate\n * @property {Date} withinRangeStartDate\n * @property {Date} withinRangeEndDate\n */\n\n/**\n * Set the start, end, and within range values for date range variants.\n\n * @param {Date} date - Date that concludes the date range.\n * @param {Date} rangeDate - Range date data attribute value of the date picker component.\n * @returns {DateRangeContext} - Dates for range selection.\n */\nconst setRangeDates = (date, rangeDate) => {\n  const rangeConclusionDate = date;\n  const rangeStartDate = rangeDate && min(rangeConclusionDate, rangeDate);\n  const rangeEndDate = rangeDate && max(rangeConclusionDate, rangeDate);\n\n  const withinRangeStartDate = rangeDate && addDays(rangeStartDate, 1);\n  const withinRangeEndDate = rangeDate && subDays(rangeEndDate, 1);\n\n  return {\n    rangeStartDate,\n    rangeEndDate,\n    withinRangeStartDate,\n    withinRangeEndDate,\n  };\n};\n\n/**\n * Parse a date with format M-D-YY\n *\n * @param {string} dateString the date string to parse\n * @param {string} dateFormat the format of the date string\n * @param {boolean} adjustDate should the date be adjusted\n * @returns {Date} the parsed date\n */\nconst parseDateString = (\n  dateString,\n  dateFormat = INTERNAL_DATE_FORMAT,\n  adjustDate = false,\n) => {\n  let date;\n  let month;\n  let day;\n  let year;\n  let parsed;\n\n  if (dateString) {\n    let monthStr;\n    let dayStr;\n    let yearStr;\n\n    if (dateFormat === DEFAULT_EXTERNAL_DATE_FORMAT) {\n      [monthStr, dayStr, yearStr] = dateString.split(\"/\");\n    } else {\n      [yearStr, monthStr, dayStr] = dateString.split(\"-\");\n    }\n\n    if (yearStr) {\n      parsed = parseInt(yearStr, 10);\n      if (!Number.isNaN(parsed)) {\n        year = parsed;\n        if (adjustDate) {\n          year = Math.max(0, year);\n          if (yearStr.length < 3) {\n            const currentYear = today().getFullYear();\n            const currentYearStub =\n              currentYear - (currentYear % 10 ** yearStr.length);\n            year = currentYearStub + parsed;\n          }\n        }\n      }\n    }\n\n    if (monthStr) {\n      parsed = parseInt(monthStr, 10);\n      if (!Number.isNaN(parsed)) {\n        month = parsed;\n        if (adjustDate) {\n          month = Math.max(1, month);\n          month = Math.min(12, month);\n        }\n      }\n    }\n\n    if (month && dayStr && year != null) {\n      parsed = parseInt(dayStr, 10);\n      if (!Number.isNaN(parsed)) {\n        day = parsed;\n        if (adjustDate) {\n          const lastDayOfTheMonth = setDate(year, month, 0).getDate();\n          day = Math.max(1, day);\n          day = Math.min(lastDayOfTheMonth, day);\n        }\n      }\n    }\n\n    if (month && day && year != null) {\n      date = setDate(year, month - 1, day);\n    }\n  }\n\n  return date;\n};\n\n/**\n * Format a date to format MM-DD-YYYY\n *\n * @param {Date} date the date to format\n * @param {string} dateFormat the format of the date string\n * @returns {string} the formatted date string\n */\nconst formatDate = (date, dateFormat = INTERNAL_DATE_FORMAT) => {\n  const padZeros = (value, length) => `0000${value}`.slice(-length);\n\n  const month = date.getMonth() + 1;\n  const day = date.getDate();\n  const year = date.getFullYear();\n\n  if (dateFormat === DEFAULT_EXTERNAL_DATE_FORMAT) {\n    return [padZeros(month, 2), padZeros(day, 2), padZeros(year, 4)].join(\"/\");\n  }\n\n  return [padZeros(year, 4), padZeros(month, 2), padZeros(day, 2)].join(\"-\");\n};\n\n// #endregion Date Manipulation Functions\n\n/**\n * Create a grid string from an array of html strings\n *\n * @param {string[]} htmlArray the array of html items\n * @param {number} rowSize the length of a row\n * @returns {string} the grid string\n */\nconst listToGridHtml = (htmlArray, rowSize) => {\n  const grid = [];\n  let row = [];\n\n  let i = 0;\n  while (i < htmlArray.length) {\n    row = [];\n\n    const tr = document.createElement(\"tr\");\n    while (i < htmlArray.length && row.length < rowSize) {\n      const td = document.createElement(\"td\");\n      td.insertAdjacentElement(\"beforeend\", htmlArray[i]);\n      row.push(td);\n      i += 1;\n    }\n\n    row.forEach((element) => {\n      tr.insertAdjacentElement(\"beforeend\", element);\n    });\n\n    grid.push(tr);\n  }\n\n  return grid;\n};\n\nconst createTableBody = (grid) => {\n  const tableBody = document.createElement(\"tbody\");\n  grid.forEach((element) => {\n    tableBody.insertAdjacentElement(\"beforeend\", element);\n  });\n\n  return tableBody;\n};\n\n/**\n * set the value of the element and dispatch a change event\n *\n * @param {HTMLInputElement} el The element to update\n * @param {string} value The new value of the element\n */\nconst changeElementValue = (el, value = \"\") => {\n  const elementToChange = el;\n  elementToChange.value = value;\n\n  const event = new CustomEvent(\"change\", {\n    bubbles: true,\n    cancelable: true,\n    detail: { value },\n  });\n  elementToChange.dispatchEvent(event);\n};\n\n/**\n * The properties and elements within the date picker.\n * @typedef {Object} DatePickerContext\n * @property {HTMLDivElement} calendarEl\n * @property {HTMLElement} datePickerEl\n * @property {HTMLInputElement} internalInputEl\n * @property {HTMLInputElement} externalInputEl\n * @property {HTMLDivElement} statusEl\n * @property {HTMLDivElement} firstYearChunkEl\n * @property {Date} calendarDate\n * @property {Date} minDate\n * @property {Date} maxDate\n * @property {Date} selectedDate\n * @property {Date} rangeDate\n * @property {Date} defaultDate\n */\n\n/**\n * Get an object of the properties and elements belonging directly to the given\n * date picker component.\n *\n * @param {HTMLElement} el the element within the date picker\n * @returns {DatePickerContext} elements\n */\nconst getDatePickerContext = (el) => {\n  const datePickerEl = el.closest(DATE_PICKER);\n\n  if (!datePickerEl) {\n    throw new Error(`Element is missing outer ${DATE_PICKER}`);\n  }\n\n  const internalInputEl = datePickerEl.querySelector(\n    DATE_PICKER_INTERNAL_INPUT,\n  );\n  const externalInputEl = datePickerEl.querySelector(\n    DATE_PICKER_EXTERNAL_INPUT,\n  );\n  const calendarEl = datePickerEl.querySelector(DATE_PICKER_CALENDAR);\n  const toggleBtnEl = datePickerEl.querySelector(DATE_PICKER_BUTTON);\n  const statusEl = datePickerEl.querySelector(DATE_PICKER_STATUS);\n  const firstYearChunkEl = datePickerEl.querySelector(CALENDAR_YEAR);\n\n  const inputDate = parseDateString(\n    externalInputEl.value,\n    DEFAULT_EXTERNAL_DATE_FORMAT,\n    true,\n  );\n  const selectedDate = parseDateString(internalInputEl.value);\n\n  const calendarDate = parseDateString(calendarEl.dataset.value);\n  const minDate = parseDateString(datePickerEl.dataset.minDate);\n  const maxDate = parseDateString(datePickerEl.dataset.maxDate);\n  const rangeDate = parseDateString(datePickerEl.dataset.rangeDate);\n  const defaultDate = parseDateString(datePickerEl.dataset.defaultDate);\n\n  if (minDate && maxDate && minDate > maxDate) {\n    throw new Error(\"Minimum date cannot be after maximum date\");\n  }\n\n  return {\n    calendarDate,\n    minDate,\n    toggleBtnEl,\n    selectedDate,\n    maxDate,\n    firstYearChunkEl,\n    datePickerEl,\n    inputDate,\n    internalInputEl,\n    externalInputEl,\n    calendarEl,\n    rangeDate,\n    defaultDate,\n    statusEl,\n  };\n};\n\n/**\n * Disable the date picker component\n *\n * @param {HTMLElement} el An element within the date picker component\n */\nconst disable = (el) => {\n  const { externalInputEl, toggleBtnEl } = getDatePickerContext(el);\n\n  toggleBtnEl.disabled = true;\n  externalInputEl.disabled = true;\n};\n\n/**\n * Add the readonly attribute to input element and the aria-disabled attribute to the toggle calendar button and external input elements.\n *\n * @param {HTMLElement} el - The date picker element\n */\nconst ariaDisable = (el) => {\n  const { externalInputEl, toggleBtnEl } = getDatePickerContext(el);\n\n  toggleBtnEl.setAttribute(\"aria-disabled\", true);\n  externalInputEl.setAttribute(\"aria-disabled\", true);\n  externalInputEl.setAttribute(\"readonly\", \"\");\n};\n\n/**\n * Enable the date picker component\n *\n * @param {HTMLElement} el An element within the date picker component\n */\nconst enable = (el) => {\n  const { externalInputEl, toggleBtnEl } = getDatePickerContext(el);\n\n  toggleBtnEl.disabled = false;\n  toggleBtnEl.removeAttribute(\"aria-disabled\");\n\n  externalInputEl.disabled = false;\n  externalInputEl.removeAttribute(\"aria-disabled\");\n  externalInputEl.removeAttribute(\"readonly\");\n};\n\n// #region Validation\n\n/**\n * Validate the value in the input as a valid date of format M/D/YYYY\n *\n * @param {HTMLElement} el An element within the date picker component\n */\nconst isDateInputInvalid = (el) => {\n  const { externalInputEl, minDate, maxDate } = getDatePickerContext(el);\n\n  const dateString = externalInputEl.value;\n  let isInvalid = false;\n\n  if (dateString) {\n    isInvalid = true;\n\n    const dateStringParts = dateString.split(\"/\");\n    const [month, day, year] = dateStringParts.map((str) => {\n      let value;\n      const parsed = parseInt(str, 10);\n      if (!Number.isNaN(parsed)) value = parsed;\n      return value;\n    });\n\n    if (month && day && year != null) {\n      const checkDate = setDate(year, month - 1, day);\n\n      if (\n        checkDate.getMonth() === month - 1 &&\n        checkDate.getDate() === day &&\n        checkDate.getFullYear() === year &&\n        dateStringParts[2].length === 4 &&\n        isDateWithinMinAndMax(checkDate, minDate, maxDate)\n      ) {\n        isInvalid = false;\n      }\n    }\n  }\n\n  return isInvalid;\n};\n\n/**\n * Validate the value in the input as a valid date of format M/D/YYYY\n *\n * @param {HTMLElement} el An element within the date picker component\n */\nconst validateDateInput = (el) => {\n  const { externalInputEl } = getDatePickerContext(el);\n  const isInvalid = isDateInputInvalid(externalInputEl);\n\n  if (isInvalid && !externalInputEl.validationMessage) {\n    externalInputEl.setCustomValidity(VALIDATION_MESSAGE);\n  }\n\n  if (!isInvalid && externalInputEl.validationMessage === VALIDATION_MESSAGE) {\n    externalInputEl.setCustomValidity(\"\");\n  }\n};\n\n// #endregion Validation\n\n/**\n * Enable the date picker component\n *\n * @param {HTMLElement} el An element within the date picker component\n */\nconst reconcileInputValues = (el) => {\n  const { internalInputEl, inputDate } = getDatePickerContext(el);\n  let newValue = \"\";\n\n  if (inputDate && !isDateInputInvalid(el)) {\n    newValue = formatDate(inputDate);\n  }\n\n  if (internalInputEl.value !== newValue) {\n    changeElementValue(internalInputEl, newValue);\n  }\n};\n\n/**\n * Select the value of the date picker inputs.\n *\n * @param {HTMLButtonElement} el An element within the date picker component\n * @param {string} dateString The date string to update in YYYY-MM-DD format\n */\nconst setCalendarValue = (el, dateString) => {\n  const parsedDate = parseDateString(dateString);\n\n  if (parsedDate) {\n    const formattedDate = formatDate(parsedDate, DEFAULT_EXTERNAL_DATE_FORMAT);\n\n    const { datePickerEl, internalInputEl, externalInputEl } =\n      getDatePickerContext(el);\n\n    changeElementValue(internalInputEl, dateString);\n    changeElementValue(externalInputEl, formattedDate);\n\n    validateDateInput(datePickerEl);\n  }\n};\n\n/**\n * Enhance an input with the date picker elements\n *\n * @param {HTMLElement} el The initial wrapping element of the date picker component\n */\nconst enhanceDatePicker = (el) => {\n  const datePickerEl = el.closest(DATE_PICKER);\n  const { defaultValue } = datePickerEl.dataset;\n\n  const internalInputEl = datePickerEl.querySelector(`input`);\n\n  if (!internalInputEl) {\n    throw new Error(`${DATE_PICKER} is missing inner input`);\n  }\n\n  if (internalInputEl.value) {\n    internalInputEl.value = \"\";\n  }\n\n  const minDate = parseDateString(\n    datePickerEl.dataset.minDate || internalInputEl.getAttribute(\"min\"),\n  );\n  datePickerEl.dataset.minDate = minDate\n    ? formatDate(minDate)\n    : DEFAULT_MIN_DATE;\n\n  const maxDate = parseDateString(\n    datePickerEl.dataset.maxDate || internalInputEl.getAttribute(\"max\"),\n  );\n  if (maxDate) {\n    datePickerEl.dataset.maxDate = formatDate(maxDate);\n  }\n\n  const calendarWrapper = document.createElement(\"div\");\n  calendarWrapper.classList.add(DATE_PICKER_WRAPPER_CLASS);\n\n  const externalInputEl = internalInputEl.cloneNode();\n  externalInputEl.classList.add(DATE_PICKER_EXTERNAL_INPUT_CLASS);\n  externalInputEl.type = \"text\";\n\n  calendarWrapper.appendChild(externalInputEl);\n  calendarWrapper.insertAdjacentHTML(\n    \"beforeend\",\n    Sanitizer.escapeHTML`\n    <button type=\"button\" class=\"${DATE_PICKER_BUTTON_CLASS}\" aria-haspopup=\"true\" aria-label=\"Toggle calendar\"></button>\n    <div class=\"${DATE_PICKER_CALENDAR_CLASS}\" role=\"application\" hidden></div>\n    <div class=\"usa-sr-only ${DATE_PICKER_STATUS_CLASS}\" role=\"status\" aria-live=\"polite\"></div>`,\n  );\n\n  internalInputEl.setAttribute(\"aria-hidden\", \"true\");\n  internalInputEl.setAttribute(\"tabindex\", \"-1\");\n  internalInputEl.style.display = \"none\";\n  internalInputEl.classList.add(DATE_PICKER_INTERNAL_INPUT_CLASS);\n  internalInputEl.removeAttribute(\"id\");\n  internalInputEl.removeAttribute(\"name\");\n  internalInputEl.required = false;\n\n  datePickerEl.appendChild(calendarWrapper);\n  datePickerEl.classList.add(DATE_PICKER_INITIALIZED_CLASS);\n\n  if (defaultValue) {\n    setCalendarValue(datePickerEl, defaultValue);\n  }\n\n  if (internalInputEl.disabled) {\n    disable(datePickerEl);\n    internalInputEl.disabled = false;\n  }\n\n  if (internalInputEl.hasAttribute(\"aria-disabled\")) {\n    ariaDisable(datePickerEl);\n    internalInputEl.removeAttribute(\"aria-disabled\");\n  }\n};\n\n// #region Calendar - Date Selection View\n\n/**\n * render the calendar.\n *\n * @param {HTMLElement} el An element within the date picker component\n * @param {Date} _dateToDisplay a date to render on the calendar\n * @returns {HTMLElement} a reference to the new calendar element\n */\nconst renderCalendar = (el, _dateToDisplay) => {\n  const {\n    datePickerEl,\n    calendarEl,\n    statusEl,\n    selectedDate,\n    maxDate,\n    minDate,\n    rangeDate,\n  } = getDatePickerContext(el);\n  const todaysDate = today();\n  let dateToDisplay = _dateToDisplay || todaysDate;\n\n  const calendarWasHidden = calendarEl.hidden;\n\n  const focusedDate = addDays(dateToDisplay, 0);\n  const focusedMonth = dateToDisplay.getMonth();\n  const focusedYear = dateToDisplay.getFullYear();\n\n  const prevMonth = subMonths(dateToDisplay, 1);\n  const nextMonth = addMonths(dateToDisplay, 1);\n\n  const currentFormattedDate = formatDate(dateToDisplay);\n\n  const firstOfMonth = startOfMonth(dateToDisplay);\n  const prevButtonsDisabled = isSameMonth(dateToDisplay, minDate);\n  const nextButtonsDisabled = isSameMonth(dateToDisplay, maxDate);\n\n  const {\n    rangeStartDate,\n    rangeEndDate,\n    withinRangeStartDate,\n    withinRangeEndDate,\n  } = setRangeDates(selectedDate || dateToDisplay, rangeDate);\n\n  const monthLabel = MONTH_LABELS[focusedMonth];\n\n  const generateDateHtml = (dateToRender) => {\n    const classes = [CALENDAR_DATE_CLASS];\n    const day = dateToRender.getDate();\n    const month = dateToRender.getMonth();\n    const year = dateToRender.getFullYear();\n    const dayOfWeek = dateToRender.getDay();\n\n    const formattedDate = formatDate(dateToRender);\n\n    let tabindex = \"-1\";\n\n    const isDisabled = !isDateWithinMinAndMax(dateToRender, minDate, maxDate);\n    const isSelected = isSameDay(dateToRender, selectedDate);\n\n    if (isSameMonth(dateToRender, prevMonth)) {\n      classes.push(CALENDAR_DATE_PREVIOUS_MONTH_CLASS);\n    }\n\n    if (isSameMonth(dateToRender, focusedDate)) {\n      classes.push(CALENDAR_DATE_CURRENT_MONTH_CLASS);\n    }\n\n    if (isSameMonth(dateToRender, nextMonth)) {\n      classes.push(CALENDAR_DATE_NEXT_MONTH_CLASS);\n    }\n\n    if (isSelected) {\n      classes.push(CALENDAR_DATE_SELECTED_CLASS);\n    }\n\n    if (isSameDay(dateToRender, todaysDate)) {\n      classes.push(CALENDAR_DATE_TODAY_CLASS);\n    }\n\n    if (rangeDate) {\n      if (isSameDay(dateToRender, rangeDate)) {\n        classes.push(CALENDAR_DATE_RANGE_DATE_CLASS);\n      }\n\n      if (isSameDay(dateToRender, rangeStartDate)) {\n        classes.push(CALENDAR_DATE_RANGE_DATE_START_CLASS);\n      }\n\n      if (isSameDay(dateToRender, rangeEndDate)) {\n        classes.push(CALENDAR_DATE_RANGE_DATE_END_CLASS);\n      }\n\n      if (\n        isDateWithinMinAndMax(\n          dateToRender,\n          withinRangeStartDate,\n          withinRangeEndDate,\n        )\n      ) {\n        classes.push(CALENDAR_DATE_WITHIN_RANGE_CLASS);\n      }\n    }\n\n    if (isSameDay(dateToRender, focusedDate)) {\n      tabindex = \"0\";\n      classes.push(CALENDAR_DATE_FOCUSED_CLASS);\n    }\n\n    const monthStr = MONTH_LABELS[month];\n    const dayStr = DAY_OF_WEEK_LABELS[dayOfWeek];\n\n    const btn = document.createElement(\"button\");\n    btn.setAttribute(\"type\", \"button\");\n    btn.setAttribute(\"tabindex\", tabindex);\n    btn.setAttribute(\"class\", classes.join(\" \"));\n    btn.setAttribute(\"data-day\", day);\n    btn.setAttribute(\"data-month\", month + 1);\n    btn.setAttribute(\"data-year\", year);\n    btn.setAttribute(\"data-value\", formattedDate);\n    btn.setAttribute(\n      \"aria-label\",\n      Sanitizer.escapeHTML`${day} ${monthStr} ${year} ${dayStr}`,\n    );\n    btn.setAttribute(\"aria-selected\", isSelected ? \"true\" : \"false\");\n    if (isDisabled === true) {\n      btn.disabled = true;\n    }\n    btn.textContent = day;\n\n    return btn;\n  };\n\n  // set date to first rendered day\n  dateToDisplay = startOfWeek(firstOfMonth);\n\n  const days = [];\n\n  while (\n    days.length < 28 ||\n    dateToDisplay.getMonth() === focusedMonth ||\n    days.length % 7 !== 0\n  ) {\n    days.push(generateDateHtml(dateToDisplay));\n    dateToDisplay = addDays(dateToDisplay, 1);\n  }\n\n  const datesGrid = listToGridHtml(days, 7);\n\n  const newCalendar = calendarEl.cloneNode();\n  newCalendar.dataset.value = currentFormattedDate;\n  newCalendar.style.top = `${datePickerEl.offsetHeight}px`;\n  newCalendar.hidden = false;\n  newCalendar.innerHTML = Sanitizer.escapeHTML`\n    <div tabindex=\"-1\" class=\"${CALENDAR_DATE_PICKER_CLASS}\">\n      <div class=\"${CALENDAR_ROW_CLASS}\">\n        <div class=\"${CALENDAR_CELL_CLASS} ${CALENDAR_CELL_CENTER_ITEMS_CLASS}\">\n          <button\n            type=\"button\"\n            class=\"${CALENDAR_PREVIOUS_YEAR_CLASS}\"\n            aria-label=\"Navigate back one year\"\n            ${prevButtonsDisabled ? `disabled=\"disabled\"` : \"\"}\n          ></button>\n        </div>\n        <div class=\"${CALENDAR_CELL_CLASS} ${CALENDAR_CELL_CENTER_ITEMS_CLASS}\">\n          <button\n            type=\"button\"\n            class=\"${CALENDAR_PREVIOUS_MONTH_CLASS}\"\n            aria-label=\"Navigate back one month\"\n            ${prevButtonsDisabled ? `disabled=\"disabled\"` : \"\"}\n          ></button>\n        </div>\n        <div class=\"${CALENDAR_CELL_CLASS} ${CALENDAR_MONTH_LABEL_CLASS}\">\n          <button\n            type=\"button\"\n            class=\"${CALENDAR_MONTH_SELECTION_CLASS}\" aria-label=\"${monthLabel}. Select month\"\n          >${monthLabel}</button>\n          <button\n            type=\"button\"\n            class=\"${CALENDAR_YEAR_SELECTION_CLASS}\" aria-label=\"${focusedYear}. Select year\"\n          >${focusedYear}</button>\n        </div>\n        <div class=\"${CALENDAR_CELL_CLASS} ${CALENDAR_CELL_CENTER_ITEMS_CLASS}\">\n          <button\n            type=\"button\"\n            class=\"${CALENDAR_NEXT_MONTH_CLASS}\"\n            aria-label=\"Navigate forward one month\"\n            ${nextButtonsDisabled ? `disabled=\"disabled\"` : \"\"}\n          ></button>\n        </div>\n        <div class=\"${CALENDAR_CELL_CLASS} ${CALENDAR_CELL_CENTER_ITEMS_CLASS}\">\n          <button\n            type=\"button\"\n            class=\"${CALENDAR_NEXT_YEAR_CLASS}\"\n            aria-label=\"Navigate forward one year\"\n            ${nextButtonsDisabled ? `disabled=\"disabled\"` : \"\"}\n          ></button>\n        </div>\n      </div>\n    </div>\n    `;\n\n  const table = document.createElement(\"table\");\n  table.setAttribute(\"class\", CALENDAR_TABLE_CLASS);\n\n  const tableHead = document.createElement(\"thead\");\n  table.insertAdjacentElement(\"beforeend\", tableHead);\n  const tableHeadRow = document.createElement(\"tr\");\n  tableHead.insertAdjacentElement(\"beforeend\", tableHeadRow);\n\n  const daysOfWeek = {\n    Sunday: \"S\",\n    Monday: \"M\",\n    Tuesday: \"T\",\n    Wednesday: \"W\",\n    Thursday: \"Th\",\n    Friday: \"Fr\",\n    Saturday: \"S\",\n  };\n\n  Object.keys(daysOfWeek).forEach((key) => {\n    const th = document.createElement(\"th\");\n    th.setAttribute(\"class\", CALENDAR_DAY_OF_WEEK_CLASS);\n    th.setAttribute(\"scope\", \"col\");\n    th.setAttribute(\"aria-label\", key);\n    th.textContent = daysOfWeek[key];\n    tableHeadRow.insertAdjacentElement(\"beforeend\", th);\n  });\n\n  const tableBody = createTableBody(datesGrid);\n  table.insertAdjacentElement(\"beforeend\", tableBody);\n\n  // Container for Years, Months, and Days\n  const datePickerCalendarContainer =\n    newCalendar.querySelector(CALENDAR_DATE_PICKER);\n\n  datePickerCalendarContainer.insertAdjacentElement(\"beforeend\", table);\n\n  calendarEl.parentNode.replaceChild(newCalendar, calendarEl);\n\n  datePickerEl.classList.add(DATE_PICKER_ACTIVE_CLASS);\n\n  const statuses = [];\n\n  if (isSameDay(selectedDate, focusedDate)) {\n    statuses.push(\"Selected date\");\n  }\n\n  if (calendarWasHidden) {\n    statuses.push(\n      \"You can navigate by day using left and right arrows\",\n      \"Weeks by using up and down arrows\",\n      \"Months by using page up and page down keys\",\n      \"Years by using shift plus page up and shift plus page down\",\n      \"Home and end keys navigate to the beginning and end of a week\",\n    );\n    statusEl.textContent = \"\";\n  } else {\n    statuses.push(`${monthLabel} ${focusedYear}`);\n  }\n  statusEl.textContent = statuses.join(\". \");\n\n  return newCalendar;\n};\n\n/**\n * Navigate back one year and display the calendar.\n *\n * @param {HTMLButtonElement} _buttonEl An element within the date picker component\n */\nconst displayPreviousYear = (_buttonEl) => {\n  if (_buttonEl.disabled) return;\n  const { calendarEl, calendarDate, minDate, maxDate } =\n    getDatePickerContext(_buttonEl);\n  let date = subYears(calendarDate, 1);\n  date = keepDateBetweenMinAndMax(date, minDate, maxDate);\n  const newCalendar = renderCalendar(calendarEl, date);\n\n  let nextToFocus = newCalendar.querySelector(CALENDAR_PREVIOUS_YEAR);\n  if (nextToFocus.disabled) {\n    nextToFocus = newCalendar.querySelector(CALENDAR_DATE_PICKER);\n  }\n  nextToFocus.focus();\n};\n\n/**\n * Navigate back one month and display the calendar.\n *\n * @param {HTMLButtonElement} _buttonEl An element within the date picker component\n */\nconst displayPreviousMonth = (_buttonEl) => {\n  if (_buttonEl.disabled) return;\n  const { calendarEl, calendarDate, minDate, maxDate } =\n    getDatePickerContext(_buttonEl);\n  let date = subMonths(calendarDate, 1);\n  date = keepDateBetweenMinAndMax(date, minDate, maxDate);\n  const newCalendar = renderCalendar(calendarEl, date);\n\n  let nextToFocus = newCalendar.querySelector(CALENDAR_PREVIOUS_MONTH);\n  if (nextToFocus.disabled) {\n    nextToFocus = newCalendar.querySelector(CALENDAR_DATE_PICKER);\n  }\n  nextToFocus.focus();\n};\n\n/**\n * Navigate forward one month and display the calendar.\n *\n * @param {HTMLButtonElement} _buttonEl An element within the date picker component\n */\nconst displayNextMonth = (_buttonEl) => {\n  if (_buttonEl.disabled) return;\n  const { calendarEl, calendarDate, minDate, maxDate } =\n    getDatePickerContext(_buttonEl);\n  let date = addMonths(calendarDate, 1);\n  date = keepDateBetweenMinAndMax(date, minDate, maxDate);\n  const newCalendar = renderCalendar(calendarEl, date);\n\n  let nextToFocus = newCalendar.querySelector(CALENDAR_NEXT_MONTH);\n  if (nextToFocus.disabled) {\n    nextToFocus = newCalendar.querySelector(CALENDAR_DATE_PICKER);\n  }\n  nextToFocus.focus();\n};\n\n/**\n * Navigate forward one year and display the calendar.\n *\n * @param {HTMLButtonElement} _buttonEl An element within the date picker component\n */\nconst displayNextYear = (_buttonEl) => {\n  if (_buttonEl.disabled) return;\n  const { calendarEl, calendarDate, minDate, maxDate } =\n    getDatePickerContext(_buttonEl);\n  let date = addYears(calendarDate, 1);\n  date = keepDateBetweenMinAndMax(date, minDate, maxDate);\n  const newCalendar = renderCalendar(calendarEl, date);\n\n  let nextToFocus = newCalendar.querySelector(CALENDAR_NEXT_YEAR);\n  if (nextToFocus.disabled) {\n    nextToFocus = newCalendar.querySelector(CALENDAR_DATE_PICKER);\n  }\n  nextToFocus.focus();\n};\n\n/**\n * Hide the calendar of a date picker component.\n *\n * @param {HTMLElement} el An element within the date picker component\n */\nconst hideCalendar = (el) => {\n  const { datePickerEl, calendarEl, statusEl } = getDatePickerContext(el);\n\n  datePickerEl.classList.remove(DATE_PICKER_ACTIVE_CLASS);\n  calendarEl.hidden = true;\n  statusEl.textContent = \"\";\n};\n\n/**\n * Select a date within the date picker component.\n *\n * @param {HTMLButtonElement} calendarDateEl A date element within the date picker component\n */\nconst selectDate = (calendarDateEl) => {\n  if (calendarDateEl.disabled) return;\n\n  const { datePickerEl, externalInputEl } =\n    getDatePickerContext(calendarDateEl);\n\n  setCalendarValue(calendarDateEl, calendarDateEl.dataset.value);\n  hideCalendar(datePickerEl);\n\n  externalInputEl.focus();\n};\n\n/**\n * Toggle the calendar.\n *\n * @param {HTMLButtonElement} el An element within the date picker component\n */\nconst toggleCalendar = (el) => {\n  if (el.disabled || el.hasAttribute(\"aria-disabled\")) return;\n  const { calendarEl, inputDate, minDate, maxDate, defaultDate } =\n    getDatePickerContext(el);\n\n  if (calendarEl.hidden) {\n    const dateToDisplay = keepDateBetweenMinAndMax(\n      inputDate || defaultDate || today(),\n      minDate,\n      maxDate,\n    );\n    const newCalendar = renderCalendar(calendarEl, dateToDisplay);\n    newCalendar.querySelector(CALENDAR_DATE_FOCUSED).focus();\n  } else {\n    hideCalendar(el);\n  }\n};\n\n/**\n * Update the calendar when visible.\n *\n * @param {HTMLElement} el an element within the date picker\n */\nconst updateCalendarIfVisible = (el) => {\n  const { calendarEl, inputDate, minDate, maxDate } = getDatePickerContext(el);\n  const calendarShown = !calendarEl.hidden;\n\n  if (calendarShown && inputDate) {\n    const dateToDisplay = keepDateBetweenMinAndMax(inputDate, minDate, maxDate);\n    renderCalendar(calendarEl, dateToDisplay);\n  }\n};\n\n// #endregion Calendar - Date Selection View\n\n// #region Calendar - Month Selection View\n/**\n * Display the month selection screen in the date picker.\n *\n * @param {HTMLButtonElement} el An element within the date picker component\n * @returns {HTMLElement} a reference to the new calendar element\n */\nconst displayMonthSelection = (el, monthToDisplay) => {\n  const { calendarEl, statusEl, calendarDate, minDate, maxDate } =\n    getDatePickerContext(el);\n\n  const selectedMonth = calendarDate.getMonth();\n  const focusedMonth = monthToDisplay == null ? selectedMonth : monthToDisplay;\n\n  const months = MONTH_LABELS.map((month, index) => {\n    const monthToCheck = setMonth(calendarDate, index);\n\n    const isDisabled = isDatesMonthOutsideMinOrMax(\n      monthToCheck,\n      minDate,\n      maxDate,\n    );\n\n    let tabindex = \"-1\";\n\n    const classes = [CALENDAR_MONTH_CLASS];\n    const isSelected = index === selectedMonth;\n\n    if (index === focusedMonth) {\n      tabindex = \"0\";\n      classes.push(CALENDAR_MONTH_FOCUSED_CLASS);\n    }\n\n    if (isSelected) {\n      classes.push(CALENDAR_MONTH_SELECTED_CLASS);\n    }\n\n    const btn = document.createElement(\"button\");\n    btn.setAttribute(\"type\", \"button\");\n    btn.setAttribute(\"tabindex\", tabindex);\n    btn.setAttribute(\"class\", classes.join(\" \"));\n    btn.setAttribute(\"data-value\", index);\n    btn.setAttribute(\"data-label\", month);\n    btn.setAttribute(\"aria-selected\", isSelected ? \"true\" : \"false\");\n    if (isDisabled === true) {\n      btn.disabled = true;\n    }\n    btn.textContent = month;\n\n    return btn;\n  });\n\n  const monthsHtml = document.createElement(\"div\");\n  monthsHtml.setAttribute(\"tabindex\", \"-1\");\n  monthsHtml.setAttribute(\"class\", CALENDAR_MONTH_PICKER_CLASS);\n\n  const table = document.createElement(\"table\");\n  table.setAttribute(\"class\", CALENDAR_TABLE_CLASS);\n  table.setAttribute(\"role\", \"presentation\");\n\n  const monthsGrid = listToGridHtml(months, 3);\n  const tableBody = createTableBody(monthsGrid);\n  table.insertAdjacentElement(\"beforeend\", tableBody);\n  monthsHtml.insertAdjacentElement(\"beforeend\", table);\n\n  const newCalendar = calendarEl.cloneNode();\n  newCalendar.insertAdjacentElement(\"beforeend\", monthsHtml);\n  calendarEl.parentNode.replaceChild(newCalendar, calendarEl);\n\n  statusEl.textContent = \"Select a month.\";\n\n  return newCalendar;\n};\n\n/**\n * Select a month in the date picker component.\n *\n * @param {HTMLButtonElement} monthEl An month element within the date picker component\n */\nconst selectMonth = (monthEl) => {\n  if (monthEl.disabled) return;\n  const { calendarEl, calendarDate, minDate, maxDate } =\n    getDatePickerContext(monthEl);\n  const selectedMonth = parseInt(monthEl.dataset.value, 10);\n  let date = setMonth(calendarDate, selectedMonth);\n  date = keepDateBetweenMinAndMax(date, minDate, maxDate);\n  const newCalendar = renderCalendar(calendarEl, date);\n  newCalendar.querySelector(CALENDAR_DATE_FOCUSED).focus();\n};\n\n// #endregion Calendar - Month Selection View\n\n// #region Calendar - Year Selection View\n\n/**\n * Display the year selection screen in the date picker.\n *\n * @param {HTMLButtonElement} el An element within the date picker component\n * @param {number} yearToDisplay year to display in year selection\n * @returns {HTMLElement} a reference to the new calendar element\n */\nconst displayYearSelection = (el, yearToDisplay) => {\n  const { calendarEl, statusEl, calendarDate, minDate, maxDate } =\n    getDatePickerContext(el);\n\n  const selectedYear = calendarDate.getFullYear();\n  const focusedYear = yearToDisplay == null ? selectedYear : yearToDisplay;\n\n  let yearToChunk = focusedYear;\n  yearToChunk -= yearToChunk % YEAR_CHUNK;\n  yearToChunk = Math.max(0, yearToChunk);\n\n  const prevYearChunkDisabled = isDatesYearOutsideMinOrMax(\n    setYear(calendarDate, yearToChunk - 1),\n    minDate,\n    maxDate,\n  );\n\n  const nextYearChunkDisabled = isDatesYearOutsideMinOrMax(\n    setYear(calendarDate, yearToChunk + YEAR_CHUNK),\n    minDate,\n    maxDate,\n  );\n\n  const years = [];\n  let yearIndex = yearToChunk;\n  while (years.length < YEAR_CHUNK) {\n    const isDisabled = isDatesYearOutsideMinOrMax(\n      setYear(calendarDate, yearIndex),\n      minDate,\n      maxDate,\n    );\n\n    let tabindex = \"-1\";\n\n    const classes = [CALENDAR_YEAR_CLASS];\n    const isSelected = yearIndex === selectedYear;\n\n    if (yearIndex === focusedYear) {\n      tabindex = \"0\";\n      classes.push(CALENDAR_YEAR_FOCUSED_CLASS);\n    }\n\n    if (isSelected) {\n      classes.push(CALENDAR_YEAR_SELECTED_CLASS);\n    }\n\n    const btn = document.createElement(\"button\");\n    btn.setAttribute(\"type\", \"button\");\n    btn.setAttribute(\"tabindex\", tabindex);\n    btn.setAttribute(\"class\", classes.join(\" \"));\n    btn.setAttribute(\"data-value\", yearIndex);\n    btn.setAttribute(\"aria-selected\", isSelected ? \"true\" : \"false\");\n    if (isDisabled === true) {\n      btn.disabled = true;\n    }\n    btn.textContent = yearIndex;\n\n    years.push(btn);\n    yearIndex += 1;\n  }\n\n  const newCalendar = calendarEl.cloneNode();\n\n  // create the years calendar wrapper\n  const yearsCalendarWrapper = document.createElement(\"div\");\n  yearsCalendarWrapper.setAttribute(\"tabindex\", \"-1\");\n  yearsCalendarWrapper.setAttribute(\"class\", CALENDAR_YEAR_PICKER_CLASS);\n\n  // create table parent\n  const yearsTableParent = document.createElement(\"table\");\n  yearsTableParent.setAttribute(\"class\", CALENDAR_TABLE_CLASS);\n\n  // create table body and table row\n  const yearsHTMLTableBody = document.createElement(\"tbody\");\n  const yearsHTMLTableBodyRow = document.createElement(\"tr\");\n\n  // create previous button\n  const previousYearsBtn = document.createElement(\"button\");\n  previousYearsBtn.setAttribute(\"type\", \"button\");\n  previousYearsBtn.setAttribute(\"class\", CALENDAR_PREVIOUS_YEAR_CHUNK_CLASS);\n  previousYearsBtn.setAttribute(\n    \"aria-label\",\n    `Navigate back ${YEAR_CHUNK} years`,\n  );\n  if (prevYearChunkDisabled === true) {\n    previousYearsBtn.disabled = true;\n  }\n  previousYearsBtn.innerHTML = Sanitizer.escapeHTML`&nbsp`;\n\n  // create next button\n  const nextYearsBtn = document.createElement(\"button\");\n  nextYearsBtn.setAttribute(\"type\", \"button\");\n  nextYearsBtn.setAttribute(\"class\", CALENDAR_NEXT_YEAR_CHUNK_CLASS);\n  nextYearsBtn.setAttribute(\n    \"aria-label\",\n    `Navigate forward ${YEAR_CHUNK} years`,\n  );\n  if (nextYearChunkDisabled === true) {\n    nextYearsBtn.disabled = true;\n  }\n  nextYearsBtn.innerHTML = Sanitizer.escapeHTML`&nbsp`;\n\n  // create the actual years table\n  const yearsTable = document.createElement(\"table\");\n  yearsTable.setAttribute(\"class\", CALENDAR_TABLE_CLASS);\n  yearsTable.setAttribute(\"role\", \"presentation\");\n\n  // create the years child table\n  const yearsGrid = listToGridHtml(years, 3);\n  const yearsTableBody = createTableBody(yearsGrid);\n\n  // append the grid to the years child table\n  yearsTable.insertAdjacentElement(\"beforeend\", yearsTableBody);\n\n  // create the prev button td and append the prev button\n  const yearsHTMLTableBodyDetailPrev = document.createElement(\"td\");\n  yearsHTMLTableBodyDetailPrev.insertAdjacentElement(\n    \"beforeend\",\n    previousYearsBtn,\n  );\n\n  // create the years td and append the years child table\n  const yearsHTMLTableBodyYearsDetail = document.createElement(\"td\");\n  yearsHTMLTableBodyYearsDetail.setAttribute(\"colspan\", \"3\");\n  yearsHTMLTableBodyYearsDetail.insertAdjacentElement(\"beforeend\", yearsTable);\n\n  // create the next button td and append the next button\n  const yearsHTMLTableBodyDetailNext = document.createElement(\"td\");\n  yearsHTMLTableBodyDetailNext.insertAdjacentElement(\"beforeend\", nextYearsBtn);\n\n  // append the three td to the years child table row\n  yearsHTMLTableBodyRow.insertAdjacentElement(\n    \"beforeend\",\n    yearsHTMLTableBodyDetailPrev,\n  );\n  yearsHTMLTableBodyRow.insertAdjacentElement(\n    \"beforeend\",\n    yearsHTMLTableBodyYearsDetail,\n  );\n  yearsHTMLTableBodyRow.insertAdjacentElement(\n    \"beforeend\",\n    yearsHTMLTableBodyDetailNext,\n  );\n\n  // append the table row to the years child table body\n  yearsHTMLTableBody.insertAdjacentElement(\"beforeend\", yearsHTMLTableBodyRow);\n\n  // append the years table body to the years parent table\n  yearsTableParent.insertAdjacentElement(\"beforeend\", yearsHTMLTableBody);\n\n  // append the parent table to the calendar wrapper\n  yearsCalendarWrapper.insertAdjacentElement(\"beforeend\", yearsTableParent);\n\n  // append the years calender to the new calendar\n  newCalendar.insertAdjacentElement(\"beforeend\", yearsCalendarWrapper);\n\n  // replace calendar\n  calendarEl.parentNode.replaceChild(newCalendar, calendarEl);\n\n  statusEl.textContent = Sanitizer.escapeHTML`Showing years ${yearToChunk} to ${\n    yearToChunk + YEAR_CHUNK - 1\n  }. Select a year.`;\n\n  return newCalendar;\n};\n\n/**\n * Navigate back by years and display the year selection screen.\n *\n * @param {HTMLButtonElement} el An element within the date picker component\n */\nconst displayPreviousYearChunk = (el) => {\n  if (el.disabled) return;\n\n  const { calendarEl, calendarDate, minDate, maxDate } =\n    getDatePickerContext(el);\n  const yearEl = calendarEl.querySelector(CALENDAR_YEAR_FOCUSED);\n  const selectedYear = parseInt(yearEl.textContent, 10);\n\n  let adjustedYear = selectedYear - YEAR_CHUNK;\n  adjustedYear = Math.max(0, adjustedYear);\n\n  const date = setYear(calendarDate, adjustedYear);\n  const cappedDate = keepDateBetweenMinAndMax(date, minDate, maxDate);\n  const newCalendar = displayYearSelection(\n    calendarEl,\n    cappedDate.getFullYear(),\n  );\n\n  let nextToFocus = newCalendar.querySelector(CALENDAR_PREVIOUS_YEAR_CHUNK);\n  if (nextToFocus.disabled) {\n    nextToFocus = newCalendar.querySelector(CALENDAR_YEAR_PICKER);\n  }\n  nextToFocus.focus();\n};\n\n/**\n * Navigate forward by years and display the year selection screen.\n *\n * @param {HTMLButtonElement} el An element within the date picker component\n */\nconst displayNextYearChunk = (el) => {\n  if (el.disabled) return;\n\n  const { calendarEl, calendarDate, minDate, maxDate } =\n    getDatePickerContext(el);\n  const yearEl = calendarEl.querySelector(CALENDAR_YEAR_FOCUSED);\n  const selectedYear = parseInt(yearEl.textContent, 10);\n\n  let adjustedYear = selectedYear + YEAR_CHUNK;\n  adjustedYear = Math.max(0, adjustedYear);\n\n  const date = setYear(calendarDate, adjustedYear);\n  const cappedDate = keepDateBetweenMinAndMax(date, minDate, maxDate);\n  const newCalendar = displayYearSelection(\n    calendarEl,\n    cappedDate.getFullYear(),\n  );\n\n  let nextToFocus = newCalendar.querySelector(CALENDAR_NEXT_YEAR_CHUNK);\n  if (nextToFocus.disabled) {\n    nextToFocus = newCalendar.querySelector(CALENDAR_YEAR_PICKER);\n  }\n  nextToFocus.focus();\n};\n\n/**\n * Select a year in the date picker component.\n *\n * @param {HTMLButtonElement} yearEl A year element within the date picker component\n */\nconst selectYear = (yearEl) => {\n  if (yearEl.disabled) return;\n  const { calendarEl, calendarDate, minDate, maxDate } =\n    getDatePickerContext(yearEl);\n  const selectedYear = parseInt(yearEl.innerHTML, 10);\n  let date = setYear(calendarDate, selectedYear);\n  date = keepDateBetweenMinAndMax(date, minDate, maxDate);\n  const newCalendar = renderCalendar(calendarEl, date);\n  newCalendar.querySelector(CALENDAR_DATE_FOCUSED).focus();\n};\n\n// #endregion Calendar - Year Selection View\n\n// #region Calendar Event Handling\n\n/**\n * Hide the calendar.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleEscapeFromCalendar = (event) => {\n  const { datePickerEl, externalInputEl } = getDatePickerContext(event.target);\n\n  hideCalendar(datePickerEl);\n  externalInputEl.focus();\n\n  event.preventDefault();\n};\n\n// #endregion Calendar Event Handling\n\n// #region Calendar Date Event Handling\n\n/**\n * Adjust the date and display the calendar if needed.\n *\n * @param {function} adjustDateFn function that returns the adjusted date\n */\nconst adjustCalendar = (adjustDateFn) => (event) => {\n  const { calendarEl, calendarDate, minDate, maxDate } = getDatePickerContext(\n    event.target,\n  );\n\n  const date = adjustDateFn(calendarDate);\n\n  const cappedDate = keepDateBetweenMinAndMax(date, minDate, maxDate);\n  if (!isSameDay(calendarDate, cappedDate)) {\n    const newCalendar = renderCalendar(calendarEl, cappedDate);\n    newCalendar.querySelector(CALENDAR_DATE_FOCUSED).focus();\n  }\n  event.preventDefault();\n};\n\n/**\n * Navigate back one week and display the calendar.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleUpFromDate = adjustCalendar((date) => subWeeks(date, 1));\n\n/**\n * Navigate forward one week and display the calendar.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleDownFromDate = adjustCalendar((date) => addWeeks(date, 1));\n\n/**\n * Navigate back one day and display the calendar.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleLeftFromDate = adjustCalendar((date) => subDays(date, 1));\n\n/**\n * Navigate forward one day and display the calendar.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleRightFromDate = adjustCalendar((date) => addDays(date, 1));\n\n/**\n * Navigate to the start of the week and display the calendar.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleHomeFromDate = adjustCalendar((date) => startOfWeek(date));\n\n/**\n * Navigate to the end of the week and display the calendar.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleEndFromDate = adjustCalendar((date) => endOfWeek(date));\n\n/**\n * Navigate forward one month and display the calendar.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handlePageDownFromDate = adjustCalendar((date) => addMonths(date, 1));\n\n/**\n * Navigate back one month and display the calendar.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handlePageUpFromDate = adjustCalendar((date) => subMonths(date, 1));\n\n/**\n * Navigate forward one year and display the calendar.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleShiftPageDownFromDate = adjustCalendar((date) => addYears(date, 1));\n\n/**\n * Navigate back one year and display the calendar.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleShiftPageUpFromDate = adjustCalendar((date) => subYears(date, 1));\n\n/**\n * Set range date classes without re-rendering the calendar. Called when date button is hovered.\n * Returns early if the date hovered is disabled or if there is already a selected date.\n *\n * @param {HTMLElement} dateEl - Calendar date button within the date picker component.\n */\n\nconst handleMouseoverFromDate = (dateEl) => {\n  if (dateEl.disabled) return;\n\n  const hoverDate = parseDateString(dateEl.dataset.value);\n  const { calendarEl, selectedDate, rangeDate } = getDatePickerContext(dateEl);\n\n  if (selectedDate) return;\n\n  const { withinRangeStartDate, withinRangeEndDate } = setRangeDates(\n    hoverDate,\n    rangeDate,\n  );\n\n  const dateButtons = calendarEl.querySelectorAll(\n    `.${CALENDAR_DATE_CURRENT_MONTH_CLASS}`,\n  );\n\n  dateButtons.forEach((button) => {\n    const buttonDate = parseDateString(button.dataset.value);\n    if (\n      isDateWithinMinAndMax(\n        buttonDate,\n        withinRangeStartDate,\n        withinRangeEndDate,\n      )\n    ) {\n      button.classList.add(CALENDAR_DATE_WITHIN_RANGE_CLASS);\n    } else {\n      button.classList.remove(CALENDAR_DATE_WITHIN_RANGE_CLASS);\n    }\n  });\n};\n\n// #endregion Calendar Date Event Handling\n\n// #region Calendar Month Event Handling\n\n/**\n * Adjust the month and display the month selection screen if needed.\n *\n * @param {function} adjustMonthFn function that returns the adjusted month\n */\nconst adjustMonthSelectionScreen = (adjustMonthFn) => (event) => {\n  const monthEl = event.target;\n  const selectedMonth = parseInt(monthEl.dataset.value, 10);\n  const { calendarEl, calendarDate, minDate, maxDate } =\n    getDatePickerContext(monthEl);\n  const currentDate = setMonth(calendarDate, selectedMonth);\n\n  let adjustedMonth = adjustMonthFn(selectedMonth);\n  adjustedMonth = Math.max(0, Math.min(11, adjustedMonth));\n\n  const date = setMonth(calendarDate, adjustedMonth);\n  const cappedDate = keepDateBetweenMinAndMax(date, minDate, maxDate);\n  if (!isSameMonth(currentDate, cappedDate)) {\n    const newCalendar = displayMonthSelection(\n      calendarEl,\n      cappedDate.getMonth(),\n    );\n    newCalendar.querySelector(CALENDAR_MONTH_FOCUSED).focus();\n  }\n  event.preventDefault();\n};\n\n/**\n * Navigate back three months and display the month selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleUpFromMonth = adjustMonthSelectionScreen((month) => month - 3);\n\n/**\n * Navigate forward three months and display the month selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleDownFromMonth = adjustMonthSelectionScreen((month) => month + 3);\n\n/**\n * Navigate back one month and display the month selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleLeftFromMonth = adjustMonthSelectionScreen((month) => month - 1);\n\n/**\n * Navigate forward one month and display the month selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleRightFromMonth = adjustMonthSelectionScreen((month) => month + 1);\n\n/**\n * Navigate to the start of the row of months and display the month selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleHomeFromMonth = adjustMonthSelectionScreen(\n  (month) => month - (month % 3),\n);\n\n/**\n * Navigate to the end of the row of months and display the month selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleEndFromMonth = adjustMonthSelectionScreen(\n  (month) => month + 2 - (month % 3),\n);\n\n/**\n * Navigate to the last month (December) and display the month selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handlePageDownFromMonth = adjustMonthSelectionScreen(() => 11);\n\n/**\n * Navigate to the first month (January) and display the month selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handlePageUpFromMonth = adjustMonthSelectionScreen(() => 0);\n\n// #endregion Calendar Month Event Handling\n\n// #region Calendar Year Event Handling\n\n/**\n * Adjust the year and display the year selection screen if needed.\n *\n * @param {function} adjustYearFn function that returns the adjusted year\n */\nconst adjustYearSelectionScreen = (adjustYearFn) => (event) => {\n  const yearEl = event.target;\n  const selectedYear = parseInt(yearEl.dataset.value, 10);\n  const { calendarEl, calendarDate, minDate, maxDate } =\n    getDatePickerContext(yearEl);\n  const currentDate = setYear(calendarDate, selectedYear);\n\n  let adjustedYear = adjustYearFn(selectedYear);\n  adjustedYear = Math.max(0, adjustedYear);\n\n  const date = setYear(calendarDate, adjustedYear);\n  const cappedDate = keepDateBetweenMinAndMax(date, minDate, maxDate);\n  if (!isSameYear(currentDate, cappedDate)) {\n    const newCalendar = displayYearSelection(\n      calendarEl,\n      cappedDate.getFullYear(),\n    );\n    newCalendar.querySelector(CALENDAR_YEAR_FOCUSED).focus();\n  }\n  event.preventDefault();\n};\n\n/**\n * Navigate back three years and display the year selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleUpFromYear = adjustYearSelectionScreen((year) => year - 3);\n\n/**\n * Navigate forward three years and display the year selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleDownFromYear = adjustYearSelectionScreen((year) => year + 3);\n\n/**\n * Navigate back one year and display the year selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleLeftFromYear = adjustYearSelectionScreen((year) => year - 1);\n\n/**\n * Navigate forward one year and display the year selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleRightFromYear = adjustYearSelectionScreen((year) => year + 1);\n\n/**\n * Navigate to the start of the row of years and display the year selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleHomeFromYear = adjustYearSelectionScreen(\n  (year) => year - (year % 3),\n);\n\n/**\n * Navigate to the end of the row of years and display the year selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleEndFromYear = adjustYearSelectionScreen(\n  (year) => year + 2 - (year % 3),\n);\n\n/**\n * Navigate to back 12 years and display the year selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handlePageUpFromYear = adjustYearSelectionScreen(\n  (year) => year - YEAR_CHUNK,\n);\n\n/**\n * Navigate forward 12 years and display the year selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handlePageDownFromYear = adjustYearSelectionScreen(\n  (year) => year + YEAR_CHUNK,\n);\n\n// #endregion Calendar Year Event Handling\n\n// #region Focus Handling Event Handling\n\nconst tabHandler = (focusable) => {\n  const getFocusableContext = (el) => {\n    const { calendarEl } = getDatePickerContext(el);\n    const focusableElements = select(focusable, calendarEl);\n\n    const firstTabIndex = 0;\n    const lastTabIndex = focusableElements.length - 1;\n    const firstTabStop = focusableElements[firstTabIndex];\n    const lastTabStop = focusableElements[lastTabIndex];\n    const focusIndex = focusableElements.indexOf(activeElement());\n\n    const isLastTab = focusIndex === lastTabIndex;\n    const isFirstTab = focusIndex === firstTabIndex;\n    const isNotFound = focusIndex === -1;\n\n    return {\n      focusableElements,\n      isNotFound,\n      firstTabStop,\n      isFirstTab,\n      lastTabStop,\n      isLastTab,\n    };\n  };\n\n  return {\n    tabAhead(event) {\n      const { firstTabStop, isLastTab, isNotFound } = getFocusableContext(\n        event.target,\n      );\n\n      if (isLastTab || isNotFound) {\n        event.preventDefault();\n        firstTabStop.focus();\n      }\n    },\n    tabBack(event) {\n      const { lastTabStop, isFirstTab, isNotFound } = getFocusableContext(\n        event.target,\n      );\n\n      if (isFirstTab || isNotFound) {\n        event.preventDefault();\n        lastTabStop.focus();\n      }\n    },\n  };\n};\n\nconst datePickerTabEventHandler = tabHandler(DATE_PICKER_FOCUSABLE);\nconst monthPickerTabEventHandler = tabHandler(MONTH_PICKER_FOCUSABLE);\nconst yearPickerTabEventHandler = tabHandler(YEAR_PICKER_FOCUSABLE);\n\n// #endregion Focus Handling Event Handling\n\n// #region Date Picker Event Delegation Registration / Component\n\nconst datePickerEvents = {\n  [CLICK]: {\n    [DATE_PICKER_BUTTON]() {\n      toggleCalendar(this);\n    },\n    [CALENDAR_DATE]() {\n      selectDate(this);\n    },\n    [CALENDAR_MONTH]() {\n      selectMonth(this);\n    },\n    [CALENDAR_YEAR]() {\n      selectYear(this);\n    },\n    [CALENDAR_PREVIOUS_MONTH]() {\n      displayPreviousMonth(this);\n    },\n    [CALENDAR_NEXT_MONTH]() {\n      displayNextMonth(this);\n    },\n    [CALENDAR_PREVIOUS_YEAR]() {\n      displayPreviousYear(this);\n    },\n    [CALENDAR_NEXT_YEAR]() {\n      displayNextYear(this);\n    },\n    [CALENDAR_PREVIOUS_YEAR_CHUNK]() {\n      displayPreviousYearChunk(this);\n    },\n    [CALENDAR_NEXT_YEAR_CHUNK]() {\n      displayNextYearChunk(this);\n    },\n    [CALENDAR_MONTH_SELECTION]() {\n      const newCalendar = displayMonthSelection(this);\n      newCalendar.querySelector(CALENDAR_MONTH_FOCUSED).focus();\n    },\n    [CALENDAR_YEAR_SELECTION]() {\n      const newCalendar = displayYearSelection(this);\n      newCalendar.querySelector(CALENDAR_YEAR_FOCUSED).focus();\n    },\n  },\n  keyup: {\n    [DATE_PICKER_CALENDAR](event) {\n      const keydown = this.dataset.keydownKeyCode;\n      if (`${event.keyCode}` !== keydown) {\n        event.preventDefault();\n      }\n    },\n  },\n  keydown: {\n    [DATE_PICKER_EXTERNAL_INPUT](event) {\n      if (event.keyCode === ENTER_KEYCODE) {\n        validateDateInput(this);\n      }\n    },\n    [CALENDAR_DATE]: keymap({\n      Up: handleUpFromDate,\n      ArrowUp: handleUpFromDate,\n      Down: handleDownFromDate,\n      ArrowDown: handleDownFromDate,\n      Left: handleLeftFromDate,\n      ArrowLeft: handleLeftFromDate,\n      Right: handleRightFromDate,\n      ArrowRight: handleRightFromDate,\n      Home: handleHomeFromDate,\n      End: handleEndFromDate,\n      PageDown: handlePageDownFromDate,\n      PageUp: handlePageUpFromDate,\n      \"Shift+PageDown\": handleShiftPageDownFromDate,\n      \"Shift+PageUp\": handleShiftPageUpFromDate,\n      Tab: datePickerTabEventHandler.tabAhead,\n    }),\n    [CALENDAR_DATE_PICKER]: keymap({\n      Tab: datePickerTabEventHandler.tabAhead,\n      \"Shift+Tab\": datePickerTabEventHandler.tabBack,\n    }),\n    [CALENDAR_MONTH]: keymap({\n      Up: handleUpFromMonth,\n      ArrowUp: handleUpFromMonth,\n      Down: handleDownFromMonth,\n      ArrowDown: handleDownFromMonth,\n      Left: handleLeftFromMonth,\n      ArrowLeft: handleLeftFromMonth,\n      Right: handleRightFromMonth,\n      ArrowRight: handleRightFromMonth,\n      Home: handleHomeFromMonth,\n      End: handleEndFromMonth,\n      PageDown: handlePageDownFromMonth,\n      PageUp: handlePageUpFromMonth,\n    }),\n    [CALENDAR_MONTH_PICKER]: keymap({\n      Tab: monthPickerTabEventHandler.tabAhead,\n      \"Shift+Tab\": monthPickerTabEventHandler.tabBack,\n    }),\n    [CALENDAR_YEAR]: keymap({\n      Up: handleUpFromYear,\n      ArrowUp: handleUpFromYear,\n      Down: handleDownFromYear,\n      ArrowDown: handleDownFromYear,\n      Left: handleLeftFromYear,\n      ArrowLeft: handleLeftFromYear,\n      Right: handleRightFromYear,\n      ArrowRight: handleRightFromYear,\n      Home: handleHomeFromYear,\n      End: handleEndFromYear,\n      PageDown: handlePageDownFromYear,\n      PageUp: handlePageUpFromYear,\n    }),\n    [CALENDAR_YEAR_PICKER]: keymap({\n      Tab: yearPickerTabEventHandler.tabAhead,\n      \"Shift+Tab\": yearPickerTabEventHandler.tabBack,\n    }),\n    [DATE_PICKER_CALENDAR](event) {\n      this.dataset.keydownKeyCode = event.keyCode;\n    },\n    [DATE_PICKER](event) {\n      const keyMap = keymap({\n        Escape: handleEscapeFromCalendar,\n      });\n\n      keyMap(event);\n    },\n  },\n  focusout: {\n    [DATE_PICKER_EXTERNAL_INPUT]() {\n      validateDateInput(this);\n    },\n    [DATE_PICKER](event) {\n      if (!this.contains(event.relatedTarget)) {\n        hideCalendar(this);\n      }\n    },\n  },\n  input: {\n    [DATE_PICKER_EXTERNAL_INPUT]() {\n      reconcileInputValues(this);\n      updateCalendarIfVisible(this);\n    },\n  },\n};\n\nif (!isIosDevice()) {\n  datePickerEvents.mouseover = {\n    [CALENDAR_DATE_CURRENT_MONTH]() {\n      handleMouseoverFromDate(this);\n    },\n  };\n}\n\nconst datePicker = behavior(datePickerEvents, {\n  init(root) {\n    selectOrMatches(DATE_PICKER, root).forEach((datePickerEl) => {\n      enhanceDatePicker(datePickerEl);\n    });\n  },\n  getDatePickerContext,\n  disable,\n  ariaDisable,\n  enable,\n  isDateInputInvalid,\n  setCalendarValue,\n  validateDateInput,\n  renderCalendar,\n  updateCalendarIfVisible,\n});\n\n// #endregion Date Picker Event Delegation Registration / Component\n\nmodule.exports = datePicker;\n","const behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst select = require(\"../../uswds-core/src/js/utils/select\");\nconst selectOrMatches = require(\"../../uswds-core/src/js/utils/select-or-matches\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\nconst {\n  getDatePickerContext,\n  isDateInputInvalid,\n  updateCalendarIfVisible,\n} = require(\"../../usa-date-picker/src/index\");\n\nconst DATE_PICKER_CLASS = `${PREFIX}-date-picker`;\nconst DATE_RANGE_PICKER_CLASS = `${PREFIX}-date-range-picker`;\nconst DATE_RANGE_PICKER_RANGE_START_CLASS = `${DATE_RANGE_PICKER_CLASS}__range-start`;\nconst DATE_RANGE_PICKER_RANGE_END_CLASS = `${DATE_RANGE_PICKER_CLASS}__range-end`;\n\nconst DATE_PICKER = `.${DATE_PICKER_CLASS}`;\nconst DATE_RANGE_PICKER = `.${DATE_RANGE_PICKER_CLASS}`;\nconst DATE_RANGE_PICKER_RANGE_START = `.${DATE_RANGE_PICKER_RANGE_START_CLASS}`;\nconst DATE_RANGE_PICKER_RANGE_END = `.${DATE_RANGE_PICKER_RANGE_END_CLASS}`;\n\nconst DEFAULT_MIN_DATE = \"0000-01-01\";\n\n/**\n * The properties and elements within the date range picker.\n * @typedef {Object} DateRangePickerContext\n * @property {HTMLElement} dateRangePickerEl\n * @property {HTMLElement} rangeStartEl\n * @property {HTMLElement} rangeEndEl\n */\n\n/**\n * Get an object of the properties and elements belonging directly to the given\n * date picker component.\n *\n * @param {HTMLElement} el the element within the date picker\n * @returns {DateRangePickerContext} elements\n */\nconst getDateRangePickerContext = (el) => {\n  const dateRangePickerEl = el.closest(DATE_RANGE_PICKER);\n\n  if (!dateRangePickerEl) {\n    throw new Error(`Element is missing outer ${DATE_RANGE_PICKER}`);\n  }\n\n  const rangeStartEl = dateRangePickerEl.querySelector(\n    DATE_RANGE_PICKER_RANGE_START,\n  );\n  const rangeEndEl = dateRangePickerEl.querySelector(\n    DATE_RANGE_PICKER_RANGE_END,\n  );\n\n  return {\n    dateRangePickerEl,\n    rangeStartEl,\n    rangeEndEl,\n  };\n};\n\n/**\n * handle update from range start date picker\n *\n * @param {HTMLElement} el an element within the date range picker\n */\nconst handleRangeStartUpdate = (el) => {\n  const { dateRangePickerEl, rangeStartEl, rangeEndEl } =\n    getDateRangePickerContext(el);\n  const { internalInputEl } = getDatePickerContext(rangeStartEl);\n  const updatedDate = internalInputEl.value;\n\n  if (updatedDate && !isDateInputInvalid(internalInputEl)) {\n    rangeEndEl.dataset.minDate = updatedDate;\n    rangeEndEl.dataset.rangeDate = updatedDate;\n    rangeEndEl.dataset.defaultDate = updatedDate;\n  } else {\n    rangeEndEl.dataset.minDate = dateRangePickerEl.dataset.minDate || \"\";\n    rangeEndEl.dataset.rangeDate = \"\";\n    rangeEndEl.dataset.defaultDate = \"\";\n  }\n\n  updateCalendarIfVisible(rangeEndEl);\n};\n\n/**\n * handle update from range start date picker\n *\n * @param {HTMLElement} el an element within the date range picker\n */\nconst handleRangeEndUpdate = (el) => {\n  const { dateRangePickerEl, rangeStartEl, rangeEndEl } =\n    getDateRangePickerContext(el);\n  const { internalInputEl } = getDatePickerContext(rangeEndEl);\n  const updatedDate = internalInputEl.value;\n\n  if (updatedDate && !isDateInputInvalid(internalInputEl)) {\n    rangeStartEl.dataset.maxDate = updatedDate;\n    rangeStartEl.dataset.rangeDate = updatedDate;\n    rangeStartEl.dataset.defaultDate = updatedDate;\n  } else {\n    rangeStartEl.dataset.maxDate = dateRangePickerEl.dataset.maxDate || \"\";\n    rangeStartEl.dataset.rangeDate = \"\";\n    rangeStartEl.dataset.defaultDate = \"\";\n  }\n\n  updateCalendarIfVisible(rangeStartEl);\n};\n\n/**\n * Enhance an input with the date picker elements\n *\n * @param {HTMLElement} el The initial wrapping element of the date range picker component\n */\nconst enhanceDateRangePicker = (el) => {\n  const dateRangePickerEl = el.closest(DATE_RANGE_PICKER);\n\n  const [rangeStart, rangeEnd] = select(DATE_PICKER, dateRangePickerEl);\n\n  if (!rangeStart) {\n    throw new Error(\n      `${DATE_RANGE_PICKER} is missing inner two '${DATE_PICKER}' elements`,\n    );\n  }\n\n  if (!rangeEnd) {\n    throw new Error(\n      `${DATE_RANGE_PICKER} is missing second '${DATE_PICKER}' element`,\n    );\n  }\n\n  rangeStart.classList.add(DATE_RANGE_PICKER_RANGE_START_CLASS);\n  rangeEnd.classList.add(DATE_RANGE_PICKER_RANGE_END_CLASS);\n\n  if (!dateRangePickerEl.dataset.minDate) {\n    dateRangePickerEl.dataset.minDate = DEFAULT_MIN_DATE;\n  }\n\n  const { minDate } = dateRangePickerEl.dataset;\n  rangeStart.dataset.minDate = minDate;\n  rangeEnd.dataset.minDate = minDate;\n\n  const { maxDate } = dateRangePickerEl.dataset;\n  if (maxDate) {\n    rangeStart.dataset.maxDate = maxDate;\n    rangeEnd.dataset.maxDate = maxDate;\n  }\n\n  handleRangeStartUpdate(dateRangePickerEl);\n  handleRangeEndUpdate(dateRangePickerEl);\n};\n\nconst dateRangePicker = behavior(\n  {\n    \"input change\": {\n      [DATE_RANGE_PICKER_RANGE_START]() {\n        handleRangeStartUpdate(this);\n      },\n      [DATE_RANGE_PICKER_RANGE_END]() {\n        handleRangeEndUpdate(this);\n      },\n    },\n  },\n  {\n    init(root) {\n      selectOrMatches(DATE_RANGE_PICKER, root).forEach((dateRangePickerEl) => {\n        enhanceDateRangePicker(dateRangePickerEl);\n      });\n    },\n  },\n);\n\nmodule.exports = dateRangePicker;\n","const selectOrMatches = require(\"../../uswds-core/src/js/utils/select-or-matches\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst Sanitizer = require(\"../../uswds-core/src/js/utils/sanitizer\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\n\nconst DROPZONE_CLASS = `${PREFIX}-file-input`;\nconst DROPZONE = `.${DROPZONE_CLASS}`;\nconst INPUT_CLASS = `${PREFIX}-file-input__input`;\nconst TARGET_CLASS = `${PREFIX}-file-input__target`;\nconst INPUT = `.${INPUT_CLASS}`;\nconst BOX_CLASS = `${PREFIX}-file-input__box`;\nconst INSTRUCTIONS_CLASS = `${PREFIX}-file-input__instructions`;\nconst PREVIEW_CLASS = `${PREFIX}-file-input__preview`;\nconst PREVIEW_HEADING_CLASS = `${PREFIX}-file-input__preview-heading`;\nconst DISABLED_CLASS = `${PREFIX}-file-input--disabled`;\nconst CHOOSE_CLASS = `${PREFIX}-file-input__choose`;\nconst ACCEPTED_FILE_MESSAGE_CLASS = `${PREFIX}-file-input__accepted-files-message`;\nconst DRAG_TEXT_CLASS = `${PREFIX}-file-input__drag-text`;\nconst DRAG_CLASS = `${PREFIX}-file-input--drag`;\nconst LOADING_CLASS = \"is-loading\";\nconst INVALID_FILE_CLASS = \"has-invalid-file\";\nconst GENERIC_PREVIEW_CLASS_NAME = `${PREFIX}-file-input__preview-image`;\nconst GENERIC_PREVIEW_CLASS = `${GENERIC_PREVIEW_CLASS_NAME}--generic`;\nconst PDF_PREVIEW_CLASS = `${GENERIC_PREVIEW_CLASS_NAME}--pdf`;\nconst WORD_PREVIEW_CLASS = `${GENERIC_PREVIEW_CLASS_NAME}--word`;\nconst VIDEO_PREVIEW_CLASS = `${GENERIC_PREVIEW_CLASS_NAME}--video`;\nconst EXCEL_PREVIEW_CLASS = `${GENERIC_PREVIEW_CLASS_NAME}--excel`;\nconst SR_ONLY_CLASS = `${PREFIX}-sr-only`;\nconst SPACER_GIF =\n  \"data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7\";\nconst DEFAULT_ERROR_LABEL_TEXT = \"Error: This is not a valid file type.\";\n\nlet TYPE_IS_VALID = Boolean(true); // logic gate for change listener\nlet DEFAULT_ARIA_LABEL_TEXT = \"\";\nlet DEFAULT_FILE_STATUS_TEXT = \"\";\n\n/**\n * The properties and elements within the file input.\n * @typedef {Object} FileInputContext\n * @property {HTMLDivElement} dropZoneEl\n * @property {HTMLInputElement} inputEl\n */\n\n/**\n * Get an object of the properties and elements belonging directly to the given\n * file input component.\n *\n * @param {HTMLElement} el the element within the file input\n * @returns {FileInputContext} elements\n */\nconst getFileInputContext = (el) => {\n  const dropZoneEl = el.closest(DROPZONE);\n\n  if (!dropZoneEl) {\n    throw new Error(`Element is missing outer ${DROPZONE}`);\n  }\n\n  const inputEl = dropZoneEl.querySelector(INPUT);\n\n  return {\n    dropZoneEl,\n    inputEl,\n  };\n};\n\n/**\n * Disable the file input component\n *\n * @param {HTMLElement} el An element within the file input component\n */\nconst disable = (el) => {\n  const { dropZoneEl, inputEl } = getFileInputContext(el);\n\n  inputEl.disabled = true;\n  dropZoneEl.classList.add(DISABLED_CLASS);\n};\n\n/**\n * Set aria-disabled attribute to file input component\n *\n * @param {HTMLElement} el An element within the file input component\n */\nconst ariaDisable = (el) => {\n  const { dropZoneEl } = getFileInputContext(el);\n\n  dropZoneEl.classList.add(DISABLED_CLASS);\n};\n\n/**\n * Enable the file input component\n *\n * @param {HTMLElement} el An element within the file input component\n */\nconst enable = (el) => {\n  const { dropZoneEl, inputEl } = getFileInputContext(el);\n\n  inputEl.disabled = false;\n  dropZoneEl.classList.remove(DISABLED_CLASS);\n  dropZoneEl.removeAttribute(\"aria-disabled\");\n};\n\n/**\n *\n * @param {String} s special characters\n * @returns {String} replaces specified values\n */\nconst replaceName = (s) => {\n  const c = s.charCodeAt(0);\n  if (c === 32) return \"-\";\n  if (c >= 65 && c <= 90) return `img_${s.toLowerCase()}`;\n  return `__${(\"000\", c.toString(16)).slice(-4)}`;\n};\n\n/**\n * Creates an ID name for each file that strips all invalid characters.\n * @param {String} name - name of the file added to file input (searchvalue)\n * @returns {String} same characters as the name with invalid chars removed (newvalue)\n */\nconst makeSafeForID = (name) => name.replace(/[^a-z0-9]/g, replaceName);\n\n// Takes a generated safe ID and creates a unique ID.\nconst createUniqueID = (name) =>\n  `${name}-${Math.floor(Date.now().toString() / 1000)}`;\n\n/**\n * Determines if the singular or plural item label should be used\n * Determination is based on the presence of the `multiple` attribute\n *\n * @param {HTMLInputElement} fileInputEl - The input element.\n * @returns {HTMLDivElement} The singular or plural version of \"item\"\n */\nconst getItemsLabel = (fileInputEl) => {\n  const acceptsMultiple = fileInputEl.hasAttribute(\"multiple\");\n  const itemsLabel = acceptsMultiple ? \"files\" : \"file\";\n\n  return itemsLabel;\n};\n\n/**\n * Scaffold the file input component with a parent wrapper and\n * Create a target area overlay for drag and drop functionality\n *\n * @param {HTMLInputElement} fileInputEl - The input element.\n * @returns {HTMLDivElement} The drag and drop target area.\n */\nconst createTargetArea = (fileInputEl) => {\n  const fileInputParent = document.createElement(\"div\");\n  const dropTarget = document.createElement(\"div\");\n  const box = document.createElement(\"div\");\n\n  // Adds class names and other attributes\n  fileInputEl.classList.remove(DROPZONE_CLASS);\n  fileInputEl.classList.add(INPUT_CLASS);\n  fileInputParent.classList.add(DROPZONE_CLASS);\n  box.classList.add(BOX_CLASS);\n  dropTarget.classList.add(TARGET_CLASS);\n\n  // Adds child elements to the DOM\n  dropTarget.prepend(box);\n  fileInputEl.parentNode.insertBefore(dropTarget, fileInputEl);\n  fileInputEl.parentNode.insertBefore(fileInputParent, dropTarget);\n  dropTarget.appendChild(fileInputEl);\n  fileInputParent.appendChild(dropTarget);\n\n  return dropTarget;\n};\n\n/**\n * Build the visible element with default interaction instructions.\n *\n * @param {HTMLInputElement} fileInputEl - The input element.\n * @returns {HTMLDivElement} The container for visible interaction instructions.\n */\nconst createVisibleInstructions = (fileInputEl) => {\n  const fileInputParent = fileInputEl.closest(DROPZONE);\n  const itemsLabel = getItemsLabel(fileInputEl);\n  const instructions = document.createElement(\"div\");\n  const dragText = `Drag ${itemsLabel} here or`;\n  const chooseText = \"choose from folder\";\n\n  // Create instructions text for aria-label\n  DEFAULT_ARIA_LABEL_TEXT = `${dragText} ${chooseText}`;\n\n  // Adds class names and other attributes\n  instructions.classList.add(INSTRUCTIONS_CLASS);\n  instructions.setAttribute(\"aria-hidden\", \"true\");\n\n  // Add initial instructions for input usage\n  fileInputEl.setAttribute(\"aria-label\", DEFAULT_ARIA_LABEL_TEXT);\n  instructions.innerHTML = Sanitizer.escapeHTML`<span class=\"${DRAG_TEXT_CLASS}\">${dragText}</span> <span class=\"${CHOOSE_CLASS}\">${chooseText}</span>`;\n\n  // Add the instructions element to the DOM\n  fileInputEl.parentNode.insertBefore(instructions, fileInputEl);\n\n  // IE11 and Edge do not support drop files on file inputs, so we've removed text that indicates that\n  if (\n    /rv:11.0/i.test(navigator.userAgent) ||\n    /Edge\\/\\d./i.test(navigator.userAgent)\n  ) {\n    fileInputParent.querySelector(`.${DRAG_TEXT_CLASS}`).outerHTML = \"\";\n  }\n\n  return instructions;\n};\n\n/**\n * Build a screen reader-only message element that contains file status updates and\n * Create and set the default file status message\n *\n * @param {HTMLInputElement} fileInputEl - The input element.\n */\nconst createSROnlyStatus = (fileInputEl) => {\n  const statusEl = document.createElement(\"div\");\n  const itemsLabel = getItemsLabel(fileInputEl);\n  const fileInputParent = fileInputEl.closest(DROPZONE);\n  const fileInputTarget = fileInputEl.closest(`.${TARGET_CLASS}`);\n\n  DEFAULT_FILE_STATUS_TEXT = `No ${itemsLabel} selected.`;\n\n  // Adds class names and other attributes\n  statusEl.classList.add(SR_ONLY_CLASS);\n  statusEl.setAttribute(\"aria-live\", \"polite\");\n\n  // Add initial file status message\n  statusEl.textContent = DEFAULT_FILE_STATUS_TEXT;\n\n  // Add the status element to the DOM\n  fileInputParent.insertBefore(statusEl, fileInputTarget);\n};\n\n/**\n * Scaffold the component with all required elements\n *\n * @param {HTMLInputElement} fileInputEl - The original input element.\n */\nconst enhanceFileInput = (fileInputEl) => {\n  const isInputDisabled =\n    fileInputEl.hasAttribute(\"aria-disabled\") ||\n    fileInputEl.hasAttribute(\"disabled\");\n  const dropTarget = createTargetArea(fileInputEl);\n  const instructions = createVisibleInstructions(fileInputEl);\n  const { dropZoneEl } = getFileInputContext(fileInputEl);\n\n  if (isInputDisabled) {\n    dropZoneEl.classList.add(DISABLED_CLASS);\n  } else {\n    createSROnlyStatus(fileInputEl);\n  }\n\n  return { instructions, dropTarget };\n};\n\n/**\n * Removes image previews\n * We want to start with a clean list every time files are added to the file input\n *\n * @param {HTMLDivElement} dropTarget - The drag and drop target area.\n * @param {HTMLDivElement} instructions - The container for visible interaction instructions.\n */\nconst removeOldPreviews = (dropTarget, instructions) => {\n  const filePreviews = dropTarget.querySelectorAll(`.${PREVIEW_CLASS}`);\n  const currentPreviewHeading = dropTarget.querySelector(\n    `.${PREVIEW_HEADING_CLASS}`,\n  );\n  const currentErrorMessage = dropTarget.querySelector(\n    `.${ACCEPTED_FILE_MESSAGE_CLASS}`,\n  );\n\n  /**\n   * finds the parent of the passed node and removes the child\n   * @param {HTMLElement} node\n   */\n  const removeImages = (node) => {\n    node.parentNode.removeChild(node);\n  };\n\n  // Remove the heading above the previews\n  if (currentPreviewHeading) {\n    currentPreviewHeading.outerHTML = \"\";\n  }\n\n  // Remove existing error messages\n  if (currentErrorMessage) {\n    currentErrorMessage.outerHTML = \"\";\n    dropTarget.classList.remove(INVALID_FILE_CLASS);\n  }\n\n  // Get rid of existing previews if they exist, show instructions\n  if (filePreviews !== null) {\n    if (instructions) {\n      instructions.removeAttribute(\"hidden\");\n    }\n    Array.prototype.forEach.call(filePreviews, removeImages);\n  }\n};\n\n/**\n * Update the screen reader-only status message after interaction\n *\n * @param {HTMLDivElement} statusElement - The screen reader-only container for file status updates.\n * @param {Object} fileNames - The selected files found in the fileList object.\n * @param {Array} fileStore - The array of uploaded file names created from the fileNames object.\n */\nconst updateStatusMessage = (statusElement, fileNames, fileStore) => {\n  const statusEl = statusElement;\n  let statusMessage = DEFAULT_FILE_STATUS_TEXT;\n\n  // If files added, update the status message with file name(s)\n  if (fileNames.length === 1) {\n    statusMessage = `You have selected the file: ${fileStore}`;\n  } else if (fileNames.length > 1) {\n    statusMessage = `You have selected ${\n      fileNames.length\n    } files: ${fileStore.join(\", \")}`;\n  }\n\n  // Add delay to encourage screen reader readout\n  setTimeout(() => {\n    statusEl.textContent = statusMessage;\n  }, 1000);\n};\n\n/**\n * Show the preview heading, hide the initial instructions and\n * Update the aria-label with new instructions text\n *\n * @param {HTMLInputElement} fileInputEl - The input element.\n * @param {Object} fileNames - The selected files found in the fileList object.\n */\nconst addPreviewHeading = (fileInputEl, fileNames) => {\n  const filePreviewsHeading = document.createElement(\"div\");\n  const dropTarget = fileInputEl.closest(`.${TARGET_CLASS}`);\n  const instructions = dropTarget.querySelector(`.${INSTRUCTIONS_CLASS}`);\n  let changeItemText = \"Change file\";\n  let previewHeadingText = \"\";\n\n  if (fileNames.length === 1) {\n    previewHeadingText = Sanitizer.escapeHTML`Selected file <span class=\"usa-file-input__choose\">${changeItemText}</span>`;\n  } else if (fileNames.length > 1) {\n    changeItemText = \"Change files\";\n    previewHeadingText = Sanitizer.escapeHTML`${fileNames.length} files selected <span class=\"usa-file-input__choose\">${changeItemText}</span>`;\n  }\n\n  // Hides null state content and sets preview heading\n  instructions.setAttribute(\"hidden\", \"true\");\n  filePreviewsHeading.classList.add(PREVIEW_HEADING_CLASS);\n  filePreviewsHeading.innerHTML = previewHeadingText;\n  dropTarget.insertBefore(filePreviewsHeading, instructions);\n\n  // Update aria label to match the visible action text\n  fileInputEl.setAttribute(\"aria-label\", changeItemText);\n};\n\n/** Add an error listener to the image preview to set a fallback image\n * @param {HTMLImageElement} previewImage - The image element\n * @param {String} fallbackClass - The CSS class of the fallback image\n */\nconst setPreviewFallback = (previewImage, fallbackClass) => {\n  previewImage.addEventListener(\n    \"error\",\n    () => {\n      const localPreviewImage = previewImage; // to avoid no-param-reassign from ESLint\n      localPreviewImage.src = SPACER_GIF;\n      localPreviewImage.classList.add(fallbackClass);\n    },\n    { once: true },\n  );\n};\n\n/**\n * When new files are applied to file input, this function generates previews\n * and removes old ones.\n *\n * @param {event} e\n * @param {HTMLInputElement} fileInputEl - The input element.\n * @param {HTMLDivElement} instructions - The container for visible interaction instructions.\n * @param {HTMLDivElement} dropTarget - The drag and drop target area.\n */\n\nconst handleChange = (e, fileInputEl, instructions, dropTarget) => {\n  const fileNames = e.target.files;\n  const inputParent = dropTarget.closest(`.${DROPZONE_CLASS}`);\n  const statusElement = inputParent.querySelector(`.${SR_ONLY_CLASS}`);\n  const fileStore = [];\n\n  // First, get rid of existing previews\n  removeOldPreviews(dropTarget, instructions);\n\n  // Then, iterate through files list and create previews\n  for (let i = 0; i < fileNames.length; i += 1) {\n    const reader = new FileReader();\n    const fileName = fileNames[i].name;\n    let imageId;\n\n    // Push updated file names into the store array\n    fileStore.push(fileName);\n\n    // Starts with a loading image while preview is created\n    reader.onloadstart = function createLoadingImage() {\n      imageId = createUniqueID(makeSafeForID(fileName));\n\n      instructions.insertAdjacentHTML(\n        \"afterend\",\n        Sanitizer.escapeHTML`<div class=\"${PREVIEW_CLASS}\" aria-hidden=\"true\">\n          <img id=\"${imageId}\" src=\"${SPACER_GIF}\" alt=\"\" class=\"${GENERIC_PREVIEW_CLASS_NAME} ${LOADING_CLASS}\"/>${fileName}\n        <div>`,\n      );\n    };\n\n    // Not all files will be able to generate previews. In case this happens, we provide several types \"generic previews\" based on the file extension.\n    reader.onloadend = function createFilePreview() {\n      const previewImage = document.getElementById(imageId);\n      const fileExtension = fileName.split(\".\").pop();\n      if (fileExtension === \"pdf\") {\n        setPreviewFallback(previewImage, PDF_PREVIEW_CLASS);\n      } else if (\n        fileExtension === \"doc\" ||\n        fileExtension === \"docx\" ||\n        fileExtension === \"pages\"\n      ) {\n        setPreviewFallback(previewImage, WORD_PREVIEW_CLASS);\n      } else if (\n        fileExtension === \"xls\" ||\n        fileExtension === \"xlsx\" ||\n        fileExtension === \"numbers\"\n      ) {\n        setPreviewFallback(previewImage, EXCEL_PREVIEW_CLASS);\n      } else if (fileExtension === \"mov\" || fileExtension === \"mp4\") {\n        setPreviewFallback(previewImage, VIDEO_PREVIEW_CLASS);\n      } else {\n        setPreviewFallback(previewImage, GENERIC_PREVIEW_CLASS);\n      }\n\n      // Removes loader and displays preview\n      previewImage.classList.remove(LOADING_CLASS);\n      previewImage.src = reader.result;\n    };\n\n    if (fileNames[i]) {\n      reader.readAsDataURL(fileNames[i]);\n    }\n  }\n\n  if (fileNames.length === 0) {\n    // Reset input aria-label with default message\n    fileInputEl.setAttribute(\"aria-label\", DEFAULT_ARIA_LABEL_TEXT);\n  } else {\n    addPreviewHeading(fileInputEl, fileNames);\n  }\n\n  updateStatusMessage(statusElement, fileNames, fileStore);\n};\n\n/**\n * When using an Accept attribute, invalid files will be hidden from\n * file browser, but they can still be dragged to the input. This\n * function prevents them from being dragged and removes error states\n * when correct files are added.\n *\n * @param {event} e\n * @param {HTMLInputElement} fileInputEl - The input element.\n * @param {HTMLDivElement} instructions - The container for visible interaction instructions.\n * @param {HTMLDivElement} dropTarget - The drag and drop target area.\n */\nconst preventInvalidFiles = (e, fileInputEl, instructions, dropTarget) => {\n  const acceptedFilesAttr = fileInputEl.getAttribute(\"accept\");\n  dropTarget.classList.remove(INVALID_FILE_CLASS);\n\n  /**\n   * We can probably move away from this once IE11 support stops, and replace\n   * with a simple es `.includes`\n   * check if element is in array\n   * check if 1 or more alphabets are in string\n   * if element is present return the position value and -1 otherwise\n   * @param {Object} file\n   * @param {String} value\n   * @returns {Boolean}\n   */\n  const isIncluded = (file, value) => {\n    let returnValue = false;\n    const pos = file.indexOf(value);\n    if (pos >= 0) {\n      returnValue = true;\n    }\n    return returnValue;\n  };\n\n  // Runs if only specific files are accepted\n  if (acceptedFilesAttr) {\n    const acceptedFiles = acceptedFilesAttr.split(\",\");\n    const errorMessage = document.createElement(\"div\");\n    const userErrorText = fileInputEl.dataset.errormessage;\n    const errorMessageText = userErrorText || DEFAULT_ERROR_LABEL_TEXT;\n\n    errorMessage.setAttribute(\"aria-hidden\", true);\n\n    // If multiple files are dragged, this iterates through them and look for any files that are not accepted.\n    let allFilesAllowed = true;\n    const scannedFiles = e.target.files || e.dataTransfer.files;\n    for (let i = 0; i < scannedFiles.length; i += 1) {\n      const file = scannedFiles[i];\n      if (allFilesAllowed) {\n        for (let j = 0; j < acceptedFiles.length; j += 1) {\n          const fileType = acceptedFiles[j];\n          allFilesAllowed =\n            file.name.indexOf(fileType) > 0 ||\n            isIncluded(file.type, fileType.replace(/\\*/g, \"\"));\n          if (allFilesAllowed) {\n            TYPE_IS_VALID = true;\n            break;\n          }\n        }\n      } else break;\n    }\n\n    // If dragged files are not accepted, this removes them from the value of the input and creates and error state\n    if (!allFilesAllowed) {\n      removeOldPreviews(dropTarget, instructions);\n      fileInputEl.value = \"\"; // eslint-disable-line no-param-reassign\n      errorMessage.textContent = errorMessageText;\n      dropTarget.insertBefore(errorMessage, fileInputEl);\n\n      const ariaLabelText = `${errorMessageText} ${DEFAULT_ARIA_LABEL_TEXT}`;\n\n      fileInputEl.setAttribute(\"aria-label\", ariaLabelText);\n      errorMessage.classList.add(ACCEPTED_FILE_MESSAGE_CLASS);\n      dropTarget.classList.add(INVALID_FILE_CLASS);\n      TYPE_IS_VALID = false;\n      e.preventDefault();\n      e.stopPropagation();\n    }\n  }\n};\n\n/**\n * 1. passes through gate for preventing invalid files\n * 2. handles updates if file is valid\n *\n * @param {event} event\n * @param {HTMLInputElement} fileInputEl - The input element.\n * @param {HTMLDivElement} instructions - The container for visible interaction instructions.\n * @param {HTMLDivElement} dropTarget - The drag and drop target area.\n */\nconst handleUpload = (event, fileInputEl, instructions, dropTarget) => {\n  preventInvalidFiles(event, fileInputEl, instructions, dropTarget);\n  if (TYPE_IS_VALID === true) {\n    handleChange(event, fileInputEl, instructions, dropTarget);\n  }\n};\n\nconst fileInput = behavior(\n  {},\n  {\n    init(root) {\n      selectOrMatches(DROPZONE, root).forEach((fileInputEl) => {\n        const { instructions, dropTarget } = enhanceFileInput(fileInputEl);\n\n        dropTarget.addEventListener(\n          \"dragover\",\n          function handleDragOver() {\n            this.classList.add(DRAG_CLASS);\n          },\n          false,\n        );\n\n        dropTarget.addEventListener(\n          \"dragleave\",\n          function handleDragLeave() {\n            this.classList.remove(DRAG_CLASS);\n          },\n          false,\n        );\n\n        dropTarget.addEventListener(\n          \"drop\",\n          function handleDrop() {\n            this.classList.remove(DRAG_CLASS);\n          },\n          false,\n        );\n\n        fileInputEl.addEventListener(\n          \"change\",\n          (e) => handleUpload(e, fileInputEl, instructions, dropTarget),\n          false,\n        );\n      });\n    },\n    teardown(root) {\n      selectOrMatches(INPUT, root).forEach((fileInputEl) => {\n        const fileInputTopElement = fileInputEl.parentElement.parentElement;\n        fileInputTopElement.parentElement.replaceChild(\n          fileInputEl,\n          fileInputTopElement,\n        );\n        // eslint-disable-next-line no-param-reassign\n        fileInputEl.className = DROPZONE_CLASS;\n      });\n    },\n    getFileInputContext,\n    disable,\n    ariaDisable,\n    enable,\n  },\n);\n\nmodule.exports = fileInput;\n","const behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst { CLICK } = require(\"../../uswds-core/src/js/events\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\n\nconst SCOPE = `.${PREFIX}-footer--big`;\nconst NAV = `${SCOPE} nav`;\nconst BUTTON = `${NAV} .${PREFIX}-footer__primary-link`;\nconst HIDE_MAX_WIDTH = 480;\n\n/**\n * Expands selected footer menu panel, while collapsing others\n */\nfunction showPanel() {\n  if (window.innerWidth < HIDE_MAX_WIDTH) {\n    const isOpen = this.getAttribute(\"aria-expanded\") === \"true\";\n    const thisFooter = this.closest(SCOPE);\n\n    // Close all other menus\n    thisFooter.querySelectorAll(BUTTON).forEach((button) => {\n      button.setAttribute(\"aria-expanded\", false);\n    });\n\n    this.setAttribute(\"aria-expanded\", !isOpen);\n  }\n}\n\n/**\n * Swaps the <h4> element for a <button> element (and vice-versa) and sets id\n * of menu list\n *\n * @param {Boolean} isMobile - If the footer is in mobile configuration\n */\nfunction toggleHtmlTag(isMobile) {\n  const bigFooter = document.querySelector(SCOPE);\n\n  if (!bigFooter) {\n    return;\n  }\n\n  const primaryLinks = bigFooter.querySelectorAll(BUTTON);\n\n  primaryLinks.forEach((currentElement) => {\n    const currentElementClasses = currentElement.getAttribute(\"class\");\n    const preservedHtmlTag =\n      currentElement.getAttribute(\"data-tag\") || currentElement.tagName;\n\n    const newElementType = isMobile ? \"button\" : preservedHtmlTag;\n\n    // Create the new element\n    const newElement = document.createElement(newElementType);\n    newElement.setAttribute(\"class\", currentElementClasses);\n    newElement.classList.toggle(\n      `${PREFIX}-footer__primary-link--button`,\n      isMobile,\n    );\n    newElement.textContent = currentElement.textContent;\n\n    if (isMobile) {\n      newElement.setAttribute(\"data-tag\", currentElement.tagName);\n      const menuId = `${PREFIX}-footer-menu-list-${Math.floor(\n        Math.random() * 100000,\n      )}`;\n\n      newElement.setAttribute(\"aria-controls\", menuId);\n      newElement.setAttribute(\"aria-expanded\", \"false\");\n      currentElement.nextElementSibling.setAttribute(\"id\", menuId);\n      newElement.setAttribute(\"type\", \"button\");\n    }\n\n    // Insert the new element and delete the old\n    currentElement.after(newElement);\n    currentElement.remove();\n  });\n}\n\nconst resize = (event) => {\n  toggleHtmlTag(event.matches);\n};\n\nmodule.exports = behavior(\n  {\n    [CLICK]: {\n      [BUTTON]: showPanel,\n    },\n  },\n  {\n    // export for use elsewhere\n    HIDE_MAX_WIDTH,\n\n    init() {\n      toggleHtmlTag(window.innerWidth < HIDE_MAX_WIDTH);\n      this.mediaQueryList = window.matchMedia(\n        `(max-width: ${HIDE_MAX_WIDTH - 0.1}px)`,\n      );\n      this.mediaQueryList.addListener(resize);\n    },\n\n    teardown() {\n      this.mediaQueryList.removeListener(resize);\n    },\n  },\n);\n","const keymap = require(\"receptor/keymap\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst select = require(\"../../uswds-core/src/js/utils/select\");\nconst toggle = require(\"../../uswds-core/src/js/utils/toggle\");\nconst FocusTrap = require(\"../../uswds-core/src/js/utils/focus-trap\");\nconst accordion = require(\"../../usa-accordion/src/index\");\nconst ScrollBarWidth = require(\"../../uswds-core/src/js/utils/scrollbar-width\");\n\nconst { CLICK } = require(\"../../uswds-core/src/js/events\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\n\nconst BODY = \"body\";\nconst HEADER = `.${PREFIX}-header`;\nconst NAV = `.${PREFIX}-nav`;\nconst NAV_CONTAINER = `.${PREFIX}-nav-container`;\nconst NAV_PRIMARY = `.${PREFIX}-nav__primary`;\nconst NAV_PRIMARY_ITEM = `.${PREFIX}-nav__primary-item`;\nconst NAV_CONTROL = `button.${PREFIX}-nav__link`;\nconst NAV_LINKS = `${NAV} a`;\nconst NON_NAV_HIDDEN_ATTRIBUTE = `data-nav-hidden`;\nconst OPENERS = `.${PREFIX}-menu-btn`;\nconst CLOSE_BUTTON = `.${PREFIX}-nav__close`;\nconst OVERLAY = `.${PREFIX}-overlay`;\nconst CLOSERS = `${CLOSE_BUTTON}, .${PREFIX}-overlay`;\nconst TOGGLES = [NAV, OVERLAY].join(\", \");\nconst NON_NAV_ELEMENTS = `body *:not(${HEADER}, ${NAV_CONTAINER}, ${NAV}, ${NAV} *):not([aria-hidden])`;\nconst NON_NAV_HIDDEN = `[${NON_NAV_HIDDEN_ATTRIBUTE}]`;\n\nconst ACTIVE_CLASS = \"usa-js-mobile-nav--active\";\nconst VISIBLE_CLASS = \"is-visible\";\n\nlet navigation;\nlet navActive;\nlet nonNavElements;\n\nconst isActive = () => document.body.classList.contains(ACTIVE_CLASS);\n// Detect Safari\n// Note: Chrome also reports the Safari userAgent so this specifically excludes Chrome.\nconst isSafari =\n  navigator.userAgent.includes(\"Safari\") &&\n  !navigator.userAgent.includes(\"Chrome\");\nconst SCROLLBAR_WIDTH = ScrollBarWidth();\nconst INITIAL_PADDING = window\n  .getComputedStyle(document.body)\n  .getPropertyValue(\"padding-right\");\nconst TEMPORARY_PADDING = `${\n  parseInt(INITIAL_PADDING.replace(/px/, \"\"), 10) +\n  parseInt(SCROLLBAR_WIDTH.replace(/px/, \"\"), 10)\n}px`;\n\nconst hideNonNavItems = () => {\n  const headerParent = document.querySelector(`${HEADER}`).parentNode;\n  nonNavElements = document.querySelectorAll(NON_NAV_ELEMENTS);\n\n  nonNavElements.forEach((nonNavElement) => {\n    if (nonNavElement !== headerParent) {\n      nonNavElement.setAttribute(\"aria-hidden\", true);\n      nonNavElement.setAttribute(NON_NAV_HIDDEN_ATTRIBUTE, \"\");\n    }\n  });\n};\n\nconst showNonNavItems = () => {\n  nonNavElements = document.querySelectorAll(NON_NAV_HIDDEN);\n\n  if (!nonNavElements) {\n    return;\n  }\n\n  // Remove aria-hidden from non-header elements\n  nonNavElements.forEach((nonNavElement) => {\n    nonNavElement.removeAttribute(\"aria-hidden\");\n    nonNavElement.removeAttribute(NON_NAV_HIDDEN_ATTRIBUTE);\n  });\n};\n\n// Toggle all non-header elements #3527.\nconst toggleNonNavItems = (active) => {\n  if (active) {\n    hideNonNavItems();\n  } else {\n    showNonNavItems();\n  }\n};\n\n/**\n * Detect Safari and add body class for a Safari-only CSS bug fix.\n * More details in https://github.com/uswds/uswds/pull/5443\n */\nconst addSafariClass = () => {\n  if (isSafari) {\n    document.body.classList.add(\"is-safari\");\n  }\n};\n\n/**\n * Set the value for the --scrolltop CSS var when the mobile menu is open.\n * This allows the CSS to lock the current scroll position in Safari\n * when overflow-y is set to scroll.\n * More details in https://github.com/uswds/uswds/pull/5443\n */\nconst setSafariScrollPosition = (body) => {\n  const currentScrollPosition = `-${window.scrollY}px`;\n  if (isSafari) {\n    body.style.setProperty(\"--scrolltop\", currentScrollPosition);\n  }\n};\n\nconst toggleNav = (active) => {\n  const { body } = document;\n  const safeActive = typeof active === \"boolean\" ? active : !isActive();\n\n  setSafariScrollPosition(body);\n\n  body.classList.toggle(ACTIVE_CLASS, safeActive);\n\n  select(TOGGLES).forEach((el) =>\n    el.classList.toggle(VISIBLE_CLASS, safeActive),\n  );\n\n  navigation.focusTrap.update(safeActive);\n\n  const closeButton = body.querySelector(CLOSE_BUTTON);\n  const menuButton = document.querySelector(OPENERS);\n\n  body.style.paddingRight =\n    body.style.paddingRight === TEMPORARY_PADDING\n      ? INITIAL_PADDING\n      : TEMPORARY_PADDING;\n\n  toggleNonNavItems(safeActive);\n\n  if (safeActive && closeButton) {\n    // The mobile nav was just activated. Focus on the close button, which is\n    // just before all the nav elements in the tab order.\n    closeButton.focus();\n  } else if (\n    !safeActive &&\n    menuButton &&\n    getComputedStyle(menuButton).display !== \"none\"\n  ) {\n    // The mobile nav was just deactivated. We don't want the focus to\n    // disappear into the void, so focus on the menu button if it's\n    // visible (this may have been what the user was just focused on,\n    // if they triggered the mobile nav by mistake).\n    menuButton.focus();\n  }\n\n  return safeActive;\n};\n\nconst resize = () => {\n  const closer = document.body.querySelector(CLOSE_BUTTON);\n\n  if (isActive() && closer && closer.getBoundingClientRect().width === 0) {\n    // When the mobile nav is active, and the close box isn't visible,\n    // we know the user's viewport has been resized to be larger.\n    // Let's make the page state consistent by deactivating the mobile nav.\n    navigation.toggleNav.call(closer, false);\n  }\n};\n\nconst onMenuClose = () => navigation.toggleNav.call(navigation, false);\n\nconst hideActiveNavDropdown = () => {\n  if (!navActive) {\n    return;\n  }\n\n  toggle(navActive, false);\n  navActive = null;\n};\n\nconst focusNavButton = (event) => {\n  const parentNavItem = event.target.closest(NAV_PRIMARY_ITEM);\n\n  // Only shift focus if within dropdown\n  if (!event.target.matches(NAV_CONTROL)) {\n    const navControl = parentNavItem.querySelector(NAV_CONTROL);\n    if (navControl) {\n      navControl.focus();\n    }\n  }\n};\n\nconst handleEscape = (event) => {\n  hideActiveNavDropdown();\n  focusNavButton(event);\n};\n\nnavigation = behavior(\n  {\n    [CLICK]: {\n      [NAV_CONTROL]() {\n        // If another nav is open, close it\n        if (navActive !== this) {\n          hideActiveNavDropdown();\n        }\n        // store a reference to the last clicked nav link element, so we\n        // can hide the dropdown if another element on the page is clicked\n        if (!navActive) {\n          navActive = this;\n          toggle(navActive, true);\n        }\n\n        // Do this so the event handler on the body doesn't fire\n        return false;\n      },\n      [BODY]: hideActiveNavDropdown,\n      [OPENERS]: toggleNav,\n      [CLOSERS]: toggleNav,\n      [NAV_LINKS]() {\n        // A navigation link has been clicked! We want to collapse any\n        // hierarchical navigation UI it's a part of, so that the user\n        // can focus on whatever they've just selected.\n\n        // Some navigation links are inside accordions; when they're\n        // clicked, we want to collapse those accordions.\n        const acc = this.closest(accordion.ACCORDION);\n\n        if (acc) {\n          accordion.getButtons(acc).forEach((btn) => accordion.hide(btn));\n        }\n\n        // If the mobile navigation menu is active, we want to hide it.\n        if (isActive()) {\n          navigation.toggleNav.call(navigation, false);\n        }\n      },\n    },\n    keydown: {\n      [NAV_PRIMARY]: keymap({ Escape: handleEscape }),\n    },\n    focusout: {\n      [NAV_PRIMARY](event) {\n        const nav = event.target.closest(NAV_PRIMARY);\n\n        if (!nav.contains(event.relatedTarget)) {\n          hideActiveNavDropdown();\n        }\n      },\n    },\n  },\n  {\n    init(root) {\n      const trapContainer = root.matches(NAV) ? root : root.querySelector(NAV);\n\n      if (trapContainer) {\n        navigation.focusTrap = FocusTrap(trapContainer, {\n          Escape: onMenuClose,\n        });\n      }\n\n      addSafariClass();\n      resize();\n      window.addEventListener(\"resize\", resize, false);\n    },\n    teardown() {\n      window.removeEventListener(\"resize\", resize, false);\n      navActive = false;\n    },\n    focusTrap: null,\n    toggleNav,\n  },\n);\n\nmodule.exports = navigation;\n","const once = require(\"receptor/once\");\nconst keymap = require(\"receptor/keymap\");\nconst selectOrMatches = require(\"../../uswds-core/src/js/utils/select-or-matches\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\nconst { CLICK } = require(\"../../uswds-core/src/js/events\");\nconst Sanitizer = require(\"../../uswds-core/src/js/utils/sanitizer\");\n\nconst CURRENT_CLASS = `${PREFIX}-current`;\nconst IN_PAGE_NAV_HEADINGS = \"h2 h3\";\nconst IN_PAGE_NAV_VALID_HEADINGS = [\"h1\", \"h2\", \"h3\", \"h4\", \"h5\", \"h6\"];\nconst IN_PAGE_NAV_TITLE_TEXT = \"On this page\";\nconst IN_PAGE_NAV_TITLE_HEADING_LEVEL = \"h4\";\nconst IN_PAGE_NAV_SCROLL_OFFSET = 0;\nconst IN_PAGE_NAV_ROOT_MARGIN = \"0px 0px 0px 0px\";\nconst IN_PAGE_NAV_THRESHOLD = \"1\";\nconst IN_PAGE_NAV_CLASS = `${PREFIX}-in-page-nav`;\nconst IN_PAGE_NAV_ANCHOR_CLASS = `${PREFIX}-anchor`;\nconst IN_PAGE_NAV_NAV_CLASS = `${IN_PAGE_NAV_CLASS}__nav`;\nconst IN_PAGE_NAV_LIST_CLASS = `${IN_PAGE_NAV_CLASS}__list`;\nconst IN_PAGE_NAV_ITEM_CLASS = `${IN_PAGE_NAV_CLASS}__item`;\nconst IN_PAGE_NAV_PRIMARY_ITEM_CLASS = `${IN_PAGE_NAV_ITEM_CLASS}--primary`;\nconst IN_PAGE_NAV_LINK_CLASS = `${IN_PAGE_NAV_CLASS}__link`;\nconst IN_PAGE_NAV_TITLE_CLASS = `${IN_PAGE_NAV_CLASS}__heading`;\nconst MAIN_ELEMENT = \"main\";\n\n/**\n * Set the active link state for the currently observed section\n *\n * @param {HTMLElement} el An element within the in-page nav component\n */\nconst setActive = (el) => {\n  const allLinks = document.querySelectorAll(`.${IN_PAGE_NAV_LINK_CLASS}`);\n  el.map((i) => {\n    if (i.isIntersecting === true && i.intersectionRatio >= 1) {\n      allLinks.forEach((link) => link.classList.remove(CURRENT_CLASS));\n      document\n        .querySelector(`a[href=\"#${i.target.id}\"]`)\n        .classList.add(CURRENT_CLASS);\n      return true;\n    }\n    return false;\n  });\n};\n\n/**\n * Return an array of the designated heading types found in the designated content region.\n * Throw an error if an invalid header element is designated.\n *\n * @param {HTMLElement} selectedContentRegion The content region the component should pull headers from\n * @param {String} selectedHeadingTypes The list of heading types that should be included in the nav list\n *\n * @return {Array} - An array of designated heading types from the designated content region\n */\nconst createSectionHeadingsArray = (\n  selectedContentRegion,\n  selectedHeadingTypes,\n) => {\n  // Convert designated headings list to an array\n  const selectedHeadingTypesArray = selectedHeadingTypes.indexOf(\" \")\n    ? selectedHeadingTypes.split(\" \")\n    : selectedHeadingTypes;\n  const contentRegion = document.querySelector(selectedContentRegion);\n\n  selectedHeadingTypesArray.forEach((headingType) => {\n    if (!IN_PAGE_NAV_VALID_HEADINGS.includes(headingType)) {\n      throw new Error(\n        `In-page navigation: data-heading-elements attribute defined with an invalid heading type: \"${headingType}\".\n        Define the attribute with one or more of the following: \"${IN_PAGE_NAV_VALID_HEADINGS}\".\n        Do not use commas or other punctuation in the attribute definition.`,\n      );\n    }\n  });\n\n  const sectionHeadingsArray = Array.from(\n    contentRegion.querySelectorAll(selectedHeadingTypesArray),\n  );\n\n  return sectionHeadingsArray;\n};\n\n/**\n * Return an array of the visible headings from sectionHeadingsArray.\n * This function removes headings that are hidden with display:none or visibility:none style rules.\n * These items will be added to the component nav list.\n *\n * @param {HTMLElement} selectedContentRegion The content region the component should pull headers from\n * @param {String} selectedHeadingTypes The list of heading types that should be included in the nav list\n *\n * @return {Array} - An array of visible headings from the designated content region\n */\nconst getVisibleSectionHeadings = (\n  selectedContentRegion,\n  selectedHeadingTypes,\n) => {\n  const sectionHeadings = createSectionHeadingsArray(\n    selectedContentRegion,\n    selectedHeadingTypes,\n  );\n\n  // Find all headings with hidden styling and remove them from the array\n  const visibleSectionHeadings = sectionHeadings.filter((heading) => {\n    const headingStyle = window.getComputedStyle(heading);\n    const visibleHeading =\n      headingStyle.getPropertyValue(\"display\") !== \"none\" &&\n      headingStyle.getPropertyValue(\"visibility\") !== \"hidden\";\n\n    return visibleHeading;\n  });\n\n  return visibleSectionHeadings;\n};\n\n/**\n * Return the highest-level header tag included in the link list\n *\n * @param {HTMLElement} sectionHeadings The array of headings selected for inclusion in the link list\n *\n * @return {tagName} - The tag name for the highest level of header in the link list\n */\n\nconst getTopLevelHeading = (sectionHeadings) => {\n  const topHeading = sectionHeadings[0].tagName.toLowerCase();\n  return topHeading;\n};\n\n/**\n * Return a node list of section anchor tags\n *\n * @return {HTMLElement[]} - An array of DOM nodes\n */\nconst getSectionAnchors = () => {\n  const sectionAnchors = document.querySelectorAll(\n    `.${IN_PAGE_NAV_ANCHOR_CLASS}`,\n  );\n  return sectionAnchors;\n};\n\n/**\n * Generates a unique ID for the given heading element.\n *\n * @param {HTMLHeadingElement} heading\n *\n * @return {string} - Unique ID\n */\nconst getHeadingId = (heading) => {\n  const baseId = heading.textContent\n    .toLowerCase()\n    // Replace non-alphanumeric characters with dashes\n    .replace(/[^a-z\\d]/g, \"-\")\n    // Replace a sequence of two or more dashes with a single dash\n    .replace(/-{2,}/g, \"-\")\n    // Trim leading or trailing dash (there should only ever be one)\n    .replace(/^-|-$/g, \"\");\n\n  let id;\n  let suffix = 0;\n  do {\n    id = baseId;\n\n    // To avoid conflicts with existing IDs on the page, loop and append an\n    // incremented suffix until a unique ID is found.\n    suffix += 1;\n    if (suffix > 1) {\n      id += `-${suffix}`;\n    }\n  } while (document.getElementById(id));\n\n  return id;\n};\n\n/**\n * Return a section id/anchor hash without the number sign\n *\n * @return {String} - Id value with the number sign removed\n */\nconst getSectionId = (value) => {\n  let id;\n\n  // Check if value is an event or element and get the cleaned up id\n  if (value && value.nodeType === 1) {\n    id = value.getAttribute(\"href\").replace(\"#\", \"\");\n  } else {\n    id = value.target.hash.replace(\"#\", \"\");\n  }\n\n  return id;\n};\n\n/**\n * Scroll smoothly to a section based on the passed in element\n *\n * @param {HTMLElement} - Id value with the number sign removed\n */\nconst handleScrollToSection = (el) => {\n  const inPageNavEl = document.querySelector(`.${IN_PAGE_NAV_CLASS}`);\n  const inPageNavScrollOffset =\n    inPageNavEl.dataset.scrollOffset || IN_PAGE_NAV_SCROLL_OFFSET;\n\n  window.scroll({\n    behavior: \"smooth\",\n    top: el.offsetTop - inPageNavScrollOffset,\n    block: \"start\",\n  });\n\n  if (window.location.hash.slice(1) !== el.id) {\n    window.history.pushState(null, \"\", `#${el.id}`);\n  }\n};\n\n/**\n * Scrolls the page to the section corresponding to the current hash fragment, if one exists.\n */\nconst scrollToCurrentSection = () => {\n  const hashFragment = window.location.hash.slice(1);\n  if (hashFragment) {\n    const anchorTag = document.getElementById(hashFragment);\n    if (anchorTag) {\n      handleScrollToSection(anchorTag);\n    }\n  }\n};\n\n/**\n * Create the in-page navigation component\n *\n * @param {HTMLElement} inPageNavEl The in-page nav element\n */\nconst createInPageNav = (inPageNavEl) => {\n  const inPageNavTitleText = Sanitizer.escapeHTML`${\n    inPageNavEl.dataset.titleText || IN_PAGE_NAV_TITLE_TEXT\n  }`;\n  const inPageNavTitleHeadingLevel = Sanitizer.escapeHTML`${\n    inPageNavEl.dataset.titleHeadingLevel || IN_PAGE_NAV_TITLE_HEADING_LEVEL\n  }`;\n  const inPageNavRootMargin = Sanitizer.escapeHTML`${\n    inPageNavEl.dataset.rootMargin || IN_PAGE_NAV_ROOT_MARGIN\n  }`;\n  const inPageNavThreshold = Sanitizer.escapeHTML`${\n    inPageNavEl.dataset.threshold || IN_PAGE_NAV_THRESHOLD\n  }`;\n  const inPageNavContentSelector = Sanitizer.escapeHTML`${\n    inPageNavEl.dataset.mainContentSelector || MAIN_ELEMENT\n  }`;\n  const inPageNavHeadingSelector = Sanitizer.escapeHTML`${\n    inPageNavEl.dataset.headingElements || IN_PAGE_NAV_HEADINGS\n  }`;\n\n  const options = {\n    root: null,\n    rootMargin: inPageNavRootMargin,\n    threshold: [inPageNavThreshold],\n  };\n\n  const sectionHeadings = getVisibleSectionHeadings(\n    inPageNavContentSelector,\n    inPageNavHeadingSelector,\n  );\n  const inPageNav = document.createElement(\"nav\");\n  inPageNav.setAttribute(\"aria-label\", inPageNavTitleText);\n  inPageNav.classList.add(IN_PAGE_NAV_NAV_CLASS);\n\n  const inPageNavTitle = document.createElement(inPageNavTitleHeadingLevel);\n  inPageNavTitle.classList.add(IN_PAGE_NAV_TITLE_CLASS);\n  inPageNavTitle.setAttribute(\"tabindex\", \"0\");\n  inPageNavTitle.textContent = inPageNavTitleText;\n  inPageNav.appendChild(inPageNavTitle);\n\n  const inPageNavList = document.createElement(\"ul\");\n  inPageNavList.classList.add(IN_PAGE_NAV_LIST_CLASS);\n  inPageNav.appendChild(inPageNavList);\n\n  sectionHeadings.forEach((el) => {\n    const listItem = document.createElement(\"li\");\n    const navLinks = document.createElement(\"a\");\n    const anchorTag = document.createElement(\"a\");\n    const textContentOfLink = el.textContent;\n    const tag = el.tagName.toLowerCase();\n    const topHeadingLevel = getTopLevelHeading(sectionHeadings);\n    const headingId = getHeadingId(el);\n\n    listItem.classList.add(IN_PAGE_NAV_ITEM_CLASS);\n\n    if (tag === topHeadingLevel) {\n      listItem.classList.add(IN_PAGE_NAV_PRIMARY_ITEM_CLASS);\n    }\n\n    navLinks.setAttribute(\"href\", `#${headingId}`);\n    navLinks.setAttribute(\"class\", IN_PAGE_NAV_LINK_CLASS);\n    navLinks.textContent = textContentOfLink;\n\n    anchorTag.setAttribute(\"id\", headingId);\n    anchorTag.setAttribute(\"class\", IN_PAGE_NAV_ANCHOR_CLASS);\n    el.insertAdjacentElement(\"afterbegin\", anchorTag);\n\n    inPageNavList.appendChild(listItem);\n    listItem.appendChild(navLinks);\n  });\n\n  inPageNavEl.appendChild(inPageNav);\n\n  const anchorTags = getSectionAnchors();\n  const observeSections = new window.IntersectionObserver(setActive, options);\n\n  anchorTags.forEach((tag) => {\n    observeSections.observe(tag);\n  });\n};\n\n/**\n * Handle click from link\n *\n * @param {HTMLElement} el An element within the in-page nav component\n */\nconst handleClickFromLink = (el) => {\n  const elementToScrollTo = document.getElementById(el.hash.slice(1));\n  handleScrollToSection(elementToScrollTo);\n};\n\n/**\n * Handle the enter event from a link within the in-page nav component\n *\n * @param {KeyboardEvent} event An event within the in-page nav component\n */\nconst handleEnterFromLink = (event) => {\n  const id = getSectionId(event);\n  const targetAnchor = document.getElementById(id);\n  const target = targetAnchor.parentElement;\n\n  if (target) {\n    target.setAttribute(\"tabindex\", 0);\n    target.focus();\n    target.addEventListener(\n      \"blur\",\n      once(() => {\n        target.setAttribute(\"tabindex\", -1);\n      }),\n    );\n  } else {\n    // throw an error?\n  }\n  handleScrollToSection(targetAnchor);\n};\n\nconst inPageNavigation = behavior(\n  {\n    [CLICK]: {\n      [`.${IN_PAGE_NAV_LINK_CLASS}`](event) {\n        event.preventDefault();\n        if (this.disabled) return;\n        handleClickFromLink(this);\n      },\n    },\n    keydown: {\n      [`.${IN_PAGE_NAV_LINK_CLASS}`]: keymap({\n        Enter: handleEnterFromLink,\n      }),\n    },\n  },\n  {\n    init(root) {\n      selectOrMatches(`.${IN_PAGE_NAV_CLASS}`, root).forEach((inPageNavEl) => {\n        createInPageNav(inPageNavEl);\n        scrollToCurrentSection();\n      });\n    },\n  },\n);\n\nmodule.exports = inPageNavigation;\n","const selectOrMatches = require(\"../../uswds-core/src/js/utils/select-or-matches\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\n\nconst MASKED_CLASS = `${PREFIX}-masked`;\nconst MASKED = `.${MASKED_CLASS}`;\nconst MASK = `${PREFIX}-input-mask`;\nconst MASK_CONTENT = `${MASK}--content`;\nconst PLACEHOLDER = \"placeholder\";\n\n// User defined Values\nconst maskedNumber = \"_#dDmMyY9\";\nconst maskedLetter = \"A\";\n\n// replaces each masked input with a shell containing the input and it's mask.\nconst createMaskedInputShell = (input) => {\n  const placeholder = input.getAttribute(`${PLACEHOLDER}`);\n  if (placeholder) {\n    input.setAttribute(\"maxlength\", placeholder.length);\n    input.setAttribute(\"data-placeholder\", placeholder);\n    input.removeAttribute(`${PLACEHOLDER}`);\n  } else {\n    return;\n  }\n\n  const shell = document.createElement(\"span\");\n  shell.classList.add(MASK);\n  shell.setAttribute(\"data-mask\", placeholder);\n\n  const content = document.createElement(\"span\");\n  content.classList.add(MASK_CONTENT);\n  content.setAttribute(\"aria-hidden\", \"true\");\n  content.id = `${input.id}Mask`;\n  content.textContent = placeholder;\n\n  shell.appendChild(content);\n  input.parentNode.insertBefore(shell, input);\n  shell.appendChild(input);\n};\n\nconst setValueOfMask = (el) => {\n  const { value } = el;\n  const placeholderVal = `${el.dataset.placeholder.substr(value.length)}`;\n\n  const theIEl = document.createElement(\"i\");\n  theIEl.textContent = value;\n  return [theIEl, placeholderVal];\n};\n\nconst strippedValue = (isCharsetPresent, value) =>\n  isCharsetPresent ? value.replace(/\\W/g, \"\") : value.replace(/\\D/g, \"\");\n\nconst isInteger = (value) => !Number.isNaN(parseInt(value, 10));\n\nconst isLetter = (value) => (value ? value.match(/[A-Z]/i) : false);\n\nconst handleCurrentValue = (el) => {\n  const isCharsetPresent = el.dataset.charset;\n  const placeholder = isCharsetPresent || el.dataset.placeholder;\n  const { value } = el;\n  const len = placeholder.length;\n  let newValue = \"\";\n  let i;\n  let charIndex;\n\n  const strippedVal = strippedValue(isCharsetPresent, value);\n\n  for (i = 0, charIndex = 0; i < len; i += 1) {\n    const isInt = isInteger(strippedVal[charIndex]);\n    const isLet = isLetter(strippedVal[charIndex]);\n    const matchesNumber = maskedNumber.indexOf(placeholder[i]) >= 0;\n    const matchesLetter = maskedLetter.indexOf(placeholder[i]) >= 0;\n\n    if (\n      (matchesNumber && isInt) ||\n      (isCharsetPresent && matchesLetter && isLet)\n    ) {\n      newValue += strippedVal[charIndex];\n      charIndex += 1;\n    } else if (\n      (!isCharsetPresent && !isInt && matchesNumber) ||\n      (isCharsetPresent &&\n        ((matchesLetter && !isLet) || (matchesNumber && !isInt)))\n    ) {\n      return newValue;\n    } else {\n      newValue += placeholder[i];\n    }\n    // break if no characters left and the pattern is non-special character\n    if (strippedVal[charIndex] === undefined) {\n      break;\n    }\n  }\n\n  return newValue;\n};\n\nconst handleValueChange = (el) => {\n  const inputEl = el;\n  const id = inputEl.getAttribute(\"id\");\n  inputEl.value = handleCurrentValue(inputEl);\n\n  const maskVal = setValueOfMask(el);\n  const maskEl = document.getElementById(`${id}Mask`);\n  maskEl.textContent = \"\";\n  maskEl.replaceChildren(maskVal[0], maskVal[1]);\n};\n\nconst inputMaskEvents = {\n  keyup: {\n    [MASKED]() {\n      handleValueChange(this);\n    },\n  },\n};\n\nconst inputMask = behavior(inputMaskEvents, {\n  init(root) {\n    selectOrMatches(MASKED, root).forEach((maskedInput) => {\n      createMaskedInputShell(maskedInput);\n    });\n  },\n});\n\nmodule.exports = inputMask;\n","const keymap = require(\"receptor/keymap\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst toggle = require(\"../../uswds-core/src/js/utils/toggle\");\nconst FocusTrap = require(\"../../uswds-core/src/js/utils/focus-trap\");\nconst accordion = require(\"../../usa-accordion/src/index\");\n\nconst { CLICK } = require(\"../../uswds-core/src/js/events\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\n\nconst BODY = \"body\";\nconst LANGUAGE = `.${PREFIX}-language`;\nconst LANGUAGE_SUB = `.${PREFIX}-language__submenu`;\nconst LANGUAGE_PRIMARY = `.${PREFIX}-language__primary`;\nconst LANGUAGE_PRIMARY_ITEM = `.${PREFIX}-language__primary-item`;\nconst LANGUAGE_CONTROL = `button.${PREFIX}-language__link`;\nconst LANGUAGE_LINKS = `${LANGUAGE} a`;\n\nlet languageSelector;\nlet languageActive;\n\nconst onLanguageClose = () =>\n  languageSelector.toggleLanguage.call(languageSelector, false);\n\nconst hideActiveLanguageDropdown = () => {\n  if (!languageActive) {\n    return;\n  }\n\n  toggle(languageActive, false);\n  languageActive = null;\n};\n\nconst focusLanguageButton = (event) => {\n  const parentLanguageItem = event.target.closest(LANGUAGE_PRIMARY_ITEM);\n\n  if (!event.target.matches(LANGUAGE_CONTROL)) {\n    parentLanguageItem.querySelector(LANGUAGE_CONTROL).focus();\n  }\n};\n\nconst handleEscape = (event) => {\n  hideActiveLanguageDropdown();\n  focusLanguageButton(event);\n};\n\nlanguageSelector = behavior(\n  {\n    [CLICK]: {\n      [LANGUAGE_CONTROL]() {\n        if (languageActive !== this) {\n          hideActiveLanguageDropdown();\n        }\n        if (languageActive === this) {\n          hideActiveLanguageDropdown();\n          return false;\n        }\n        if (!languageActive) {\n          languageActive = this;\n          toggle(languageActive, true);\n        }\n\n        return false;\n      },\n      [BODY]: hideActiveLanguageDropdown,\n      [LANGUAGE_LINKS]() {\n        const acc = this.closest(accordion.ACCORDION);\n\n        if (acc) {\n          accordion.getButtons(acc).forEach((btn) => accordion.hide(btn));\n        }\n      },\n    },\n    keydown: {\n      [LANGUAGE_PRIMARY]: keymap({ Escape: handleEscape }),\n    },\n    focusout: {\n      [LANGUAGE_PRIMARY](event) {\n        const language = event.target.closest(LANGUAGE_PRIMARY);\n\n        if (!language.contains(event.relatedTarget)) {\n          hideActiveLanguageDropdown();\n        }\n      },\n    },\n  },\n  {\n    init(root) {\n      const trapContainer = root.matches(LANGUAGE_SUB)\n        ? root\n        : root.querySelector(LANGUAGE_SUB);\n\n      if (trapContainer) {\n        languageSelector.focusTrap = FocusTrap(trapContainer, {\n          Escape: onLanguageClose,\n        });\n      }\n    },\n    teardown() {\n      languageActive = false;\n    },\n    focusTrap: null,\n  },\n);\n\nmodule.exports = languageSelector;\n","const selectOrMatches = require(\"../../uswds-core/src/js/utils/select-or-matches\");\nconst FocusTrap = require(\"../../uswds-core/src/js/utils/focus-trap\");\nconst ScrollBarWidth = require(\"../../uswds-core/src/js/utils/scrollbar-width\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\n\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\n\nconst MODAL_CLASSNAME = `${PREFIX}-modal`;\nconst OVERLAY_CLASSNAME = `${MODAL_CLASSNAME}-overlay`;\nconst WRAPPER_CLASSNAME = `${MODAL_CLASSNAME}-wrapper`;\nconst OPENER_ATTRIBUTE = \"data-open-modal\";\nconst CLOSER_ATTRIBUTE = \"data-close-modal\";\nconst FORCE_ACTION_ATTRIBUTE = \"data-force-action\";\nconst NON_MODAL_HIDDEN_ATTRIBUTE = `data-modal-hidden`;\nconst MODAL = `.${MODAL_CLASSNAME}`;\nconst INITIAL_FOCUS = `.${WRAPPER_CLASSNAME} *[data-focus]`;\nconst CLOSE_BUTTON = `${WRAPPER_CLASSNAME} *[${CLOSER_ATTRIBUTE}]`;\nconst OPENERS = `*[${OPENER_ATTRIBUTE}][aria-controls]`;\nconst CLOSERS = `${CLOSE_BUTTON}, .${OVERLAY_CLASSNAME}:not([${FORCE_ACTION_ATTRIBUTE}])`;\nconst NON_MODALS = `body > *:not(.${WRAPPER_CLASSNAME}):not([aria-hidden])`;\nconst NON_MODALS_HIDDEN = `[${NON_MODAL_HIDDEN_ATTRIBUTE}]`;\n\nconst ACTIVE_CLASS = \"usa-js-modal--active\";\nconst PREVENT_CLICK_CLASS = \"usa-js-no-click\";\nconst VISIBLE_CLASS = \"is-visible\";\nconst HIDDEN_CLASS = \"is-hidden\";\n\nlet modal;\nlet INITIAL_BODY_PADDING;\nlet TEMPORARY_BODY_PADDING;\n\nconst isActive = () => document.body.classList.contains(ACTIVE_CLASS);\nconst SCROLLBAR_WIDTH = ScrollBarWidth();\n\n/**\n *  Closes modal when bound to a button and pressed.\n */\nconst onMenuClose = () => {\n  modal.toggleModal.call(modal, false);\n};\n\n/**\n * Set the value for temporary body padding that will be applied when the modal is open.\n * Value is created by checking for initial body padding and adding the width of the scrollbar.\n */\nconst setTemporaryBodyPadding = () => {\n  INITIAL_BODY_PADDING = window\n    .getComputedStyle(document.body)\n    .getPropertyValue(\"padding-right\");\n  TEMPORARY_BODY_PADDING = `${\n    parseInt(INITIAL_BODY_PADDING.replace(/px/, \"\"), 10) +\n    parseInt(SCROLLBAR_WIDTH.replace(/px/, \"\"), 10)\n  }px`;\n};\n\n/**\n *  Toggle the visibility of a modal window\n *\n * @param {KeyboardEvent} event the keydown event.\n * @returns {boolean} safeActive if mobile is open.\n */\nfunction toggleModal(event) {\n  let originalOpener;\n  let clickedElement = event.target;\n  const { body } = document;\n  const safeActive = !isActive();\n  const modalId = clickedElement\n    ? clickedElement.getAttribute(\"aria-controls\")\n    : document.querySelector(`.${WRAPPER_CLASSNAME}.${VISIBLE_CLASS}`);\n  const targetModal = safeActive\n    ? document.getElementById(modalId)\n    : document.querySelector(`.${WRAPPER_CLASSNAME}.${VISIBLE_CLASS}`);\n\n  // if there is no modal we return early\n  if (!targetModal) {\n    return false;\n  }\n\n  const openFocusEl = targetModal.querySelector(INITIAL_FOCUS)\n    ? targetModal.querySelector(INITIAL_FOCUS)\n    : targetModal.querySelector(`.${MODAL_CLASSNAME}`);\n  const returnFocus = document.getElementById(\n    targetModal.getAttribute(\"data-opener\"),\n  );\n  const menuButton = body.querySelector(OPENERS);\n  const forceUserAction = targetModal.getAttribute(FORCE_ACTION_ATTRIBUTE);\n\n  // Sets the clicked element to the close button\n  // so esc key always closes modal\n  if (event.type === \"keydown\" && targetModal !== null) {\n    clickedElement = targetModal.querySelector(CLOSE_BUTTON);\n  }\n\n  // When we're not hitting the escape key…\n  if (clickedElement) {\n    // Make sure we click the opener\n    // If it doesn't have an ID, make one\n    // Store id as data attribute on modal\n    if (clickedElement.hasAttribute(OPENER_ATTRIBUTE)) {\n      if (this.getAttribute(\"id\") === null) {\n        originalOpener = `modal-${Math.floor(Math.random() * 900000) + 100000}`;\n        this.setAttribute(\"id\", originalOpener);\n      } else {\n        originalOpener = this.getAttribute(\"id\");\n      }\n      targetModal.setAttribute(\"data-opener\", originalOpener);\n    }\n\n    // This basically stops the propagation if the element\n    // is inside the modal and not a close button or\n    // element inside a close button\n    if (clickedElement.closest(`.${MODAL_CLASSNAME}`)) {\n      if (\n        clickedElement.hasAttribute(CLOSER_ATTRIBUTE) ||\n        clickedElement.closest(`[${CLOSER_ATTRIBUTE}]`)\n      ) {\n        // do nothing. move on.\n      } else {\n        return false;\n      }\n    }\n  }\n\n  body.classList.toggle(ACTIVE_CLASS, safeActive);\n  targetModal.classList.toggle(VISIBLE_CLASS, safeActive);\n  targetModal.classList.toggle(HIDDEN_CLASS, !safeActive);\n\n  // If user is forced to take an action, adding\n  // a class to the body that prevents clicking underneath\n  // overlay\n  if (forceUserAction) {\n    body.classList.toggle(PREVENT_CLICK_CLASS, safeActive);\n  }\n\n  // Temporarily increase body padding to include the width of the scrollbar.\n  // This accounts for the content shift when the scrollbar is removed on modal open.\n  if (body.style.paddingRight === TEMPORARY_BODY_PADDING) {\n    body.style.removeProperty(\"padding-right\");\n  } else {\n    body.style.paddingRight = TEMPORARY_BODY_PADDING;\n  }\n\n  // Handle the focus actions\n  if (safeActive && openFocusEl) {\n    // The modal window is opened. Focus is set to close button.\n\n    // Binds escape key if we're not forcing\n    // the user to take an action\n    if (forceUserAction) {\n      modal.focusTrap = FocusTrap(targetModal);\n    } else {\n      modal.focusTrap = FocusTrap(targetModal, {\n        Escape: onMenuClose,\n      });\n    }\n\n    // Handles focus setting and interactions\n    modal.focusTrap.update(safeActive);\n    openFocusEl.focus();\n\n    // Hides everything that is not the modal from screen readers\n    document.querySelectorAll(NON_MODALS).forEach((nonModal) => {\n      nonModal.setAttribute(\"aria-hidden\", \"true\");\n      nonModal.setAttribute(NON_MODAL_HIDDEN_ATTRIBUTE, \"\");\n    });\n  } else if (!safeActive && menuButton && returnFocus) {\n    // The modal window is closed.\n    // Non-modals now accesible to screen reader\n    document.querySelectorAll(NON_MODALS_HIDDEN).forEach((nonModal) => {\n      nonModal.removeAttribute(\"aria-hidden\");\n      nonModal.removeAttribute(NON_MODAL_HIDDEN_ATTRIBUTE);\n    });\n\n    // Focus is returned to the opener\n    returnFocus.focus();\n    modal.focusTrap.update(safeActive);\n  }\n\n  return safeActive;\n}\n\n/**\n * Creates a placeholder with data attributes for cleanup function.\n * The cleanup function uses this placeholder to easily restore the original Modal HTML on teardown.\n *\n * @param {HTMLDivElement} baseComponent - Modal HTML from the DOM.\n * @returns {HTMLDivElement} Placeholder used for cleanup function.\n */\nconst createPlaceHolder = (baseComponent) => {\n  const modalID = baseComponent.getAttribute(\"id\");\n  const originalLocationPlaceHolder = document.createElement(\"div\");\n  const modalAttributes = Array.from(baseComponent.attributes);\n\n  setTemporaryBodyPadding();\n\n  originalLocationPlaceHolder.setAttribute(`data-placeholder-for`, modalID);\n  originalLocationPlaceHolder.style.display = \"none\";\n  originalLocationPlaceHolder.setAttribute(\"aria-hidden\", \"true\");\n\n  modalAttributes.forEach((attribute) => {\n    originalLocationPlaceHolder.setAttribute(\n      `data-original-${attribute.name}`,\n      attribute.value,\n    );\n  });\n\n  return originalLocationPlaceHolder;\n};\n\n/**\n * Moves necessary attributes from Modal HTML to wrapper element.\n *\n * @param {HTMLDivElement} baseComponent - Modal HTML in the DOM.\n * @param {HTMLDivElement} modalContentWrapper - Modal component wrapper element.\n * @returns Modal wrapper with correct attributes.\n */\nconst setModalAttributes = (baseComponent, modalContentWrapper) => {\n  const modalID = baseComponent.getAttribute(\"id\");\n  const ariaLabelledBy = baseComponent.getAttribute(\"aria-labelledby\");\n  const ariaDescribedBy = baseComponent.getAttribute(\"aria-describedby\");\n  const forceUserAction = baseComponent.hasAttribute(FORCE_ACTION_ATTRIBUTE);\n\n  if (!ariaLabelledBy)\n    throw new Error(`${modalID} is missing aria-labelledby attribute`);\n\n  if (!ariaDescribedBy)\n    throw new Error(`${modalID} is missing aria-desribedby attribute`);\n\n  // Set attributes\n  modalContentWrapper.setAttribute(\"role\", \"dialog\");\n  modalContentWrapper.setAttribute(\"id\", modalID);\n  modalContentWrapper.setAttribute(\"aria-labelledby\", ariaLabelledBy);\n  modalContentWrapper.setAttribute(\"aria-describedby\", ariaDescribedBy);\n\n  if (forceUserAction) {\n    modalContentWrapper.setAttribute(FORCE_ACTION_ATTRIBUTE, forceUserAction);\n  }\n\n  // Add aria-controls\n  const modalClosers = modalContentWrapper.querySelectorAll(CLOSERS);\n  modalClosers.forEach((el) => {\n    el.setAttribute(\"aria-controls\", modalID);\n  });\n\n  // Update the base element HTML\n  baseComponent.removeAttribute(\"id\");\n  baseComponent.removeAttribute(\"aria-labelledby\");\n  baseComponent.removeAttribute(\"aria-describedby\");\n  baseComponent.setAttribute(\"tabindex\", \"-1\");\n\n  return modalContentWrapper;\n};\n\n/**\n * Creates a hidden modal content wrapper.\n * Rebuilds the original Modal HTML in the new wrapper and adds a page overlay.\n * Then moves original Modal HTML attributes to the new wrapper.\n *\n * @param {HTMLDivElement} baseComponent - Original Modal HTML in the DOM.\n * @returns Modal component - Modal wrapper w/ nested Overlay and Modal Content.\n */\nconst rebuildModal = (baseComponent) => {\n  const modalContent = baseComponent;\n  const modalContentWrapper = document.createElement(\"div\");\n  const overlayDiv = document.createElement(\"div\");\n\n  // Add classes\n  modalContentWrapper.classList.add(HIDDEN_CLASS, WRAPPER_CLASSNAME);\n  overlayDiv.classList.add(OVERLAY_CLASSNAME);\n\n  // Rebuild the modal element\n  modalContentWrapper.append(overlayDiv);\n  overlayDiv.append(modalContent);\n\n  // Add attributes\n  setModalAttributes(modalContent, modalContentWrapper);\n\n  return modalContentWrapper;\n};\n\n/**\n *  Builds modal window from base HTML and appends to the end of the DOM.\n *\n * @param {HTMLDivElement} baseComponent - The modal div element in the DOM.\n */\nconst setUpModal = (baseComponent) => {\n  const modalID = baseComponent.getAttribute(\"id\");\n\n  if (!modalID) {\n    throw new Error(`Modal markup is missing ID`);\n  }\n\n  // Create placeholder where modal is for cleanup\n  const originalLocationPlaceHolder = createPlaceHolder(baseComponent);\n  baseComponent.after(originalLocationPlaceHolder);\n\n  // Build modal component\n  const modalComponent = rebuildModal(baseComponent);\n\n  // Move all modals to the end of the DOM. Doing this allows us to\n  // more easily find the elements to hide from screen readers\n  // when the modal is open.\n  document.body.appendChild(modalComponent);\n};\n\n/**\n * Removes dynamically created Modal and Wrapper elements and restores original Modal HTML.\n *\n * @param {HTMLDivElement} baseComponent - The modal div element in the DOM.\n */\nconst cleanUpModal = (baseComponent) => {\n  const modalContent = baseComponent;\n  const modalContentWrapper = modalContent.parentElement.parentElement;\n  const modalID = modalContentWrapper.getAttribute(\"id\");\n\n  // if there is no modalID, return early\n  if (!modalID) {\n    return;\n  }\n\n  const originalLocationPlaceHolder = document.querySelector(\n    `[data-placeholder-for=\"${modalID}\"]`,\n  );\n\n  if (originalLocationPlaceHolder) {\n    const modalAttributes = Array.from(originalLocationPlaceHolder.attributes);\n    modalAttributes.forEach((attribute) => {\n      if (attribute.name.startsWith(\"data-original-\")) {\n        // data-original- is 14 long\n        modalContent.setAttribute(attribute.name.substr(14), attribute.value);\n      }\n    });\n\n    originalLocationPlaceHolder.after(modalContent);\n    originalLocationPlaceHolder.parentElement.removeChild(\n      originalLocationPlaceHolder,\n    );\n  }\n\n  modalContentWrapper.parentElement.removeChild(modalContentWrapper);\n};\n\nmodal = behavior(\n  {},\n  {\n    init(root) {\n      selectOrMatches(MODAL, root).forEach((modalWindow) => {\n        const modalId = modalWindow.id;\n\n        setUpModal(modalWindow);\n\n        // Query all openers and closers including the overlay\n        selectOrMatches(`[aria-controls=\"${modalId}\"]`, document).forEach(\n          (modalTrigger) => {\n            // If modalTrigger is an anchor...\n            if (modalTrigger.nodeName === \"A\") {\n              // Turn anchor links into buttons for screen readers\n              modalTrigger.setAttribute(\"role\", \"button\");\n\n              // Prevent modal triggers from acting like links\n              modalTrigger.addEventListener(\"click\", (e) => e.preventDefault());\n            }\n\n            // Can uncomment when aria-haspopup=\"dialog\" is supported\n            // https://a11ysupport.io/tech/aria/aria-haspopup_attribute\n            // Most screen readers support aria-haspopup, but might announce\n            // as opening a menu if \"dialog\" is not supported.\n            // modalTrigger.setAttribute(\"aria-haspopup\", \"dialog\");\n\n            modalTrigger.addEventListener(\"click\", toggleModal);\n          },\n        );\n      });\n    },\n    teardown(root) {\n      selectOrMatches(MODAL, root).forEach((modalWindow) => {\n        const modalId = modalWindow.id;\n        cleanUpModal(modalWindow);\n\n        selectOrMatches(`[aria-controls=\"${modalId}\"]`, document).forEach(\n          (modalTrigger) =>\n            modalTrigger.removeEventListener(\"click\", toggleModal),\n        );\n      });\n    },\n    focusTrap: null,\n    toggleModal,\n  },\n);\n\nmodule.exports = modal;\n","const selectOrMatches = require(\"../../uswds-core/src/js/utils/select-or-matches\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\n\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\n\nconst RANGE_CLASSNAME = `${PREFIX}-range`;\nconst RANGE = `.${RANGE_CLASSNAME}`;\n\n/**\n * Update range callout for screen readers using the optional data attributes.\n *\n * Get optional data attributes, construct and appends aria-valuetext attribute.\n *\n * @example\n *\n * <input id=\"usa-range\" class=\"usa-range\" type=\"range\" min=\"0\" max=\"100\" step=\"10\" value=\"20\" data-text-unit=\"degrees\">\n *\n * Callout returns \"20 degrees of 100.\"\n *\n * <input id=\"usa-range\" class=\"usa-range\" type=\"range\" min=\"0\" max=\"100\" step=\"10\" value=\"20\" data-text-preposition=\"de\">\n *\n * Callout returns \"20 de 100.\"\n *\n * @param {HTMLInputElement} targetRange - The range slider input element\n */\nconst updateCallout = (targetRange) => {\n  const rangeSlider = targetRange;\n  const defaultPrep = \"of\";\n  const optionalPrep = rangeSlider.dataset.textPreposition;\n  const prep = optionalPrep || defaultPrep;\n  const unit = rangeSlider.dataset.textUnit;\n  const val = rangeSlider.value;\n  // Note: 100 is the max attribute's native default value on range inputs\n  // Reference: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/range#validation\n  const max = rangeSlider.getAttribute(\"max\") || 100;\n\n  let callout;\n\n  if (unit) {\n    callout = `${val} ${unit} ${prep} ${max}`;\n  } else {\n    callout = `${val} ${prep} ${max}`;\n  }\n\n  rangeSlider.setAttribute(\"aria-valuetext\", callout);\n};\n\nconst rangeEvents = {\n  change: {\n    [RANGE]() {\n      updateCallout(this);\n    },\n  },\n};\n\nconst range = behavior(rangeEvents, {\n  init(root) {\n    selectOrMatches(RANGE, root).forEach((rangeSlider) => {\n      updateCallout(rangeSlider);\n    });\n  },\n  updateCallout,\n});\n\nmodule.exports = range;\n","const ignore = require(\"receptor/ignore\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst select = require(\"../../uswds-core/src/js/utils/select\");\n\nconst { CLICK } = require(\"../../uswds-core/src/js/events\");\n\nconst BUTTON = \".js-search-button\";\nconst FORM = \".js-search-form\";\nconst INPUT = \"[type=search]\";\nconst CONTEXT = \"header\"; // XXX\n\nlet lastButton;\n\nconst getForm = (button) => {\n  const context = button.closest(CONTEXT);\n  return context ? context.querySelector(FORM) : document.querySelector(FORM);\n};\n\nconst toggleSearch = (button, active) => {\n  const form = getForm(button);\n\n  if (!form) {\n    throw new Error(`No ${FORM} found for search toggle in ${CONTEXT}!`);\n  }\n\n  /* eslint-disable no-param-reassign */\n  button.hidden = active;\n  form.hidden = !active;\n  /* eslint-enable */\n\n  if (!active) {\n    return;\n  }\n\n  const input = form.querySelector(INPUT);\n\n  if (input) {\n    input.focus();\n  }\n  // when the user clicks _outside_ of the form w/ignore(): hide the\n  // search, then remove the listener\n  const listener = ignore(form, () => {\n    if (lastButton) {\n      hideSearch.call(lastButton); // eslint-disable-line no-use-before-define\n    }\n\n    document.body.removeEventListener(CLICK, listener);\n  });\n\n  // Normally we would just run this code without a timeout, but\n  // IE11 and Edge will actually call the listener *immediately* because\n  // they are currently handling this exact type of event, so we'll\n  // make sure the browser is done handling the current click event,\n  // if any, before we attach the listener.\n  setTimeout(() => {\n    document.body.addEventListener(CLICK, listener);\n  }, 0);\n};\n\nfunction showSearch() {\n  toggleSearch(this, true);\n  lastButton = this;\n}\n\nfunction hideSearch() {\n  toggleSearch(this, false);\n  lastButton = undefined;\n}\n\nconst search = behavior(\n  {\n    [CLICK]: {\n      [BUTTON]: showSearch,\n    },\n  },\n  {\n    init(target) {\n      select(BUTTON, target).forEach((button) => {\n        toggleSearch(button, false);\n      });\n    },\n    teardown() {\n      // forget the last button clicked\n      lastButton = undefined;\n    },\n  },\n);\n\nmodule.exports = search;\n","const once = require(\"receptor/once\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst { CLICK } = require(\"../../uswds-core/src/js/events\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\n\nconst LINK = `.${PREFIX}-skipnav[href^=\"#\"], .${PREFIX}-footer__return-to-top [href^=\"#\"]`;\nconst MAINCONTENT = \"main-content\";\n\nfunction setTabindex() {\n  // NB: we know because of the selector we're delegating to below that the\n  // href already begins with '#'\n  const id = encodeURI(this.getAttribute(\"href\"));\n  const target = document.getElementById(\n    id === \"#\" ? MAINCONTENT : id.slice(1),\n  );\n\n  if (target) {\n    target.style.outline = \"0\";\n    target.setAttribute(\"tabindex\", 0);\n    target.focus();\n    target.addEventListener(\n      \"blur\",\n      once(() => {\n        target.setAttribute(\"tabindex\", -1);\n      }),\n    );\n  } else {\n    // throw an error?\n  }\n}\n\nmodule.exports = behavior({\n  [CLICK]: {\n    [LINK]: setTabindex,\n  },\n});\n","const select = require(\"../../uswds-core/src/js/utils/select\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst { CLICK } = require(\"../../uswds-core/src/js/events\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\nconst Sanitizer = require(\"../../uswds-core/src/js/utils/sanitizer\");\n\nconst TABLE = `.${PREFIX}-table`;\nconst SORTED = \"aria-sort\";\nconst ASCENDING = \"ascending\";\nconst DESCENDING = \"descending\";\nconst SORT_OVERRIDE = \"data-sort-value\";\nconst SORT_BUTTON_CLASS = `${PREFIX}-table__header__button`;\nconst SORT_BUTTON = `.${SORT_BUTTON_CLASS}`;\nconst SORTABLE_HEADER = `th[data-sortable]`;\nconst ANNOUNCEMENT_REGION = `.${PREFIX}-table__announcement-region[aria-live=\"polite\"]`;\n\n/** Gets the data-sort-value attribute value, if provided — otherwise, gets\n * the innerText or textContent — of the child element (HTMLTableCellElement)\n * at the specified index of the given table row\n *\n * @param {number} index\n * @param {array<HTMLTableRowElement>} tr\n * @return {boolean}\n */\nconst getCellValue = (tr, index) =>\n  tr.children[index].getAttribute(SORT_OVERRIDE) ||\n  tr.children[index].innerText ||\n  tr.children[index].textContent;\n\n/**\n * Compares the values of two row array items at the given index, then sorts by the given direction\n * @param {number} index\n * @param {string} direction\n * @return {boolean}\n */\nconst compareFunction = (index, isAscending) => (thisRow, nextRow) => {\n  // get values to compare from data attribute or cell content\n  const value1 = getCellValue(isAscending ? thisRow : nextRow, index);\n  const value2 = getCellValue(isAscending ? nextRow : thisRow, index);\n\n  // if neither value is empty, and if both values are already numbers, compare numerically\n  if (\n    value1 &&\n    value2 &&\n    !Number.isNaN(Number(value1)) &&\n    !Number.isNaN(Number(value2))\n  ) {\n    return value1 - value2;\n  }\n  // Otherwise, compare alphabetically based on current user locale\n  return value1.toString().localeCompare(value2, navigator.language, {\n    numeric: true,\n    ignorePunctuation: true,\n  });\n};\n\n/**\n * Get an Array of column headers elements belonging directly to the given\n * table element.\n * @param {HTMLTableElement} table\n * @return {array<HTMLTableHeaderCellElement>}\n */\nconst getColumnHeaders = (table) => {\n  const headers = select(SORTABLE_HEADER, table);\n  return headers.filter((header) => header.closest(TABLE) === table);\n};\n\n/**\n * Update the button label within the given header element, resetting it\n * to the default state (ready to sort ascending) if it's no longer sorted\n * @param {HTMLTableHeaderCellElement} header\n */\nconst updateSortLabel = (header) => {\n  const headerName = header.innerText;\n  const sortedAscending = header.getAttribute(SORTED) === ASCENDING;\n  const isSorted =\n    header.getAttribute(SORTED) === ASCENDING ||\n    header.getAttribute(SORTED) === DESCENDING ||\n    false;\n  const headerLabel = `${headerName}, sortable column, currently ${\n    isSorted\n      ? `${sortedAscending ? `sorted ${ASCENDING}` : `sorted ${DESCENDING}`}`\n      : \"unsorted\"\n  }`;\n  const headerButtonLabel = `Click to sort by ${headerName} in ${\n    sortedAscending ? DESCENDING : ASCENDING\n  } order.`;\n  header.setAttribute(\"aria-label\", headerLabel);\n  header.querySelector(SORT_BUTTON).setAttribute(\"title\", headerButtonLabel);\n};\n\n/**\n * Remove the aria-sort attribute on the given header element, and reset the label and button icon\n * @param {HTMLTableHeaderCellElement} header\n */\nconst unsetSort = (header) => {\n  header.removeAttribute(SORTED);\n  updateSortLabel(header);\n};\n\n/**\n * Sort rows either ascending or descending, based on a given header's aria-sort attribute\n * @param {HTMLTableHeaderCellElement} header\n * @param {boolean} isAscending\n * @return {boolean} true\n */\nconst sortRows = (header, isAscending) => {\n  header.setAttribute(SORTED, isAscending === true ? DESCENDING : ASCENDING);\n  updateSortLabel(header);\n\n  const tbody = header.closest(TABLE).querySelector(\"tbody\");\n\n  // We can use Array.from() and Array.sort() instead once we drop IE11 support, likely in the summer of 2021\n  //\n  // Array.from(tbody.querySelectorAll('tr').sort(\n  //   compareFunction(\n  //     Array.from(header.parentNode.children).indexOf(header),\n  //     !isAscending)\n  //   )\n  // .forEach(tr => tbody.appendChild(tr) );\n\n  // [].slice.call() turns array-like sets into true arrays so that we can sort them\n  const allRows = [].slice.call(tbody.querySelectorAll(\"tr\"));\n  const allHeaders = [].slice.call(header.parentNode.children);\n  const thisHeaderIndex = allHeaders.indexOf(header);\n  allRows.sort(compareFunction(thisHeaderIndex, !isAscending)).forEach((tr) => {\n    [].slice\n      .call(tr.children)\n      .forEach((td) => td.removeAttribute(\"data-sort-active\"));\n    tr.children[thisHeaderIndex].setAttribute(\"data-sort-active\", true);\n    tbody.appendChild(tr);\n  });\n\n  return true;\n};\n\n/**\n * Update the live region immediately following the table whenever sort changes.\n * @param {HTMLTableElement} table\n * @param {HTMLTableHeaderCellElement} sortedHeader\n */\n\nconst updateLiveRegion = (table, sortedHeader) => {\n  const caption = table.querySelector(\"caption\").innerText;\n  const sortedAscending = sortedHeader.getAttribute(SORTED) === ASCENDING;\n  const headerLabel = sortedHeader.innerText;\n  const liveRegion = table.nextElementSibling;\n  if (liveRegion && liveRegion.matches(ANNOUNCEMENT_REGION)) {\n    const sortAnnouncement = `The table named \"${caption}\" is now sorted by ${headerLabel} in ${\n      sortedAscending ? ASCENDING : DESCENDING\n    } order.`;\n    liveRegion.innerText = sortAnnouncement;\n  } else {\n    throw new Error(\n      `Table containing a sortable column header is not followed by an aria-live region.`,\n    );\n  }\n};\n\n/**\n * Toggle a header's sort state, optionally providing a target\n * state.\n *\n * @param {HTMLTableHeaderCellElement} header\n * @param {boolean?} isAscending If no state is provided, the current\n * state will be toggled (from false to true, and vice-versa).\n */\nconst toggleSort = (header, isAscending) => {\n  const table = header.closest(TABLE);\n  let safeAscending = isAscending;\n  if (typeof safeAscending !== \"boolean\") {\n    safeAscending = header.getAttribute(SORTED) === ASCENDING;\n  }\n\n  if (!table) {\n    throw new Error(`${SORTABLE_HEADER} is missing outer ${TABLE}`);\n  }\n\n  safeAscending = sortRows(header, isAscending);\n\n  if (safeAscending) {\n    getColumnHeaders(table).forEach((otherHeader) => {\n      if (otherHeader !== header) {\n        unsetSort(otherHeader);\n      }\n    });\n    updateLiveRegion(table, header);\n  }\n};\n\n/**\n ** Inserts a button with icon inside a sortable header\n * @param {HTMLTableHeaderCellElement} header\n */\n\nconst createHeaderButton = (header) => {\n  const buttonEl = document.createElement(\"button\");\n  buttonEl.setAttribute(\"tabindex\", \"0\");\n  buttonEl.classList.add(SORT_BUTTON_CLASS);\n  // ICON_SOURCE\n  buttonEl.innerHTML = Sanitizer.escapeHTML`\n  <svg class=\"${PREFIX}-icon\" xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\">\n    <g class=\"descending\" fill=\"transparent\">\n      <path d=\"M17 17L15.59 15.59L12.9999 18.17V2H10.9999V18.17L8.41 15.58L7 17L11.9999 22L17 17Z\" />\n    </g>\n    <g class=\"ascending\" fill=\"transparent\">\n      <path transform=\"rotate(180, 12, 12)\" d=\"M17 17L15.59 15.59L12.9999 18.17V2H10.9999V18.17L8.41 15.58L7 17L11.9999 22L17 17Z\" />\n    </g>\n    <g class=\"unsorted\" fill=\"transparent\">\n      <polygon points=\"15.17 15 13 17.17 13 6.83 15.17 9 16.58 7.59 12 3 7.41 7.59 8.83 9 11 6.83 11 17.17 8.83 15 7.42 16.41 12 21 16.59 16.41 15.17 15\"/>\n    </g>\n  </svg>\n  `;\n  header.appendChild(buttonEl);\n  updateSortLabel(header);\n};\n\nconst table = behavior(\n  {\n    [CLICK]: {\n      [SORT_BUTTON](event) {\n        event.preventDefault();\n        toggleSort(\n          event.target.closest(SORTABLE_HEADER),\n          event.target.closest(SORTABLE_HEADER).getAttribute(SORTED) ===\n            ASCENDING,\n        );\n      },\n    },\n  },\n  {\n    init(root) {\n      const sortableHeaders = select(SORTABLE_HEADER, root);\n      sortableHeaders.forEach((header) => createHeaderButton(header));\n\n      const firstSorted = sortableHeaders.filter(\n        (header) =>\n          header.getAttribute(SORTED) === ASCENDING ||\n          header.getAttribute(SORTED) === DESCENDING,\n      )[0];\n      if (typeof firstSorted === \"undefined\") {\n        // no sortable headers found\n        return;\n      }\n      const sortDir = firstSorted.getAttribute(SORTED);\n      if (sortDir === ASCENDING) {\n        toggleSort(firstSorted, true);\n      } else if (sortDir === DESCENDING) {\n        toggleSort(firstSorted, false);\n      }\n    },\n    TABLE,\n    SORTABLE_HEADER,\n    SORT_BUTTON,\n  },\n);\n\nmodule.exports = table;\n","const behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst selectOrMatches = require(\"../../uswds-core/src/js/utils/select-or-matches\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\nconst {\n  COMBO_BOX_CLASS,\n  enhanceComboBox,\n} = require(\"../../usa-combo-box/src/index\");\n\nconst TIME_PICKER_CLASS = `${PREFIX}-time-picker`;\nconst TIME_PICKER = `.${TIME_PICKER_CLASS}`;\nconst MAX_TIME = 60 * 24 - 1;\nconst MIN_TIME = 0;\nconst DEFAULT_STEP = 30;\nconst MIN_STEP = 1;\n\nconst FILTER_DATASET = {\n  filter:\n    \"0?{{ hourQueryFilter }}:{{minuteQueryFilter}}.*{{ apQueryFilter }}m?\",\n  apQueryFilter: \"([ap])\",\n  hourQueryFilter: \"([1-9][0-2]?)\",\n  minuteQueryFilter: \"[\\\\d]+:([0-9]{0,2})\",\n};\n\n/**\n * Parse a string of hh:mm into minutes\n *\n * @param {string} timeStr the time string to parse\n * @returns {number} the number of minutes\n */\nconst parseTimeString = (timeStr) => {\n  let minutes;\n\n  if (timeStr) {\n    const [hours, mins] = timeStr.split(\":\").map((str) => {\n      let value;\n      const parsed = parseInt(str, 10);\n      if (!Number.isNaN(parsed)) value = parsed;\n      return value;\n    });\n\n    if (hours != null && mins != null) {\n      minutes = hours * 60 + mins;\n    }\n  }\n\n  return minutes;\n};\n\n/**\n * Enhance an input with the date picker elements\n *\n * @param {HTMLElement} el The initial wrapping element of the date picker component\n */\nconst transformTimePicker = (el) => {\n  const timePickerEl = el.closest(TIME_PICKER);\n\n  const initialInputEl = timePickerEl.querySelector(`input`);\n\n  if (!initialInputEl) {\n    throw new Error(`${TIME_PICKER} is missing inner input`);\n  }\n\n  const selectEl = document.createElement(\"select\");\n\n  [\n    \"id\",\n    \"name\",\n    \"required\",\n    \"aria-label\",\n    \"aria-labelledby\",\n    \"disabled\",\n    \"aria-disabled\",\n  ].forEach((name) => {\n    if (initialInputEl.hasAttribute(name)) {\n      const value = initialInputEl.getAttribute(name);\n      selectEl.setAttribute(name, value);\n      initialInputEl.removeAttribute(name);\n    }\n  });\n\n  const padZeros = (value, length) => `0000${value}`.slice(-length);\n\n  const getTimeContext = (minutes) => {\n    const minute = minutes % 60;\n    const hour24 = Math.floor(minutes / 60);\n    const hour12 = hour24 % 12 || 12;\n    const ampm = hour24 < 12 ? \"am\" : \"pm\";\n\n    return {\n      minute,\n      hour24,\n      hour12,\n      ampm,\n    };\n  };\n\n  const minTime = Math.max(\n    MIN_TIME,\n    parseTimeString(timePickerEl.dataset.minTime) || MIN_TIME,\n  );\n  const maxTime = Math.min(\n    MAX_TIME,\n    parseTimeString(timePickerEl.dataset.maxTime) || MAX_TIME,\n  );\n  const step = Math.floor(\n    Math.max(MIN_STEP, timePickerEl.dataset.step || DEFAULT_STEP),\n  );\n\n  let defaultValue;\n  for (let time = minTime; time <= maxTime; time += step) {\n    const { minute, hour24, hour12, ampm } = getTimeContext(time);\n\n    const option = document.createElement(\"option\");\n    option.value = `${padZeros(hour24, 2)}:${padZeros(minute, 2)}`;\n    option.text = `${hour12}:${padZeros(minute, 2)}${ampm}`;\n    if (option.text === initialInputEl.value) {\n      defaultValue = option.value;\n    }\n    selectEl.appendChild(option);\n  }\n\n  timePickerEl.classList.add(COMBO_BOX_CLASS);\n\n  // combo box properties\n  Object.keys(FILTER_DATASET).forEach((key) => {\n    timePickerEl.dataset[key] = FILTER_DATASET[key];\n  });\n  timePickerEl.dataset.disableFiltering = \"true\";\n  timePickerEl.dataset.defaultValue = defaultValue;\n\n  timePickerEl.appendChild(selectEl);\n  initialInputEl.remove();\n};\n\nconst timePicker = behavior(\n  {},\n  {\n    init(root) {\n      selectOrMatches(TIME_PICKER, root).forEach((timePickerEl) => {\n        transformTimePicker(timePickerEl);\n        enhanceComboBox(timePickerEl);\n      });\n    },\n    FILTER_DATASET,\n  },\n);\n\nmodule.exports = timePicker;\n","// Tooltips\nconst keymap = require(\"receptor/keymap\");\nconst selectOrMatches = require(\"../../uswds-core/src/js/utils/select-or-matches\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\nconst isElementInViewport = require(\"../../uswds-core/src/js/utils/is-in-viewport\");\n\nconst BODY = \"body\";\nconst TOOLTIP = `.${PREFIX}-tooltip`;\nconst TOOLTIP_TRIGGER = `.${PREFIX}-tooltip__trigger`;\nconst TOOLTIP_TRIGGER_CLASS = `${PREFIX}-tooltip__trigger`;\nconst TOOLTIP_CLASS = `${PREFIX}-tooltip`;\nconst TOOLTIP_BODY_CLASS = `${PREFIX}-tooltip__body`;\nconst SET_CLASS = \"is-set\";\nconst VISIBLE_CLASS = \"is-visible\";\nconst TRIANGLE_SIZE = 5;\nconst ADJUST_WIDTH_CLASS = `${PREFIX}-tooltip__body--wrap`;\n\n/**\n *\n * @param {DOMElement} trigger - The tooltip trigger\n * @returns {object} Elements for initialized tooltip; includes trigger, wrapper, and body\n */\nconst getTooltipElements = (trigger) => {\n  const wrapper = trigger.parentNode;\n  const body = wrapper.querySelector(`.${TOOLTIP_BODY_CLASS}`);\n\n  return { trigger, wrapper, body };\n};\n\n/**\n * Shows the tooltip\n * @param {HTMLElement} tooltipTrigger - the element that initializes the tooltip\n */\nconst showToolTip = (tooltipBody, tooltipTrigger, position) => {\n  tooltipBody.setAttribute(\"aria-hidden\", \"false\");\n\n  // This sets up the tooltip body. The opacity is 0, but\n  // we can begin running the calculations below.\n  tooltipBody.classList.add(SET_CLASS);\n\n  /**\n   * Position the tooltip body when the trigger is hovered\n   * Removes old positioning classnames and reapplies. This allows\n   * positioning to change in case the user resizes browser or DOM manipulation\n   * causes tooltip to get clipped from viewport\n   *\n   * @param {string} setPos - can be \"top\", \"bottom\", \"right\", \"left\"\n   */\n  const setPositionClass = (setPos) => {\n    tooltipBody.classList.remove(`${TOOLTIP_BODY_CLASS}--top`);\n    tooltipBody.classList.remove(`${TOOLTIP_BODY_CLASS}--bottom`);\n    tooltipBody.classList.remove(`${TOOLTIP_BODY_CLASS}--right`);\n    tooltipBody.classList.remove(`${TOOLTIP_BODY_CLASS}--left`);\n    tooltipBody.classList.add(`${TOOLTIP_BODY_CLASS}--${setPos}`);\n  };\n\n  /**\n   * Removes old positioning styles. This allows\n   * re-positioning to change without inheriting other\n   * dynamic styles\n   *\n   * @param {HTMLElement} e - this is the tooltip body\n   */\n  const resetPositionStyles = (e) => {\n    // we don't override anything in the stylesheet when finding alt positions\n    e.style.top = null;\n    e.style.bottom = null;\n    e.style.right = null;\n    e.style.left = null;\n    e.style.margin = null;\n  };\n\n  /**\n   * get margin offset calculations\n   *\n   * @param {HTMLElement} target - this is the tooltip body\n   * @param {String} propertyValue - this is the tooltip body\n   */\n\n  const offsetMargin = (target, propertyValue) =>\n    parseInt(\n      window.getComputedStyle(target).getPropertyValue(propertyValue),\n      10,\n    );\n\n  // offsetLeft = the left position, and margin of the element, the left\n  // padding, scrollbar and border of the offsetParent element\n  // offsetWidth = The offsetWidth property returns the viewable width of an\n  // element in pixels, including padding, border and scrollbar, but not\n  // the margin.\n\n  /**\n   * Calculate margin offset\n   * tooltip trigger margin(position) offset + tooltipBody offsetWidth\n   * @param {String} marginPosition\n   * @param {Number} tooltipBodyOffset\n   * @param {HTMLElement} trigger\n   */\n  const calculateMarginOffset = (\n    marginPosition,\n    tooltipBodyOffset,\n    trigger,\n  ) => {\n    const offset =\n      offsetMargin(trigger, `margin-${marginPosition}`) > 0\n        ? tooltipBodyOffset - offsetMargin(trigger, `margin-${marginPosition}`)\n        : tooltipBodyOffset;\n\n    return offset;\n  };\n\n  /**\n   * Positions tooltip at the top\n   * @param {HTMLElement} e - this is the tooltip body\n   */\n  const positionTop = (e) => {\n    resetPositionStyles(e); // ensures we start from the same point\n    // get details on the elements object with\n\n    const topMargin = calculateMarginOffset(\n      \"top\",\n      e.offsetHeight,\n      tooltipTrigger,\n    );\n\n    const leftMargin = calculateMarginOffset(\n      \"left\",\n      e.offsetWidth,\n      tooltipTrigger,\n    );\n\n    setPositionClass(\"top\");\n    e.style.left = `50%`; // center the element\n    e.style.top = `-${TRIANGLE_SIZE}px`; // consider the pseudo element\n    // apply our margins based on the offset\n    e.style.margin = `-${topMargin}px 0 0 -${leftMargin / 2}px`;\n  };\n\n  /**\n   * Positions tooltip at the bottom\n   * @param {HTMLElement} e - this is the tooltip body\n   */\n  const positionBottom = (e) => {\n    resetPositionStyles(e);\n\n    const leftMargin = calculateMarginOffset(\n      \"left\",\n      e.offsetWidth,\n      tooltipTrigger,\n    );\n\n    setPositionClass(\"bottom\");\n    e.style.left = `50%`;\n    e.style.margin = `${TRIANGLE_SIZE}px 0 0 -${leftMargin / 2}px`;\n  };\n\n  /**\n   * Positions tooltip at the right\n   * @param {HTMLElement} e - this is the tooltip body\n   */\n  const positionRight = (e) => {\n    resetPositionStyles(e);\n\n    const topMargin = calculateMarginOffset(\n      \"top\",\n      e.offsetHeight,\n      tooltipTrigger,\n    );\n\n    setPositionClass(\"right\");\n    e.style.top = `50%`;\n    e.style.left = `${\n      tooltipTrigger.offsetLeft + tooltipTrigger.offsetWidth + TRIANGLE_SIZE\n    }px`;\n    e.style.margin = `-${topMargin / 2}px 0 0 0`;\n  };\n\n  /**\n   * Positions tooltip at the right\n   * @param {HTMLElement} e - this is the tooltip body\n   */\n  const positionLeft = (e) => {\n    resetPositionStyles(e);\n\n    const topMargin = calculateMarginOffset(\n      \"top\",\n      e.offsetHeight,\n      tooltipTrigger,\n    );\n\n    // we have to check for some utility margins\n    const leftMargin = calculateMarginOffset(\n      \"left\",\n      tooltipTrigger.offsetLeft > e.offsetWidth\n        ? tooltipTrigger.offsetLeft - e.offsetWidth\n        : e.offsetWidth,\n      tooltipTrigger,\n    );\n\n    setPositionClass(\"left\");\n    e.style.top = `50%`;\n    e.style.left = `-${TRIANGLE_SIZE}px`;\n    e.style.margin = `-${topMargin / 2}px 0 0 ${\n      tooltipTrigger.offsetLeft > e.offsetWidth ? leftMargin : -leftMargin\n    }px`; // adjust the margin\n  };\n\n  /**\n   * We try to set the position based on the\n   * original intention, but make adjustments\n   * if the element is clipped out of the viewport\n   * we constrain the width only as a last resort\n   * @param {HTMLElement} element(alias tooltipBody)\n   * @param {Number} attempt (--flag)\n   */\n\n  const maxAttempts = 2;\n\n  function findBestPosition(element, attempt = 1) {\n    // create array of optional positions\n    const positions = [\n      positionTop,\n      positionBottom,\n      positionRight,\n      positionLeft,\n    ];\n\n    let hasVisiblePosition = false;\n\n    // we take a recursive approach\n    function tryPositions(i) {\n      if (i < positions.length) {\n        const pos = positions[i];\n        pos(element);\n\n        if (!isElementInViewport(element)) {\n          // eslint-disable-next-line no-param-reassign\n          tryPositions((i += 1));\n        } else {\n          hasVisiblePosition = true;\n        }\n      }\n    }\n\n    tryPositions(0);\n    // if we can't find a position we compress it and try again\n    if (!hasVisiblePosition) {\n      element.classList.add(ADJUST_WIDTH_CLASS);\n      if (attempt <= maxAttempts) {\n        // eslint-disable-next-line no-param-reassign\n        findBestPosition(element, (attempt += 1));\n      }\n    }\n  }\n\n  switch (position) {\n    case \"top\":\n      positionTop(tooltipBody);\n      if (!isElementInViewport(tooltipBody)) {\n        findBestPosition(tooltipBody);\n      }\n      break;\n    case \"bottom\":\n      positionBottom(tooltipBody);\n      if (!isElementInViewport(tooltipBody)) {\n        findBestPosition(tooltipBody);\n      }\n      break;\n    case \"right\":\n      positionRight(tooltipBody);\n      if (!isElementInViewport(tooltipBody)) {\n        findBestPosition(tooltipBody);\n      }\n      break;\n    case \"left\":\n      positionLeft(tooltipBody);\n      if (!isElementInViewport(tooltipBody)) {\n        findBestPosition(tooltipBody);\n      }\n      break;\n\n    default:\n      // skip default case\n      break;\n  }\n\n  /**\n   * Actually show the tooltip. The VISIBLE_CLASS\n   * will change the opacity to 1\n   */\n  setTimeout(() => {\n    tooltipBody.classList.add(VISIBLE_CLASS);\n  }, 20);\n};\n\n/**\n * Removes all the properties to show and position the tooltip,\n * and resets the tooltip position to the original intention\n * in case the window is resized or the element is moved through\n * DOM manipulation.\n * @param {HTMLElement} tooltipBody - The body of the tooltip\n */\nconst hideToolTip = (tooltipBody) => {\n  tooltipBody.classList.remove(VISIBLE_CLASS);\n  tooltipBody.classList.remove(SET_CLASS);\n  tooltipBody.classList.remove(ADJUST_WIDTH_CLASS);\n  tooltipBody.setAttribute(\"aria-hidden\", \"true\");\n};\n\n/**\n * Setup the tooltip component\n * @param {HTMLElement} tooltipTrigger The element that creates the tooltip\n */\nconst setUpAttributes = (tooltipTrigger) => {\n  const tooltipID = `tooltip-${Math.floor(Math.random() * 900000) + 100000}`;\n  const tooltipContent = tooltipTrigger.getAttribute(\"title\");\n  const wrapper = document.createElement(\"span\");\n  const tooltipBody = document.createElement(\"span\");\n  const additionalClasses = tooltipTrigger.getAttribute(\"data-classes\");\n  let position = tooltipTrigger.getAttribute(\"data-position\");\n\n  // Apply default position if not set as attribute\n  if (!position) {\n    position = \"top\";\n    tooltipTrigger.setAttribute(\"data-position\", position);\n  }\n\n  // Set up tooltip attributes\n  tooltipTrigger.setAttribute(\"aria-describedby\", tooltipID);\n  tooltipTrigger.setAttribute(\"tabindex\", \"0\");\n  tooltipTrigger.removeAttribute(\"title\");\n  tooltipTrigger.classList.remove(TOOLTIP_CLASS);\n  tooltipTrigger.classList.add(TOOLTIP_TRIGGER_CLASS);\n\n  // insert wrapper before el in the DOM tree\n  tooltipTrigger.parentNode.insertBefore(wrapper, tooltipTrigger);\n\n  // set up the wrapper\n  wrapper.appendChild(tooltipTrigger);\n  wrapper.classList.add(TOOLTIP_CLASS);\n  wrapper.appendChild(tooltipBody);\n\n  // Apply additional class names to wrapper element\n  if (additionalClasses) {\n    const classesArray = additionalClasses.split(\" \");\n    classesArray.forEach((classname) => wrapper.classList.add(classname));\n  }\n\n  // set up the tooltip body\n  tooltipBody.classList.add(TOOLTIP_BODY_CLASS);\n  tooltipBody.setAttribute(\"id\", tooltipID);\n  tooltipBody.setAttribute(\"role\", \"tooltip\");\n  tooltipBody.setAttribute(\"aria-hidden\", \"true\");\n\n  // place the text in the tooltip\n  tooltipBody.textContent = tooltipContent;\n\n  return { tooltipBody, position, tooltipContent, wrapper };\n};\n\n/**\n * Hide all active tooltips when escape key is pressed.\n */\n\nconst handleEscape = () => {\n  const activeTooltips = selectOrMatches(`.${TOOLTIP_BODY_CLASS}.${SET_CLASS}`);\n\n  if (!activeTooltips) {\n    return;\n  }\n\n  activeTooltips.forEach((activeTooltip) => hideToolTip(activeTooltip));\n};\n\n// Setup our function to run on various events\nconst tooltip = behavior(\n  {\n    \"mouseover focusin\": {\n      [TOOLTIP](e) {\n        const trigger = e.target;\n        const elementType = trigger.nodeName;\n\n        // Initialize tooltip if it hasn't already\n        if (elementType === \"BUTTON\" && trigger.hasAttribute(\"title\")) {\n          setUpAttributes(trigger);\n        }\n      },\n      [TOOLTIP_TRIGGER](e) {\n        const { trigger, body } = getTooltipElements(e.target);\n\n        showToolTip(body, trigger, trigger.dataset.position);\n      },\n    },\n    focusout: {\n      [TOOLTIP_TRIGGER](e) {\n        const { body } = getTooltipElements(e.target);\n\n        hideToolTip(body);\n      },\n    },\n    keydown: {\n      [BODY]: keymap({ Escape: handleEscape }),\n    },\n  },\n  {\n    init(root) {\n      selectOrMatches(TOOLTIP, root).forEach((tooltipTrigger) => {\n        setUpAttributes(tooltipTrigger);\n\n        const { body, wrapper } = getTooltipElements(tooltipTrigger);\n        wrapper.addEventListener(\"mouseleave\", () => hideToolTip(body));\n      });\n    },\n    teardown(root) {\n      selectOrMatches(TOOLTIP, root).forEach((tooltipWrapper) => {\n        tooltipWrapper.removeEventListener(\"mouseleave\", hideToolTip);\n      });\n    },\n    setup: setUpAttributes,\n    getTooltipElements,\n    show: showToolTip,\n    hide: hideToolTip,\n  },\n);\n\nmodule.exports = tooltip;\n","const behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst validate = require(\"../../uswds-core/src/js/utils/validate-input\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\nconst selectOrMatches = require(\"../../uswds-core/src/js/utils/select-or-matches\");\n\nconst VALIDATE_INPUT =\n  \"input[data-validation-element],textarea[data-validation-element]\";\nconst CHECKLIST_ITEM = `.${PREFIX}-checklist__item`;\n\n// Trigger validation on input change\nconst handleChange = (el) => validate(el);\n\n// Create container to hold aria readout\nconst createStatusElement = (input) => {\n  const validationContainer = input.parentNode;\n  const inputID = input.getAttribute(\"id\");\n  const statusSummaryID = `${inputID}-sr-summary`;\n  input.setAttribute(\"aria-describedby\", statusSummaryID);\n\n  const statusSummaryContainer = document.createElement(\"span\");\n\n  statusSummaryContainer.setAttribute(\"data-validation-status\", \"\");\n  statusSummaryContainer.classList.add(\"usa-sr-only\");\n  statusSummaryContainer.setAttribute(\"aria-live\", \"polite\");\n  statusSummaryContainer.setAttribute(\"aria-atomic\", true);\n  statusSummaryContainer.setAttribute(\"id\", statusSummaryID);\n  validationContainer.append(statusSummaryContainer);\n};\n\n// Set up checklist items with initial aria-label (incomplete) values\nconst createInitialStatus = (input) => {\n  const validationContainer = input.parentNode;\n  const checklistItems = validationContainer.querySelectorAll(CHECKLIST_ITEM);\n  const validationElement = input.getAttribute(\"data-validation-element\");\n\n  input.setAttribute(\"aria-controls\", validationElement);\n\n  checklistItems.forEach((listItem) => {\n    let currentStatus = \"status incomplete\";\n    if (input.hasAttribute(\"data-validation-incomplete\")) {\n      currentStatus = input.getAttribute(\"data-validation-incomplete\");\n    }\n    const itemStatus = `${listItem.textContent} ${currentStatus} `;\n    listItem.setAttribute(\"aria-label\", itemStatus);\n  });\n};\n\nconst enhanceValidation = (input) => {\n  createStatusElement(input);\n  createInitialStatus(input);\n};\n\nconst validator = behavior(\n  {\n    \"input change\": {\n      [VALIDATE_INPUT](event) {\n        handleChange(event.target);\n      },\n    },\n  },\n  {\n    init(root) {\n      selectOrMatches(VALIDATE_INPUT, root).forEach((input) =>\n        enhanceValidation(input),\n      );\n    },\n  },\n);\n\nmodule.exports = validator;\n","module.exports = {\n  prefix: \"usa\",\n};\n","module.exports = {\n  // This used to be conditionally dependent on whether the\n  // browser supported touch events; if it did, `CLICK` was set to\n  // `touchstart`.  However, this had downsides:\n  //\n  // * It pre-empted mobile browsers' default behavior of detecting\n  //   whether a touch turned into a scroll, thereby preventing\n  //   users from using some of our components as scroll surfaces.\n  //\n  // * Some devices, such as the Microsoft Surface Pro, support *both*\n  //   touch and clicks. This meant the conditional effectively dropped\n  //   support for the user's mouse, frustrating users who preferred\n  //   it on those systems.\n  CLICK: \"click\",\n};\n","const accordion = require(\"../../../usa-accordion/src/index\");\nconst banner = require(\"../../../usa-banner/src/index\");\nconst button = require(\"../../../usa-button/src/index\");\nconst characterCount = require(\"../../../usa-character-count/src/index\");\nconst comboBox = require(\"../../../usa-combo-box/src/index\");\nconst datePicker = require(\"../../../usa-date-picker/src/index\");\nconst dateRangePicker = require(\"../../../usa-date-range-picker/src/index\");\nconst fileInput = require(\"../../../usa-file-input/src/index\");\nconst footer = require(\"../../../usa-footer/src/index\");\nconst inPageNavigation = require(\"../../../usa-in-page-navigation/src/index\");\nconst inputMask = require(\"../../../usa-input-mask/src/index\");\nconst languageSelector = require(\"../../../usa-language-selector/src/index\");\nconst modal = require(\"../../../usa-modal/src/index\");\nconst navigation = require(\"../../../usa-header/src/index\");\nconst password = require(\"../../../_usa-password/src/index\");\nconst range = require(\"../../../usa-range/src/index\");\nconst search = require(\"../../../usa-search/src/index\");\nconst skipnav = require(\"../../../usa-skipnav/src/index\");\nconst table = require(\"../../../usa-table/src/index\");\nconst timePicker = require(\"../../../usa-time-picker/src/index\");\nconst tooltip = require(\"../../../usa-tooltip/src/index\");\nconst validator = require(\"../../../usa-validation/src/index\");\n\nmodule.exports = {\n  accordion,\n  banner,\n  button,\n  characterCount,\n  comboBox,\n  datePicker,\n  dateRangePicker,\n  fileInput,\n  footer,\n  inPageNavigation,\n  inputMask,\n  languageSelector,\n  modal,\n  navigation,\n  password,\n  range,\n  search,\n  skipnav,\n  table,\n  timePicker,\n  tooltip,\n  validator,\n};\n","window.uswdsPresent = true; // GLOBAL variable to indicate that the uswds.js has loaded in the DOM.\n\nconst uswds = require(\"./config\");\n\nconst components = require(\"./index\");\n\nuswds.components = components;\n\nconst initComponents = () => {\n  const target = document.body;\n  Object.keys(components).forEach((key) => {\n    const behavior = components[key];\n    behavior.on(target);\n  });\n};\n\nif (document.readyState === \"loading\") {\n  document.addEventListener(\"DOMContentLoaded\", initComponents, { once: true });\n} else {\n  initComponents();\n}\n\nexports.default = uswds;\nexports.initComponents = initComponents;\n","module.exports = (htmlDocument = document) => htmlDocument.activeElement;\n","const Behavior = require(\"receptor/behavior\");\n\n/**\n * @name sequence\n * @param {...Function} seq an array of functions\n * @return { closure } callHooks\n */\n// We use a named function here because we want it to inherit its lexical scope\n// from the behavior props object, not from the module\nconst sequence = (...seq) =>\n  function callHooks(target = document.body) {\n    seq.forEach((method) => {\n      if (typeof this[method] === \"function\") {\n        this[method].call(this, target);\n      }\n    });\n  };\n\n/**\n * @name behavior\n * @param {object} events\n * @param {object?} props\n * @return {receptor.behavior}\n */\nmodule.exports = (events, props) =>\n  Behavior(events, {\n    on: sequence(\"init\", \"add\"),\n    off: sequence(\"teardown\", \"remove\"),\n    ...props,\n  });\n","/**\n * Call a function every X amount of milliseconds.\n *\n * @param  {Function} callback - A callback function to be debounced\n * @param  {number} delay - Milliseconds to wait before calling function\n * @returns {Function} A debounced function\n * @example const updateStatus = debounce((string) => console.log(string), 2000)\n */\n\nmodule.exports = function debounce(callback, delay = 500) {\n  let timer = null;\n  return (...args) => {\n    window.clearTimeout(timer);\n    timer = window.setTimeout(() => {\n      callback.apply(this, args);\n    }, delay);\n  };\n};\n","const { keymap } = require(\"receptor\");\nconst behavior = require(\"./behavior\");\nconst select = require(\"./select\");\nconst activeElement = require(\"./active-element\");\n\nconst FOCUSABLE =\n  'a[href], area[href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), button:not([disabled]), iframe, object, embed, [tabindex=\"0\"], [contenteditable]';\n\nconst tabHandler = (context) => {\n  const focusableElements = select(FOCUSABLE, context);\n  const firstTabStop = focusableElements[0];\n  const lastTabStop = focusableElements[focusableElements.length - 1];\n\n  // Special rules for when the user is tabbing forward from the last focusable element,\n  // or when tabbing backwards from the first focusable element\n  function tabAhead(event) {\n    if (activeElement() === lastTabStop) {\n      event.preventDefault();\n      firstTabStop.focus();\n    }\n  }\n\n  function tabBack(event) {\n    if (activeElement() === firstTabStop) {\n      event.preventDefault();\n      lastTabStop.focus();\n    }\n    // This checks if you want to set the initial focus to a container\n    // instead of an element within, and the user tabs back.\n    // Then we set the focus to the first\n    else if (!focusableElements.includes(activeElement())) {\n      event.preventDefault();\n      firstTabStop.focus();\n    }\n  }\n\n  return {\n    firstTabStop,\n    lastTabStop,\n    tabAhead,\n    tabBack,\n  };\n};\n\nmodule.exports = (context, additionalKeyBindings = {}) => {\n  const tabEventHandler = tabHandler(context);\n  const bindings = additionalKeyBindings;\n  const { Esc, Escape } = bindings;\n\n  if (Escape && !Esc) bindings.Esc = Escape;\n\n  //  TODO: In the future, loop over additional keybindings and pass an array\n  // of functions, if necessary, to the map keys. Then people implementing\n  // the focus trap could pass callbacks to fire when tabbing\n  const keyMappings = keymap({\n    Tab: tabEventHandler.tabAhead,\n    \"Shift+Tab\": tabEventHandler.tabBack,\n    ...additionalKeyBindings,\n  });\n\n  const focusTrap = behavior(\n    {\n      keydown: keyMappings,\n    },\n    {\n      init() {\n        // TODO: is this desireable behavior? Should the trap always do this by default or should\n        // the component getting decorated handle this?\n        if (tabEventHandler.firstTabStop) {\n          tabEventHandler.firstTabStop.focus();\n        }\n      },\n      update(isActive) {\n        if (isActive) {\n          this.on();\n        } else {\n          this.off();\n        }\n      },\n    },\n  );\n\n  return focusTrap;\n};\n","// https://stackoverflow.com/a/7557433\nfunction isElementInViewport(\n  el,\n  win = window,\n  docEl = document.documentElement,\n) {\n  const rect = el.getBoundingClientRect();\n\n  return (\n    rect.top >= 0 &&\n    rect.left >= 0 &&\n    rect.bottom <= (win.innerHeight || docEl.clientHeight) &&\n    rect.right <= (win.innerWidth || docEl.clientWidth)\n  );\n}\n\nmodule.exports = isElementInViewport;\n","// iOS detection from: http://stackoverflow.com/a/9039885/177710\nfunction isIosDevice() {\n  return (\n    typeof navigator !== \"undefined\" &&\n    (navigator.userAgent.match(/(iPod|iPhone|iPad)/g) ||\n      (navigator.platform === \"MacIntel\" && navigator.maxTouchPoints > 1)) &&\n    !window.MSStream\n  );\n}\n\nmodule.exports = isIosDevice;\n","/* eslint-disable */\n/* globals define, module */\n\n/**\n * A simple library to help you escape HTML using template strings.\n *\n * It's the counterpart to our eslint \"no-unsafe-innerhtml\" plugin that helps us\n * avoid unsafe coding practices.\n * A full write-up of the Hows and Whys are documented\n * for developers at\n *  https://developer.mozilla.org/en-US/Firefox_OS/Security/Security_Automation\n * with additional background information and design docs at\n *  https://wiki.mozilla.org/User:Fbraun/Gaia/SafeinnerHTMLRoadmap\n *\n */\n\n!(function (factory) {\n  module.exports = factory();\n})(function () {\n  \"use strict\";\n\n  var Sanitizer = {\n    _entity: /[&<>\"'/]/g,\n\n    _entities: {\n      \"&\": \"&amp;\",\n      \"<\": \"&lt;\",\n      \">\": \"&gt;\",\n      '\"': \"&quot;\",\n      \"'\": \"&apos;\",\n      \"/\": \"&#x2F;\",\n    },\n\n    getEntity: function (s) {\n      return Sanitizer._entities[s];\n    },\n\n    /**\n     * Escapes HTML for all values in a tagged template string.\n     */\n    escapeHTML: function (strings) {\n      var result = \"\";\n\n      for (var i = 0; i < strings.length; i++) {\n        result += strings[i];\n        if (i + 1 < arguments.length) {\n          var value = arguments[i + 1] || \"\";\n          result += String(value).replace(\n            Sanitizer._entity,\n            Sanitizer.getEntity,\n          );\n        }\n      }\n\n      return result;\n    },\n    /**\n     * Escapes HTML and returns a wrapped object to be used during DOM insertion\n     */\n    createSafeHTML: function (strings) {\n      var _len = arguments.length;\n      var values = new Array(_len > 1 ? _len - 1 : 0);\n      for (var _key = 1; _key < _len; _key++) {\n        values[_key - 1] = arguments[_key];\n      }\n\n      var escaped = Sanitizer.escapeHTML.apply(\n        Sanitizer,\n        [strings].concat(values),\n      );\n      return {\n        __html: escaped,\n        toString: function () {\n          return \"[object WrappedHTMLObject]\";\n        },\n        info:\n          \"This is a wrapped HTML object. See https://developer.mozilla.or\" +\n          \"g/en-US/Firefox_OS/Security/Security_Automation for more.\",\n      };\n    },\n    /**\n     * Unwrap safe HTML created by createSafeHTML or a custom replacement that\n     * underwent security review.\n     */\n    unwrapSafeHTML: function () {\n      var _len = arguments.length;\n      var htmlObjects = new Array(_len);\n      for (var _key = 0; _key < _len; _key++) {\n        htmlObjects[_key] = arguments[_key];\n      }\n\n      var markupList = htmlObjects.map(function (obj) {\n        return obj.__html;\n      });\n      return markupList.join(\"\");\n    },\n  };\n\n  return Sanitizer;\n});\n","module.exports = function getScrollbarWidth() {\n  // Creating invisible container\n  const outer = document.createElement(\"div\");\n  outer.style.visibility = \"hidden\";\n  outer.style.overflow = \"scroll\"; // forcing scrollbar to appear\n  outer.style.msOverflowStyle = \"scrollbar\"; // needed for WinJS apps\n  document.body.appendChild(outer);\n\n  // Creating inner element and placing it in the container\n  const inner = document.createElement(\"div\");\n  outer.appendChild(inner);\n\n  // Calculating difference between container's full width and the child width\n  const scrollbarWidth = `${outer.offsetWidth - inner.offsetWidth}px`;\n\n  // Removing temporary elements from the DOM\n  outer.parentNode.removeChild(outer);\n\n  return scrollbarWidth;\n};\n","const select = require(\"./select\");\n/**\n * @name isElement\n * @desc returns whether or not the given argument is a DOM element.\n * @param {any} value\n * @return {boolean}\n */\nconst isElement = (value) =>\n  value && typeof value === \"object\" && value.nodeType === 1;\n\n/**\n * @name selectOrMatches\n * @desc selects elements from the DOM by class selector or ID selector.\n * @param {string} selector - The selector to traverse the DOM with.\n * @param {Document|HTMLElement?} context - The context to traverse the DOM\n *   in. If not provided, it defaults to the document.\n * @return {HTMLElement[]} - An array of DOM nodes or an empty array.\n */\nmodule.exports = (selector, context) => {\n  const selection = select(selector, context);\n  if (typeof selector !== \"string\") {\n    return selection;\n  }\n\n  if (isElement(context) && context.matches(selector)) {\n    selection.push(context);\n  }\n\n  return selection;\n};\n","/**\n * @name isElement\n * @desc returns whether or not the given argument is a DOM element.\n * @param {any} value\n * @return {boolean}\n */\nconst isElement = (value) =>\n  value && typeof value === \"object\" && value.nodeType === 1;\n\n/**\n * @name select\n * @desc selects elements from the DOM by class selector or ID selector.\n * @param {string} selector - The selector to traverse the DOM with.\n * @param {Document|HTMLElement?} context - The context to traverse the DOM\n *   in. If not provided, it defaults to the document.\n * @return {HTMLElement[]} - An array of DOM nodes or an empty array.\n */\nmodule.exports = (selector, context) => {\n  if (typeof selector !== \"string\") {\n    return [];\n  }\n\n  if (!context || !isElement(context)) {\n    context = window.document; // eslint-disable-line no-param-reassign\n  }\n\n  const selection = context.querySelectorAll(selector);\n  return Array.prototype.slice.call(selection);\n};\n","/**\n * Flips given INPUT elements between masked (hiding the field value) and unmasked\n * @param {Array.HTMLElement} fields - An array of INPUT elements\n * @param {Boolean} mask - Whether the mask should be applied, hiding the field value\n */\nmodule.exports = (field, mask) => {\n  field.setAttribute(\"autocapitalize\", \"off\");\n  field.setAttribute(\"autocorrect\", \"off\");\n  field.setAttribute(\"type\", mask ? \"password\" : \"text\");\n};\n","const resolveIdRefs = require(\"resolve-id-refs\");\nconst toggleFieldMask = require(\"./toggle-field-mask\");\n\nconst CONTROLS = \"aria-controls\";\nconst PRESSED = \"aria-pressed\";\nconst SHOW_ATTR = \"data-show-text\";\nconst HIDE_ATTR = \"data-hide-text\";\n\n/**\n * Replace the word \"Show\" (or \"show\") with \"Hide\" (or \"hide\") in a string.\n * @param {string} showText\n * @return {strong} hideText\n */\nconst getHideText = (showText) =>\n  showText.replace(/\\bShow\\b/i, (show) => `${show[0] === \"S\" ? \"H\" : \"h\"}ide`);\n\n/**\n * Component that decorates an HTML element with the ability to toggle the\n * masked state of an input field (like a password) when clicked.\n * The ids of the fields to be masked will be pulled directly from the button's\n * `aria-controls` attribute.\n *\n * @param  {HTMLElement} el    Parent element containing the fields to be masked\n * @return {boolean}\n */\nmodule.exports = (el) => {\n  // this is the *target* state:\n  // * if the element has the attr and it's !== \"true\", pressed is true\n  // * otherwise, pressed is false\n  const pressed =\n    el.hasAttribute(PRESSED) && el.getAttribute(PRESSED) !== \"true\";\n\n  const fields = resolveIdRefs(el.getAttribute(CONTROLS));\n  fields.forEach((field) => toggleFieldMask(field, pressed));\n\n  if (!el.hasAttribute(SHOW_ATTR)) {\n    el.setAttribute(SHOW_ATTR, el.textContent);\n  }\n\n  const showText = el.getAttribute(SHOW_ATTR);\n  const hideText = el.getAttribute(HIDE_ATTR) || getHideText(showText);\n\n  el.textContent = pressed ? showText : hideText; // eslint-disable-line no-param-reassign\n  el.setAttribute(PRESSED, pressed);\n  return pressed;\n};\n","const EXPANDED = \"aria-expanded\";\nconst CONTROLS = \"aria-controls\";\nconst HIDDEN = \"hidden\";\n\nmodule.exports = (button, expanded) => {\n  let safeExpanded = expanded;\n\n  if (typeof safeExpanded !== \"boolean\") {\n    safeExpanded = button.getAttribute(EXPANDED) === \"false\";\n  }\n\n  button.setAttribute(EXPANDED, safeExpanded);\n\n  const id = button.getAttribute(CONTROLS);\n  const controls = document.getElementById(id);\n  if (!controls) {\n    throw new Error(`No toggle target found with id: \"${id}\"`);\n  }\n\n  if (safeExpanded) {\n    controls.removeAttribute(HIDDEN);\n  } else {\n    controls.setAttribute(HIDDEN, \"\");\n  }\n\n  return safeExpanded;\n};\n","const debounce = require(\"./debounce\");\nconst { prefix: PREFIX } = require(\"../config\");\n\nconst CHECKED_CLASS = `${PREFIX}-checklist__item--checked`;\n\nmodule.exports = function validate(el) {\n  const id = el.dataset.validationElement;\n  const checkList =\n    id.charAt(0) === \"#\"\n      ? document.querySelector(id)\n      : document.getElementById(id);\n\n  if (!checkList) {\n    throw new Error(`No validation element found with id: \"${id}\"`);\n  }\n\n  let statusSummary = \"\";\n  Object.entries(el.dataset).forEach(([key, value]) => {\n    if (key.startsWith(\"validate\")) {\n      const validatorName = key.substr(\"validate\".length).toLowerCase();\n      const validatorPattern = new RegExp(value);\n      const validatorSelector = `[data-validator=\"${validatorName}\"]`;\n      const validatorCheckbox = checkList.querySelector(validatorSelector);\n      const validatorParent = el.parentNode;\n      const statusSummaryContainer = validatorParent.querySelector(\n        `[data-validation-status]`,\n      );\n\n      const checked = validatorPattern.test(el.value);\n      validatorCheckbox.classList.toggle(CHECKED_CLASS, checked);\n\n      if (!validatorCheckbox) {\n        throw new Error(`No validator checkbox found for: \"${validatorName}\"`);\n      }\n\n      // Create status reports for checklist items\n      const statusComplete = el.dataset.validationComplete || \"status complete\";\n      const statusIncomplete =\n        el.dataset.validationIncomplete || \"status incomplete\";\n      let checkboxContent = `${validatorCheckbox.textContent} `;\n\n      if (validatorCheckbox.classList.contains(CHECKED_CLASS)) {\n        checkboxContent += statusComplete;\n      } else {\n        checkboxContent += statusIncomplete;\n      }\n\n      // move status updates to aria-label on checklist item\n      validatorCheckbox.setAttribute(\"aria-label\", checkboxContent);\n\n      // Create a summary of status for all checklist items\n      statusSummary += `${checkboxContent}. `;\n\n      // Add summary to screen reader summary container, after a delay\n      const srUpdateStatus = debounce(() => {\n        statusSummaryContainer.textContent = statusSummary;\n      }, 1000);\n\n      srUpdateStatus();\n    }\n  });\n};\n"]} diff --git a/html/matt-chat/uswds/js/uswds.min.js b/html/matt-chat/uswds/js/uswds.min.js new file mode 100644 index 0000000..4b7948d --- /dev/null +++ b/html/matt-chat/uswds/js/uswds.min.js @@ -0,0 +1,84 @@ +!function a(s,i,n){function o(t,e){if(!i[t]){if(!s[t]){var r="function"==typeof require&&require;if(!e&&r)return r(t,!0);if(l)return l(t,!0);throw(e=new Error("Cannot find module '"+t+"'")).code="MODULE_NOT_FOUND",e}r=i[t]={exports:{}},s[t][0].call(r.exports,function(e){return o(s[t][1][e]||e)},r,r.exports,a,s,i,n)}return i[t].exports}for(var l="function"==typeof require&&require,e=0;e<n.length;e++)o(n[e]);return o}({1:[function(e,t,r){var a;"function"!=typeof(a=window.Element.prototype).matches&&(a.matches=a.msMatchesSelector||a.mozMatchesSelector||a.webkitMatchesSelector||function(e){for(var t=this,r=(t.document||t.ownerDocument).querySelectorAll(e),a=0;r[a]&&r[a]!==t;)++a;return Boolean(r[a])}),"function"!=typeof a.closest&&(a.closest=function(e){for(var t=this;t&&1===t.nodeType;){if(t.matches(e))return t;t=t.parentNode}return null})},{}],2:[function(e,t,r){for(var a={polyfill:function(){if(!("KeyboardEvent"in window)||"key"in KeyboardEvent.prototype)return!1;var e={get:function(e){var t=a.keys[this.which||this.keyCode];return t=Array.isArray(t)?t[+this.shiftKey]:t}};return Object.defineProperty(KeyboardEvent.prototype,"key",e),e},keys:{3:"Cancel",6:"Help",8:"Backspace",9:"Tab",12:"Clear",13:"Enter",16:"Shift",17:"Control",18:"Alt",19:"Pause",20:"CapsLock",27:"Escape",28:"Convert",29:"NonConvert",30:"Accept",31:"ModeChange",32:" ",33:"PageUp",34:"PageDown",35:"End",36:"Home",37:"ArrowLeft",38:"ArrowUp",39:"ArrowRight",40:"ArrowDown",41:"Select",42:"Print",43:"Execute",44:"PrintScreen",45:"Insert",46:"Delete",48:["0",")"],49:["1","!"],50:["2","@"],51:["3","#"],52:["4","$"],53:["5","%"],54:["6","^"],55:["7","&"],56:["8","*"],57:["9","("],91:"OS",93:"ContextMenu",144:"NumLock",145:"ScrollLock",181:"VolumeMute",182:"VolumeDown",183:"VolumeUp",186:[";",":"],187:["=","+"],188:[",","<"],189:["-","_"],190:[".",">"],191:["/","?"],192:["`","~"],219:["[","{"],220:["\\","|"],221:["]","}"],222:["'",'"'],224:"Meta",225:"AltGraph",246:"Attn",247:"CrSel",248:"ExSel",249:"EraseEof",250:"Play",251:"ZoomOut"}},s=1;s<25;s++)a.keys[111+s]="F"+s;var i="";for(s=65;s<91;s++)i=String.fromCharCode(s),a.keys[s]=[i.toLowerCase(),i.toUpperCase()];"function"==typeof define&&define.amd?define("keyboardevent-key-polyfill",a):void 0!==r&&void 0!==t?t.exports=a:window&&(window.keyboardeventKeyPolyfill=a)},{}],3:[function(e,t,r){var l=Object.getOwnPropertySymbols,c=Object.prototype.hasOwnProperty,u=Object.prototype.propertyIsEnumerable;t.exports=(()=>{try{if(Object.assign){var e=new String("abc");if(e[5]="de","5"!==Object.getOwnPropertyNames(e)[0]){for(var t={},r=0;r<10;r++)t["_"+String.fromCharCode(r)]=r;var a,s=Object.getOwnPropertyNames(t).map(function(e){return t[e]});if("0123456789"===s.join(""))return a={},"abcdefghijklmnopqrst".split("").forEach(function(e){a[e]=e}),"abcdefghijklmnopqrst"===Object.keys(Object.assign({},a)).join("")?1:void 0}}}catch(e){}})()?Object.assign:function(e,t){for(var r,a=(e=>{if(null==e)throw new TypeError("Object.assign cannot be called with null or undefined");return Object(e)})(e),s=1;s<arguments.length;s++){for(var i in r=Object(arguments[s]))c.call(r,i)&&(a[i]=r[i]);if(l)for(var n=l(r),o=0;o<n.length;o++)u.call(r,n[o])&&(a[n[o]]=r[n[o]])}return a}},{}],4:[function(e,t,r){let l=e("object-assign"),c=e("../delegate"),u=e("../delegateAll"),d=/^(.+):delegate\((.+)\)$/;function p(e,t){var r=e[t];return delete e[t],r}t.exports=function(o,e){let r=Object.keys(o).reduce(function(e,t){r=o[t=t],(n=t.match(d))&&(t=n[1],a=n[2]),"object"==typeof r&&(s={capture:p(r,"capture"),passive:p(r,"passive")}),i={selector:a,delegate:"object"==typeof r?u(r):a?c(a,r):r,options:s};var r,a,s,i,n=-1<t.indexOf(" ")?t.split(" ").map(function(e){return l({type:e},i)}):(i.type=t,[i]);return e.concat(n)},[]);return l({add:function(t){r.forEach(function(e){t.addEventListener(e.type,e.delegate,e.options)})},remove:function(t){r.forEach(function(e){t.removeEventListener(e.type,e.delegate,e.options)})}},e)}},{"../delegate":6,"../delegateAll":7,"object-assign":3}],5:[function(e,t,r){t.exports=function(e){return function(t){return e.some(function(e){return!1===e.call(this,t)},this)}}},{}],6:[function(e,t,r){e("element-closest"),t.exports=function(r,a){return function(e){var t=e.target.closest(r);if(t)return a.call(t,e)}}},{"element-closest":1}],7:[function(e,t,r){let a=e("../delegate"),s=e("../compose");t.exports=function(r){var e=Object.keys(r);return 1===e.length&&"*"===e[0]?r["*"]:(e=e.reduce(function(e,t){return e.push(a(t,r[t])),e},[]),s(e))}},{"../compose":5,"../delegate":6}],8:[function(e,t,r){t.exports=function(t,r){return function(e){if(t!==e.target&&!t.contains(e.target))return r.call(this,e)}}},{}],9:[function(e,t,r){t.exports={behavior:e("./behavior"),delegate:e("./delegate"),delegateAll:e("./delegateAll"),ignore:e("./ignore"),keymap:e("./keymap")}},{"./behavior":4,"./delegate":6,"./delegateAll":7,"./ignore":8,"./keymap":10}],10:[function(e,t,r){e("keyboardevent-key-polyfill");let i={Alt:"altKey",Control:"ctrlKey",Ctrl:"ctrlKey",Shift:"shiftKey"};t.exports=function(s){let e=Object.keys(s).some(function(e){return-1<e.indexOf("+")});return function(r){var a=((e,t)=>{var r=e.key;if(t)for(var a in i)!0===e[i[a]]&&(r=[a,r].join("+"));return r})(r,e);return[a,a.toLowerCase()].reduce(function(e,t){return e=t in s?s[a].call(this,r):e},void 0)}},t.exports.MODIFIERS=i},{"keyboardevent-key-polyfill":2}],11:[function(e,t,r){t.exports=function(t,r){function a(e){return e.currentTarget.removeEventListener(e.type,a,r),t.call(this,e)}return a}},{}],12:[function(e,t,r){var a=/(^\s+)|(\s+$)/g,s=/\s+/,i=String.prototype.trim?function(e){return e.trim()}:function(e){return e.replace(a,"")};t.exports=function(e,t){if("string"!=typeof e)throw new Error("Expected a string but got "+typeof e);var r=((t=t||window.document).getElementById||function(e){return this.querySelector('[id="'+e.replace(/"/g,'\\"')+'"]')}).bind(t);return 1===(e=i(e).split(s)).length&&""===e[0]?[]:e.map(function(e){var t=r(e);if(t)return t;throw new Error('no element with id: "'+e+'"')})}},{}],13:[function(e,t,r){var a=e("../../uswds-core/src/js/utils/behavior");let s=e("../../uswds-core/src/js/utils/toggle-form-input");var i=e("../../uswds-core/src/js/events").CLICK,e=e("../../uswds-core/src/js/config").prefix;t.exports=a({[i]:{[`.${e}-show-password`]:function(e){e.preventDefault(),s(this)}}})},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/events":36,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/toggle-form-input":50}],14:[function(e,t,r){let a=e("../../uswds-core/src/js/utils/select");var s=e("../../uswds-core/src/js/utils/behavior");let i=e("../../uswds-core/src/js/utils/toggle"),n=e("../../uswds-core/src/js/utils/is-in-viewport");var o=e("../../uswds-core/src/js/events").CLICK,e=e("../../uswds-core/src/js/config").prefix;let l=`.${e}-accordion, .${e}-accordion--bordered`,c=`.${e}-accordion__button[aria-controls]:not(${`.${e}-banner__button`})`,u="aria-expanded",d=t=>a(c,t).filter(e=>e.closest(l)===t),p=(t,e)=>{var r=t.closest(l);if(!r)throw new Error(c+" is missing outer "+l);var e=i(t,e),a=r.hasAttribute("data-allow-multiple");e&&!a&&d(r).forEach(e=>{e!==t&&i(e,!1)})};e=s({[o]:{[c](){p(this),"true"!==this.getAttribute(u)||n(this)||this.scrollIntoView()}}},{init(e){a(c,e).forEach(e=>{var t="true"===e.getAttribute(u);p(e,t)})},ACCORDION:l,BUTTON:c,show:e=>p(e,!0),hide:e=>p(e,!1),toggle:p,getButtons:d});t.exports=e},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/events":36,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/is-in-viewport":43,"../../uswds-core/src/js/utils/select":48,"../../uswds-core/src/js/utils/toggle":51}],15:[function(e,t,r){var a=e("../../uswds-core/src/js/utils/behavior");let s=e("../../uswds-core/src/js/utils/select");var i=e("../../uswds-core/src/js/events").CLICK,n=e("../../uswds-core/src/js/config").prefix;let o=e("../../uswds-core/src/js/utils/toggle"),l=`.${n}-banner__header`,c=n+"-banner__header--expanded",u=l+" [aria-controls]";t.exports=a({[i]:{[u]:function(e){e.preventDefault();e=e.target.closest(u);o(e),this.closest(l).classList.toggle(c)}}},{init(e){s(u,e).forEach(e=>{var t="true"===e.getAttribute(c);o(e,t)})}})},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/events":36,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/select":48,"../../uswds-core/src/js/utils/toggle":51}],16:[function(e,t,r){var a=e("receptor/keymap"),e=e("../../uswds-core/src/js/utils/behavior")({keydown:{'a[class*="usa-button"]':a({" ":e=>{e.preventDefault(),e.target.click()}})}});t.exports=e},{"../../uswds-core/src/js/utils/behavior":40,"receptor/keymap":10}],17:[function(e,t,r){let a=e("../../uswds-core/src/js/utils/select");var s=e("../../uswds-core/src/js/utils/behavior"),i=e("../../uswds-core/src/js/utils/debounce"),e=e("../../uswds-core/src/js/config").prefix,n=e+"-character-count";let o="."+n;var l=e+"-form-group";let c=l+"--error",u="."+l,d=e+"-label"+"--error",p=`.${e}-character-count__field`,b=e+"-input--error",f=`.${e}-character-count__message`,h="The content is too long.",m=e+"-character-count__status--invalid",v=n+"__status",g=n+"__sr-status",w="."+v,y="."+g,E="characters allowed",A=e=>{var t=e.closest(o);if(!t)throw new Error(p+" is missing outer "+o);var r=t.querySelector(u),e=e.getAttribute("id"),a=document.querySelector(`label[for=${e}]`),s=t.querySelector(f);if(s)return{characterCountEl:t,formGroupEl:r,inputID:e,labelEl:a,messageEl:s};throw new Error(o+" is missing inner "+f)},x=e=>{var t=document.createElement("div"),r=document.createElement("div"),a=e.dataset.maxlength+" "+E;t.classList.add(""+v,"usa-hint"),r.classList.add(""+g,"usa-sr-only"),t.setAttribute("aria-hidden",!0),r.setAttribute("aria-live","polite"),t.textContent=a,r.textContent=a,e.append(t,r)},j=(e,t)=>{let r="";var a;return r=0===e?t+" "+E:(a=Math.abs(t-e))+` ${"character"+(1===a?"":"s")} `+(t<e?"over limit":"left")},L=i((e,t)=>{e.textContent=t},1e3),S=e=>{var{characterCountEl:t,labelEl:r,formGroupEl:a}=A(e),s=e.value.length,i=parseInt(t.getAttribute("data-maxlength"),10),n=t.querySelector(w),t=t.querySelector(y),o=j(s,i);i&&(i=s&&i<s,n.textContent=o,L(t,o),i&&!e.validationMessage&&e.setCustomValidity(h),i||e.validationMessage!==h||e.setCustomValidity(""),a&&a.classList.toggle(c,i),r&&r.classList.toggle(d,i),e.classList.toggle(b,i),n.classList.toggle(m,i))},_=e=>{var t,{characterCountEl:r,messageEl:a}=A(e);a.classList.add("usa-sr-only"),a.removeAttribute("aria-live"),a=e,e=A(a).characterCountEl,(t=a.getAttribute("maxlength"))&&(a.removeAttribute("maxlength"),e.setAttribute("data-maxlength",t)),x(r)};l=s({input:{[p](){S(this)}}},{init(e){a(p,e).forEach(e=>_(e))},FORM_GROUP_ERROR_CLASS:c,LABEL_ERROR_CLASS:d,INPUT_ERROR_CLASS:b,MESSAGE_INVALID_CLASS:m,VALIDATION_MESSAGE:h,STATUS_MESSAGE_CLASS:v,STATUS_MESSAGE_SR_ONLY_CLASS:g,DEFAULT_STATUS_LABEL:E,createStatusMessages:x,getCountMessage:j,updateCountMessage:S});t.exports=l},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/debounce":41,"../../uswds-core/src/js/utils/select":48}],18:[function(e,t,N){var r=e("receptor/keymap");let a=e("../../uswds-core/src/js/utils/select-or-matches");var s=e("../../uswds-core/src/js/utils/behavior");let p=e("../../uswds-core/src/js/utils/sanitizer");var i=e("../../uswds-core/src/js/config").prefix,e=e("../../uswds-core/src/js/events").CLICK,i=i+"-combo-box";let b=i+"--pristine",f=i+"__select",h=i+"__input",m=i+"__clear-input",B=m+"__wrapper",O=i+"__input-button-separator",v=i+"__toggle-list",H=v+"__wrapper",g=i+"__list",y=i+"__list-option",E=y+"--focused",A=y+"--selected",w=i+"__status",x="."+i,P="."+f,u="."+h,d="."+m,j="."+v,R="."+g,n="."+y,L="."+E,F="."+A,Y="."+w,U=".*{{query}}.*";let S=(e,t="")=>{e.value=t,t=new CustomEvent("change",{bubbles:!0,cancelable:!0,detail:{value:t}});e.dispatchEvent(t)},_=e=>{var t,r,a,s,i,n,o,l,c,e=e.closest(x);if(e)return t=e.querySelector(P),r=e.querySelector(u),a=e.querySelector(R),s=e.querySelector(Y),i=e.querySelector(L),n=e.querySelector(F),o=e.querySelector(j),l=e.querySelector(d),c=e.classList.contains(b),{comboBoxEl:e,selectEl:t,inputEl:r,listEl:a,statusEl:s,focusedOptionEl:i,selectedOptionEl:n,toggleListBtnEl:o,clearInputBtnEl:l,isPristine:c,disableFiltering:"true"===e.dataset.disableFiltering};throw new Error("Element is missing outer "+x)},D=e=>{var{inputEl:e,toggleListBtnEl:t,clearInputBtnEl:r}=_(e);r.hidden=!0,t.disabled=r.disabled=!0,e.disabled=!0};let o=e=>{e=e.closest(x);if(!e.dataset.enhanced){let r=e.querySelector("select");if(!r)throw new Error(x+" is missing inner select");var t=r.id,n=document.querySelector(`label[for="${t}"]`),o=t+"--list",l=t+"-label";let a=[];var c=e.dataset.defaultValue,u=e.dataset.placeholder;let s;if(u&&a.push({placeholder:u}),c)for(let e=0,t=r.options.length;e<t;e+=1){var d=r.options[e];if(d.value===c){s=d;break}}if(!n||!n.matches(`label[for="${t}"]`))throw new Error(x+` for ${t} is either missing a label or a "for" attribute`);n.setAttribute("id",l),n.setAttribute("id",l),r.setAttribute("aria-hidden","true"),r.setAttribute("tabindex","-1"),r.classList.add("usa-sr-only",f),r.id="",r.value="",["required","aria-label","aria-labelledby"].forEach(e=>{var t;r.hasAttribute(e)&&(t=r.getAttribute(e),a.push({[e]:t}),r.removeAttribute(e))});let i=document.createElement("input");i.setAttribute("id",t),i.setAttribute("aria-owns",o),i.setAttribute("aria-controls",o),i.setAttribute("aria-autocomplete","list"),i.setAttribute("aria-expanded","false"),i.setAttribute("autocapitalize","off"),i.setAttribute("autocomplete","off"),i.setAttribute("class",h),i.setAttribute("type","text"),i.setAttribute("role","combobox"),a.forEach(r=>Object.keys(r).forEach(e=>{var t=p.escapeHTML`${r[e]}`;i.setAttribute(e,t)})),e.insertAdjacentElement("beforeend",i),e.insertAdjacentHTML("beforeend",p.escapeHTML` + <span class="${B}" tabindex="-1"> + <button type="button" class="${m}" aria-label="Clear the select contents"> </button> + </span> + <span class="${O}"> </span> + <span class="${H}" tabindex="-1"> + <button type="button" tabindex="-1" class="${v}" aria-label="Toggle the dropdown list"> </button> + </span> + <ul + tabindex="-1" + id="${o}" + class="${g}" + role="listbox" + aria-labelledby="${l}" + hidden> + </ul> + <div class="${w} usa-sr-only" role="status"></div>`),s&&(u=_(e).inputEl,S(r,s.value),S(u,s.text),e.classList.add(b)),r.disabled&&(D(e),r.disabled=!1),r.hasAttribute("aria-disabled")&&((e=>{var{inputEl:e,toggleListBtnEl:t,clearInputBtnEl:r}=_(e);r.hidden=!0,r.setAttribute("aria-disabled",!0),t.setAttribute("aria-disabled",!0),e.setAttribute("aria-disabled",!0)})(e),r.removeAttribute("aria-disabled")),e.dataset.enhanced="true"}},C=(e,t,{skipFocus:r,preventScroll:a}={})=>{var{inputEl:e,listEl:s,focusedOptionEl:i}=_(e);i&&(i.classList.remove(E),i.setAttribute("tabIndex","-1")),t?(e.setAttribute("aria-activedescendant",t.id),t.setAttribute("tabIndex","0"),t.classList.add(E),a||(i=t.offsetTop+t.offsetHeight,s.scrollTop+s.offsetHeight<i&&(s.scrollTop=i-s.offsetHeight),t.offsetTop<s.scrollTop&&(s.scrollTop=t.offsetTop)),r||t.focus({preventScroll:a})):(e.setAttribute("aria-activedescendant",""),e.focus())},$=(e,a="",s={})=>{let i=e=>e.replace(/[-[\]{}()*+?.,\\^$|#\s]/g,"\\$&");e=`^(?:${e.replace(/{{(.*?)}}/g,(e,t)=>{var t=t.trim(),r=s[t];return"query"!==t&&r?(t=new RegExp(r,"i"),(r=a.match(t))?i(r[1]):""):i(a)})})$`;return new RegExp(e,"i")},l=e=>{let{comboBoxEl:t,selectEl:a,inputEl:r,listEl:s,statusEl:i,isPristine:n,disableFiltering:o}=_(e),l,c,u=s.id+"--option-",d=(r.value||"").toLowerCase();e=t.dataset.filter||U;let p=$(e,d,t.dataset),b=[],f=[],h=[];e=[...a.options];let m=e=>p.test(e.text);e.forEach(e=>{var t,r;(r=e).value&&(o||n||!d||m(r))&&(r=e,o||n?b.push(r):((r.text.toLowerCase().startsWith(d)?f:h).push(r),b=[...f,...h]),r=u+b.indexOf(e),t=e,o&&!c&&m(t)&&(c=r),t=e,a.value)&&t.value===a.value&&(l=r)});var e=b.length,v=b.map((e,t)=>{var r=u+t,a=[y];let s="-1",i="false";r===l&&(a.push(A,E),s="0",i="true"),l||0!==t||(a.push(E),s="0");var n=document.createElement("li");return n.setAttribute("aria-setsize",b.length),n.setAttribute("aria-posinset",t+1),n.setAttribute("aria-selected",i),n.setAttribute("id",r),n.setAttribute("class",a.join(" ")),n.setAttribute("tabindex",s),n.setAttribute("role","option"),n.setAttribute("data-value",e.value),n.textContent=e.text,n}),g=document.createElement("li");g.setAttribute("class",y+"--no-results"),g.textContent="No results found",s.hidden=!1,e?(s.innerHTML="",v.forEach(e=>s.insertAdjacentElement("beforeend",e))):(s.innerHTML="",s.insertAdjacentElement("beforeend",g)),r.setAttribute("aria-expanded","true"),i.textContent=e?e+` result${1<e?"s":""} available.`:"No results.";let w;n&&l?w=s.querySelector("#"+l):o&&c&&(w=s.querySelector("#"+c)),w&&C(s,w,{skipFocus:!0})},c=e=>{var{inputEl:e,listEl:t,statusEl:r,focusedOptionEl:a}=_(e);r.innerHTML="",e.setAttribute("aria-expanded","false"),e.setAttribute("aria-activedescendant",""),a&&a.classList.remove(E),t.scrollTop=0,t.hidden=!0},T=e=>{var{comboBoxEl:t,selectEl:r,inputEl:a}=_(e);S(r,e.dataset.value),S(a,e.textContent),t.classList.add(b),c(t),a.focus()},k=e=>{var{comboBoxEl:r,selectEl:a,inputEl:s}=_(e),i=a.value,n=(s.value||"").toLowerCase();if(i)for(let e=0,t=a.options.length;e<t;e+=1){var o=a.options[e];if(o.value===i)return n!==o.text&&S(s,o.text),void r.classList.add(b)}n&&S(s)};var M=e=>{var{comboBoxEl:t,listEl:r}=_(e.target),r=(r.hidden&&l(t),r.querySelector(L)||r.querySelector(n));r&&C(t,r),e.preventDefault()},q=e=>{var t=e.target,r=t.nextSibling;r&&C(t,r),e.preventDefault()},I=e=>{var{comboBoxEl:t,listEl:r,focusedOptionEl:a}=_(e.target),a=a&&a.previousSibling,r=!r.hidden;C(t,a),r&&e.preventDefault(),a||c(t)};s=s({[e]:{[u](){this.disabled||(e=>{var{comboBoxEl:e,listEl:t}=_(e);t.hidden&&l(e)})(this)},[j](){this.disabled||(e=>{var{comboBoxEl:e,listEl:t,inputEl:r}=_(e);(t.hidden?l:c)(e),r.focus()})(this)},[n](){this.disabled||T(this)},[d](){this.disabled||(e=>{var{comboBoxEl:e,listEl:t,selectEl:r,inputEl:a}=_(e),t=!t.hidden;r.value&&S(r),a.value&&S(a),e.classList.remove(b),t&&l(e),a.focus()})(this)}},focusout:{[x](e){this.contains(e.relatedTarget)||(k(this),c(this))}},keydown:{[x]:r({Escape:e=>{var{comboBoxEl:e,inputEl:t}=_(e.target);c(e),k(e),t.focus()}}),[u]:r({Enter:e=>{var{comboBoxEl:t,listEl:r}=_(e.target),r=!r.hidden;(e=>{var{comboBoxEl:r,selectEl:a,inputEl:s,statusEl:e}=_(e),i=(e.textContent="",(s.value||"").toLowerCase());if(i)for(let e=0,t=a.options.length;e<t;e+=1){var n=a.options[e];if(n.text.toLowerCase()===i)return S(a,n.value),S(s,n.text),r.classList.add(b)}k(r)})(t),r&&c(t),e.preventDefault()},ArrowDown:M,Down:M}),[n]:r({ArrowUp:I,Up:I,ArrowDown:q,Down:q,Enter:e=>{T(e.target),e.preventDefault()}," ":e=>{T(e.target),e.preventDefault()},"Shift+Tab":()=>{}})},input:{[u](){this.closest(x).classList.remove(b),l(this)}},mouseover:{[n](){var e;(e=this).classList.contains(E)||C(e,e,{preventScroll:!0})}}},{init(e){a(x,e).forEach(e=>{o(e)})},getComboBoxContext:_,enhanceComboBox:o,generateDynamicRegExp:$,disable:D,enable:e=>{var{inputEl:e,toggleListBtnEl:t,clearInputBtnEl:r}=_(e);r.hidden=!1,t.disabled=r.disabled=!1,e.disabled=!1},displayList:l,hideList:c,COMBO_BOX_CLASS:i});t.exports=s},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/events":36,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/sanitizer":45,"../../uswds-core/src/js/utils/select-or-matches":47,"receptor/keymap":10}],19:[function(e,E,A){let t=e("receptor/keymap");var S=e("../../uswds-core/src/js/utils/behavior");let _=e("../../uswds-core/src/js/utils/select"),P=e("../../uswds-core/src/js/utils/select-or-matches");var r=e("../../uswds-core/src/js/config").prefix,R=e("../../uswds-core/src/js/events").CLICK;let F=e("../../uswds-core/src/js/utils/active-element");var Y=e("../../uswds-core/src/js/utils/is-ios-device");let D=e("../../uswds-core/src/js/utils/sanitizer");e=r+"-date-picker";let U=e+"__wrapper",V=e+"--initialized",K=e+"--active",W=e+"__internal-input",z=e+"__external-input",Q=e+"__button",i=e+"__calendar",G=e+"__status",C=i+"__date",Z=C+"--focused",J=C+"--selected",X=C+"--previous-month",ee=C+"--current-month",te=C+"--next-month",re=C+"--range-date",ae=C+"--today",se=C+"--range-date-start",ie=C+"--range-date-end",ne=C+"--within-range",oe=i+"__previous-year",le=i+"__previous-month",ce=i+"__next-year",ue=i+"__next-month",de=i+"__month-selection",pe=i+"__year-selection",p=i+"__month",be=p+"--focused",fe=p+"--selected",x=i+"__year",he=x+"--focused",me=x+"--selected",ve=i+"__previous-year-chunk",ge=i+"__next-year-chunk",we=i+"__date-picker",ye=i+"__month-picker",Ee=i+"__year-picker",$=i+"__table",Ae=i+"__row",T=i+"__cell",k=T+"--center-items",xe=i+"__month-label",je=i+"__day-of-week",f="."+e,Le="."+Q,Se="."+W,h="."+z,_e="."+i,De="."+G;r="."+C;let o="."+Z;e="."+ee;let Ce="."+oe,$e="."+le,Te="."+ce,ke="."+ue;var Me="."+pe,qe="."+de,Ie="."+p;let Ne="."+x,Be="."+ve,Oe="."+ge,M="."+we;var He="."+ye;let Pe="."+Ee,Re="."+be,l="."+he,Fe="Please enter a valid date",Ye=["January","February","March","April","May","June","July","August","September","October","November","December"],Ue=["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],j=12,m="MM/DD/YYYY",Ve="YYYY-MM-DD";var a=(...e)=>e.map(e=>e+":not([disabled])").join(", "),s=a(Ce,$e,Me,qe,Te,ke,o),Ke=a(Re),a=a(Be,Oe,l);let We=(e,t)=>(t!==e.getMonth()&&e.setDate(0),e),d=(e,t,r)=>{var a=new Date(0);return a.setFullYear(e,t,r),a},ze=()=>{var e=new Date,t=e.getDate(),r=e.getMonth(),e=e.getFullYear();return d(e,r,t)},Qe=e=>{var t=new Date(0);return t.setFullYear(e.getFullYear(),e.getMonth(),1),t},Ge=e=>{var t=new Date(0);return t.setFullYear(e.getFullYear(),e.getMonth()+1,0),t},q=(e,t)=>{e=new Date(e.getTime());return e.setDate(e.getDate()+t),e},Ze=(e,t)=>q(e,-t),Je=(e,t)=>q(e,7*t),Xe=e=>{var t=e.getDay();return Ze(e,t)},I=(e,t)=>{var e=new Date(e.getTime()),r=(e.getMonth()+12+t)%12;return e.setMonth(e.getMonth()+t),We(e,r),e},et=(e,t)=>I(e,-t),tt=(e,t)=>I(e,12*t),rt=(e,t)=>tt(e,-t),b=(e,t)=>{e=new Date(e.getTime());return e.setMonth(t),We(e,t),e},L=(e,t)=>{var e=new Date(e.getTime()),r=e.getMonth();return e.setFullYear(t),We(e,r),e},at=(e,t)=>{let r=t<e?t:e;return new Date(r.getTime())},st=(e,t)=>{let r=e<t?t:e;return new Date(r.getTime())},it=(e,t)=>e&&t&&e.getFullYear()===t.getFullYear(),N=(e,t)=>it(e,t)&&e.getMonth()===t.getMonth(),B=(e,t)=>N(e,t)&&e.getDate()===t.getDate(),c=(e,t,r)=>{let a=e;return e<t?a=t:r&&r<e&&(a=r),new Date(a.getTime())},nt=(e,t,r)=>t<=e&&(!r||e<=r),ot=(e,t,r)=>Ge(e)<t||r&&Qe(e)>r,lt=(e,t,r)=>Ge(b(e,11))<t||r&&Qe(b(e,0))>r,ct=(e,t)=>{var r=t&&at(e,t),e=t&&st(e,t);return{rangeStartDate:r,rangeEndDate:e,withinRangeStartDate:t&&q(r,1),withinRangeEndDate:t&&Ze(e,1)}},v=(a,s=Ve,i=!1)=>{let n,o,l,c,u;if(a){let e,t,r;s===m?[e,t,r]=a.split("/"):[r,e,t]=a.split("-"),r&&(u=parseInt(r,10),Number.isNaN(u)||(c=u,i&&(c=Math.max(0,c),r.length<3)&&(a=(s=ze().getFullYear())-s%10**r.length,c=a+u))),e&&(u=parseInt(e,10),Number.isNaN(u)||(o=u,i&&(o=Math.max(1,o),o=Math.min(12,o)))),o&&t&&null!=c&&(u=parseInt(t,10),Number.isNaN(u)||(l=u,i&&(s=d(c,o,0).getDate(),l=Math.max(1,l),l=Math.min(s,l)))),o&&l&&null!=c&&(n=d(c,o-1,l))}return n},O=(e,t=Ve)=>{var r=(e,t)=>("0000"+e).slice(-t),a=e.getMonth()+1,s=e.getDate(),e=e.getFullYear();return t===m?[r(a,2),r(s,2),r(e,4)].join("/"):[r(e,4),r(a,2),r(s,2)].join("-")},ut=(e,r)=>{var a=[],s=[];let i=0;for(;i<e.length;){s=[];let t=document.createElement("tr");for(;i<e.length&&s.length<r;){var n=document.createElement("td");n.insertAdjacentElement("beforeend",e[i]),s.push(n),i+=1}s.forEach(e=>{t.insertAdjacentElement("beforeend",e)}),a.push(t)}return a},dt=e=>{let t=document.createElement("tbody");return e.forEach(e=>{t.insertAdjacentElement("beforeend",e)}),t},pt=(e,t="")=>{e.value=t,t=new CustomEvent("change",{bubbles:!0,cancelable:!0,detail:{value:t}});e.dispatchEvent(t)},H=e=>{e=e.closest(f);if(!e)throw new Error("Element is missing outer "+f);var t=e.querySelector(Se),r=e.querySelector(h),a=e.querySelector(_e),s=e.querySelector(Le),i=e.querySelector(De),n=e.querySelector(Ne),o=v(r.value,m,!0),l=v(t.value),c=v(a.dataset.value),u=v(e.dataset.minDate),d=v(e.dataset.maxDate),p=v(e.dataset.rangeDate),b=v(e.dataset.defaultDate);if(u&&d&&d<u)throw new Error("Minimum date cannot be after maximum date");return{calendarDate:c,minDate:u,toggleBtnEl:s,selectedDate:l,maxDate:d,firstYearChunkEl:n,datePickerEl:e,inputDate:o,internalInputEl:t,externalInputEl:r,calendarEl:a,rangeDate:p,defaultDate:b,statusEl:i}},bt=e=>{var{externalInputEl:e,toggleBtnEl:t}=H(e);t.disabled=!0,e.disabled=!0},ft=e=>{var{externalInputEl:e,toggleBtnEl:t}=H(e);t.setAttribute("aria-disabled",!0),e.setAttribute("aria-disabled",!0),e.setAttribute("readonly","")};let ht=e=>{var t,r,a,s,{externalInputEl:e,minDate:i,maxDate:n}=H(e),e=e.value;let o=!1;return o=e&&(o=!0,[t,r,a]=(e=e.split("/")).map(e=>{let t;e=parseInt(e,10);return t=Number.isNaN(e)?t:e}),t)&&r&&null!=a&&(s=d(a,t-1,r)).getMonth()===t-1&&s.getDate()===r&&s.getFullYear()===a&&4===e[2].length&&nt(s,i,n)?!1:o},mt=e=>{var e=H(e).externalInputEl,t=ht(e);t&&!e.validationMessage&&e.setCustomValidity(Fe),t||e.validationMessage!==Fe||e.setCustomValidity("")},vt=(e,t)=>{var r,a,s=v(t);s&&(s=O(s,m),{datePickerEl:e,internalInputEl:r,externalInputEl:a}=H(e),pt(r,t),pt(a,s),mt(e))},u=(e,t)=>{let{datePickerEl:r,calendarEl:a,statusEl:s,selectedDate:d,maxDate:p,minDate:b,rangeDate:f}=H(e),h=ze(),i=t||h;e=a.hidden;let m=q(i,0);var n=i.getMonth(),t=i.getFullYear();let v=et(i,1),g=I(i,1);var o=O(i),l=Qe(i),c=N(i,b),u=N(i,p);let{rangeStartDate:w,rangeEndDate:y,withinRangeStartDate:E,withinRangeEndDate:A}=ct(d||i,f);for(var x=Ye[n],j=(i=Xe(l),[]);j.length<28||i.getMonth()===n||j.length%7!=0;)j.push((e=>{var t=[C],r=e.getDate(),a=e.getMonth(),s=e.getFullYear(),i=e.getDay(),n=O(e);let o="-1";var l=!nt(e,b,p),c=B(e,d),e=(N(e,v)&&t.push(X),N(e,m)&&t.push(ee),N(e,g)&&t.push(te),c&&t.push(J),B(e,h)&&t.push(ae),f&&(B(e,f)&&t.push(re),B(e,w)&&t.push(se),B(e,y)&&t.push(ie),nt(e,E,A))&&t.push(ne),B(e,m)&&(o="0",t.push(Z)),Ye[a]),i=Ue[i],u=document.createElement("button");return u.setAttribute("type","button"),u.setAttribute("tabindex",o),u.setAttribute("class",t.join(" ")),u.setAttribute("data-day",r),u.setAttribute("data-month",a+1),u.setAttribute("data-year",s),u.setAttribute("data-value",n),u.setAttribute("aria-label",D.escapeHTML`${r} ${e} ${s} ${i}`),u.setAttribute("aria-selected",c?"true":"false"),!0==l&&(u.disabled=!0),u.textContent=r,u})(i)),i=q(i,1);var l=ut(j,7),L=a.cloneNode(),o=(L.dataset.value=o,L.style.top=r.offsetHeight+"px",L.hidden=!1,L.innerHTML=D.escapeHTML` + <div tabindex="-1" class="${we}"> + <div class="${Ae}"> + <div class="${T} ${k}"> + <button + type="button" + class="${oe}" + aria-label="Navigate back one year" + ${c?'disabled="disabled"':""} + ></button> + </div> + <div class="${T} ${k}"> + <button + type="button" + class="${le}" + aria-label="Navigate back one month" + ${c?'disabled="disabled"':""} + ></button> + </div> + <div class="${T} ${xe}"> + <button + type="button" + class="${de}" aria-label="${x}. Select month" + >${x}</button> + <button + type="button" + class="${pe}" aria-label="${t}. Select year" + >${t}</button> + </div> + <div class="${T} ${k}"> + <button + type="button" + class="${ue}" + aria-label="Navigate forward one month" + ${u?'disabled="disabled"':""} + ></button> + </div> + <div class="${T} ${k}"> + <button + type="button" + class="${ce}" + aria-label="Navigate forward one year" + ${u?'disabled="disabled"':""} + ></button> + </div> + </div> + </div> + `,document.createElement("table")),c=(o.setAttribute("class",$),document.createElement("thead"));o.insertAdjacentElement("beforeend",c);let S=document.createElement("tr"),_=(c.insertAdjacentElement("beforeend",S),{Sunday:"S",Monday:"M",Tuesday:"T",Wednesday:"W",Thursday:"Th",Friday:"Fr",Saturday:"S"});Object.keys(_).forEach(e=>{var t=document.createElement("th");t.setAttribute("class",je),t.setAttribute("scope","col"),t.setAttribute("aria-label",e),t.textContent=_[e],S.insertAdjacentElement("beforeend",t)});u=dt(l);o.insertAdjacentElement("beforeend",u);L.querySelector(M).insertAdjacentElement("beforeend",o),a.parentNode.replaceChild(L,a),r.classList.add(K);c=[];return B(d,m)&&c.push("Selected date"),e?(c.push("You can navigate by day using left and right arrows","Weeks by using up and down arrows","Months by using page up and page down keys","Years by using shift plus page up and shift plus page down","Home and end keys navigate to the beginning and end of a week"),s.textContent=""):c.push(x+" "+t),s.textContent=c.join(". "),L},gt=e=>{var{datePickerEl:e,calendarEl:t,statusEl:r}=H(e);e.classList.remove(K),t.hidden=!0,r.textContent=""},wt=e=>{var{calendarEl:e,inputDate:t,minDate:r,maxDate:a}=H(e);!e.hidden&&t&&(t=c(t,r,a),u(e,t))},yt=(e,t)=>{let{calendarEl:r,statusEl:a,calendarDate:o,minDate:l,maxDate:c}=H(e),u=o.getMonth(),d=null==t?u:t;var e=Ye.map((e,t)=>{var r=b(o,t),r=ot(r,l,c);let a="-1";var s=[p],i=t===u,n=(t===d&&(a="0",s.push(be)),i&&s.push(fe),document.createElement("button"));return n.setAttribute("type","button"),n.setAttribute("tabindex",a),n.setAttribute("class",s.join(" ")),n.setAttribute("data-value",t),n.setAttribute("data-label",e),n.setAttribute("aria-selected",i?"true":"false"),!0===r&&(n.disabled=!0),n.textContent=e,n}),t=document.createElement("div"),s=(t.setAttribute("tabindex","-1"),t.setAttribute("class",ye),document.createElement("table")),e=(s.setAttribute("class",$),s.setAttribute("role","presentation"),ut(e,3)),e=dt(e),e=(s.insertAdjacentElement("beforeend",e),t.insertAdjacentElement("beforeend",s),r.cloneNode());return e.insertAdjacentElement("beforeend",t),r.parentNode.replaceChild(e,r),a.textContent="Select a month.",e},Et=(e,t)=>{var{calendarEl:e,statusEl:r,calendarDate:a,minDate:s,maxDate:i}=H(e),n=a.getFullYear(),o=null==t?n:t,t=o,l=(t-=t%j,t=Math.max(0,t),lt(L(a,t-1),s,i)),c=lt(L(a,t+j),s,i),u=[];let d=t;for(;u.length<j;){var p=lt(L(a,d),s,i);let e="-1";var b=[x],f=d===n,h=(d===o&&(e="0",b.push(he)),f&&b.push(me),document.createElement("button"));h.setAttribute("type","button"),h.setAttribute("tabindex",e),h.setAttribute("class",b.join(" ")),h.setAttribute("data-value",d),h.setAttribute("aria-selected",f?"true":"false"),!0===p&&(h.disabled=!0),h.textContent=d,u.push(h),d+=1}var m=e.cloneNode(),v=document.createElement("div"),g=(v.setAttribute("tabindex","-1"),v.setAttribute("class",Ee),document.createElement("table")),w=(g.setAttribute("class",$),document.createElement("tbody")),y=document.createElement("tr"),E=document.createElement("button"),l=(E.setAttribute("type","button"),E.setAttribute("class",ve),E.setAttribute("aria-label",`Navigate back ${j} years`),!0===l&&(E.disabled=!0),E.innerHTML=D.escapeHTML` `,document.createElement("button")),c=(l.setAttribute("type","button"),l.setAttribute("class",ge),l.setAttribute("aria-label",`Navigate forward ${j} years`),!0===c&&(l.disabled=!0),l.innerHTML=D.escapeHTML` `,document.createElement("table")),A=(c.setAttribute("class",$),c.setAttribute("role","presentation"),ut(u,3)),A=dt(A),A=(c.insertAdjacentElement("beforeend",A),document.createElement("td")),E=(A.insertAdjacentElement("beforeend",E),document.createElement("td")),c=(E.setAttribute("colspan","3"),E.insertAdjacentElement("beforeend",c),document.createElement("td"));return c.insertAdjacentElement("beforeend",l),y.insertAdjacentElement("beforeend",A),y.insertAdjacentElement("beforeend",E),y.insertAdjacentElement("beforeend",c),w.insertAdjacentElement("beforeend",y),g.insertAdjacentElement("beforeend",w),v.insertAdjacentElement("beforeend",g),m.insertAdjacentElement("beforeend",v),e.parentNode.replaceChild(m,e),r.textContent=D.escapeHTML`Showing years ${t} to ${t+j-1}. Select a year.`,m},At=e=>{var{datePickerEl:t,externalInputEl:r}=H(e.target);gt(t),r.focus(),e.preventDefault()};var n=n=>e=>{var{calendarEl:t,calendarDate:r,minDate:a,maxDate:s}=H(e.target),i=n(r),i=c(i,a,s);B(r,i)||u(t,i).querySelector(o).focus(),e.preventDefault()},xt=n(e=>{return e=e,t=1,Je(e,-t);var t}),jt=n(e=>Je(e,1)),Lt=n(e=>Ze(e,1)),St=n(e=>q(e,1)),_t=n(e=>Xe(e)),Dt=n(e=>{return t=(e=e).getDay(),q(e,6-t);var t}),Ct=n(e=>I(e,1)),$t=n(e=>et(e,1)),Tt=n(e=>tt(e,1)),n=n(e=>rt(e,1));var g=o=>e=>{var t=e.target,r=parseInt(t.dataset.value,10),{calendarEl:t,calendarDate:a,minDate:s,maxDate:i}=H(t),n=b(a,r),r=o(r),r=Math.max(0,Math.min(11,r)),a=b(a,r),r=c(a,s,i);N(n,r)||yt(t,r.getMonth()).querySelector(Re).focus(),e.preventDefault()},kt=g(e=>e-3),Mt=g(e=>e+3),qt=g(e=>e-1),It=g(e=>e+1),Nt=g(e=>e-e%3),Bt=g(e=>e+2-e%3),Ot=g(()=>11),g=g(()=>0),w=o=>e=>{var t=e.target,r=parseInt(t.dataset.value,10),{calendarEl:t,calendarDate:a,minDate:s,maxDate:i}=H(t),n=L(a,r),r=o(r),r=Math.max(0,r),a=L(a,r),r=c(a,s,i);it(n,r)||Et(t,r.getFullYear()).querySelector(l).focus(),e.preventDefault()},Ht=w(e=>e-3),Pt=w(e=>e+3),Rt=w(e=>e-1),Ft=w(e=>e+1),Yt=w(e=>e-e%3),Ut=w(e=>e+2-e%3),Vt=w(e=>e-j),w=w(e=>e+j),y=i=>{let s=e=>{var e=H(e).calendarEl,e=_(i,e),t=e.length-1,r=e[0],a=e[t],s=e.indexOf(F());return{focusableElements:e,isNotFound:-1===s,firstTabStop:r,isFirstTab:0===s,lastTabStop:a,isLastTab:s===t}};return{tabAhead(e){var{firstTabStop:t,isLastTab:r,isNotFound:a}=s(e.target);(r||a)&&(e.preventDefault(),t.focus())},tabBack(e){var{lastTabStop:t,isFirstTab:r,isNotFound:a}=s(e.target);(r||a)&&(e.preventDefault(),t.focus())}}},s=y(s),Ke=y(Ke),y=y(a),a={[R]:{[Le](){var e,t,r,a,s,i;(e=this).disabled||e.hasAttribute("aria-disabled")||({calendarEl:t,inputDate:i,minDate:r,maxDate:a,defaultDate:s}=H(e),t.hidden?(i=c(i||s||ze(),r,a),u(t,i).querySelector(o).focus()):gt(e))},[r](){var e,t,r;(e=this).disabled||({datePickerEl:t,externalInputEl:r}=H(e),vt(e,e.dataset.value),gt(t),r.focus())},[Ie](){var e,t,r,a,s;(e=this).disabled||({calendarEl:t,calendarDate:s,minDate:r,maxDate:a}=H(e),e=parseInt(e.dataset.value,10),s=b(s,e),s=c(s,r,a),u(t,s).querySelector(o).focus())},[Ne](){var e,t,r,a,s;(e=this).disabled||({calendarEl:t,calendarDate:s,minDate:r,maxDate:a}=H(e),e=parseInt(e.innerHTML,10),s=L(s,e),s=c(s,r,a),u(t,s).querySelector(o).focus())},[$e](){(t=>{if(!t.disabled){var{calendarEl:t,calendarDate:r,minDate:a,maxDate:s}=H(t),r=et(r,1),r=c(r,a,s),a=u(t,r);let e=a.querySelector($e);(e=e.disabled?a.querySelector(M):e).focus()}})(this)},[ke](){(t=>{if(!t.disabled){var{calendarEl:t,calendarDate:r,minDate:a,maxDate:s}=H(t),r=I(r,1),r=c(r,a,s),a=u(t,r);let e=a.querySelector(ke);(e=e.disabled?a.querySelector(M):e).focus()}})(this)},[Ce](){(t=>{if(!t.disabled){var{calendarEl:t,calendarDate:r,minDate:a,maxDate:s}=H(t),r=rt(r,1),r=c(r,a,s),a=u(t,r);let e=a.querySelector(Ce);(e=e.disabled?a.querySelector(M):e).focus()}})(this)},[Te](){(t=>{if(!t.disabled){var{calendarEl:t,calendarDate:r,minDate:a,maxDate:s}=H(t),r=tt(r,1),r=c(r,a,s),a=u(t,r);let e=a.querySelector(Te);(e=e.disabled?a.querySelector(M):e).focus()}})(this)},[Be](){(t=>{if(!t.disabled){var{calendarEl:t,calendarDate:r,minDate:a,maxDate:s}=H(t),i=t.querySelector(l),i=parseInt(i.textContent,10)-j,i=Math.max(0,i),r=L(r,i),i=c(r,a,s),r=Et(t,i.getFullYear());let e=r.querySelector(Be);(e=e.disabled?r.querySelector(Pe):e).focus()}})(this)},[Oe](){(t=>{if(!t.disabled){var{calendarEl:t,calendarDate:r,minDate:a,maxDate:s}=H(t),i=t.querySelector(l),i=parseInt(i.textContent,10)+j,i=Math.max(0,i),r=L(r,i),i=c(r,a,s),r=Et(t,i.getFullYear());let e=r.querySelector(Oe);(e=e.disabled?r.querySelector(Pe):e).focus()}})(this)},[qe](){yt(this).querySelector(Re).focus()},[Me](){Et(this).querySelector(l).focus()}},keyup:{[_e](e){var t=this.dataset.keydownKeyCode;""+e.keyCode!==t&&e.preventDefault()}},keydown:{[h](e){13===e.keyCode&&mt(this)},[r]:t({Up:xt,ArrowUp:xt,Down:jt,ArrowDown:jt,Left:Lt,ArrowLeft:Lt,Right:St,ArrowRight:St,Home:_t,End:Dt,PageDown:Ct,PageUp:$t,"Shift+PageDown":Tt,"Shift+PageUp":n,Tab:s.tabAhead}),[M]:t({Tab:s.tabAhead,"Shift+Tab":s.tabBack}),[Ie]:t({Up:kt,ArrowUp:kt,Down:Mt,ArrowDown:Mt,Left:qt,ArrowLeft:qt,Right:It,ArrowRight:It,Home:Nt,End:Bt,PageDown:Ot,PageUp:g}),[He]:t({Tab:Ke.tabAhead,"Shift+Tab":Ke.tabBack}),[Ne]:t({Up:Ht,ArrowUp:Ht,Down:Pt,ArrowDown:Pt,Left:Rt,ArrowLeft:Rt,Right:Ft,ArrowRight:Ft,Home:Yt,End:Ut,PageDown:w,PageUp:Vt}),[Pe]:t({Tab:y.tabAhead,"Shift+Tab":y.tabBack}),[_e](e){this.dataset.keydownKeyCode=e.keyCode},[f](e){t({Escape:At})(e)}},focusout:{[h](){mt(this)},[f](e){this.contains(e.relatedTarget)||gt(this)}},input:{[h](){(e=>{var{internalInputEl:t,inputDate:r}=H(e);let a="";r&&!ht(e)&&(a=O(r)),t.value!==a&&pt(t,a)})(this),wt(this)}}},R=(Y()||(a.mouseover={[e](){(e=>{if(!e.disabled){var t=v(e.dataset.value),{calendarEl:e,selectedDate:r,rangeDate:s}=H(e);if(!r){let{withinRangeStartDate:r,withinRangeEndDate:a}=ct(t,s);e.querySelectorAll("."+ee).forEach(e=>{var t=v(e.dataset.value);nt(t,r,a)?e.classList.add(ne):e.classList.remove(ne)})}}})(this)}}),S(a,{init(e){P(f,e).forEach(e=>{(e=>{var e=e.closest(f),t=e.dataset.defaultValue,r=e.querySelector("input");if(!r)throw new Error(f+" is missing inner input");r.value&&(r.value="");var a=v(e.dataset.minDate||r.getAttribute("min")),a=(e.dataset.minDate=a?O(a):"0000-01-01",v(e.dataset.maxDate||r.getAttribute("max"))),a=(a&&(e.dataset.maxDate=O(a)),document.createElement("div")),s=(a.classList.add(U),r.cloneNode());s.classList.add(z),s.type="text",a.appendChild(s),a.insertAdjacentHTML("beforeend",D.escapeHTML` + <button type="button" class="${Q}" aria-haspopup="true" aria-label="Toggle calendar"></button> + <div class="${i}" role="application" hidden></div> + <div class="usa-sr-only ${G}" role="status" aria-live="polite"></div>`),r.setAttribute("aria-hidden","true"),r.setAttribute("tabindex","-1"),r.style.display="none",r.classList.add(W),r.removeAttribute("id"),r.removeAttribute("name"),r.required=!1,e.appendChild(a),e.classList.add(V),t&&vt(e,t),r.disabled&&(bt(e),r.disabled=!1),r.hasAttribute("aria-disabled")&&(ft(e),r.removeAttribute("aria-disabled"))})(e)})},getDatePickerContext:H,disable:bt,ariaDisable:ft,enable:e=>{var{externalInputEl:e,toggleBtnEl:t}=H(e);t.disabled=!1,t.removeAttribute("aria-disabled"),e.disabled=!1,e.removeAttribute("aria-disabled"),e.removeAttribute("readonly")},isDateInputInvalid:ht,setCalendarValue:vt,validateDateInput:mt,renderCalendar:u,updateCalendarIfVisible:wt}));E.exports=R},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/events":36,"../../uswds-core/src/js/utils/active-element":39,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/is-ios-device":44,"../../uswds-core/src/js/utils/sanitizer":45,"../../uswds-core/src/js/utils/select":48,"../../uswds-core/src/js/utils/select-or-matches":47,"receptor/keymap":10}],20:[function(e,t,r){var a=e("../../uswds-core/src/js/utils/behavior");let s=e("../../uswds-core/src/js/utils/select"),i=e("../../uswds-core/src/js/utils/select-or-matches");var n=e("../../uswds-core/src/js/config").prefix;let{getDatePickerContext:o,isDateInputInvalid:l,updateCalendarIfVisible:c}=e("../../usa-date-picker/src/index");e=n+"-date-range-picker";let u=e+"__range-start",d=e+"__range-end",p="."+(n+"-date-picker"),b="."+e,f="."+u,h="."+d,m=e=>{var t,r,e=e.closest(b);if(e)return t=e.querySelector(f),r=e.querySelector(h),{dateRangePickerEl:e,rangeStartEl:t,rangeEndEl:r};throw new Error("Element is missing outer "+b)},v=e=>{var{dateRangePickerEl:e,rangeStartEl:t,rangeEndEl:r}=m(e),t=o(t).internalInputEl,a=t.value;a&&!l(t)?(r.dataset.minDate=a,r.dataset.rangeDate=a,r.dataset.defaultDate=a):(r.dataset.minDate=e.dataset.minDate||"",r.dataset.rangeDate="",r.dataset.defaultDate=""),c(r)},g=e=>{var{dateRangePickerEl:e,rangeStartEl:t,rangeEndEl:r}=m(e),r=o(r).internalInputEl,a=r.value;a&&!l(r)?(t.dataset.maxDate=a,t.dataset.rangeDate=a,t.dataset.defaultDate=a):(t.dataset.maxDate=e.dataset.maxDate||"",t.dataset.rangeDate="",t.dataset.defaultDate=""),c(t)};n=a({"input change":{[f](){v(this)},[h](){g(this)}}},{init(e){i(b,e).forEach(e=>{(e=>{var e=e.closest(b),[t,r]=s(p,e);if(!t)throw new Error(`${b} is missing inner two '${p}' elements`);if(!r)throw new Error(`${b} is missing second '${p}' element`);t.classList.add(u),r.classList.add(d),e.dataset.minDate||(e.dataset.minDate="0000-01-01");var a=e.dataset.minDate,a=(t.dataset.minDate=a,r.dataset.minDate=a,e.dataset).maxDate;a&&(t.dataset.maxDate=a,r.dataset.maxDate=a),v(e),g(e)})(e)})}});t.exports=n},{"../../usa-date-picker/src/index":19,"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/select":48,"../../uswds-core/src/js/utils/select-or-matches":47}],21:[function(e,t,n){let r=e("../../uswds-core/src/js/utils/select-or-matches");var a=e("../../uswds-core/src/js/utils/behavior");let l=e("../../uswds-core/src/js/utils/sanitizer");e=e("../../uswds-core/src/js/config").prefix;let c=e+"-file-input",u="."+c,d=e+"-file-input__input",p=e+"-file-input__target",s="."+d,b=e+"-file-input__box",f=e+"-file-input__instructions",h=e+"-file-input__preview",o=e+"-file-input__preview-heading",m=e+"-file-input--disabled",v=e+"-file-input__choose",g=e+"-file-input__accepted-files-message",w=e+"-file-input__drag-text",i=e+"-file-input--drag",y="is-loading",E="has-invalid-file",A=e+"-file-input__preview-image",x=A+"--generic",j=A+"--pdf",L=A+"--word",S=A+"--video",_=A+"--excel",D=e+"-sr-only",C="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7",B="Error: This is not a valid file type.",$=Boolean(!0),T="",k="",M=e=>{var t,e=e.closest(u);if(e)return t=e.querySelector(s),{dropZoneEl:e,inputEl:t};throw new Error("Element is missing outer "+u)};let O=e=>{var t=e.charCodeAt(0);return 32===t?"-":65<=t&&t<=90?"img_"+e.toLowerCase():"__"+t.toString(16).slice(-4)},H=e=>e.replace(/[^a-z0-9]/g,O),P=e=>e+"-"+Math.floor(Date.now().toString()/1e3),q=e=>e.hasAttribute("multiple")?"files":"file",R=e=>{var t,r,a,s=e.hasAttribute("aria-disabled")||e.hasAttribute("disabled"),i=(t=e,r=document.createElement("div"),n=document.createElement("div"),i=document.createElement("div"),t.classList.remove(c),t.classList.add(d),r.classList.add(c),i.classList.add(b),n.classList.add(p),n.prepend(i),t.parentNode.insertBefore(n,t),t.parentNode.insertBefore(r,n),n.appendChild(t),r.appendChild(n),n),n=(r=(t=e).closest(u),n=q(t),a=document.createElement("div"),n=`Drag ${n} here or`,o="choose from folder",T=n+" "+o,a.classList.add(f),a.setAttribute("aria-hidden","true"),t.setAttribute("aria-label",T),a.innerHTML=l.escapeHTML`<span class="${w}">${n}</span> <span class="${v}">${o}</span>`,t.parentNode.insertBefore(a,t),(/rv:11.0/i.test(navigator.userAgent)||/Edge\/\d./i.test(navigator.userAgent))&&(r.querySelector("."+w).outerHTML=""),a),o=M(e).dropZoneEl;return s?o.classList.add(m):(t=e,r=document.createElement("div"),a=q(t),s=t.closest(u),t=t.closest("."+p),k=`No ${a} selected.`,r.classList.add(D),r.setAttribute("aria-live","polite"),r.textContent=k,s.insertBefore(r,t)),{instructions:n,dropTarget:i}},I=(e,t)=>{var r=e.querySelectorAll("."+h),a=e.querySelector("."+o),s=e.querySelector("."+g);a&&(a.outerHTML=""),s&&(s.outerHTML="",e.classList.remove(E)),null!==r&&(t&&t.removeAttribute("hidden"),Array.prototype.forEach.call(r,e=>{e.parentNode.removeChild(e)}))},F=(e,t,r)=>{let a=e,s=k;1===t.length?s="You have selected the file: "+r:1<t.length&&(s=`You have selected ${t.length} files: `+r.join(", ")),setTimeout(()=>{a.textContent=s},1e3)},Y=(e,t)=>{var r=document.createElement("div"),a=e.closest("."+p),s=a.querySelector("."+f);let i="Change file",n="";1===t.length?n=l.escapeHTML`Selected file <span class="usa-file-input__choose">${i}</span>`:1<t.length&&(i="Change files",n=l.escapeHTML`${t.length} files selected <span class="usa-file-input__choose">${i}</span>`),s.setAttribute("hidden","true"),r.classList.add(o),r.innerHTML=n,a.insertBefore(r,s),e.setAttribute("aria-label",i)},N=(t,r)=>{t.addEventListener("error",()=>{var e=t;e.src=C,e.classList.add(r)},{once:!0})},U=(e,t,r,a)=>{((e,r,a,s)=>{var i=r.getAttribute("accept");s.classList.remove(E);if(i){var n=i.split(","),i=document.createElement("div"),o=r.dataset.errormessage||B;i.setAttribute("aria-hidden",!0);let t=!0;var l=e.target.files||e.dataTransfer.files;for(let e=0;e<l.length;e+=1){var c=l[e];if(!t)break;for(let e=0;e<n.length;e+=1){var u=n[e];if(t=0<c.name.indexOf(u)||((e,t)=>{let r=!1;e=e.indexOf(t);return r=0<=e?!0:r})(c.type,u.replace(/\*/g,""))){$=!0;break}}}t||(I(s,a),r.value="",i.textContent=o,s.insertBefore(i,r),a=o+" "+T,r.setAttribute("aria-label",a),i.classList.add(g),s.classList.add(E),$=!1,e.preventDefault(),e.stopPropagation())}})(e,t,r,a),!0===$&&((e,t,i,r)=>{var n=e.target.files,e=r.closest("."+c).querySelector("."+D),o=[];I(r,i);for(let e=0;e<n.length;e+=1){let r=new FileReader,a=n[e].name,s;o.push(a),r.onloadstart=function(){s=P(H(a)),i.insertAdjacentHTML("afterend",l.escapeHTML`<div class="${h}" aria-hidden="true"> + <img id="${s}" src="${C}" alt="" class="${A} ${y}"/>${a} + <div>`)},r.onloadend=function(){var e=document.getElementById(s),t=a.split(".").pop();"pdf"===t?N(e,j):"doc"===t||"docx"===t||"pages"===t?N(e,L):"xls"===t||"xlsx"===t||"numbers"===t?N(e,_):"mov"===t||"mp4"===t?N(e,S):N(e,x),e.classList.remove(y),e.src=r.result},n[e]&&r.readAsDataURL(n[e])}0===n.length?t.setAttribute("aria-label",T):Y(t,n),F(e,n,o)})(e,t,r,a)};e=a({},{init(e){r(u,e).forEach(t=>{let{instructions:r,dropTarget:a}=R(t);a.addEventListener("dragover",function(){this.classList.add(i)},!1),a.addEventListener("dragleave",function(){this.classList.remove(i)},!1),a.addEventListener("drop",function(){this.classList.remove(i)},!1),t.addEventListener("change",e=>U(e,t,r,a),!1)})},teardown(e){r(s,e).forEach(e=>{var t=e.parentElement.parentElement;t.parentElement.replaceChild(e,t),e.className=c})},getFileInputContext:M,disable:e=>{var{dropZoneEl:e,inputEl:t}=M(e);t.disabled=!0,e.classList.add(m)},ariaDisable:e=>{e=M(e).dropZoneEl;e.classList.add(m)},enable:e=>{var{dropZoneEl:e,inputEl:t}=M(e);t.disabled=!1,e.classList.remove(m),e.removeAttribute("aria-disabled")}});t.exports=e},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/sanitizer":45,"../../uswds-core/src/js/utils/select-or-matches":47}],22:[function(e,t,r){var a=e("../../uswds-core/src/js/utils/behavior"),s=e("../../uswds-core/src/js/events").CLICK;let i=e("../../uswds-core/src/js/config").prefix,n=`.${i}-footer--big`,o=n+" nav"+` .${i}-footer__primary-link`;function l(a){var e=document.querySelector(n);e&&e.querySelectorAll(o).forEach(e=>{var t=e.getAttribute("class"),r=e.getAttribute("data-tag")||e.tagName,r=document.createElement(a?"button":r);r.setAttribute("class",t),r.classList.toggle(i+"-footer__primary-link--button",a),r.textContent=e.textContent,a&&(r.setAttribute("data-tag",e.tagName),t=i+"-footer-menu-list-"+Math.floor(1e5*Math.random()),r.setAttribute("aria-controls",t),r.setAttribute("aria-expanded","false"),e.nextElementSibling.setAttribute("id",t),r.setAttribute("type","button")),e.after(r),e.remove()})}let c=e=>{l(e.matches)};t.exports=a({[s]:{[o]:function(){var e;window.innerWidth<480&&(e="true"===this.getAttribute("aria-expanded"),this.closest(n).querySelectorAll(o).forEach(e=>{e.setAttribute("aria-expanded",!1)}),this.setAttribute("aria-expanded",!e))}}},{HIDE_MAX_WIDTH:480,init(){l(window.innerWidth<480),this.mediaQueryList=window.matchMedia("(max-width: 479.9px)"),this.mediaQueryList.addListener(c)},teardown(){this.mediaQueryList.removeListener(c)}})},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/events":36,"../../uswds-core/src/js/utils/behavior":40}],23:[function(e,t,N){var r=e("receptor/keymap"),a=e("../../uswds-core/src/js/utils/behavior");let s=e("../../uswds-core/src/js/utils/select"),i=e("../../uswds-core/src/js/utils/toggle"),n=e("../../uswds-core/src/js/utils/focus-trap"),o=e("../../usa-accordion/src/index");var l=e("../../uswds-core/src/js/utils/scrollbar-width"),c=e("../../uswds-core/src/js/events").CLICK,e=e("../../uswds-core/src/js/config").prefix;let u=`.${e}-header`,d=`.${e}-nav`;var p=`.${e}-nav-container`;let b=`.${e}-nav__primary`,f=`.${e}-nav__primary-item`,h=`button.${e}-nav__link`;var m=d+" a";let v="data-nav-hidden",g=`.${e}-menu-btn`,w=`.${e}-nav__close`;var y=w+`, .${e}-overlay`;let E=[d,`.${e}-overlay`].join(", "),A=`body *:not(${u}, ${p}, ${d}, ${d} *):not([aria-hidden])`,x=`[${v}]`,j="usa-js-mobile-nav--active",L,S,_,D=()=>document.body.classList.contains(j),C=navigator.userAgent.includes("Safari")&&!navigator.userAgent.includes("Chrome");e=l();let $=window.getComputedStyle(document.body).getPropertyValue("padding-right"),T=parseInt($.replace(/px/,""),10)+parseInt(e.replace(/px/,""),10)+"px",k=()=>{let t=document.querySelector(""+u).parentNode;(_=document.querySelectorAll(A)).forEach(e=>{e!==t&&(e.setAttribute("aria-hidden",!0),e.setAttribute(v,""))})},M=()=>{(_=document.querySelectorAll(x))&&_.forEach(e=>{e.removeAttribute("aria-hidden"),e.removeAttribute(v)})};p=e=>{var t=document.body;let r="boolean"==typeof e?e:!D();e=t,a=`-${window.scrollY}px`,C&&e.style.setProperty("--scrolltop",a),t.classList.toggle(j,r),s(E).forEach(e=>e.classList.toggle("is-visible",r)),L.focusTrap.update(r);var e=t.querySelector(w),a=document.querySelector(g);return t.style.paddingRight=t.style.paddingRight===T?$:T,(r?k:M)(),r&&e?e.focus():!r&&a&&"none"!==getComputedStyle(a).display&&a.focus(),r};let q=()=>{var e=document.body.querySelector(w);D()&&e&&0===e.getBoundingClientRect().width&&L.toggleNav.call(e,!1)},B=()=>L.toggleNav.call(L,!1),I=()=>{S&&(i(S,!1),S=null)};L=a({[c]:{[h](){return S!==this&&I(),S||(S=this,i(S,!0)),!1},body:I,[g]:p,[y]:p,[m](){var e=this.closest(o.ACCORDION);e&&o.getButtons(e).forEach(e=>o.hide(e)),D()&&L.toggleNav.call(L,!1)}},keydown:{[b]:r({Escape:e=>{var t;I(),t=(e=e).target.closest(f),e.target.matches(h)||(e=t.querySelector(h))&&e.focus()}})},focusout:{[b](e){e.target.closest(b).contains(e.relatedTarget)||I()}}},{init(e){e=e.matches(d)?e:e.querySelector(d);e&&(L.focusTrap=n(e,{Escape:B})),C&&document.body.classList.add("is-safari"),q(),window.addEventListener("resize",q,!1)},teardown(){window.removeEventListener("resize",q,!1),S=!1},focusTrap:null,toggleNav:p}),t.exports=L},{"../../usa-accordion/src/index":14,"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/events":36,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/focus-trap":42,"../../uswds-core/src/js/utils/scrollbar-width":46,"../../uswds-core/src/js/utils/select":48,"../../uswds-core/src/js/utils/toggle":51,"receptor/keymap":10}],24:[function(e,t,r){let a=e("receptor/once");var s=e("receptor/keymap");let i=e("../../uswds-core/src/js/utils/select-or-matches");var n=e("../../uswds-core/src/js/utils/behavior"),o=e("../../uswds-core/src/js/config").prefix,l=e("../../uswds-core/src/js/events").CLICK;let u=e("../../uswds-core/src/js/utils/sanitizer"),c=o+"-current",d=["h1","h2","h3","h4","h5","h6"],p=0,b=o+"-in-page-nav",f=o+"-anchor",h=b+"__nav",m=b+"__list",v=b+"__item",g=v+"--primary",w=b+"__link",y=b+"__heading",E=e=>{let t=document.querySelectorAll("."+w);e.map(e=>!0===e.isIntersecting&&1<=e.intersectionRatio&&(t.forEach(e=>e.classList.remove(c)),document.querySelector(`a[href="#${e.target.id}"]`).classList.add(c),!0))},A=(e,t)=>{t=t.indexOf(" ")?t.split(" "):t,e=document.querySelector(e),t.forEach(e=>{if(!d.includes(e))throw new Error(`In-page navigation: data-heading-elements attribute defined with an invalid heading type: "${e}". + Define the attribute with one or more of the following: "${d}". + Do not use commas or other punctuation in the attribute definition.`)}),e=Array.from(e.querySelectorAll(t));return e},x=e=>{var t=document.querySelector("."+b).dataset.scrollOffset||p;window.scroll({behavior:"smooth",top:e.offsetTop-t,block:"start"}),window.location.hash.slice(1)!==e.id&&window.history.pushState(null,"","#"+e.id)},j=e=>{var t=u.escapeHTML`${e.dataset.titleText||"On this page"}`,r=u.escapeHTML`${e.dataset.titleHeadingLevel||"h4"}`,a=u.escapeHTML`${e.dataset.rootMargin||"0px 0px 0px 0px"}`,s=u.escapeHTML`${e.dataset.threshold||"1"}`,i=u.escapeHTML`${e.dataset.mainContentSelector||"main"}`,n=u.escapeHTML`${e.dataset.headingElements||"h2 h3"}`,a={root:null,rootMargin:a,threshold:[s]};s=i,i=n;let l=A(s,i).filter(e=>{e=window.getComputedStyle(e);return"none"!==e.getPropertyValue("display")&&"hidden"!==e.getPropertyValue("visibility")});n=document.createElement("nav"),n.setAttribute("aria-label",t),n.classList.add(h),s=document.createElement(r);s.classList.add(y),s.setAttribute("tabindex","0"),s.textContent=t,n.appendChild(s);let c=document.createElement("ul");c.classList.add(m),n.appendChild(c),l.forEach(e=>{var t=document.createElement("li"),r=document.createElement("a"),a=document.createElement("a"),s=e.textContent,i=e.tagName.toLowerCase(),n=l[0].tagName.toLowerCase(),o=(e=>{var t=e.textContent.toLowerCase().replace(/[^a-z\d]/g,"-").replace(/-{2,}/g,"-").replace(/^-|-$/g,"");let r,a=0;for(;r=t,1<(a+=1)&&(r+="-"+a),document.getElementById(r););return r})(e);t.classList.add(v),i===n&&t.classList.add(g),r.setAttribute("href","#"+o),r.setAttribute("class",w),r.textContent=s,a.setAttribute("id",o),a.setAttribute("class",f),e.insertAdjacentElement("afterbegin",a),c.appendChild(t),t.appendChild(r)}),e.appendChild(n);i=document.querySelectorAll("."+f);let o=new window.IntersectionObserver(E,a);i.forEach(e=>{o.observe(e)})};e=n({[l]:{["."+w](e){e.preventDefault(),this.disabled||(e=>{e=document.getElementById(e.hash.slice(1));x(e)})(this)}},keydown:{["."+w]:s({Enter:e=>{e=(e=>{let t;return t=(e&&1===e.nodeType?e.getAttribute("href"):e.target.hash).replace("#","")})(e),e=document.getElementById(e);let t=e.parentElement;t&&(t.setAttribute("tabindex",0),t.focus(),t.addEventListener("blur",a(()=>{t.setAttribute("tabindex",-1)}))),x(e)}})}},{init(e){i("."+b,e).forEach(e=>{j(e),(e=window.location.hash.slice(1))&&(e=document.getElementById(e))&&x(e)})}});t.exports=e},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/events":36,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/sanitizer":45,"../../uswds-core/src/js/utils/select-or-matches":47,"receptor/keymap":10,"receptor/once":11}],25:[function(e,t,r){let a=e("../../uswds-core/src/js/utils/select-or-matches");var s=e("../../uswds-core/src/js/utils/behavior"),e=e("../../uswds-core/src/js/config").prefix;let i="."+(e+"-masked"),n=e+"-input-mask",o=n+"--content",l="placeholder",p="_#dDmMyY9",b="A",f=(e,t)=>e?t.replace(/\W/g,""):t.replace(/\D/g,""),h=e=>!Number.isNaN(parseInt(e,10)),m=e=>!!e&&e.match(/[A-Z]/i),c=e=>{var t=e,r=t.getAttribute("id"),a=(t.value=(e=>{var t=e.dataset.charset,r=t||e.dataset.placeholder,e=e.value,a=r.length;let s="",i,n;var o=f(t,e);for(i=0,n=0;i<a;i+=1){var l=h(o[n]),c=m(o[n]),u=0<=p.indexOf(r[i]),d=0<=b.indexOf(r[i]);if(u&&l||t&&d&&c)s+=o[n],n+=1;else{if(!t&&!l&&u||t&&(d&&!c||u&&!l))return s;s+=r[i]}if(void 0===o[n])break}return s})(t),a=(t=e).value,t=""+e.dataset.placeholder.substr(a.length),(e=document.createElement("i")).textContent=a,[e,t]),e=document.getElementById(r+"Mask");e.textContent="",e.replaceChildren(a[0],a[1])};e=s({keyup:{[i](){c(this)}}},{init(e){a(i,e).forEach(e=>{var t,r,a;(a=(e=e).getAttribute(l))&&(e.setAttribute("maxlength",a.length),e.setAttribute("data-placeholder",a),e.removeAttribute(l),(t=document.createElement("span")).classList.add(n),t.setAttribute("data-mask",a),(r=document.createElement("span")).classList.add(o),r.setAttribute("aria-hidden","true"),r.id=e.id+"Mask",r.textContent=a,t.appendChild(r),e.parentNode.insertBefore(t,e),t.appendChild(e))})}});t.exports=e},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/select-or-matches":47}],26:[function(e,t,r){var a=e("receptor/keymap"),s=e("../../uswds-core/src/js/utils/behavior");let i=e("../../uswds-core/src/js/utils/toggle"),n=e("../../uswds-core/src/js/utils/focus-trap"),o=e("../../usa-accordion/src/index");var l=e("../../uswds-core/src/js/events").CLICK,e=e("../../uswds-core/src/js/config").prefix;let c=`.${e}-language__submenu`,u=`.${e}-language__primary`,d=`.${e}-language__primary-item`,p=`button.${e}-language__link`,b,f,h=()=>b.toggleLanguage.call(b,!1),m=()=>{f&&(i(f,!1),f=null)};b=s({[l]:{[p](){return f!==this&&m(),f===this?m():f||(f=this,i(f,!0)),!1},body:m,[`.${e}-language`+" a"](){var e=this.closest(o.ACCORDION);e&&o.getButtons(e).forEach(e=>o.hide(e))}},keydown:{[u]:a({Escape:e=>{var t;m(),t=(e=e).target.closest(d),e.target.matches(p)||t.querySelector(p).focus()}})},focusout:{[u](e){e.target.closest(u).contains(e.relatedTarget)||m()}}},{init(e){e=e.matches(c)?e:e.querySelector(c);e&&(b.focusTrap=n(e,{Escape:h}))},teardown(){f=!1},focusTrap:null}),t.exports=b},{"../../usa-accordion/src/index":14,"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/events":36,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/focus-trap":42,"../../uswds-core/src/js/utils/toggle":51,"receptor/keymap":10}],27:[function(e,t,r){let a=e("../../uswds-core/src/js/utils/select-or-matches"),u=e("../../uswds-core/src/js/utils/focus-trap");var s=e("../../uswds-core/src/js/utils/scrollbar-width"),i=e("../../uswds-core/src/js/utils/behavior"),e=e("../../uswds-core/src/js/config").prefix;let d=e+"-modal",n=d+"-overlay",p=d+"-wrapper",b="data-open-modal",f="data-close-modal",h="data-force-action",m="data-modal-hidden",o="."+d,v=`.${p} *[data-focus]`,g=`${p} *[${f}]`,l=(b,g+`, .${n}:not([${h}])`),w=`body > *:not(.${p}):not([aria-hidden])`,y=(m,"usa-js-modal--active"),E="is-visible",A="is-hidden",x,c,j,L=s(),S=()=>{x.toggleModal.call(x,!1)},_=()=>{c=window.getComputedStyle(document.body).getPropertyValue("padding-right"),j=parseInt(c.replace(/px/,""),10)+parseInt(L.replace(/px/,""),10)+"px"};function D(e){let t,r=e.target;var a,s,i,n,o=document.body,l=!document.body.classList.contains(y),c=r?r.getAttribute("aria-controls"):document.querySelector(`.${p}.`+E),c=l?document.getElementById(c):document.querySelector(`.${p}.`+E);return!(!c||(a=c.querySelector(v)?c.querySelector(v):c.querySelector("."+d),s=document.getElementById(c.getAttribute("data-opener")),i=o.querySelector("*[data-open-modal][aria-controls]"),n=c.getAttribute(h),(r="keydown"===e.type&&null!==c?c.querySelector(g):r)&&(r.hasAttribute(b)&&(null===this.getAttribute("id")?(t="modal-"+(Math.floor(9e5*Math.random())+1e5),this.setAttribute("id",t)):t=this.getAttribute("id"),c.setAttribute("data-opener",t)),r.closest("."+d))&&!r.hasAttribute(f)&&!r.closest(`[${f}]`)))&&(o.classList.toggle(y,l),c.classList.toggle(E,l),c.classList.toggle(A,!l),n&&o.classList.toggle("usa-js-no-click",l),o.style.paddingRight===j?o.style.removeProperty("padding-right"):o.style.paddingRight=j,l&&a?(x.focusTrap=n?u(c):u(c,{Escape:S}),x.focusTrap.update(l),a.focus(),document.querySelectorAll(w).forEach(e=>{e.setAttribute("aria-hidden","true"),e.setAttribute(m,"")})):!l&&i&&s&&(document.querySelectorAll("[data-modal-hidden]").forEach(e=>{e.removeAttribute("aria-hidden"),e.removeAttribute(m)}),s.focus(),x.focusTrap.update(l)),l)}let C=(e,t)=>{let r=e.getAttribute("id");var a=e.getAttribute("aria-labelledby"),s=e.getAttribute("aria-describedby"),i=e.hasAttribute(h);if(!a)throw new Error(r+" is missing aria-labelledby attribute");if(s)return t.setAttribute("role","dialog"),t.setAttribute("id",r),t.setAttribute("aria-labelledby",a),t.setAttribute("aria-describedby",s),i&&t.setAttribute(h,i),t.querySelectorAll(l).forEach(e=>{e.setAttribute("aria-controls",r)}),e.removeAttribute("id"),e.removeAttribute("aria-labelledby"),e.removeAttribute("aria-describedby"),e.setAttribute("tabindex","-1"),t;throw new Error(r+" is missing aria-desribedby attribute")},$=e=>{if(!e.getAttribute("id"))throw new Error("Modal markup is missing ID");var t=(e=>{var t=e.getAttribute("id");let r=document.createElement("div");e=Array.from(e.attributes);return _(),r.setAttribute("data-placeholder-for",t),r.style.display="none",r.setAttribute("aria-hidden","true"),e.forEach(e=>{r.setAttribute("data-original-"+e.name,e.value)}),r})(e),r=(e.after(t),t=e,e=document.createElement("div"),r=document.createElement("div"),e.classList.add(A,p),r.classList.add(n),e.append(r),r.append(t),C(t,e),e);document.body.appendChild(r)};x=i({},{init(e){a(o,e).forEach(e=>{var t=e.id;$(e),a(`[aria-controls="${t}"]`,document).forEach(e=>{"A"===e.nodeName&&(e.setAttribute("role","button"),e.addEventListener("click",e=>e.preventDefault())),e.addEventListener("click",D)})})},teardown(e){a(o,e).forEach(e=>{var t=e.id;(e=>{let t=e;var e=t.parentElement.parentElement,r=e.getAttribute("id");r&&((r=document.querySelector(`[data-placeholder-for="${r}"]`))&&(Array.from(r.attributes).forEach(e=>{e.name.startsWith("data-original-")&&t.setAttribute(e.name.substr(14),e.value)}),r.after(t),r.parentElement.removeChild(r)),e.parentElement.removeChild(e))})(e),a(`[aria-controls="${t}"]`,document).forEach(e=>e.removeEventListener("click",D))})},focusTrap:null,toggleModal:D}),t.exports=x},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/focus-trap":42,"../../uswds-core/src/js/utils/scrollbar-width":46,"../../uswds-core/src/js/utils/select-or-matches":47}],28:[function(e,t,r){let a=e("../../uswds-core/src/js/utils/select-or-matches");var s=e("../../uswds-core/src/js/utils/behavior"),e=e("../../uswds-core/src/js/config").prefix;let i="."+(e+"-range"),n=e=>{var t=e.dataset.textPreposition||"of",r=e.dataset.textUnit,a=e.value,s=e.getAttribute("max")||100;let i;i=r?a+` ${r} ${t} `+s:a+` ${t} `+s,e.setAttribute("aria-valuetext",i)};e=s({change:{[i](){n(this)}}},{init(e){a(i,e).forEach(e=>{n(e)})},updateCallout:n});t.exports=e},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/select-or-matches":47}],29:[function(e,t,r){let a=e("receptor/ignore");var s=e("../../uswds-core/src/js/utils/behavior");let i=e("../../uswds-core/src/js/utils/select"),n=e("../../uswds-core/src/js/events").CLICK,o=".js-search-button",l=".js-search-form",c="[type=search]",u="header",d,p=e=>{e=e.closest(u);return(e||document).querySelector(l)},b=(t,e)=>{var r=p(t);if(!r)throw new Error(`No ${l} found for search toggle in ${u}!`);if(t.hidden=e,r.hidden=!e,e){t=r.querySelector(c);t&&t.focus();let e=a(r,()=>{d&&!function(){b(this,!1),d=void 0}.call(d),document.body.removeEventListener(n,e)});setTimeout(()=>{document.body.addEventListener(n,e)},0)}};e=s({[n]:{".js-search-button":function(){b(this,!0),d=this}}},{init(e){i(o,e).forEach(e=>{b(e,!1)})},teardown(){d=void 0}});t.exports=e},{"../../uswds-core/src/js/events":36,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/select":48,"receptor/ignore":8}],30:[function(e,t,r){let a=e("receptor/once");var s=e("../../uswds-core/src/js/utils/behavior"),i=e("../../uswds-core/src/js/events").CLICK,e=e("../../uswds-core/src/js/config").prefix;t.exports=s({[i]:{[`.${e}-skipnav[href^="#"], .${e}-footer__return-to-top [href^="#"]`]:function(){var e=encodeURI(this.getAttribute("href"));let t=document.getElementById("#"===e?"main-content":e.slice(1));t&&(t.style.outline="0",t.setAttribute("tabindex",0),t.focus(),t.addEventListener("blur",a(()=>{t.setAttribute("tabindex",-1)})))}}})},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/events":36,"../../uswds-core/src/js/utils/behavior":40,"receptor/once":11}],31:[function(e,t,r){let i=e("../../uswds-core/src/js/utils/select");var a=e("../../uswds-core/src/js/utils/behavior"),s=e("../../uswds-core/src/js/events").CLICK;let n=e("../../uswds-core/src/js/config").prefix,o=e("../../uswds-core/src/js/utils/sanitizer"),l=`.${n}-table`,c="aria-sort",u="ascending",d="descending",p="data-sort-value",b=n+"-table__header__button",f="."+b,h="th[data-sortable]",m=`.${n}-table__announcement-region[aria-live="polite"]`,v=(e,t)=>e.children[t].getAttribute(p)||e.children[t].innerText||e.children[t].textContent,g=(a,s)=>(e,t)=>{var r=v(s?e:t,a),t=v(s?t:e,a);return r&&t&&!Number.isNaN(Number(r))&&!Number.isNaN(Number(t))?r-t:r.toString().localeCompare(t,navigator.language,{numeric:!0,ignorePunctuation:!0})},w=e=>{var t=e.innerText,r=e.getAttribute(c)===u,a=t+", sortable column, currently "+(e.getAttribute(c)===u||e.getAttribute(c)===d||!1?r?"sorted "+u:"sorted "+d:"unsorted"),t=`Click to sort by ${t} in ${r?d:u} order.`;e.setAttribute("aria-label",a),e.querySelector(f).setAttribute("title",t)},y=(t,e)=>{var r,a=t.closest(l);let s=e;if("boolean"!=typeof s&&(s=t.getAttribute(c)===u),!a)throw new Error(h+" is missing outer "+l);(s=((e,t)=>{e.setAttribute(c,!0===t?d:u),w(e);let r=e.closest(l).querySelector("tbody");var a=[].slice.call(r.querySelectorAll("tr"));let s=[].slice.call(e.parentNode.children).indexOf(e);return a.sort(g(s,!t)).forEach(e=>{[].slice.call(e.children).forEach(e=>e.removeAttribute("data-sort-active")),e.children[s].setAttribute("data-sort-active",!0),r.appendChild(e)}),!0})(t,e))&&(r=a,i(h,r).filter(e=>e.closest(l)===r).forEach(e=>{e!==t&&((e=e).removeAttribute(c),w(e))}),((e,t)=>{var r=e.querySelector("caption").innerText,a=t.getAttribute(c)===u,t=t.innerText,e=e.nextElementSibling;if(!e||!e.matches(m))throw new Error("Table containing a sortable column header is not followed by an aria-live region.");r=`The table named "${r}" is now sorted by ${t} in ${a?u:d} order.`;e.innerText=r})(a,t))};e=a({[s]:{[f](e){e.preventDefault(),y(e.target.closest(h),e.target.closest(h).getAttribute(c)===u)}}},{init(e){var t,e=i(h,e),e=(e.forEach(e=>{return e=e,(t=document.createElement("button")).setAttribute("tabindex","0"),t.classList.add(b),t.innerHTML=o.escapeHTML` + <svg class="${n}-icon" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"> + <g class="descending" fill="transparent"> + <path d="M17 17L15.59 15.59L12.9999 18.17V2H10.9999V18.17L8.41 15.58L7 17L11.9999 22L17 17Z" /> + </g> + <g class="ascending" fill="transparent"> + <path transform="rotate(180, 12, 12)" d="M17 17L15.59 15.59L12.9999 18.17V2H10.9999V18.17L8.41 15.58L7 17L11.9999 22L17 17Z" /> + </g> + <g class="unsorted" fill="transparent"> + <polygon points="15.17 15 13 17.17 13 6.83 15.17 9 16.58 7.59 12 3 7.41 7.59 8.83 9 11 6.83 11 17.17 8.83 15 7.42 16.41 12 21 16.59 16.41 15.17 15"/> + </g> + </svg> + `,e.appendChild(t),void w(e);var t}),e.filter(e=>e.getAttribute(c)===u||e.getAttribute(c)===d)[0]);void 0!==e&&((t=e.getAttribute(c))===u?y(e,!0):t===d&&y(e,!1))},TABLE:l,SORTABLE_HEADER:h,SORT_BUTTON:f});t.exports=e},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/events":36,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/sanitizer":45,"../../uswds-core/src/js/utils/select":48}],32:[function(e,t,r){var a=e("../../uswds-core/src/js/utils/behavior");let s=e("../../uswds-core/src/js/utils/select-or-matches");var i=e("../../uswds-core/src/js/config").prefix;let{COMBO_BOX_CLASS:f,enhanceComboBox:n}=e("../../usa-combo-box/src/index"),h="."+(i+"-time-picker"),m={filter:"0?{{ hourQueryFilter }}:{{minuteQueryFilter}}.*{{ apQueryFilter }}m?",apQueryFilter:"([ap])",hourQueryFilter:"([1-9][0-2]?)",minuteQueryFilter:"[\\d]+:([0-9]{0,2})"},v=e=>{let t;var r;return t=e&&([e,r]=e.split(":").map(e=>{let t;e=parseInt(e,10);return t=Number.isNaN(e)?t:e}),null!=e)&&null!=r?60*e+r:t},o=t=>{let r=t.closest(h),a=r.querySelector("input");if(!a)throw new Error(h+" is missing inner input");let s=document.createElement("select");["id","name","required","aria-label","aria-labelledby","disabled","aria-disabled"].forEach(e=>{var t;a.hasAttribute(e)&&(t=a.getAttribute(e),s.setAttribute(e,t),a.removeAttribute(e))});var i=(e,t)=>("0000"+e).slice(-t),t=Math.max(0,v(r.dataset.minTime)||0),n=Math.min(1439,v(r.dataset.maxTime)||1439),o=Math.floor(Math.max(1,r.dataset.step||30));let l;for(let e=t;e<=n;e+=o){u=e,c=void 0,c=u%60,u=Math.floor(u/60);var{minute:c,hour24:u,hour12:d,ampm:p}={minute:c,hour24:u,hour12:u%12||12,ampm:u<12?"am":"pm"},b=document.createElement("option");b.value=i(u,2)+":"+i(c,2),b.text=d+":"+i(c,2)+p,b.text===a.value&&(l=b.value),s.appendChild(b)}r.classList.add(f),Object.keys(m).forEach(e=>{r.dataset[e]=m[e]}),r.dataset.disableFiltering="true",r.dataset.defaultValue=l,r.appendChild(s),a.remove()};e=a({},{init(e){s(h,e).forEach(e=>{o(e),n(e)})},FILTER_DATASET:m});t.exports=e},{"../../usa-combo-box/src/index":18,"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/select-or-matches":47}],33:[function(e,t,r){var a=e("receptor/keymap");let s=e("../../uswds-core/src/js/utils/select-or-matches");var i=e("../../uswds-core/src/js/utils/behavior"),n=e("../../uswds-core/src/js/config").prefix;let b=e("../../uswds-core/src/js/utils/is-in-viewport");let o=`.${n}-tooltip`;e=`.${n}-tooltip__trigger`;let l=n+"-tooltip__trigger",c=n+"-tooltip",f=n+"-tooltip__body",h="is-set",m="is-visible",v=n+"-tooltip__body--wrap",u=e=>{var t=e.parentNode,r=t.querySelector("."+f);return{trigger:e,wrapper:t,body:r}},d=(t,a,e)=>{t.setAttribute("aria-hidden","false"),t.classList.add(h);let s=e=>{t.classList.remove(f+"--top"),t.classList.remove(f+"--bottom"),t.classList.remove(f+"--right"),t.classList.remove(f+"--left"),t.classList.add(f+"--"+e)},i=e=>{e.style.top=null,e.style.bottom=null,e.style.right=null,e.style.left=null,e.style.margin=null},n=(e,t)=>parseInt(window.getComputedStyle(e).getPropertyValue(t),10),o=(e,t,r)=>0<n(r,"margin-"+e)?t-n(r,"margin-"+e):t,l=e=>{i(e);var t=o("top",e.offsetHeight,a),r=o("left",e.offsetWidth,a);s("top"),e.style.left="50%",e.style.top="-5px",e.style.margin=`-${t}px 0 0 -${r/2}px`},c=e=>{i(e);var t=o("left",e.offsetWidth,a);s("bottom"),e.style.left="50%",e.style.margin=`5px 0 0 -${t/2}px`},u=e=>{i(e);var t=o("top",e.offsetHeight,a);s("right"),e.style.top="50%",e.style.left=a.offsetLeft+a.offsetWidth+5+"px",e.style.margin=`-${t/2}px 0 0 0`},d=e=>{i(e);var t=o("top",e.offsetHeight,a),r=o("left",a.offsetLeft>e.offsetWidth?a.offsetLeft-e.offsetWidth:e.offsetWidth,a);s("left"),e.style.top="50%",e.style.left="-5px",e.style.margin=`-${t/2}px 0 0 ${a.offsetLeft>e.offsetWidth?r:-r}px`};function p(r,e=1){let a=[l,c,u,d],s=!1;!function e(t){t<a.length&&((0,a[t])(r),b(r)?s=!0:e(t+=1))}(0),s||(r.classList.add(v),e<=2&&p(r,e+=1))}switch(e){case"top":l(t),b(t)||p(t);break;case"bottom":c(t),b(t)||p(t);break;case"right":u(t),b(t)||p(t);break;case"left":d(t),b(t)||p(t)}setTimeout(()=>{t.classList.add(m)},20)},p=e=>{e.classList.remove(m),e.classList.remove(h),e.classList.remove(v),e.setAttribute("aria-hidden","true")},g=e=>{var t="tooltip-"+(Math.floor(9e5*Math.random())+1e5),r=e.getAttribute("title");let a=document.createElement("span");var s=document.createElement("span"),i=e.getAttribute("data-classes");let n=e.getAttribute("data-position");return n||(n="top",e.setAttribute("data-position",n)),e.setAttribute("aria-describedby",t),e.setAttribute("tabindex","0"),e.removeAttribute("title"),e.classList.remove(c),e.classList.add(l),e.parentNode.insertBefore(a,e),a.appendChild(e),a.classList.add(c),a.appendChild(s),i&&i.split(" ").forEach(e=>a.classList.add(e)),s.classList.add(f),s.setAttribute("id",t),s.setAttribute("role","tooltip"),s.setAttribute("aria-hidden","true"),s.textContent=r,{tooltipBody:s,position:n,tooltipContent:r,wrapper:a}};n=i({"mouseover focusin":{[o](e){e=e.target;"BUTTON"===e.nodeName&&e.hasAttribute("title")&&g(e)},[e](e){var{trigger:e,body:t}=u(e.target);d(t,e,e.dataset.position)}},focusout:{[e](e){e=u(e.target).body;p(e)}},keydown:{body:a({Escape:()=>{var e=s(`.${f}.`+h);e&&e.forEach(e=>p(e))}})}},{init(e){s(o,e).forEach(e=>{g(e);let{body:t,wrapper:r}=u(e);r.addEventListener("mouseleave",()=>p(t))})},teardown(e){s(o,e).forEach(e=>{e.removeEventListener("mouseleave",p)})},setup:g,getTooltipElements:u,show:d,hide:p});t.exports=n},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/is-in-viewport":43,"../../uswds-core/src/js/utils/select-or-matches":47,"receptor/keymap":10}],34:[function(e,t,r){var a=e("../../uswds-core/src/js/utils/behavior");let s=e("../../uswds-core/src/js/utils/validate-input");var i=e("../../uswds-core/src/js/config").prefix;let n=e("../../uswds-core/src/js/utils/select-or-matches"),o="input[data-validation-element],textarea[data-validation-element]",l=`.${i}-checklist__item`,c=e=>{var t,a,r,s;s=(t=e).parentNode,r=t.getAttribute("id")+"-sr-summary",t.setAttribute("aria-describedby",r),(t=document.createElement("span")).setAttribute("data-validation-status",""),t.classList.add("usa-sr-only"),t.setAttribute("aria-live","polite"),t.setAttribute("aria-atomic",!0),t.setAttribute("id",r),s.append(t),r=(a=e).parentNode.querySelectorAll(l),s=a.getAttribute("data-validation-element"),a.setAttribute("aria-controls",s),r.forEach(e=>{let t="status incomplete";a.hasAttribute("data-validation-incomplete")&&(t=a.getAttribute("data-validation-incomplete"));var r=`${e.textContent} ${t} `;e.setAttribute("aria-label",r)})};e=a({"input change":{"input[data-validation-element],textarea[data-validation-element]"(e){e=e.target,s(e)}}},{init(e){n(o,e).forEach(e=>c(e))}});t.exports=e},{"../../uswds-core/src/js/config":35,"../../uswds-core/src/js/utils/behavior":40,"../../uswds-core/src/js/utils/select-or-matches":47,"../../uswds-core/src/js/utils/validate-input":52}],35:[function(e,t,r){t.exports={prefix:"usa"}},{}],36:[function(e,t,r){t.exports={CLICK:"click"}},{}],37:[function(e,t,r){var a=e("../../../usa-accordion/src/index"),s=e("../../../usa-banner/src/index"),i=e("../../../usa-button/src/index"),n=e("../../../usa-character-count/src/index"),o=e("../../../usa-combo-box/src/index"),l=e("../../../usa-date-picker/src/index"),c=e("../../../usa-date-range-picker/src/index"),u=e("../../../usa-file-input/src/index"),d=e("../../../usa-footer/src/index"),p=e("../../../usa-in-page-navigation/src/index"),b=e("../../../usa-input-mask/src/index"),f=e("../../../usa-language-selector/src/index"),h=e("../../../usa-modal/src/index"),m=e("../../../usa-header/src/index"),v=e("../../../_usa-password/src/index"),g=e("../../../usa-range/src/index"),w=e("../../../usa-search/src/index"),y=e("../../../usa-skipnav/src/index"),E=e("../../../usa-table/src/index"),A=e("../../../usa-time-picker/src/index"),x=e("../../../usa-tooltip/src/index"),e=e("../../../usa-validation/src/index");t.exports={accordion:a,banner:s,button:i,characterCount:n,comboBox:o,datePicker:l,dateRangePicker:c,fileInput:u,footer:d,inPageNavigation:p,inputMask:b,languageSelector:f,modal:h,navigation:m,password:v,range:g,search:w,skipnav:y,table:E,timePicker:A,tooltip:x,validator:e}},{"../../../_usa-password/src/index":13,"../../../usa-accordion/src/index":14,"../../../usa-banner/src/index":15,"../../../usa-button/src/index":16,"../../../usa-character-count/src/index":17,"../../../usa-combo-box/src/index":18,"../../../usa-date-picker/src/index":19,"../../../usa-date-range-picker/src/index":20,"../../../usa-file-input/src/index":21,"../../../usa-footer/src/index":22,"../../../usa-header/src/index":23,"../../../usa-in-page-navigation/src/index":24,"../../../usa-input-mask/src/index":25,"../../../usa-language-selector/src/index":26,"../../../usa-modal/src/index":27,"../../../usa-range/src/index":28,"../../../usa-search/src/index":29,"../../../usa-skipnav/src/index":30,"../../../usa-table/src/index":31,"../../../usa-time-picker/src/index":32,"../../../usa-tooltip/src/index":33,"../../../usa-validation/src/index":34}],38:[function(e,t,r){window.uswdsPresent=!0;var a=e("./config");let s=e("./index");a.components=s;e=()=>{let t=document.body;Object.keys(s).forEach(e=>{s[e].on(t)})};"loading"===document.readyState?document.addEventListener("DOMContentLoaded",e,{once:!0}):e(),r.default=a,r.initComponents=e},{"./config":35,"./index":37}],39:[function(e,t,r){t.exports=(e=document)=>e.activeElement},{}],40:[function(e,t,r){let a=e("receptor/behavior"),s=(...e)=>function(t=document.body){e.forEach(e=>{"function"==typeof this[e]&&this[e].call(this,t)})};t.exports=(e,t)=>a(e,{on:s("init","add"),off:s("teardown","remove"),...t})},{"receptor/behavior":4}],41:[function(e,t,r){t.exports=function(t,r=500){let a=null;return(...e)=>{window.clearTimeout(a),a=window.setTimeout(()=>{t.apply(this,e)},r)}}},{}],42:[function(e,t,r){let s=e("receptor").keymap,i=e("./behavior"),n=e("./select"),o=e("./active-element"),l=e=>{let t=n('a[href], area[href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), button:not([disabled]), iframe, object, embed, [tabindex="0"], [contenteditable]',e),r=t[0],a=t[t.length-1];return{firstTabStop:r,lastTabStop:a,tabAhead:function(e){o()===a&&(e.preventDefault(),r.focus())},tabBack:function(e){o()===r?(e.preventDefault(),a.focus()):t.includes(o())||(e.preventDefault(),r.focus())}}};t.exports=(e,t={})=>{let r=l(e);var{Esc:e,Escape:a}=t,e=(a&&!e&&(t.Esc=a),s({Tab:r.tabAhead,"Shift+Tab":r.tabBack,...t}));return i({keydown:e},{init(){r.firstTabStop&&r.firstTabStop.focus()},update(e){e?this.on():this.off()}})}},{"./active-element":39,"./behavior":40,"./select":48,receptor:9}],43:[function(e,t,r){t.exports=function(e,t=window,r=document.documentElement){return 0<=(e=e.getBoundingClientRect()).top&&0<=e.left&&e.bottom<=(t.innerHeight||r.clientHeight)&&e.right<=(t.innerWidth||r.clientWidth)}},{}],44:[function(e,t,r){t.exports=function(){return"undefined"!=typeof navigator&&(navigator.userAgent.match(/(iPod|iPhone|iPad)/g)||"MacIntel"===navigator.platform&&1<navigator.maxTouchPoints)&&!window.MSStream}},{}],45:[function(e,t,r){t.exports=(()=>{var s={_entity:/[&<>"'/]/g,_entities:{"&":"&","<":"<",">":">",'"':""","'":"'","/":"/"},getEntity:function(e){return s._entities[e]},escapeHTML:function(e){for(var t="",r=0;r<e.length;r++)t+=e[r],r+1<arguments.length&&(t+=String(arguments[r+1]||"").replace(s._entity,s.getEntity));return t},createSafeHTML:function(e){for(var t=arguments.length,r=new Array(1<t?t-1:0),a=1;a<t;a++)r[a-1]=arguments[a];return{__html:s.escapeHTML.apply(s,[e].concat(r)),toString:function(){return"[object WrappedHTMLObject]"},info:"This is a wrapped HTML object. See https://developer.mozilla.org/en-US/Firefox_OS/Security/Security_Automation for more."}},unwrapSafeHTML:function(){for(var e=arguments.length,t=new Array(e),r=0;r<e;r++)t[r]=arguments[r];return t.map(function(e){return e.__html}).join("")}};return s})()},{}],46:[function(e,t,r){t.exports=function(){var e=document.createElement("div"),t=(e.style.visibility="hidden",e.style.overflow="scroll",e.style.msOverflowStyle="scrollbar",document.body.appendChild(e),document.createElement("div")),t=(e.appendChild(t),e.offsetWidth-t.offsetWidth+"px");return e.parentNode.removeChild(e),t}},{}],47:[function(e,t,r){let s=e("./select");t.exports=(e,t)=>{var r,a=s(e,t);return"string"==typeof e&&(r=t)&&"object"==typeof r&&1===r.nodeType&&t.matches(e)&&a.push(t),a}},{"./select":48}],48:[function(e,t,r){t.exports=(e,t)=>{var r;return"string"!=typeof e?[]:(r=(t=t&&(r=t)&&"object"==typeof r&&1===r.nodeType?t:window.document).querySelectorAll(e),Array.prototype.slice.call(r))}},{}],49:[function(e,t,r){t.exports=(e,t)=>{e.setAttribute("autocapitalize","off"),e.setAttribute("autocorrect","off"),e.setAttribute("type",t?"password":"text")}},{}],50:[function(e,t,r){let s=e("resolve-id-refs"),i=e("./toggle-field-mask"),n="aria-pressed",o="data-show-text";t.exports=e=>{let t=e.hasAttribute(n)&&"true"!==e.getAttribute(n);s(e.getAttribute("aria-controls")).forEach(e=>i(e,t)),e.hasAttribute(o)||e.setAttribute(o,e.textContent);var r=e.getAttribute(o),a=e.getAttribute("data-hide-text")||r.replace(/\bShow\b/i,e=>`${"S"===e[0]?"H":"h"}ide`);return e.textContent=t?r:a,e.setAttribute(n,t),t}},{"./toggle-field-mask":49,"resolve-id-refs":12}],51:[function(e,t,r){let a="aria-expanded";t.exports=(e,t)=>{let r=t;"boolean"!=typeof r&&(r="false"===e.getAttribute(a)),e.setAttribute(a,r);t=e.getAttribute("aria-controls"),e=document.getElementById(t);if(e)return r?e.removeAttribute("hidden"):e.setAttribute("hidden",""),r;throw new Error(`No toggle target found with id: "${t}"`)}},{}],52:[function(e,t,r){let l=e("./debounce");e=e("../config").prefix;let c=e+"-checklist__item--checked";t.exports=function(i){var e=i.dataset.validationElement;let n="#"===e.charAt(0)?document.querySelector(e):document.getElementById(e);if(!n)throw new Error(`No validation element found with id: "${e}"`);let o="";Object.entries(i.dataset).forEach(([r,a])=>{if(r.startsWith("validate")){var r=r.substr("validate".length).toLowerCase(),a=new RegExp(a),s=`[data-validator="${r}"]`,s=n.querySelector(s);let e=i.parentNode.querySelector("[data-validation-status]");a=a.test(i.value);if(s.classList.toggle(c,a),!s)throw new Error(`No validator checkbox found for: "${r}"`);a=i.dataset.validationComplete||"status complete",r=i.dataset.validationIncomplete||"status incomplete";let t=s.textContent+" ";s.classList.contains(c)?t+=a:t+=r,s.setAttribute("aria-label",t),o+=t+". ",l(()=>{e.textContent=o},1e3)()}})}},{"../config":35,"./debounce":41}]},{},[38]); +//# sourceMappingURL=uswds.min.js.map diff --git a/html/matt-chat/uswds/js/uswds.min.js.map b/html/matt-chat/uswds/js/uswds.min.js.map new file mode 100644 index 0000000..d1237b4 --- /dev/null +++ b/html/matt-chat/uswds/js/uswds.min.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["node_modules/browser-pack/_prelude.js","node_modules/element-closest/element-closest.js","node_modules/keyboardevent-key-polyfill/index.js","node_modules/object-assign/index.js","node_modules/receptor/behavior/index.js","node_modules/receptor/compose/index.js","node_modules/receptor/delegate/index.js","node_modules/receptor/delegateAll/index.js","node_modules/receptor/ignore/index.js","node_modules/receptor/index.js","node_modules/receptor/keymap/index.js","node_modules/receptor/once/index.js","node_modules/resolve-id-refs/index.js","packages/_usa-password/src/index.js","packages/usa-accordion/src/index.js","packages/usa-banner/src/index.js","packages/usa-button/src/index.js","packages/usa-character-count/src/index.js","packages/usa-combo-box/src/index.js","packages/usa-date-picker/src/index.js","packages/usa-date-range-picker/src/index.js","packages/usa-file-input/src/index.js","packages/usa-footer/src/index.js","packages/usa-header/src/index.js","packages/usa-in-page-navigation/src/index.js","packages/usa-input-mask/src/index.js","packages/usa-language-selector/src/index.js","packages/usa-modal/src/index.js","packages/usa-range/src/index.js","packages/usa-search/src/index.js","packages/usa-skipnav/src/index.js","packages/usa-table/src/index.js","packages/usa-time-picker/src/index.js","packages/usa-tooltip/src/index.js","packages/usa-validation/src/index.js","packages/uswds-core/src/js/config.js","packages/uswds-core/src/js/events.js","packages/uswds-core/src/js/index.js","packages/uswds-core/src/js/start.js","packages/uswds-core/src/js/utils/active-element.js","packages/uswds-core/src/js/utils/behavior.js","packages/uswds-core/src/js/utils/debounce.js","packages/uswds-core/src/js/utils/focus-trap.js","packages/uswds-core/src/js/utils/is-in-viewport.js","packages/uswds-core/src/js/utils/is-ios-device.js","packages/uswds-core/src/js/utils/sanitizer.js","packages/uswds-core/src/js/utils/scrollbar-width.js","packages/uswds-core/src/js/utils/select-or-matches.js","packages/uswds-core/src/js/utils/select.js","packages/uswds-core/src/js/utils/toggle-field-mask.js","packages/uswds-core/src/js/utils/toggle-form-input.js","packages/uswds-core/src/js/utils/toggle.js","packages/uswds-core/src/js/utils/validate-input.js"],"names":["r","e","n","t","o","i","f","c","require","u","a","Error","code","p","exports","call","length","1","module","ElementProto","window","Element","prototype","matches","msMatchesSelector","mozMatchesSelector","webkitMatchesSelector","selector","element","this","elements","document","ownerDocument","querySelectorAll","index","Boolean","closest","nodeType","parentNode","keyboardeventKeyPolyfill","polyfill","KeyboardEvent","proto","get","x","key","keys","which","keyCode","Array","isArray","shiftKey","Object","defineProperty","3","6","8","9","12","13","16","17","18","19","20","27","28","29","30","31","32","33","34","35","36","37","38","39","40","41","42","43","44","45","46","48","49","50","51","52","53","54","55","56","57","91","93","144","145","181","182","183","186","187","188","189","190","191","192","219","220","221","222","224","225","246","247","248","249","250","251","letter","String","fromCharCode","toLowerCase","toUpperCase","define","amd","getOwnPropertySymbols","hasOwnProperty","propIsEnumerable","propertyIsEnumerable","assign","test1","getOwnPropertyNames","test2","test3","order2","map","join","split","forEach","err","target","source","from","to","val","TypeError","s","arguments","symbols","delegate","delegateAll","DELEGATE_PATTERN","popKey","obj","value","events","props","listeners","reduce","memo","type","handler","match","options","capture","passive","listener","indexOf","_type","concat","add","addEventListener","remove","removeEventListener","functions","some","fn","event","compose","selectors","delegates","push","contains","behavior","ignore","keymap","MODIFIERS","Alt","Control","Ctrl","Shift","hasModifiers","modifier","result","_key","undefined","wrapped","currentTarget","RE_TRIM","RE_SPLIT","trim","str","replace","ids","doc","getElementById","id","querySelector","bind","el","toggleFormInput","CLICK","PREFIX","preventDefault","select","toggle","isElementInViewport","ACCORDION","BUTTON","EXPANDED","getAccordionButtons","accordion","filter","button","toggleButton","expanded","safeExpanded","multiselectable","hasAttribute","other","getAttribute","scrollIntoView","init","root","show","hide","getButtons","HEADER","EXPANDED_CLASS","BANNER_BUTTON","trigger","classList","anchorButton","keydown","a[class*=\"usa-button\"]"," ","click","debounce","CHARACTER_COUNT_CLASS","CHARACTER_COUNT","FORM_GROUP_CLASS","FORM_GROUP_ERROR_CLASS","FORM_GROUP","LABEL_ERROR_CLASS","INPUT","INPUT_ERROR_CLASS","MESSAGE","VALIDATION_MESSAGE","MESSAGE_INVALID_CLASS","STATUS_MESSAGE_CLASS","STATUS_MESSAGE_SR_ONLY_CLASS","STATUS_MESSAGE","STATUS_MESSAGE_SR_ONLY","DEFAULT_STATUS_LABEL","getCharacterCountElements","inputEl","characterCountEl","formGroupEl","inputID","labelEl","messageEl","createStatusMessages","statusMessage","createElement","srStatusMessage","defaultMessage","dataset","maxlength","setAttribute","textContent","append","getCountMessage","currentLength","maxLength","let","newMessage","difference","Math","abs","srUpdateStatus","msgEl","updateCountMessage","parseInt","currentStatusMessage","isOverLimit","validationMessage","setCustomValidity","enhanceCharacterCount","removeAttribute","characterCount","input","selectOrMatches","Sanitizer","COMBO_BOX_CLASS","COMBO_BOX_PRISTINE_CLASS","SELECT_CLASS","INPUT_CLASS","CLEAR_INPUT_BUTTON_CLASS","CLEAR_INPUT_BUTTON_WRAPPER_CLASS","INPUT_BUTTON_SEPARATOR_CLASS","TOGGLE_LIST_BUTTON_CLASS","TOGGLE_LIST_BUTTON_WRAPPER_CLASS","LIST_CLASS","LIST_OPTION_CLASS","LIST_OPTION_FOCUSED_CLASS","LIST_OPTION_SELECTED_CLASS","STATUS_CLASS","COMBO_BOX","SELECT","CLEAR_INPUT_BUTTON","TOGGLE_LIST_BUTTON","LIST","LIST_OPTION","LIST_OPTION_FOCUSED","LIST_OPTION_SELECTED","STATUS","DEFAULT_FILTER","changeElementValue","elementToChange","CustomEvent","bubbles","cancelable","detail","dispatchEvent","getComboBoxContext","selectEl","listEl","statusEl","focusedOptionEl","selectedOptionEl","toggleListBtnEl","clearInputBtnEl","isPristine","comboBoxEl","disableFiltering","disable","hidden","disabled","enhanceComboBox","_comboBoxEl","enhanced","selectId","selectLabel","listId","listIdLabel","additionalAttributes","defaultValue","placeholder","selectedOption","len","optionEl","name","attr","escapeHTML","insertAdjacentElement","insertAdjacentHTML","text","highlightOption","nextEl","skipFocus","preventScroll","optionBottom","offsetTop","offsetHeight","scrollTop","focus","generateDynamicRegExp","query","extras","escapeRegExp","find","m","$1","queryFilter","matcher","RegExp","displayList","selectedItemId","firstFoundId","listOptionBaseId","inputValue","regex","optionsStartsWith","optionsContains","optionList","optionMatchesQuery","option","test","startsWith","optionId","numOptions","optionHtml","classes","tabindex","ariaSelected","li","noResults","innerHTML","item","itemToFocus","hideList","selectItem","listOptionEl","resetSelection","selectValue","handleDownFromInput","nextOptionEl","handleDownFromListOption","nextSibling","handleUpFromListOption","previousSibling","listShown","comboBox","clearButtonEl","focusout","relatedTarget","Escape","Enter","ArrowDown","Down","ArrowUp","Up","Shift+Tab","mouseover","enable","activeElement","isIosDevice","DATE_PICKER_CLASS","DATE_PICKER_WRAPPER_CLASS","DATE_PICKER_INITIALIZED_CLASS","DATE_PICKER_ACTIVE_CLASS","DATE_PICKER_INTERNAL_INPUT_CLASS","DATE_PICKER_EXTERNAL_INPUT_CLASS","DATE_PICKER_BUTTON_CLASS","DATE_PICKER_CALENDAR_CLASS","DATE_PICKER_STATUS_CLASS","CALENDAR_DATE_CLASS","CALENDAR_DATE_FOCUSED_CLASS","CALENDAR_DATE_SELECTED_CLASS","CALENDAR_DATE_PREVIOUS_MONTH_CLASS","CALENDAR_DATE_CURRENT_MONTH_CLASS","CALENDAR_DATE_NEXT_MONTH_CLASS","CALENDAR_DATE_RANGE_DATE_CLASS","CALENDAR_DATE_TODAY_CLASS","CALENDAR_DATE_RANGE_DATE_START_CLASS","CALENDAR_DATE_RANGE_DATE_END_CLASS","CALENDAR_DATE_WITHIN_RANGE_CLASS","CALENDAR_PREVIOUS_YEAR_CLASS","CALENDAR_PREVIOUS_MONTH_CLASS","CALENDAR_NEXT_YEAR_CLASS","CALENDAR_NEXT_MONTH_CLASS","CALENDAR_MONTH_SELECTION_CLASS","CALENDAR_YEAR_SELECTION_CLASS","CALENDAR_MONTH_CLASS","CALENDAR_MONTH_FOCUSED_CLASS","CALENDAR_MONTH_SELECTED_CLASS","CALENDAR_YEAR_CLASS","CALENDAR_YEAR_FOCUSED_CLASS","CALENDAR_YEAR_SELECTED_CLASS","CALENDAR_PREVIOUS_YEAR_CHUNK_CLASS","CALENDAR_NEXT_YEAR_CHUNK_CLASS","CALENDAR_DATE_PICKER_CLASS","CALENDAR_MONTH_PICKER_CLASS","CALENDAR_YEAR_PICKER_CLASS","CALENDAR_TABLE_CLASS","CALENDAR_ROW_CLASS","CALENDAR_CELL_CLASS","CALENDAR_CELL_CENTER_ITEMS_CLASS","CALENDAR_MONTH_LABEL_CLASS","CALENDAR_DAY_OF_WEEK_CLASS","DATE_PICKER","DATE_PICKER_BUTTON","DATE_PICKER_INTERNAL_INPUT","DATE_PICKER_EXTERNAL_INPUT","DATE_PICKER_CALENDAR","DATE_PICKER_STATUS","CALENDAR_DATE","CALENDAR_DATE_FOCUSED","CALENDAR_DATE_CURRENT_MONTH","CALENDAR_PREVIOUS_YEAR","CALENDAR_PREVIOUS_MONTH","CALENDAR_NEXT_YEAR","CALENDAR_NEXT_MONTH","CALENDAR_YEAR_SELECTION","CALENDAR_MONTH_SELECTION","CALENDAR_MONTH","CALENDAR_YEAR","CALENDAR_PREVIOUS_YEAR_CHUNK","CALENDAR_NEXT_YEAR_CHUNK","CALENDAR_DATE_PICKER","CALENDAR_MONTH_PICKER","CALENDAR_YEAR_PICKER","CALENDAR_MONTH_FOCUSED","CALENDAR_YEAR_FOCUSED","MONTH_LABELS","DAY_OF_WEEK_LABELS","YEAR_CHUNK","DEFAULT_EXTERNAL_DATE_FORMAT","INTERNAL_DATE_FORMAT","processFocusableSelectors","DATE_PICKER_FOCUSABLE","MONTH_PICKER_FOCUSABLE","YEAR_PICKER_FOCUSABLE","keepDateWithinMonth","dateToCheck","month","getMonth","setDate","year","date","newDate","Date","setFullYear","today","day","getDate","getFullYear","startOfMonth","lastDayOfMonth","addDays","_date","numDays","getTime","subDays","addWeeks","numWeeks","startOfWeek","dayOfWeek","getDay","addMonths","numMonths","dateMonth","setMonth","subMonths","addYears","numYears","subYears","setYear","min","dateA","dateB","max","isSameYear","isSameMonth","isSameDay","keepDateBetweenMinAndMax","minDate","maxDate","isDateWithinMinAndMax","isDatesMonthOutsideMinOrMax","isDatesYearOutsideMinOrMax","setRangeDates","rangeDate","rangeStartDate","rangeConclusionDate","rangeEndDate","withinRangeStartDate","withinRangeEndDate","parseDateString","dateString","dateFormat","adjustDate","parsed","monthStr","dayStr","yearStr","Number","isNaN","currentYearStub","currentYear","lastDayOfTheMonth","formatDate","padZeros","slice","listToGridHtml","htmlArray","rowSize","grid","row","tr","td","createTableBody","tableBody","getDatePickerContext","datePickerEl","internalInputEl","externalInputEl","calendarEl","toggleBtnEl","firstYearChunkEl","inputDate","selectedDate","calendarDate","defaultDate","ariaDisable","isDateInputInvalid","checkDate","isInvalid","dateStringParts","validateDateInput","setCalendarValue","parsedDate","formattedDate","renderCalendar","_dateToDisplay","todaysDate","dateToDisplay","calendarWasHidden","focusedDate","focusedMonth","focusedYear","prevMonth","nextMonth","currentFormattedDate","firstOfMonth","prevButtonsDisabled","nextButtonsDisabled","monthLabel","days","dateToRender","isDisabled","isSelected","btn","datesGrid","newCalendar","cloneNode","table","style","top","tableHead","tableHeadRow","daysOfWeek","Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","th","replaceChild","statuses","hideCalendar","updateCalendarIfVisible","displayMonthSelection","monthToDisplay","selectedMonth","months","monthToCheck","monthsHtml","monthsGrid","displayYearSelection","yearToDisplay","selectedYear","yearToChunk","prevYearChunkDisabled","nextYearChunkDisabled","years","yearIndex","yearsCalendarWrapper","yearsTableParent","yearsHTMLTableBody","yearsHTMLTableBodyRow","previousYearsBtn","nextYearsBtn","yearsTable","yearsGrid","yearsTableBody","yearsHTMLTableBodyDetailPrev","yearsHTMLTableBodyYearsDetail","yearsHTMLTableBodyDetailNext","handleEscapeFromCalendar","adjustCalendar","adjustDateFn","cappedDate","handleUpFromDate","subWeeks","handleDownFromDate","handleLeftFromDate","handleRightFromDate","handleHomeFromDate","handleEndFromDate","endOfWeek","handlePageDownFromDate","handlePageUpFromDate","handleShiftPageDownFromDate","handleShiftPageUpFromDate","adjustMonthSelectionScreen","adjustMonthFn","monthEl","currentDate","adjustedMonth","handleUpFromMonth","handleDownFromMonth","handleLeftFromMonth","handleRightFromMonth","handleHomeFromMonth","handleEndFromMonth","handlePageDownFromMonth","handlePageUpFromMonth","adjustYearSelectionScreen","adjustYearFn","yearEl","adjustedYear","handleUpFromYear","handleDownFromYear","handleLeftFromYear","handleRightFromYear","handleHomeFromYear","handleEndFromYear","handlePageUpFromYear","handlePageDownFromYear","tabHandler","focusable","getFocusableContext","focusableElements","lastTabIndex","firstTabStop","lastTabStop","focusIndex","isNotFound","isFirstTab","isLastTab","tabAhead","tabBack","datePickerTabEventHandler","monthPickerTabEventHandler","yearPickerTabEventHandler","datePickerEvents","calendarDateEl","_buttonEl","nextToFocus","keyup","keydownKeyCode","Left","ArrowLeft","Right","ArrowRight","Home","End","PageDown","PageUp","Shift+PageDown","Shift+PageUp","Tab","newValue","datePicker","dateEl","hoverDate","buttonDate","calendarWrapper","appendChild","display","required","DATE_RANGE_PICKER_CLASS","DATE_RANGE_PICKER_RANGE_START_CLASS","DATE_RANGE_PICKER_RANGE_END_CLASS","DATE_RANGE_PICKER","DATE_RANGE_PICKER_RANGE_START","DATE_RANGE_PICKER_RANGE_END","getDateRangePickerContext","rangeStartEl","rangeEndEl","dateRangePickerEl","handleRangeStartUpdate","updatedDate","handleRangeEndUpdate","dateRangePicker","input change","rangeStart","rangeEnd","DROPZONE_CLASS","DROPZONE","TARGET_CLASS","BOX_CLASS","INSTRUCTIONS_CLASS","PREVIEW_CLASS","PREVIEW_HEADING_CLASS","DISABLED_CLASS","CHOOSE_CLASS","ACCEPTED_FILE_MESSAGE_CLASS","DRAG_TEXT_CLASS","DRAG_CLASS","LOADING_CLASS","INVALID_FILE_CLASS","GENERIC_PREVIEW_CLASS_NAME","GENERIC_PREVIEW_CLASS","PDF_PREVIEW_CLASS","WORD_PREVIEW_CLASS","VIDEO_PREVIEW_CLASS","EXCEL_PREVIEW_CLASS","SR_ONLY_CLASS","SPACER_GIF","DEFAULT_ERROR_LABEL_TEXT","TYPE_IS_VALID","DEFAULT_ARIA_LABEL_TEXT","DEFAULT_FILE_STATUS_TEXT","getFileInputContext","dropZoneEl","replaceName","charCodeAt","toString","makeSafeForID","createUniqueID","floor","now","getItemsLabel","fileInputEl","enhanceFileInput","itemsLabel","isInputDisabled","dropTarget","fileInputParent","box","prepend","insertBefore","instructions","dragText","chooseText","navigator","userAgent","outerHTML","fileInputTarget","removeOldPreviews","filePreviews","currentPreviewHeading","currentErrorMessage","node","removeChild","updateStatusMessage","statusElement","fileNames","fileStore","setTimeout","addPreviewHeading","filePreviewsHeading","changeItemText","previewHeadingText","setPreviewFallback","previewImage","fallbackClass","localPreviewImage","src","once","handleUpload","acceptedFilesAttr","acceptedFiles","errorMessage","errorMessageText","errormessage","allFilesAllowed","scannedFiles","files","dataTransfer","file","j","fileType","returnValue","pos","ariaLabelText","stopPropagation","reader","FileReader","fileName","imageId","onloadstart","onloadend","fileExtension","pop","readAsDataURL","fileInput","teardown","fileInputTopElement","parentElement","className","SCOPE","toggleHtmlTag","isMobile","bigFooter","currentElement","currentElementClasses","preservedHtmlTag","tagName","newElement","menuId","random","nextElementSibling","after","resize","isOpen","innerWidth","HIDE_MAX_WIDTH","mediaQueryList","matchMedia","addListener","removeListener","FocusTrap","ScrollBarWidth","NAV","NAV_CONTAINER","NAV_PRIMARY","NAV_PRIMARY_ITEM","NAV_CONTROL","NAV_LINKS","NON_NAV_HIDDEN_ATTRIBUTE","OPENERS","CLOSE_BUTTON","CLOSERS","TOGGLES","NON_NAV_ELEMENTS","NON_NAV_HIDDEN","ACTIVE_CLASS","navigation","navActive","nonNavElements","isActive","body","isSafari","includes","SCROLLBAR_WIDTH","INITIAL_PADDING","getComputedStyle","getPropertyValue","TEMPORARY_PADDING","hideNonNavItems","headerParent","nonNavElement","showNonNavItems","toggleNav","active","safeActive","currentScrollPosition","scrollY","setProperty","focusTrap","update","closeButton","menuButton","paddingRight","closer","getBoundingClientRect","width","onMenuClose","hideActiveNavDropdown","acc","parentNavItem","navControl","trapContainer","CURRENT_CLASS","IN_PAGE_NAV_VALID_HEADINGS","IN_PAGE_NAV_SCROLL_OFFSET","IN_PAGE_NAV_CLASS","IN_PAGE_NAV_ANCHOR_CLASS","IN_PAGE_NAV_NAV_CLASS","IN_PAGE_NAV_LIST_CLASS","IN_PAGE_NAV_ITEM_CLASS","IN_PAGE_NAV_PRIMARY_ITEM_CLASS","IN_PAGE_NAV_LINK_CLASS","IN_PAGE_NAV_TITLE_CLASS","setActive","allLinks","isIntersecting","intersectionRatio","link","createSectionHeadingsArray","selectedContentRegion","selectedHeadingTypes","selectedHeadingTypesArray","contentRegion","headingType","sectionHeadingsArray","handleScrollToSection","inPageNavScrollOffset","scrollOffset","scroll","block","location","hash","history","pushState","createInPageNav","inPageNavEl","inPageNavTitleText","titleText","inPageNavTitleHeadingLevel","titleHeadingLevel","inPageNavRootMargin","rootMargin","inPageNavThreshold","threshold","inPageNavContentSelector","mainContentSelector","inPageNavHeadingSelector","headingElements","sectionHeadings","heading","headingStyle","inPageNav","inPageNavTitle","inPageNavList","listItem","navLinks","anchorTag","textContentOfLink","tag","topHeadingLevel","headingId","baseId","suffix","anchorTags","observeSections","IntersectionObserver","observe","inPageNavigation","elementToScrollTo","targetAnchor","hashFragment","MASKED","MASK","MASK_CONTENT","PLACEHOLDER","maskedNumber","maskedLetter","strippedValue","isCharsetPresent","isInteger","isLetter","handleValueChange","maskVal","charset","charIndex","strippedVal","isInt","isLet","matchesNumber","matchesLetter","placeholderVal","substr","theIEl","maskEl","replaceChildren","inputMask","maskedInput","shell","content","LANGUAGE_SUB","LANGUAGE_PRIMARY","LANGUAGE_PRIMARY_ITEM","LANGUAGE_CONTROL","languageSelector","languageActive","onLanguageClose","toggleLanguage","hideActiveLanguageDropdown","parentLanguageItem","MODAL_CLASSNAME","OVERLAY_CLASSNAME","WRAPPER_CLASSNAME","OPENER_ATTRIBUTE","CLOSER_ATTRIBUTE","FORCE_ACTION_ATTRIBUTE","NON_MODAL_HIDDEN_ATTRIBUTE","MODAL","INITIAL_FOCUS","NON_MODALS","VISIBLE_CLASS","HIDDEN_CLASS","modal","INITIAL_BODY_PADDING","TEMPORARY_BODY_PADDING","toggleModal","setTemporaryBodyPadding","originalOpener","clickedElement","openFocusEl","returnFocus","forceUserAction","modalId","targetModal","removeProperty","nonModal","setModalAttributes","baseComponent","modalContentWrapper","modalID","ariaLabelledBy","ariaDescribedBy","setUpModal","originalLocationPlaceHolder","modalAttributes","attributes","attribute","modalComponent","overlayDiv","modalContent","modalWindow","modalTrigger","nodeName","RANGE","updateCallout","targetRange","prep","rangeSlider","textPreposition","unit","textUnit","callout","range","change","FORM","CONTEXT","lastButton","getForm","context","toggleSearch","form","hideSearch","search",".js-search-button","encodeURI","outline","TABLE","SORTED","ASCENDING","DESCENDING","SORT_OVERRIDE","SORT_BUTTON_CLASS","SORT_BUTTON","SORTABLE_HEADER","ANNOUNCEMENT_REGION","getCellValue","children","innerText","compareFunction","isAscending","thisRow","nextRow","value1","value2","localeCompare","language","numeric","ignorePunctuation","updateSortLabel","header","headerName","sortedAscending","headerLabel","headerButtonLabel","toggleSort","safeAscending","tbody","allRows","thisHeaderIndex","sort","otherHeader","sortedHeader","caption","liveRegion","sortAnnouncement","sortDir","sortableHeaders","firstSorted","createHeaderButton","buttonEl","TIME_PICKER","FILTER_DATASET","apQueryFilter","hourQueryFilter","minuteQueryFilter","parseTimeString","timeStr","minutes","mins","hours","transformTimePicker","timePickerEl","initialInputEl","minTime","maxTime","step","time","minute","hour24","hour12","ampm","timePicker","TOOLTIP","TOOLTIP_TRIGGER","TOOLTIP_TRIGGER_CLASS","TOOLTIP_CLASS","TOOLTIP_BODY_CLASS","SET_CLASS","ADJUST_WIDTH_CLASS","getTooltipElements","wrapper","showToolTip","tooltipBody","tooltipTrigger","position","setPositionClass","setPos","resetPositionStyles","bottom","right","left","margin","offsetMargin","propertyValue","calculateMarginOffset","marginPosition","tooltipBodyOffset","positionTop","topMargin","leftMargin","offsetWidth","positionBottom","positionRight","offsetLeft","positionLeft","findBestPosition","attempt","positions","hasVisiblePosition","tryPositions","hideToolTip","setUpAttributes","tooltipID","tooltipContent","additionalClasses","classname","tooltip","mouseover focusin","activeTooltips","activeTooltip","tooltipWrapper","setup","validate","VALIDATE_INPUT","CHECKLIST_ITEM","enhanceValidation","checklistItems","validationElement","validationContainer","statusSummaryID","statusSummaryContainer","currentStatus","itemStatus","validator","input[data-validation-element],textarea[data-validation-element]","prefix","banner","footer","password","skipnav","uswdsPresent","uswds","components","initComponents","on","readyState","default","htmlDocument","Behavior","sequence","seq","method","off","callback","delay","timer","args","clearTimeout","apply","additionalKeyBindings","tabEventHandler","Esc","keyMappings","win","docEl","documentElement","rect","innerHeight","clientHeight","clientWidth","platform","maxTouchPoints","MSStream","_entity","_entities","&","<",">","\"","'","/","getEntity","strings","createSafeHTML","_len","values","__html","info","unwrapSafeHTML","htmlObjects","outer","inner","visibility","overflow","msOverflowStyle","scrollbarWidth","selection","field","mask","resolveIdRefs","toggleFieldMask","PRESSED","SHOW_ATTR","pressed","showText","hideText","controls","CHECKED_CLASS","checkList","charAt","statusSummary","entries","validatorName","validatorPattern","validatorSelector","validatorCheckbox","checked","statusComplete","validationComplete","statusIncomplete","validationIncomplete","checkboxContent"],"mappings":"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","file":"uswds.min.js","sourcesContent":["(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()","// element-closest | CC0-1.0 | github.com/jonathantneal/closest\n\n(function (ElementProto) {\n\tif (typeof ElementProto.matches !== 'function') {\n\t\tElementProto.matches = ElementProto.msMatchesSelector || ElementProto.mozMatchesSelector || ElementProto.webkitMatchesSelector || function matches(selector) {\n\t\t\tvar element = this;\n\t\t\tvar elements = (element.document || element.ownerDocument).querySelectorAll(selector);\n\t\t\tvar index = 0;\n\n\t\t\twhile (elements[index] && elements[index] !== element) {\n\t\t\t\t++index;\n\t\t\t}\n\n\t\t\treturn Boolean(elements[index]);\n\t\t};\n\t}\n\n\tif (typeof ElementProto.closest !== 'function') {\n\t\tElementProto.closest = function closest(selector) {\n\t\t\tvar element = this;\n\n\t\t\twhile (element && element.nodeType === 1) {\n\t\t\t\tif (element.matches(selector)) {\n\t\t\t\t\treturn element;\n\t\t\t\t}\n\n\t\t\t\telement = element.parentNode;\n\t\t\t}\n\n\t\t\treturn null;\n\t\t};\n\t}\n})(window.Element.prototype);\n","/* global define, KeyboardEvent, module */\n\n(function () {\n\n var keyboardeventKeyPolyfill = {\n polyfill: polyfill,\n keys: {\n 3: 'Cancel',\n 6: 'Help',\n 8: 'Backspace',\n 9: 'Tab',\n 12: 'Clear',\n 13: 'Enter',\n 16: 'Shift',\n 17: 'Control',\n 18: 'Alt',\n 19: 'Pause',\n 20: 'CapsLock',\n 27: 'Escape',\n 28: 'Convert',\n 29: 'NonConvert',\n 30: 'Accept',\n 31: 'ModeChange',\n 32: ' ',\n 33: 'PageUp',\n 34: 'PageDown',\n 35: 'End',\n 36: 'Home',\n 37: 'ArrowLeft',\n 38: 'ArrowUp',\n 39: 'ArrowRight',\n 40: 'ArrowDown',\n 41: 'Select',\n 42: 'Print',\n 43: 'Execute',\n 44: 'PrintScreen',\n 45: 'Insert',\n 46: 'Delete',\n 48: ['0', ')'],\n 49: ['1', '!'],\n 50: ['2', '@'],\n 51: ['3', '#'],\n 52: ['4', '$'],\n 53: ['5', '%'],\n 54: ['6', '^'],\n 55: ['7', '&'],\n 56: ['8', '*'],\n 57: ['9', '('],\n 91: 'OS',\n 93: 'ContextMenu',\n 144: 'NumLock',\n 145: 'ScrollLock',\n 181: 'VolumeMute',\n 182: 'VolumeDown',\n 183: 'VolumeUp',\n 186: [';', ':'],\n 187: ['=', '+'],\n 188: [',', '<'],\n 189: ['-', '_'],\n 190: ['.', '>'],\n 191: ['/', '?'],\n 192: ['`', '~'],\n 219: ['[', '{'],\n 220: ['\\\\', '|'],\n 221: [']', '}'],\n 222: [\"'\", '\"'],\n 224: 'Meta',\n 225: 'AltGraph',\n 246: 'Attn',\n 247: 'CrSel',\n 248: 'ExSel',\n 249: 'EraseEof',\n 250: 'Play',\n 251: 'ZoomOut'\n }\n };\n\n // Function keys (F1-24).\n var i;\n for (i = 1; i < 25; i++) {\n keyboardeventKeyPolyfill.keys[111 + i] = 'F' + i;\n }\n\n // Printable ASCII characters.\n var letter = '';\n for (i = 65; i < 91; i++) {\n letter = String.fromCharCode(i);\n keyboardeventKeyPolyfill.keys[i] = [letter.toLowerCase(), letter.toUpperCase()];\n }\n\n function polyfill () {\n if (!('KeyboardEvent' in window) ||\n 'key' in KeyboardEvent.prototype) {\n return false;\n }\n\n // Polyfill `key` on `KeyboardEvent`.\n var proto = {\n get: function (x) {\n var key = keyboardeventKeyPolyfill.keys[this.which || this.keyCode];\n\n if (Array.isArray(key)) {\n key = key[+this.shiftKey];\n }\n\n return key;\n }\n };\n Object.defineProperty(KeyboardEvent.prototype, 'key', proto);\n return proto;\n }\n\n if (typeof define === 'function' && define.amd) {\n define('keyboardevent-key-polyfill', keyboardeventKeyPolyfill);\n } else if (typeof exports !== 'undefined' && typeof module !== 'undefined') {\n module.exports = keyboardeventKeyPolyfill;\n } else if (window) {\n window.keyboardeventKeyPolyfill = keyboardeventKeyPolyfill;\n }\n\n})();\n","/*\nobject-assign\n(c) Sindre Sorhus\n@license MIT\n*/\n\n'use strict';\n/* eslint-disable no-unused-vars */\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nfunction toObject(val) {\n\tif (val === null || val === undefined) {\n\t\tthrow new TypeError('Object.assign cannot be called with null or undefined');\n\t}\n\n\treturn Object(val);\n}\n\nfunction shouldUseNative() {\n\ttry {\n\t\tif (!Object.assign) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Detect buggy property enumeration order in older V8 versions.\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=4118\n\t\tvar test1 = new String('abc'); // eslint-disable-line no-new-wrappers\n\t\ttest1[5] = 'de';\n\t\tif (Object.getOwnPropertyNames(test1)[0] === '5') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test2 = {};\n\t\tfor (var i = 0; i < 10; i++) {\n\t\t\ttest2['_' + String.fromCharCode(i)] = i;\n\t\t}\n\t\tvar order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n\t\t\treturn test2[n];\n\t\t});\n\t\tif (order2.join('') !== '0123456789') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test3 = {};\n\t\t'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n\t\t\ttest3[letter] = letter;\n\t\t});\n\t\tif (Object.keys(Object.assign({}, test3)).join('') !==\n\t\t\t\t'abcdefghijklmnopqrst') {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t} catch (err) {\n\t\t// We don't expect any of the above to throw, but better to be safe.\n\t\treturn false;\n\t}\n}\n\nmodule.exports = shouldUseNative() ? Object.assign : function (target, source) {\n\tvar from;\n\tvar to = toObject(target);\n\tvar symbols;\n\n\tfor (var s = 1; s < arguments.length; s++) {\n\t\tfrom = Object(arguments[s]);\n\n\t\tfor (var key in from) {\n\t\t\tif (hasOwnProperty.call(from, key)) {\n\t\t\t\tto[key] = from[key];\n\t\t\t}\n\t\t}\n\n\t\tif (getOwnPropertySymbols) {\n\t\t\tsymbols = getOwnPropertySymbols(from);\n\t\t\tfor (var i = 0; i < symbols.length; i++) {\n\t\t\t\tif (propIsEnumerable.call(from, symbols[i])) {\n\t\t\t\t\tto[symbols[i]] = from[symbols[i]];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn to;\n};\n","const assign = require('object-assign');\nconst delegate = require('../delegate');\nconst delegateAll = require('../delegateAll');\n\nconst DELEGATE_PATTERN = /^(.+):delegate\\((.+)\\)$/;\nconst SPACE = ' ';\n\nconst getListeners = function(type, handler) {\n var match = type.match(DELEGATE_PATTERN);\n var selector;\n if (match) {\n type = match[1];\n selector = match[2];\n }\n\n var options;\n if (typeof handler === 'object') {\n options = {\n capture: popKey(handler, 'capture'),\n passive: popKey(handler, 'passive')\n };\n }\n\n var listener = {\n selector: selector,\n delegate: (typeof handler === 'object')\n ? delegateAll(handler)\n : selector\n ? delegate(selector, handler)\n : handler,\n options: options\n };\n\n if (type.indexOf(SPACE) > -1) {\n return type.split(SPACE).map(function(_type) {\n return assign({type: _type}, listener);\n });\n } else {\n listener.type = type;\n return [listener];\n }\n};\n\nvar popKey = function(obj, key) {\n var value = obj[key];\n delete obj[key];\n return value;\n};\n\nmodule.exports = function behavior(events, props) {\n const listeners = Object.keys(events)\n .reduce(function(memo, type) {\n var listeners = getListeners(type, events[type]);\n return memo.concat(listeners);\n }, []);\n\n return assign({\n add: function addBehavior(element) {\n listeners.forEach(function(listener) {\n element.addEventListener(\n listener.type,\n listener.delegate,\n listener.options\n );\n });\n },\n remove: function removeBehavior(element) {\n listeners.forEach(function(listener) {\n element.removeEventListener(\n listener.type,\n listener.delegate,\n listener.options\n );\n });\n }\n }, props);\n};\n","module.exports = function compose(functions) {\n return function(e) {\n return functions.some(function(fn) {\n return fn.call(this, e) === false;\n }, this);\n };\n};\n","// polyfill Element.prototype.closest\nrequire('element-closest');\n\nmodule.exports = function delegate(selector, fn) {\n return function delegation(event) {\n var target = event.target.closest(selector);\n if (target) {\n return fn.call(target, event);\n }\n }\n};\n","const delegate = require('../delegate');\nconst compose = require('../compose');\n\nconst SPLAT = '*';\n\nmodule.exports = function delegateAll(selectors) {\n const keys = Object.keys(selectors)\n\n // XXX optimization: if there is only one handler and it applies to\n // all elements (the \"*\" CSS selector), then just return that\n // handler\n if (keys.length === 1 && keys[0] === SPLAT) {\n return selectors[SPLAT];\n }\n\n const delegates = keys.reduce(function(memo, selector) {\n memo.push(delegate(selector, selectors[selector]));\n return memo;\n }, []);\n return compose(delegates);\n};\n","module.exports = function ignore(element, fn) {\n return function ignorance(e) {\n if (element !== e.target && !element.contains(e.target)) {\n return fn.call(this, e);\n }\n };\n};\n","module.exports = {\n behavior: require('./behavior'),\n delegate: require('./delegate'),\n delegateAll: require('./delegateAll'),\n ignore: require('./ignore'),\n keymap: require('./keymap'),\n};\n","require('keyboardevent-key-polyfill');\n\n// these are the only relevant modifiers supported on all platforms,\n// according to MDN:\n// <https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/getModifierState>\nconst MODIFIERS = {\n 'Alt': 'altKey',\n 'Control': 'ctrlKey',\n 'Ctrl': 'ctrlKey',\n 'Shift': 'shiftKey'\n};\n\nconst MODIFIER_SEPARATOR = '+';\n\nconst getEventKey = function(event, hasModifiers) {\n var key = event.key;\n if (hasModifiers) {\n for (var modifier in MODIFIERS) {\n if (event[MODIFIERS[modifier]] === true) {\n key = [modifier, key].join(MODIFIER_SEPARATOR);\n }\n }\n }\n return key;\n};\n\nmodule.exports = function keymap(keys) {\n const hasModifiers = Object.keys(keys).some(function(key) {\n return key.indexOf(MODIFIER_SEPARATOR) > -1;\n });\n return function(event) {\n var key = getEventKey(event, hasModifiers);\n return [key, key.toLowerCase()]\n .reduce(function(result, _key) {\n if (_key in keys) {\n result = keys[key].call(this, event);\n }\n return result;\n }, undefined);\n };\n};\n\nmodule.exports.MODIFIERS = MODIFIERS;\n","module.exports = function once(listener, options) {\n var wrapped = function wrappedOnce(e) {\n e.currentTarget.removeEventListener(e.type, wrapped, options);\n return listener.call(this, e);\n };\n return wrapped;\n};\n\n","'use strict';\n\nvar RE_TRIM = /(^\\s+)|(\\s+$)/g;\nvar RE_SPLIT = /\\s+/;\n\nvar trim = String.prototype.trim\n ? function(str) { return str.trim(); }\n : function(str) { return str.replace(RE_TRIM, ''); };\n\nvar queryById = function(id) {\n return this.querySelector('[id=\"' + id.replace(/\"/g, '\\\\\"') + '\"]');\n};\n\nmodule.exports = function resolveIds(ids, doc) {\n if (typeof ids !== 'string') {\n throw new Error('Expected a string but got ' + (typeof ids));\n }\n\n if (!doc) {\n doc = window.document;\n }\n\n var getElementById = doc.getElementById\n ? doc.getElementById.bind(doc)\n : queryById.bind(doc);\n\n ids = trim(ids).split(RE_SPLIT);\n\n // XXX we can short-circuit here because trimming and splitting a\n // string of just whitespace produces an array containing a single,\n // empty string\n if (ids.length === 1 && ids[0] === '') {\n return [];\n }\n\n return ids\n .map(function(id) {\n var el = getElementById(id);\n if (!el) {\n throw new Error('no element with id: \"' + id + '\"');\n }\n return el;\n });\n};\n","const behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst toggleFormInput = require(\"../../uswds-core/src/js/utils/toggle-form-input\");\n\nconst { CLICK } = require(\"../../uswds-core/src/js/events\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\n\nconst LINK = `.${PREFIX}-show-password`;\n\nfunction toggle(event) {\n event.preventDefault();\n toggleFormInput(this);\n}\n\nmodule.exports = behavior({\n [CLICK]: {\n [LINK]: toggle,\n },\n});\n","const select = require(\"../../uswds-core/src/js/utils/select\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst toggle = require(\"../../uswds-core/src/js/utils/toggle\");\nconst isElementInViewport = require(\"../../uswds-core/src/js/utils/is-in-viewport\");\nconst { CLICK } = require(\"../../uswds-core/src/js/events\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\n\nconst ACCORDION = `.${PREFIX}-accordion, .${PREFIX}-accordion--bordered`;\nconst BANNER_BUTTON = `.${PREFIX}-banner__button`;\nconst BUTTON = `.${PREFIX}-accordion__button[aria-controls]:not(${BANNER_BUTTON})`;\nconst EXPANDED = \"aria-expanded\";\nconst MULTISELECTABLE = \"data-allow-multiple\";\n\n/**\n * Get an Array of button elements belonging directly to the given\n * accordion element.\n * @param {HTMLElement} accordion\n * @return {array<HTMLButtonElement>}\n */\nconst getAccordionButtons = (accordion) => {\n const buttons = select(BUTTON, accordion);\n\n return buttons.filter((button) => button.closest(ACCORDION) === accordion);\n};\n\n/**\n * Toggle a button's \"pressed\" state, optionally providing a target\n * state.\n *\n * @param {HTMLButtonElement} button\n * @param {boolean?} expanded If no state is provided, the current\n * state will be toggled (from false to true, and vice-versa).\n * @return {boolean} the resulting state\n */\nconst toggleButton = (button, expanded) => {\n const accordion = button.closest(ACCORDION);\n let safeExpanded = expanded;\n\n if (!accordion) {\n throw new Error(`${BUTTON} is missing outer ${ACCORDION}`);\n }\n\n safeExpanded = toggle(button, expanded);\n\n // XXX multiselectable is opt-in, to preserve legacy behavior\n const multiselectable = accordion.hasAttribute(MULTISELECTABLE);\n\n if (safeExpanded && !multiselectable) {\n getAccordionButtons(accordion).forEach((other) => {\n if (other !== button) {\n toggle(other, false);\n }\n });\n }\n};\n\n/**\n * @param {HTMLButtonElement} button\n * @return {boolean} true\n */\nconst showButton = (button) => toggleButton(button, true);\n\n/**\n * @param {HTMLButtonElement} button\n * @return {boolean} false\n */\nconst hideButton = (button) => toggleButton(button, false);\n\nconst accordion = behavior(\n {\n [CLICK]: {\n [BUTTON]() {\n toggleButton(this);\n\n if (this.getAttribute(EXPANDED) === \"true\") {\n // We were just expanded, but if another accordion was also just\n // collapsed, we may no longer be in the viewport. This ensures\n // that we are still visible, so the user isn't confused.\n if (!isElementInViewport(this)) this.scrollIntoView();\n }\n },\n },\n },\n {\n init(root) {\n select(BUTTON, root).forEach((button) => {\n const expanded = button.getAttribute(EXPANDED) === \"true\";\n toggleButton(button, expanded);\n });\n },\n ACCORDION,\n BUTTON,\n show: showButton,\n hide: hideButton,\n toggle: toggleButton,\n getButtons: getAccordionButtons,\n },\n);\n\nmodule.exports = accordion;\n","const behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst select = require(\"../../uswds-core/src/js/utils/select\");\nconst { CLICK } = require(\"../../uswds-core/src/js/events\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\nconst toggle = require(\"../../uswds-core/src/js/utils/toggle\");\n\nconst HEADER = `.${PREFIX}-banner__header`;\nconst EXPANDED_CLASS = `${PREFIX}-banner__header--expanded`;\nconst BANNER_BUTTON = `${HEADER} [aria-controls]`;\n\n/**\n * Toggle Banner display and class.\n * @param {Event} event\n */\nconst toggleBanner = function toggleEl(event) {\n event.preventDefault();\n const trigger = event.target.closest(BANNER_BUTTON);\n\n toggle(trigger);\n this.closest(HEADER).classList.toggle(EXPANDED_CLASS);\n};\n\nmodule.exports = behavior(\n {\n [CLICK]: {\n [BANNER_BUTTON]: toggleBanner,\n },\n },\n {\n init(root) {\n select(BANNER_BUTTON, root).forEach((button) => {\n const expanded = button.getAttribute(EXPANDED_CLASS) === \"true\";\n toggle(button, expanded);\n });\n },\n },\n);\n","const keymap = require(\"receptor/keymap\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\n\nconst ANCHOR_BUTTON = `a[class*=\"usa-button\"]`;\n\nconst toggleButton = (event) => {\n event.preventDefault();\n event.target.click();\n};\n\nconst anchorButton = behavior({\n keydown: {\n [ANCHOR_BUTTON]: keymap({\n \" \": toggleButton,\n }),\n },\n});\n\nmodule.exports = anchorButton;\n","const select = require(\"../../uswds-core/src/js/utils/select\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst debounce = require(\"../../uswds-core/src/js/utils/debounce\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\n\nconst CHARACTER_COUNT_CLASS = `${PREFIX}-character-count`;\nconst CHARACTER_COUNT = `.${CHARACTER_COUNT_CLASS}`;\nconst FORM_GROUP_CLASS = `${PREFIX}-form-group`;\nconst FORM_GROUP_ERROR_CLASS = `${FORM_GROUP_CLASS}--error`;\nconst FORM_GROUP = `.${FORM_GROUP_CLASS}`;\nconst LABEL_CLASS = `${PREFIX}-label`;\nconst LABEL_ERROR_CLASS = `${LABEL_CLASS}--error`;\nconst INPUT = `.${PREFIX}-character-count__field`;\nconst INPUT_ERROR_CLASS = `${PREFIX}-input--error`;\nconst MESSAGE = `.${PREFIX}-character-count__message`;\nconst VALIDATION_MESSAGE = \"The content is too long.\";\nconst MESSAGE_INVALID_CLASS = `${PREFIX}-character-count__status--invalid`;\nconst STATUS_MESSAGE_CLASS = `${CHARACTER_COUNT_CLASS}__status`;\nconst STATUS_MESSAGE_SR_ONLY_CLASS = `${CHARACTER_COUNT_CLASS}__sr-status`;\nconst STATUS_MESSAGE = `.${STATUS_MESSAGE_CLASS}`;\nconst STATUS_MESSAGE_SR_ONLY = `.${STATUS_MESSAGE_SR_ONLY_CLASS}`;\nconst DEFAULT_STATUS_LABEL = `characters allowed`;\n\n/**\n * Returns the root, form group, label, and message elements for an character count input\n *\n * @param {HTMLInputElement|HTMLTextAreaElement} inputEl The character count input element\n * @returns {CharacterCountElements} elements The root form group, input ID, label, and message element.\n */\nconst getCharacterCountElements = (inputEl) => {\n const characterCountEl = inputEl.closest(CHARACTER_COUNT);\n\n if (!characterCountEl) {\n throw new Error(`${INPUT} is missing outer ${CHARACTER_COUNT}`);\n }\n\n const formGroupEl = characterCountEl.querySelector(FORM_GROUP);\n\n const inputID = inputEl.getAttribute(\"id\");\n const labelEl = document.querySelector(`label[for=${inputID}]`);\n\n const messageEl = characterCountEl.querySelector(MESSAGE);\n\n if (!messageEl) {\n throw new Error(`${CHARACTER_COUNT} is missing inner ${MESSAGE}`);\n }\n\n return { characterCountEl, formGroupEl, inputID, labelEl, messageEl };\n};\n\n/**\n * Move maxlength attribute to a data attribute on usa-character-count\n *\n * @param {HTMLInputElement|HTMLTextAreaElement} inputEl The character count input element\n */\nconst setDataLength = (inputEl) => {\n const { characterCountEl } = getCharacterCountElements(inputEl);\n\n const maxlength = inputEl.getAttribute(\"maxlength\");\n\n if (!maxlength) return;\n\n inputEl.removeAttribute(\"maxlength\");\n characterCountEl.setAttribute(\"data-maxlength\", maxlength);\n};\n\n/**\n * Create and append status messages for visual and screen readers\n *\n * @param {HTMLDivElement} characterCountEl - Div with `.usa-character-count` class\n * @description Create two status messages for number of characters left;\n * one visual status and another for screen readers\n */\nconst createStatusMessages = (characterCountEl) => {\n const statusMessage = document.createElement(\"div\");\n const srStatusMessage = document.createElement(\"div\");\n const maxLength = characterCountEl.dataset.maxlength;\n const defaultMessage = `${maxLength} ${DEFAULT_STATUS_LABEL}`;\n\n statusMessage.classList.add(`${STATUS_MESSAGE_CLASS}`, \"usa-hint\");\n srStatusMessage.classList.add(\n `${STATUS_MESSAGE_SR_ONLY_CLASS}`,\n \"usa-sr-only\",\n );\n\n statusMessage.setAttribute(\"aria-hidden\", true);\n srStatusMessage.setAttribute(\"aria-live\", \"polite\");\n\n statusMessage.textContent = defaultMessage;\n srStatusMessage.textContent = defaultMessage;\n\n characterCountEl.append(statusMessage, srStatusMessage);\n};\n\n/**\n * Returns message with how many characters are left\n *\n * @param {number} currentLength - The number of characters used\n * @param {number} maxLength - The total number of characters allowed\n * @returns {string} A string description of how many characters are left\n */\nconst getCountMessage = (currentLength, maxLength) => {\n let newMessage = \"\";\n\n if (currentLength === 0) {\n newMessage = `${maxLength} ${DEFAULT_STATUS_LABEL}`;\n } else {\n const difference = Math.abs(maxLength - currentLength);\n const characters = `character${difference === 1 ? \"\" : \"s\"}`;\n const guidance = currentLength > maxLength ? \"over limit\" : \"left\";\n\n newMessage = `${difference} ${characters} ${guidance}`;\n }\n\n return newMessage;\n};\n\n/**\n * Updates the character count status for screen readers after a 1000ms delay.\n *\n * @param {HTMLElement} msgEl - The screen reader status message element\n * @param {string} statusMessage - A string of the current character status\n */\nconst srUpdateStatus = debounce((msgEl, statusMessage) => {\n const srStatusMessage = msgEl;\n srStatusMessage.textContent = statusMessage;\n}, 1000);\n\n/**\n * Update the character count component\n *\n * @description On input, it will update visual status, screenreader\n * status and update input validation (if over character length)\n * @param {HTMLInputElement|HTMLTextAreaElement} inputEl The character count input element\n */\nconst updateCountMessage = (inputEl) => {\n const { characterCountEl, labelEl, formGroupEl } =\n getCharacterCountElements(inputEl);\n const currentLength = inputEl.value.length;\n const maxLength = parseInt(\n characterCountEl.getAttribute(\"data-maxlength\"),\n 10,\n );\n const statusMessage = characterCountEl.querySelector(STATUS_MESSAGE);\n const srStatusMessage = characterCountEl.querySelector(\n STATUS_MESSAGE_SR_ONLY,\n );\n const currentStatusMessage = getCountMessage(currentLength, maxLength);\n\n if (!maxLength) return;\n\n const isOverLimit = currentLength && currentLength > maxLength;\n\n statusMessage.textContent = currentStatusMessage;\n srUpdateStatus(srStatusMessage, currentStatusMessage);\n\n if (isOverLimit && !inputEl.validationMessage) {\n inputEl.setCustomValidity(VALIDATION_MESSAGE);\n }\n\n if (!isOverLimit && inputEl.validationMessage === VALIDATION_MESSAGE) {\n inputEl.setCustomValidity(\"\");\n }\n\n if (formGroupEl) {\n formGroupEl.classList.toggle(FORM_GROUP_ERROR_CLASS, isOverLimit);\n }\n\n if (labelEl) {\n labelEl.classList.toggle(LABEL_ERROR_CLASS, isOverLimit);\n }\n\n inputEl.classList.toggle(INPUT_ERROR_CLASS, isOverLimit);\n statusMessage.classList.toggle(MESSAGE_INVALID_CLASS, isOverLimit);\n};\n\n/**\n * Initialize component\n *\n * @description On init this function will create elements and update any\n * attributes so it can tell the user how many characters are left.\n * @param {HTMLInputElement|HTMLTextAreaElement} inputEl the components input\n */\nconst enhanceCharacterCount = (inputEl) => {\n const { characterCountEl, messageEl } = getCharacterCountElements(inputEl);\n\n // Hide hint and remove aria-live for backwards compatibility\n messageEl.classList.add(\"usa-sr-only\");\n messageEl.removeAttribute(\"aria-live\");\n\n setDataLength(inputEl);\n createStatusMessages(characterCountEl);\n};\n\nconst characterCount = behavior(\n {\n input: {\n [INPUT]() {\n updateCountMessage(this);\n },\n },\n },\n {\n init(root) {\n select(INPUT, root).forEach((input) => enhanceCharacterCount(input));\n },\n FORM_GROUP_ERROR_CLASS,\n LABEL_ERROR_CLASS,\n INPUT_ERROR_CLASS,\n MESSAGE_INVALID_CLASS,\n VALIDATION_MESSAGE,\n STATUS_MESSAGE_CLASS,\n STATUS_MESSAGE_SR_ONLY_CLASS,\n DEFAULT_STATUS_LABEL,\n createStatusMessages,\n getCountMessage,\n updateCountMessage,\n },\n);\n\nmodule.exports = characterCount;\n","const keymap = require(\"receptor/keymap\");\nconst selectOrMatches = require(\"../../uswds-core/src/js/utils/select-or-matches\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst Sanitizer = require(\"../../uswds-core/src/js/utils/sanitizer\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\nconst { CLICK } = require(\"../../uswds-core/src/js/events\");\n\nconst COMBO_BOX_CLASS = `${PREFIX}-combo-box`;\nconst COMBO_BOX_PRISTINE_CLASS = `${COMBO_BOX_CLASS}--pristine`;\nconst SELECT_CLASS = `${COMBO_BOX_CLASS}__select`;\nconst INPUT_CLASS = `${COMBO_BOX_CLASS}__input`;\nconst CLEAR_INPUT_BUTTON_CLASS = `${COMBO_BOX_CLASS}__clear-input`;\nconst CLEAR_INPUT_BUTTON_WRAPPER_CLASS = `${CLEAR_INPUT_BUTTON_CLASS}__wrapper`;\nconst INPUT_BUTTON_SEPARATOR_CLASS = `${COMBO_BOX_CLASS}__input-button-separator`;\nconst TOGGLE_LIST_BUTTON_CLASS = `${COMBO_BOX_CLASS}__toggle-list`;\nconst TOGGLE_LIST_BUTTON_WRAPPER_CLASS = `${TOGGLE_LIST_BUTTON_CLASS}__wrapper`;\nconst LIST_CLASS = `${COMBO_BOX_CLASS}__list`;\nconst LIST_OPTION_CLASS = `${COMBO_BOX_CLASS}__list-option`;\nconst LIST_OPTION_FOCUSED_CLASS = `${LIST_OPTION_CLASS}--focused`;\nconst LIST_OPTION_SELECTED_CLASS = `${LIST_OPTION_CLASS}--selected`;\nconst STATUS_CLASS = `${COMBO_BOX_CLASS}__status`;\n\nconst COMBO_BOX = `.${COMBO_BOX_CLASS}`;\nconst SELECT = `.${SELECT_CLASS}`;\nconst INPUT = `.${INPUT_CLASS}`;\nconst CLEAR_INPUT_BUTTON = `.${CLEAR_INPUT_BUTTON_CLASS}`;\nconst TOGGLE_LIST_BUTTON = `.${TOGGLE_LIST_BUTTON_CLASS}`;\nconst LIST = `.${LIST_CLASS}`;\nconst LIST_OPTION = `.${LIST_OPTION_CLASS}`;\nconst LIST_OPTION_FOCUSED = `.${LIST_OPTION_FOCUSED_CLASS}`;\nconst LIST_OPTION_SELECTED = `.${LIST_OPTION_SELECTED_CLASS}`;\nconst STATUS = `.${STATUS_CLASS}`;\n\nconst DEFAULT_FILTER = \".*{{query}}.*\";\n\nconst noop = () => {};\n\n/**\n * set the value of the element and dispatch a change event\n *\n * @param {HTMLInputElement|HTMLSelectElement} el The element to update\n * @param {string} value The new value of the element\n */\nconst changeElementValue = (el, value = \"\") => {\n const elementToChange = el;\n elementToChange.value = value;\n\n const event = new CustomEvent(\"change\", {\n bubbles: true,\n cancelable: true,\n detail: { value },\n });\n elementToChange.dispatchEvent(event);\n};\n\n/**\n * The elements within the combo box.\n * @typedef {Object} ComboBoxContext\n * @property {HTMLElement} comboBoxEl\n * @property {HTMLSelectElement} selectEl\n * @property {HTMLInputElement} inputEl\n * @property {HTMLUListElement} listEl\n * @property {HTMLDivElement} statusEl\n * @property {HTMLLIElement} focusedOptionEl\n * @property {HTMLLIElement} selectedOptionEl\n * @property {HTMLButtonElement} toggleListBtnEl\n * @property {HTMLButtonElement} clearInputBtnEl\n * @property {boolean} isPristine\n * @property {boolean} disableFiltering\n */\n\n/**\n * Get an object of elements belonging directly to the given\n * combo box component.\n *\n * @param {HTMLElement} el the element within the combo box\n * @returns {ComboBoxContext} elements\n */\nconst getComboBoxContext = (el) => {\n const comboBoxEl = el.closest(COMBO_BOX);\n\n if (!comboBoxEl) {\n throw new Error(`Element is missing outer ${COMBO_BOX}`);\n }\n\n const selectEl = comboBoxEl.querySelector(SELECT);\n const inputEl = comboBoxEl.querySelector(INPUT);\n const listEl = comboBoxEl.querySelector(LIST);\n const statusEl = comboBoxEl.querySelector(STATUS);\n const focusedOptionEl = comboBoxEl.querySelector(LIST_OPTION_FOCUSED);\n const selectedOptionEl = comboBoxEl.querySelector(LIST_OPTION_SELECTED);\n const toggleListBtnEl = comboBoxEl.querySelector(TOGGLE_LIST_BUTTON);\n const clearInputBtnEl = comboBoxEl.querySelector(CLEAR_INPUT_BUTTON);\n\n const isPristine = comboBoxEl.classList.contains(COMBO_BOX_PRISTINE_CLASS);\n const disableFiltering = comboBoxEl.dataset.disableFiltering === \"true\";\n\n return {\n comboBoxEl,\n selectEl,\n inputEl,\n listEl,\n statusEl,\n focusedOptionEl,\n selectedOptionEl,\n toggleListBtnEl,\n clearInputBtnEl,\n isPristine,\n disableFiltering,\n };\n};\n\n/**\n * Disable the combo-box component\n *\n * @param {HTMLInputElement} el An element within the combo box component\n */\nconst disable = (el) => {\n const { inputEl, toggleListBtnEl, clearInputBtnEl } = getComboBoxContext(el);\n\n clearInputBtnEl.hidden = true;\n clearInputBtnEl.disabled = true;\n toggleListBtnEl.disabled = true;\n inputEl.disabled = true;\n};\n\n/**\n * Check for aria-disabled on initialization\n *\n * @param {HTMLInputElement} el An element within the combo box component\n */\nconst ariaDisable = (el) => {\n const { inputEl, toggleListBtnEl, clearInputBtnEl } = getComboBoxContext(el);\n\n clearInputBtnEl.hidden = true;\n clearInputBtnEl.setAttribute(\"aria-disabled\", true);\n toggleListBtnEl.setAttribute(\"aria-disabled\", true);\n inputEl.setAttribute(\"aria-disabled\", true);\n};\n\n/**\n * Enable the combo-box component\n *\n * @param {HTMLInputElement} el An element within the combo box component\n */\nconst enable = (el) => {\n const { inputEl, toggleListBtnEl, clearInputBtnEl } = getComboBoxContext(el);\n\n clearInputBtnEl.hidden = false;\n clearInputBtnEl.disabled = false;\n toggleListBtnEl.disabled = false;\n inputEl.disabled = false;\n};\n\n/**\n * Enhance a select element into a combo box component.\n *\n * @param {HTMLElement} _comboBoxEl The initial element of the combo box component\n */\nconst enhanceComboBox = (_comboBoxEl) => {\n const comboBoxEl = _comboBoxEl.closest(COMBO_BOX);\n\n if (comboBoxEl.dataset.enhanced) return;\n\n const selectEl = comboBoxEl.querySelector(\"select\");\n\n if (!selectEl) {\n throw new Error(`${COMBO_BOX} is missing inner select`);\n }\n\n const selectId = selectEl.id;\n const selectLabel = document.querySelector(`label[for=\"${selectId}\"]`);\n const listId = `${selectId}--list`;\n const listIdLabel = `${selectId}-label`;\n const additionalAttributes = [];\n const { defaultValue } = comboBoxEl.dataset;\n const { placeholder } = comboBoxEl.dataset;\n let selectedOption;\n\n if (placeholder) {\n additionalAttributes.push({ placeholder });\n }\n\n if (defaultValue) {\n for (let i = 0, len = selectEl.options.length; i < len; i += 1) {\n const optionEl = selectEl.options[i];\n\n if (optionEl.value === defaultValue) {\n selectedOption = optionEl;\n break;\n }\n }\n }\n\n /**\n * Throw error if combobox is missing a label or label is missing\n * `for` attribute. Otherwise, set the ID to match the <ul> aria-labelledby\n */\n if (!selectLabel || !selectLabel.matches(`label[for=\"${selectId}\"]`)) {\n throw new Error(\n `${COMBO_BOX} for ${selectId} is either missing a label or a \"for\" attribute`,\n );\n } else {\n selectLabel.setAttribute(\"id\", listIdLabel);\n }\n\n selectLabel.setAttribute(\"id\", listIdLabel);\n selectEl.setAttribute(\"aria-hidden\", \"true\");\n selectEl.setAttribute(\"tabindex\", \"-1\");\n selectEl.classList.add(\"usa-sr-only\", SELECT_CLASS);\n selectEl.id = \"\";\n selectEl.value = \"\";\n\n [\"required\", \"aria-label\", \"aria-labelledby\"].forEach((name) => {\n if (selectEl.hasAttribute(name)) {\n const value = selectEl.getAttribute(name);\n additionalAttributes.push({ [name]: value });\n selectEl.removeAttribute(name);\n }\n });\n\n // sanitize doesn't like functions in template literals\n const input = document.createElement(\"input\");\n input.setAttribute(\"id\", selectId);\n input.setAttribute(\"aria-owns\", listId);\n input.setAttribute(\"aria-controls\", listId);\n input.setAttribute(\"aria-autocomplete\", \"list\");\n input.setAttribute(\"aria-expanded\", \"false\");\n input.setAttribute(\"autocapitalize\", \"off\");\n input.setAttribute(\"autocomplete\", \"off\");\n input.setAttribute(\"class\", INPUT_CLASS);\n input.setAttribute(\"type\", \"text\");\n input.setAttribute(\"role\", \"combobox\");\n additionalAttributes.forEach((attr) =>\n Object.keys(attr).forEach((key) => {\n const value = Sanitizer.escapeHTML`${attr[key]}`;\n input.setAttribute(key, value);\n }),\n );\n\n comboBoxEl.insertAdjacentElement(\"beforeend\", input);\n\n comboBoxEl.insertAdjacentHTML(\n \"beforeend\",\n Sanitizer.escapeHTML`\n <span class=\"${CLEAR_INPUT_BUTTON_WRAPPER_CLASS}\" tabindex=\"-1\">\n <button type=\"button\" class=\"${CLEAR_INPUT_BUTTON_CLASS}\" aria-label=\"Clear the select contents\"> </button>\n </span>\n <span class=\"${INPUT_BUTTON_SEPARATOR_CLASS}\"> </span>\n <span class=\"${TOGGLE_LIST_BUTTON_WRAPPER_CLASS}\" tabindex=\"-1\">\n <button type=\"button\" tabindex=\"-1\" class=\"${TOGGLE_LIST_BUTTON_CLASS}\" aria-label=\"Toggle the dropdown list\"> </button>\n </span>\n <ul\n tabindex=\"-1\"\n id=\"${listId}\"\n class=\"${LIST_CLASS}\"\n role=\"listbox\"\n aria-labelledby=\"${listIdLabel}\"\n hidden>\n </ul>\n <div class=\"${STATUS_CLASS} usa-sr-only\" role=\"status\"></div>`,\n );\n\n if (selectedOption) {\n const { inputEl } = getComboBoxContext(comboBoxEl);\n changeElementValue(selectEl, selectedOption.value);\n changeElementValue(inputEl, selectedOption.text);\n comboBoxEl.classList.add(COMBO_BOX_PRISTINE_CLASS);\n }\n\n if (selectEl.disabled) {\n disable(comboBoxEl);\n selectEl.disabled = false;\n }\n\n if (selectEl.hasAttribute(\"aria-disabled\")) {\n ariaDisable(comboBoxEl);\n selectEl.removeAttribute(\"aria-disabled\");\n }\n\n comboBoxEl.dataset.enhanced = \"true\";\n};\n\n/**\n * Manage the focused element within the list options when\n * navigating via keyboard.\n *\n * @param {HTMLElement} el An anchor element within the combo box component\n * @param {HTMLElement} nextEl An element within the combo box component\n * @param {Object} options options\n * @param {boolean} options.skipFocus skip focus of highlighted item\n * @param {boolean} options.preventScroll should skip procedure to scroll to element\n */\nconst highlightOption = (el, nextEl, { skipFocus, preventScroll } = {}) => {\n const { inputEl, listEl, focusedOptionEl } = getComboBoxContext(el);\n\n if (focusedOptionEl) {\n focusedOptionEl.classList.remove(LIST_OPTION_FOCUSED_CLASS);\n focusedOptionEl.setAttribute(\"tabIndex\", \"-1\");\n }\n\n if (nextEl) {\n inputEl.setAttribute(\"aria-activedescendant\", nextEl.id);\n nextEl.setAttribute(\"tabIndex\", \"0\");\n nextEl.classList.add(LIST_OPTION_FOCUSED_CLASS);\n\n if (!preventScroll) {\n const optionBottom = nextEl.offsetTop + nextEl.offsetHeight;\n const currentBottom = listEl.scrollTop + listEl.offsetHeight;\n\n if (optionBottom > currentBottom) {\n listEl.scrollTop = optionBottom - listEl.offsetHeight;\n }\n\n if (nextEl.offsetTop < listEl.scrollTop) {\n listEl.scrollTop = nextEl.offsetTop;\n }\n }\n\n if (!skipFocus) {\n nextEl.focus({ preventScroll });\n }\n } else {\n inputEl.setAttribute(\"aria-activedescendant\", \"\");\n inputEl.focus();\n }\n};\n\n/**\n * Generate a dynamic regular expression based off of a replaceable and possibly filtered value.\n *\n * @param {string} el An element within the combo box component\n * @param {string} query The value to use in the regular expression\n * @param {object} extras An object of regular expressions to replace and filter the query\n */\nconst generateDynamicRegExp = (filter, query = \"\", extras = {}) => {\n const escapeRegExp = (text) =>\n text.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, \"\\\\$&\");\n\n let find = filter.replace(/{{(.*?)}}/g, (m, $1) => {\n const key = $1.trim();\n const queryFilter = extras[key];\n if (key !== \"query\" && queryFilter) {\n const matcher = new RegExp(queryFilter, \"i\");\n const matches = query.match(matcher);\n\n if (matches) {\n return escapeRegExp(matches[1]);\n }\n\n return \"\";\n }\n return escapeRegExp(query);\n });\n\n find = `^(?:${find})$`;\n\n return new RegExp(find, \"i\");\n};\n\n/**\n * Display the option list of a combo box component.\n *\n * @param {HTMLElement} el An element within the combo box component\n */\nconst displayList = (el) => {\n const {\n comboBoxEl,\n selectEl,\n inputEl,\n listEl,\n statusEl,\n isPristine,\n disableFiltering,\n } = getComboBoxContext(el);\n let selectedItemId;\n let firstFoundId;\n\n const listOptionBaseId = `${listEl.id}--option-`;\n\n const inputValue = (inputEl.value || \"\").toLowerCase();\n const filter = comboBoxEl.dataset.filter || DEFAULT_FILTER;\n const regex = generateDynamicRegExp(filter, inputValue, comboBoxEl.dataset);\n\n let options = [];\n const optionsStartsWith = [];\n const optionsContains = [];\n const optionList = [...selectEl.options];\n\n /**\n * Builds and sorts options array.\n *\n * Option param is passed through regex test before passing into this function.\n * When filtering is enabled, the array will be sorted by options that start with the query, followed by\n * options that contain the query.\n * When filtering is disabled, all options will be included in the array unsorted.\n *\n * These array items will populate the list that is displayed to the user after a search query is entered.\n * Array attributes are also used to set option IDs and aria-setsize attributes.\n *\n * @param {HTMLOptionElement} option - Option element from select array\n */\n const buildOptionsArray = (option) => {\n if (disableFiltering || isPristine) {\n options.push(option);\n return;\n }\n\n const matchStartsWith = option.text.toLowerCase().startsWith(inputValue);\n\n if (matchStartsWith) {\n optionsStartsWith.push(option);\n } else {\n optionsContains.push(option);\n }\n\n options = [...optionsStartsWith, ...optionsContains];\n };\n\n /**\n * Compares option text to query using generated regex filter.\n *\n * @param {HTMLOptionElement} option\n * @returns {boolean} - True when option text matches user input query.\n */\n const optionMatchesQuery = (option) => regex.test(option.text);\n\n /**\n * Logic check to determine if options array needs to be updated.\n *\n * @param {HTMLOptionElement} option\n * @returns {boolean} - True when option has value && if filtering is disabled, combo box has an active selection,\n * there is no inputValue, or if option matches user query\n */\n const arrayNeedsUpdate = (option) =>\n option.value &&\n (disableFiltering ||\n isPristine ||\n !inputValue ||\n optionMatchesQuery(option));\n\n /**\n * Checks if firstFoundId should be assigned, which is then used to set itemToFocus.\n *\n * @param {HTMLOptionElement} option\n * @return {boolean} - Returns true if filtering is disabled, no firstFoundId is assigned, and the option matches the query.\n */\n const isFirstMatch = (option) =>\n disableFiltering && !firstFoundId && optionMatchesQuery(option);\n\n /**\n * Checks if isCurrentSelection should be assigned, which is then used to set itemToFocus.\n *\n * @param {HTMLOptionElement} option\n * @returns {boolean} - Returns true if option.value matches selectEl.value.\n */\n const isCurrentSelection = (option) =>\n selectEl.value && option.value === selectEl.value;\n\n /**\n * Update the array of options that should be displayed on the page.\n * Assign an ID to each displayed option.\n * Identify and assign the option that should receive focus.\n */\n optionList.forEach((option) => {\n if (arrayNeedsUpdate(option)) {\n buildOptionsArray(option);\n\n const optionId = `${listOptionBaseId}${options.indexOf(option)}`;\n\n if (isFirstMatch(option)) {\n firstFoundId = optionId;\n }\n\n if (isCurrentSelection(option)) {\n selectedItemId = optionId;\n }\n }\n });\n\n const numOptions = options.length;\n const optionHtml = options.map((option, index) => {\n const optionId = `${listOptionBaseId}${index}`;\n const classes = [LIST_OPTION_CLASS];\n let tabindex = \"-1\";\n let ariaSelected = \"false\";\n\n if (optionId === selectedItemId) {\n classes.push(LIST_OPTION_SELECTED_CLASS, LIST_OPTION_FOCUSED_CLASS);\n tabindex = \"0\";\n ariaSelected = \"true\";\n }\n\n if (!selectedItemId && index === 0) {\n classes.push(LIST_OPTION_FOCUSED_CLASS);\n tabindex = \"0\";\n }\n\n const li = document.createElement(\"li\");\n\n li.setAttribute(\"aria-setsize\", options.length);\n li.setAttribute(\"aria-posinset\", index + 1);\n li.setAttribute(\"aria-selected\", ariaSelected);\n li.setAttribute(\"id\", optionId);\n li.setAttribute(\"class\", classes.join(\" \"));\n li.setAttribute(\"tabindex\", tabindex);\n li.setAttribute(\"role\", \"option\");\n li.setAttribute(\"data-value\", option.value);\n li.textContent = option.text;\n\n return li;\n });\n\n const noResults = document.createElement(\"li\");\n noResults.setAttribute(\"class\", `${LIST_OPTION_CLASS}--no-results`);\n noResults.textContent = \"No results found\";\n\n listEl.hidden = false;\n\n if (numOptions) {\n listEl.innerHTML = \"\";\n optionHtml.forEach((item) =>\n listEl.insertAdjacentElement(\"beforeend\", item),\n );\n } else {\n listEl.innerHTML = \"\";\n listEl.insertAdjacentElement(\"beforeend\", noResults);\n }\n\n inputEl.setAttribute(\"aria-expanded\", \"true\");\n\n statusEl.textContent = numOptions\n ? `${numOptions} result${numOptions > 1 ? \"s\" : \"\"} available.`\n : \"No results.\";\n\n let itemToFocus;\n\n if (isPristine && selectedItemId) {\n itemToFocus = listEl.querySelector(`#${selectedItemId}`);\n } else if (disableFiltering && firstFoundId) {\n itemToFocus = listEl.querySelector(`#${firstFoundId}`);\n }\n\n if (itemToFocus) {\n highlightOption(listEl, itemToFocus, {\n skipFocus: true,\n });\n }\n};\n\n/**\n * Hide the option list of a combo box component.\n *\n * @param {HTMLElement} el An element within the combo box component\n */\nconst hideList = (el) => {\n const { inputEl, listEl, statusEl, focusedOptionEl } = getComboBoxContext(el);\n\n statusEl.innerHTML = \"\";\n\n inputEl.setAttribute(\"aria-expanded\", \"false\");\n inputEl.setAttribute(\"aria-activedescendant\", \"\");\n\n if (focusedOptionEl) {\n focusedOptionEl.classList.remove(LIST_OPTION_FOCUSED_CLASS);\n }\n\n listEl.scrollTop = 0;\n listEl.hidden = true;\n};\n\n/**\n * Select an option list of the combo box component.\n *\n * @param {HTMLElement} listOptionEl The list option being selected\n */\nconst selectItem = (listOptionEl) => {\n const { comboBoxEl, selectEl, inputEl } = getComboBoxContext(listOptionEl);\n\n changeElementValue(selectEl, listOptionEl.dataset.value);\n changeElementValue(inputEl, listOptionEl.textContent);\n comboBoxEl.classList.add(COMBO_BOX_PRISTINE_CLASS);\n hideList(comboBoxEl);\n inputEl.focus();\n};\n\n/**\n * Clear the input of the combo box\n *\n * @param {HTMLButtonElement} clearButtonEl The clear input button\n */\nconst clearInput = (clearButtonEl) => {\n const { comboBoxEl, listEl, selectEl, inputEl } =\n getComboBoxContext(clearButtonEl);\n const listShown = !listEl.hidden;\n\n if (selectEl.value) changeElementValue(selectEl);\n if (inputEl.value) changeElementValue(inputEl);\n comboBoxEl.classList.remove(COMBO_BOX_PRISTINE_CLASS);\n\n if (listShown) displayList(comboBoxEl);\n inputEl.focus();\n};\n\n/**\n * Reset the select based off of currently set select value\n *\n * @param {HTMLElement} el An element within the combo box component\n */\nconst resetSelection = (el) => {\n const { comboBoxEl, selectEl, inputEl } = getComboBoxContext(el);\n\n const selectValue = selectEl.value;\n const inputValue = (inputEl.value || \"\").toLowerCase();\n\n if (selectValue) {\n for (let i = 0, len = selectEl.options.length; i < len; i += 1) {\n const optionEl = selectEl.options[i];\n if (optionEl.value === selectValue) {\n if (inputValue !== optionEl.text) {\n changeElementValue(inputEl, optionEl.text);\n }\n comboBoxEl.classList.add(COMBO_BOX_PRISTINE_CLASS);\n return;\n }\n }\n }\n\n if (inputValue) {\n changeElementValue(inputEl);\n }\n};\n\n/**\n * Select an option list of the combo box component based off of\n * having a current focused list option or\n * having test that completely matches a list option.\n * Otherwise it clears the input and select.\n *\n * @param {HTMLElement} el An element within the combo box component\n */\nconst completeSelection = (el) => {\n const { comboBoxEl, selectEl, inputEl, statusEl } = getComboBoxContext(el);\n\n statusEl.textContent = \"\";\n\n const inputValue = (inputEl.value || \"\").toLowerCase();\n\n if (inputValue) {\n for (let i = 0, len = selectEl.options.length; i < len; i += 1) {\n const optionEl = selectEl.options[i];\n if (optionEl.text.toLowerCase() === inputValue) {\n changeElementValue(selectEl, optionEl.value);\n changeElementValue(inputEl, optionEl.text);\n comboBoxEl.classList.add(COMBO_BOX_PRISTINE_CLASS);\n return;\n }\n }\n }\n\n resetSelection(comboBoxEl);\n};\n\n/**\n * Handle the escape event within the combo box component.\n *\n * @param {KeyboardEvent} event An event within the combo box component\n */\nconst handleEscape = (event) => {\n const { comboBoxEl, inputEl } = getComboBoxContext(event.target);\n\n hideList(comboBoxEl);\n resetSelection(comboBoxEl);\n inputEl.focus();\n};\n\n/**\n * Handle the down event within the combo box component.\n *\n * @param {KeyboardEvent} event An event within the combo box component\n */\nconst handleDownFromInput = (event) => {\n const { comboBoxEl, listEl } = getComboBoxContext(event.target);\n\n if (listEl.hidden) {\n displayList(comboBoxEl);\n }\n\n const nextOptionEl =\n listEl.querySelector(LIST_OPTION_FOCUSED) ||\n listEl.querySelector(LIST_OPTION);\n\n if (nextOptionEl) {\n highlightOption(comboBoxEl, nextOptionEl);\n }\n\n event.preventDefault();\n};\n\n/**\n * Handle the enter event from an input element within the combo box component.\n *\n * @param {KeyboardEvent} event An event within the combo box component\n */\nconst handleEnterFromInput = (event) => {\n const { comboBoxEl, listEl } = getComboBoxContext(event.target);\n const listShown = !listEl.hidden;\n\n completeSelection(comboBoxEl);\n\n if (listShown) {\n hideList(comboBoxEl);\n }\n\n event.preventDefault();\n};\n\n/**\n * Handle the down event within the combo box component.\n *\n * @param {KeyboardEvent} event An event within the combo box component\n */\nconst handleDownFromListOption = (event) => {\n const focusedOptionEl = event.target;\n const nextOptionEl = focusedOptionEl.nextSibling;\n\n if (nextOptionEl) {\n highlightOption(focusedOptionEl, nextOptionEl);\n }\n\n event.preventDefault();\n};\n\n/**\n * Handle the space event from an list option element within the combo box component.\n *\n * @param {KeyboardEvent} event An event within the combo box component\n */\nconst handleSpaceFromListOption = (event) => {\n selectItem(event.target);\n event.preventDefault();\n};\n\n/**\n * Handle the enter event from list option within the combo box component.\n *\n * @param {KeyboardEvent} event An event within the combo box component\n */\nconst handleEnterFromListOption = (event) => {\n selectItem(event.target);\n event.preventDefault();\n};\n\n/**\n * Handle the up event from list option within the combo box component.\n *\n * @param {KeyboardEvent} event An event within the combo box component\n */\nconst handleUpFromListOption = (event) => {\n const { comboBoxEl, listEl, focusedOptionEl } = getComboBoxContext(\n event.target,\n );\n const nextOptionEl = focusedOptionEl && focusedOptionEl.previousSibling;\n const listShown = !listEl.hidden;\n\n highlightOption(comboBoxEl, nextOptionEl);\n\n if (listShown) {\n event.preventDefault();\n }\n\n if (!nextOptionEl) {\n hideList(comboBoxEl);\n }\n};\n\n/**\n * Select list option on the mouseover event.\n *\n * @param {MouseEvent} event The mouseover event\n * @param {HTMLLIElement} listOptionEl An element within the combo box component\n */\nconst handleMouseover = (listOptionEl) => {\n const isCurrentlyFocused = listOptionEl.classList.contains(\n LIST_OPTION_FOCUSED_CLASS,\n );\n\n if (isCurrentlyFocused) return;\n\n highlightOption(listOptionEl, listOptionEl, {\n preventScroll: true,\n });\n};\n\n/**\n * Toggle the list when the button is clicked\n *\n * @param {HTMLElement} el An element within the combo box component\n */\nconst toggleList = (el) => {\n const { comboBoxEl, listEl, inputEl } = getComboBoxContext(el);\n\n if (listEl.hidden) {\n displayList(comboBoxEl);\n } else {\n hideList(comboBoxEl);\n }\n\n inputEl.focus();\n};\n\n/**\n * Handle click from input\n *\n * @param {HTMLInputElement} el An element within the combo box component\n */\nconst handleClickFromInput = (el) => {\n const { comboBoxEl, listEl } = getComboBoxContext(el);\n\n if (listEl.hidden) {\n displayList(comboBoxEl);\n }\n};\n\nconst comboBox = behavior(\n {\n [CLICK]: {\n [INPUT]() {\n if (this.disabled) return;\n handleClickFromInput(this);\n },\n [TOGGLE_LIST_BUTTON]() {\n if (this.disabled) return;\n toggleList(this);\n },\n [LIST_OPTION]() {\n if (this.disabled) return;\n selectItem(this);\n },\n [CLEAR_INPUT_BUTTON]() {\n if (this.disabled) return;\n clearInput(this);\n },\n },\n focusout: {\n [COMBO_BOX](event) {\n if (!this.contains(event.relatedTarget)) {\n resetSelection(this);\n hideList(this);\n }\n },\n },\n keydown: {\n [COMBO_BOX]: keymap({\n Escape: handleEscape,\n }),\n [INPUT]: keymap({\n Enter: handleEnterFromInput,\n ArrowDown: handleDownFromInput,\n Down: handleDownFromInput,\n }),\n [LIST_OPTION]: keymap({\n ArrowUp: handleUpFromListOption,\n Up: handleUpFromListOption,\n ArrowDown: handleDownFromListOption,\n Down: handleDownFromListOption,\n Enter: handleEnterFromListOption,\n \" \": handleSpaceFromListOption,\n \"Shift+Tab\": noop,\n }),\n },\n input: {\n [INPUT]() {\n const comboBoxEl = this.closest(COMBO_BOX);\n comboBoxEl.classList.remove(COMBO_BOX_PRISTINE_CLASS);\n displayList(this);\n },\n },\n mouseover: {\n [LIST_OPTION]() {\n handleMouseover(this);\n },\n },\n },\n {\n init(root) {\n selectOrMatches(COMBO_BOX, root).forEach((comboBoxEl) => {\n enhanceComboBox(comboBoxEl);\n });\n },\n getComboBoxContext,\n enhanceComboBox,\n generateDynamicRegExp,\n disable,\n enable,\n displayList,\n hideList,\n COMBO_BOX_CLASS,\n },\n);\n\nmodule.exports = comboBox;\n","const keymap = require(\"receptor/keymap\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst select = require(\"../../uswds-core/src/js/utils/select\");\nconst selectOrMatches = require(\"../../uswds-core/src/js/utils/select-or-matches\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\nconst { CLICK } = require(\"../../uswds-core/src/js/events\");\nconst activeElement = require(\"../../uswds-core/src/js/utils/active-element\");\nconst isIosDevice = require(\"../../uswds-core/src/js/utils/is-ios-device\");\nconst Sanitizer = require(\"../../uswds-core/src/js/utils/sanitizer\");\n\nconst DATE_PICKER_CLASS = `${PREFIX}-date-picker`;\nconst DATE_PICKER_WRAPPER_CLASS = `${DATE_PICKER_CLASS}__wrapper`;\nconst DATE_PICKER_INITIALIZED_CLASS = `${DATE_PICKER_CLASS}--initialized`;\nconst DATE_PICKER_ACTIVE_CLASS = `${DATE_PICKER_CLASS}--active`;\nconst DATE_PICKER_INTERNAL_INPUT_CLASS = `${DATE_PICKER_CLASS}__internal-input`;\nconst DATE_PICKER_EXTERNAL_INPUT_CLASS = `${DATE_PICKER_CLASS}__external-input`;\nconst DATE_PICKER_BUTTON_CLASS = `${DATE_PICKER_CLASS}__button`;\nconst DATE_PICKER_CALENDAR_CLASS = `${DATE_PICKER_CLASS}__calendar`;\nconst DATE_PICKER_STATUS_CLASS = `${DATE_PICKER_CLASS}__status`;\nconst CALENDAR_DATE_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__date`;\n\nconst CALENDAR_DATE_FOCUSED_CLASS = `${CALENDAR_DATE_CLASS}--focused`;\nconst CALENDAR_DATE_SELECTED_CLASS = `${CALENDAR_DATE_CLASS}--selected`;\nconst CALENDAR_DATE_PREVIOUS_MONTH_CLASS = `${CALENDAR_DATE_CLASS}--previous-month`;\nconst CALENDAR_DATE_CURRENT_MONTH_CLASS = `${CALENDAR_DATE_CLASS}--current-month`;\nconst CALENDAR_DATE_NEXT_MONTH_CLASS = `${CALENDAR_DATE_CLASS}--next-month`;\nconst CALENDAR_DATE_RANGE_DATE_CLASS = `${CALENDAR_DATE_CLASS}--range-date`;\nconst CALENDAR_DATE_TODAY_CLASS = `${CALENDAR_DATE_CLASS}--today`;\nconst CALENDAR_DATE_RANGE_DATE_START_CLASS = `${CALENDAR_DATE_CLASS}--range-date-start`;\nconst CALENDAR_DATE_RANGE_DATE_END_CLASS = `${CALENDAR_DATE_CLASS}--range-date-end`;\nconst CALENDAR_DATE_WITHIN_RANGE_CLASS = `${CALENDAR_DATE_CLASS}--within-range`;\nconst CALENDAR_PREVIOUS_YEAR_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__previous-year`;\nconst CALENDAR_PREVIOUS_MONTH_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__previous-month`;\nconst CALENDAR_NEXT_YEAR_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__next-year`;\nconst CALENDAR_NEXT_MONTH_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__next-month`;\nconst CALENDAR_MONTH_SELECTION_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__month-selection`;\nconst CALENDAR_YEAR_SELECTION_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__year-selection`;\nconst CALENDAR_MONTH_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__month`;\nconst CALENDAR_MONTH_FOCUSED_CLASS = `${CALENDAR_MONTH_CLASS}--focused`;\nconst CALENDAR_MONTH_SELECTED_CLASS = `${CALENDAR_MONTH_CLASS}--selected`;\nconst CALENDAR_YEAR_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__year`;\nconst CALENDAR_YEAR_FOCUSED_CLASS = `${CALENDAR_YEAR_CLASS}--focused`;\nconst CALENDAR_YEAR_SELECTED_CLASS = `${CALENDAR_YEAR_CLASS}--selected`;\nconst CALENDAR_PREVIOUS_YEAR_CHUNK_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__previous-year-chunk`;\nconst CALENDAR_NEXT_YEAR_CHUNK_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__next-year-chunk`;\nconst CALENDAR_DATE_PICKER_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__date-picker`;\nconst CALENDAR_MONTH_PICKER_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__month-picker`;\nconst CALENDAR_YEAR_PICKER_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__year-picker`;\nconst CALENDAR_TABLE_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__table`;\nconst CALENDAR_ROW_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__row`;\nconst CALENDAR_CELL_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__cell`;\nconst CALENDAR_CELL_CENTER_ITEMS_CLASS = `${CALENDAR_CELL_CLASS}--center-items`;\nconst CALENDAR_MONTH_LABEL_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__month-label`;\nconst CALENDAR_DAY_OF_WEEK_CLASS = `${DATE_PICKER_CALENDAR_CLASS}__day-of-week`;\n\nconst DATE_PICKER = `.${DATE_PICKER_CLASS}`;\nconst DATE_PICKER_BUTTON = `.${DATE_PICKER_BUTTON_CLASS}`;\nconst DATE_PICKER_INTERNAL_INPUT = `.${DATE_PICKER_INTERNAL_INPUT_CLASS}`;\nconst DATE_PICKER_EXTERNAL_INPUT = `.${DATE_PICKER_EXTERNAL_INPUT_CLASS}`;\nconst DATE_PICKER_CALENDAR = `.${DATE_PICKER_CALENDAR_CLASS}`;\nconst DATE_PICKER_STATUS = `.${DATE_PICKER_STATUS_CLASS}`;\nconst CALENDAR_DATE = `.${CALENDAR_DATE_CLASS}`;\nconst CALENDAR_DATE_FOCUSED = `.${CALENDAR_DATE_FOCUSED_CLASS}`;\nconst CALENDAR_DATE_CURRENT_MONTH = `.${CALENDAR_DATE_CURRENT_MONTH_CLASS}`;\nconst CALENDAR_PREVIOUS_YEAR = `.${CALENDAR_PREVIOUS_YEAR_CLASS}`;\nconst CALENDAR_PREVIOUS_MONTH = `.${CALENDAR_PREVIOUS_MONTH_CLASS}`;\nconst CALENDAR_NEXT_YEAR = `.${CALENDAR_NEXT_YEAR_CLASS}`;\nconst CALENDAR_NEXT_MONTH = `.${CALENDAR_NEXT_MONTH_CLASS}`;\nconst CALENDAR_YEAR_SELECTION = `.${CALENDAR_YEAR_SELECTION_CLASS}`;\nconst CALENDAR_MONTH_SELECTION = `.${CALENDAR_MONTH_SELECTION_CLASS}`;\nconst CALENDAR_MONTH = `.${CALENDAR_MONTH_CLASS}`;\nconst CALENDAR_YEAR = `.${CALENDAR_YEAR_CLASS}`;\nconst CALENDAR_PREVIOUS_YEAR_CHUNK = `.${CALENDAR_PREVIOUS_YEAR_CHUNK_CLASS}`;\nconst CALENDAR_NEXT_YEAR_CHUNK = `.${CALENDAR_NEXT_YEAR_CHUNK_CLASS}`;\nconst CALENDAR_DATE_PICKER = `.${CALENDAR_DATE_PICKER_CLASS}`;\nconst CALENDAR_MONTH_PICKER = `.${CALENDAR_MONTH_PICKER_CLASS}`;\nconst CALENDAR_YEAR_PICKER = `.${CALENDAR_YEAR_PICKER_CLASS}`;\nconst CALENDAR_MONTH_FOCUSED = `.${CALENDAR_MONTH_FOCUSED_CLASS}`;\nconst CALENDAR_YEAR_FOCUSED = `.${CALENDAR_YEAR_FOCUSED_CLASS}`;\n\nconst VALIDATION_MESSAGE = \"Please enter a valid date\";\n\nconst MONTH_LABELS = [\n \"January\",\n \"February\",\n \"March\",\n \"April\",\n \"May\",\n \"June\",\n \"July\",\n \"August\",\n \"September\",\n \"October\",\n \"November\",\n \"December\",\n];\n\nconst DAY_OF_WEEK_LABELS = [\n \"Sunday\",\n \"Monday\",\n \"Tuesday\",\n \"Wednesday\",\n \"Thursday\",\n \"Friday\",\n \"Saturday\",\n];\n\nconst ENTER_KEYCODE = 13;\n\nconst YEAR_CHUNK = 12;\n\nconst DEFAULT_MIN_DATE = \"0000-01-01\";\nconst DEFAULT_EXTERNAL_DATE_FORMAT = \"MM/DD/YYYY\";\nconst INTERNAL_DATE_FORMAT = \"YYYY-MM-DD\";\n\nconst NOT_DISABLED_SELECTOR = \":not([disabled])\";\n\nconst processFocusableSelectors = (...selectors) =>\n selectors.map((query) => query + NOT_DISABLED_SELECTOR).join(\", \");\n\nconst DATE_PICKER_FOCUSABLE = processFocusableSelectors(\n CALENDAR_PREVIOUS_YEAR,\n CALENDAR_PREVIOUS_MONTH,\n CALENDAR_YEAR_SELECTION,\n CALENDAR_MONTH_SELECTION,\n CALENDAR_NEXT_YEAR,\n CALENDAR_NEXT_MONTH,\n CALENDAR_DATE_FOCUSED,\n);\n\nconst MONTH_PICKER_FOCUSABLE = processFocusableSelectors(\n CALENDAR_MONTH_FOCUSED,\n);\n\nconst YEAR_PICKER_FOCUSABLE = processFocusableSelectors(\n CALENDAR_PREVIOUS_YEAR_CHUNK,\n CALENDAR_NEXT_YEAR_CHUNK,\n CALENDAR_YEAR_FOCUSED,\n);\n\n// #region Date Manipulation Functions\n\n/**\n * Keep date within month. Month would only be over by 1 to 3 days\n *\n * @param {Date} dateToCheck the date object to check\n * @param {number} month the correct month\n * @returns {Date} the date, corrected if needed\n */\nconst keepDateWithinMonth = (dateToCheck, month) => {\n if (month !== dateToCheck.getMonth()) {\n dateToCheck.setDate(0);\n }\n\n return dateToCheck;\n};\n\n/**\n * Set date from month day year\n *\n * @param {number} year the year to set\n * @param {number} month the month to set (zero-indexed)\n * @param {number} date the date to set\n * @returns {Date} the set date\n */\nconst setDate = (year, month, date) => {\n const newDate = new Date(0);\n newDate.setFullYear(year, month, date);\n return newDate;\n};\n\n/**\n * todays date\n *\n * @returns {Date} todays date\n */\nconst today = () => {\n const newDate = new Date();\n const day = newDate.getDate();\n const month = newDate.getMonth();\n const year = newDate.getFullYear();\n return setDate(year, month, day);\n};\n\n/**\n * Set date to first day of the month\n *\n * @param {number} date the date to adjust\n * @returns {Date} the adjusted date\n */\nconst startOfMonth = (date) => {\n const newDate = new Date(0);\n newDate.setFullYear(date.getFullYear(), date.getMonth(), 1);\n return newDate;\n};\n\n/**\n * Set date to last day of the month\n *\n * @param {number} date the date to adjust\n * @returns {Date} the adjusted date\n */\nconst lastDayOfMonth = (date) => {\n const newDate = new Date(0);\n newDate.setFullYear(date.getFullYear(), date.getMonth() + 1, 0);\n return newDate;\n};\n\n/**\n * Add days to date\n *\n * @param {Date} _date the date to adjust\n * @param {number} numDays the difference in days\n * @returns {Date} the adjusted date\n */\nconst addDays = (_date, numDays) => {\n const newDate = new Date(_date.getTime());\n newDate.setDate(newDate.getDate() + numDays);\n return newDate;\n};\n\n/**\n * Subtract days from date\n *\n * @param {Date} _date the date to adjust\n * @param {number} numDays the difference in days\n * @returns {Date} the adjusted date\n */\nconst subDays = (_date, numDays) => addDays(_date, -numDays);\n\n/**\n * Add weeks to date\n *\n * @param {Date} _date the date to adjust\n * @param {number} numWeeks the difference in weeks\n * @returns {Date} the adjusted date\n */\nconst addWeeks = (_date, numWeeks) => addDays(_date, numWeeks * 7);\n\n/**\n * Subtract weeks from date\n *\n * @param {Date} _date the date to adjust\n * @param {number} numWeeks the difference in weeks\n * @returns {Date} the adjusted date\n */\nconst subWeeks = (_date, numWeeks) => addWeeks(_date, -numWeeks);\n\n/**\n * Set date to the start of the week (Sunday)\n *\n * @param {Date} _date the date to adjust\n * @returns {Date} the adjusted date\n */\nconst startOfWeek = (_date) => {\n const dayOfWeek = _date.getDay();\n return subDays(_date, dayOfWeek);\n};\n\n/**\n * Set date to the end of the week (Saturday)\n *\n * @param {Date} _date the date to adjust\n * @param {number} numWeeks the difference in weeks\n * @returns {Date} the adjusted date\n */\nconst endOfWeek = (_date) => {\n const dayOfWeek = _date.getDay();\n return addDays(_date, 6 - dayOfWeek);\n};\n\n/**\n * Add months to date and keep date within month\n *\n * @param {Date} _date the date to adjust\n * @param {number} numMonths the difference in months\n * @returns {Date} the adjusted date\n */\nconst addMonths = (_date, numMonths) => {\n const newDate = new Date(_date.getTime());\n\n const dateMonth = (newDate.getMonth() + 12 + numMonths) % 12;\n newDate.setMonth(newDate.getMonth() + numMonths);\n keepDateWithinMonth(newDate, dateMonth);\n\n return newDate;\n};\n\n/**\n * Subtract months from date\n *\n * @param {Date} _date the date to adjust\n * @param {number} numMonths the difference in months\n * @returns {Date} the adjusted date\n */\nconst subMonths = (_date, numMonths) => addMonths(_date, -numMonths);\n\n/**\n * Add years to date and keep date within month\n *\n * @param {Date} _date the date to adjust\n * @param {number} numYears the difference in years\n * @returns {Date} the adjusted date\n */\nconst addYears = (_date, numYears) => addMonths(_date, numYears * 12);\n\n/**\n * Subtract years from date\n *\n * @param {Date} _date the date to adjust\n * @param {number} numYears the difference in years\n * @returns {Date} the adjusted date\n */\nconst subYears = (_date, numYears) => addYears(_date, -numYears);\n\n/**\n * Set months of date\n *\n * @param {Date} _date the date to adjust\n * @param {number} month zero-indexed month to set\n * @returns {Date} the adjusted date\n */\nconst setMonth = (_date, month) => {\n const newDate = new Date(_date.getTime());\n\n newDate.setMonth(month);\n keepDateWithinMonth(newDate, month);\n\n return newDate;\n};\n\n/**\n * Set year of date\n *\n * @param {Date} _date the date to adjust\n * @param {number} year the year to set\n * @returns {Date} the adjusted date\n */\nconst setYear = (_date, year) => {\n const newDate = new Date(_date.getTime());\n\n const month = newDate.getMonth();\n newDate.setFullYear(year);\n keepDateWithinMonth(newDate, month);\n\n return newDate;\n};\n\n/**\n * Return the earliest date\n *\n * @param {Date} dateA date to compare\n * @param {Date} dateB date to compare\n * @returns {Date} the earliest date\n */\nconst min = (dateA, dateB) => {\n let newDate = dateA;\n\n if (dateB < dateA) {\n newDate = dateB;\n }\n\n return new Date(newDate.getTime());\n};\n\n/**\n * Return the latest date\n *\n * @param {Date} dateA date to compare\n * @param {Date} dateB date to compare\n * @returns {Date} the latest date\n */\nconst max = (dateA, dateB) => {\n let newDate = dateA;\n\n if (dateB > dateA) {\n newDate = dateB;\n }\n\n return new Date(newDate.getTime());\n};\n\n/**\n * Check if dates are the in the same year\n *\n * @param {Date} dateA date to compare\n * @param {Date} dateB date to compare\n * @returns {boolean} are dates in the same year\n */\nconst isSameYear = (dateA, dateB) =>\n dateA && dateB && dateA.getFullYear() === dateB.getFullYear();\n\n/**\n * Check if dates are the in the same month\n *\n * @param {Date} dateA date to compare\n * @param {Date} dateB date to compare\n * @returns {boolean} are dates in the same month\n */\nconst isSameMonth = (dateA, dateB) =>\n isSameYear(dateA, dateB) && dateA.getMonth() === dateB.getMonth();\n\n/**\n * Check if dates are the same date\n *\n * @param {Date} dateA the date to compare\n * @param {Date} dateA the date to compare\n * @returns {boolean} are dates the same date\n */\nconst isSameDay = (dateA, dateB) =>\n isSameMonth(dateA, dateB) && dateA.getDate() === dateB.getDate();\n\n/**\n * return a new date within minimum and maximum date\n *\n * @param {Date} date date to check\n * @param {Date} minDate minimum date to allow\n * @param {Date} maxDate maximum date to allow\n * @returns {Date} the date between min and max\n */\nconst keepDateBetweenMinAndMax = (date, minDate, maxDate) => {\n let newDate = date;\n\n if (date < minDate) {\n newDate = minDate;\n } else if (maxDate && date > maxDate) {\n newDate = maxDate;\n }\n\n return new Date(newDate.getTime());\n};\n\n/**\n * Check if dates is valid.\n *\n * @param {Date} date date to check\n * @param {Date} minDate minimum date to allow\n * @param {Date} maxDate maximum date to allow\n * @return {boolean} is there a day within the month within min and max dates\n */\nconst isDateWithinMinAndMax = (date, minDate, maxDate) =>\n date >= minDate && (!maxDate || date <= maxDate);\n\n/**\n * Check if dates month is invalid.\n *\n * @param {Date} date date to check\n * @param {Date} minDate minimum date to allow\n * @param {Date} maxDate maximum date to allow\n * @return {boolean} is the month outside min or max dates\n */\nconst isDatesMonthOutsideMinOrMax = (date, minDate, maxDate) =>\n lastDayOfMonth(date) < minDate || (maxDate && startOfMonth(date) > maxDate);\n\n/**\n * Check if dates year is invalid.\n *\n * @param {Date} date date to check\n * @param {Date} minDate minimum date to allow\n * @param {Date} maxDate maximum date to allow\n * @return {boolean} is the month outside min or max dates\n */\nconst isDatesYearOutsideMinOrMax = (date, minDate, maxDate) =>\n lastDayOfMonth(setMonth(date, 11)) < minDate ||\n (maxDate && startOfMonth(setMonth(date, 0)) > maxDate);\n\n/**\n * @typedef {Object} DateRangeContext\n * @property {Date} rangeStartDate\n * @property {Date} rangeEndDate\n * @property {Date} withinRangeStartDate\n * @property {Date} withinRangeEndDate\n */\n\n/**\n * Set the start, end, and within range values for date range variants.\n\n * @param {Date} date - Date that concludes the date range.\n * @param {Date} rangeDate - Range date data attribute value of the date picker component.\n * @returns {DateRangeContext} - Dates for range selection.\n */\nconst setRangeDates = (date, rangeDate) => {\n const rangeConclusionDate = date;\n const rangeStartDate = rangeDate && min(rangeConclusionDate, rangeDate);\n const rangeEndDate = rangeDate && max(rangeConclusionDate, rangeDate);\n\n const withinRangeStartDate = rangeDate && addDays(rangeStartDate, 1);\n const withinRangeEndDate = rangeDate && subDays(rangeEndDate, 1);\n\n return {\n rangeStartDate,\n rangeEndDate,\n withinRangeStartDate,\n withinRangeEndDate,\n };\n};\n\n/**\n * Parse a date with format M-D-YY\n *\n * @param {string} dateString the date string to parse\n * @param {string} dateFormat the format of the date string\n * @param {boolean} adjustDate should the date be adjusted\n * @returns {Date} the parsed date\n */\nconst parseDateString = (\n dateString,\n dateFormat = INTERNAL_DATE_FORMAT,\n adjustDate = false,\n) => {\n let date;\n let month;\n let day;\n let year;\n let parsed;\n\n if (dateString) {\n let monthStr;\n let dayStr;\n let yearStr;\n\n if (dateFormat === DEFAULT_EXTERNAL_DATE_FORMAT) {\n [monthStr, dayStr, yearStr] = dateString.split(\"/\");\n } else {\n [yearStr, monthStr, dayStr] = dateString.split(\"-\");\n }\n\n if (yearStr) {\n parsed = parseInt(yearStr, 10);\n if (!Number.isNaN(parsed)) {\n year = parsed;\n if (adjustDate) {\n year = Math.max(0, year);\n if (yearStr.length < 3) {\n const currentYear = today().getFullYear();\n const currentYearStub =\n currentYear - (currentYear % 10 ** yearStr.length);\n year = currentYearStub + parsed;\n }\n }\n }\n }\n\n if (monthStr) {\n parsed = parseInt(monthStr, 10);\n if (!Number.isNaN(parsed)) {\n month = parsed;\n if (adjustDate) {\n month = Math.max(1, month);\n month = Math.min(12, month);\n }\n }\n }\n\n if (month && dayStr && year != null) {\n parsed = parseInt(dayStr, 10);\n if (!Number.isNaN(parsed)) {\n day = parsed;\n if (adjustDate) {\n const lastDayOfTheMonth = setDate(year, month, 0).getDate();\n day = Math.max(1, day);\n day = Math.min(lastDayOfTheMonth, day);\n }\n }\n }\n\n if (month && day && year != null) {\n date = setDate(year, month - 1, day);\n }\n }\n\n return date;\n};\n\n/**\n * Format a date to format MM-DD-YYYY\n *\n * @param {Date} date the date to format\n * @param {string} dateFormat the format of the date string\n * @returns {string} the formatted date string\n */\nconst formatDate = (date, dateFormat = INTERNAL_DATE_FORMAT) => {\n const padZeros = (value, length) => `0000${value}`.slice(-length);\n\n const month = date.getMonth() + 1;\n const day = date.getDate();\n const year = date.getFullYear();\n\n if (dateFormat === DEFAULT_EXTERNAL_DATE_FORMAT) {\n return [padZeros(month, 2), padZeros(day, 2), padZeros(year, 4)].join(\"/\");\n }\n\n return [padZeros(year, 4), padZeros(month, 2), padZeros(day, 2)].join(\"-\");\n};\n\n// #endregion Date Manipulation Functions\n\n/**\n * Create a grid string from an array of html strings\n *\n * @param {string[]} htmlArray the array of html items\n * @param {number} rowSize the length of a row\n * @returns {string} the grid string\n */\nconst listToGridHtml = (htmlArray, rowSize) => {\n const grid = [];\n let row = [];\n\n let i = 0;\n while (i < htmlArray.length) {\n row = [];\n\n const tr = document.createElement(\"tr\");\n while (i < htmlArray.length && row.length < rowSize) {\n const td = document.createElement(\"td\");\n td.insertAdjacentElement(\"beforeend\", htmlArray[i]);\n row.push(td);\n i += 1;\n }\n\n row.forEach((element) => {\n tr.insertAdjacentElement(\"beforeend\", element);\n });\n\n grid.push(tr);\n }\n\n return grid;\n};\n\nconst createTableBody = (grid) => {\n const tableBody = document.createElement(\"tbody\");\n grid.forEach((element) => {\n tableBody.insertAdjacentElement(\"beforeend\", element);\n });\n\n return tableBody;\n};\n\n/**\n * set the value of the element and dispatch a change event\n *\n * @param {HTMLInputElement} el The element to update\n * @param {string} value The new value of the element\n */\nconst changeElementValue = (el, value = \"\") => {\n const elementToChange = el;\n elementToChange.value = value;\n\n const event = new CustomEvent(\"change\", {\n bubbles: true,\n cancelable: true,\n detail: { value },\n });\n elementToChange.dispatchEvent(event);\n};\n\n/**\n * The properties and elements within the date picker.\n * @typedef {Object} DatePickerContext\n * @property {HTMLDivElement} calendarEl\n * @property {HTMLElement} datePickerEl\n * @property {HTMLInputElement} internalInputEl\n * @property {HTMLInputElement} externalInputEl\n * @property {HTMLDivElement} statusEl\n * @property {HTMLDivElement} firstYearChunkEl\n * @property {Date} calendarDate\n * @property {Date} minDate\n * @property {Date} maxDate\n * @property {Date} selectedDate\n * @property {Date} rangeDate\n * @property {Date} defaultDate\n */\n\n/**\n * Get an object of the properties and elements belonging directly to the given\n * date picker component.\n *\n * @param {HTMLElement} el the element within the date picker\n * @returns {DatePickerContext} elements\n */\nconst getDatePickerContext = (el) => {\n const datePickerEl = el.closest(DATE_PICKER);\n\n if (!datePickerEl) {\n throw new Error(`Element is missing outer ${DATE_PICKER}`);\n }\n\n const internalInputEl = datePickerEl.querySelector(\n DATE_PICKER_INTERNAL_INPUT,\n );\n const externalInputEl = datePickerEl.querySelector(\n DATE_PICKER_EXTERNAL_INPUT,\n );\n const calendarEl = datePickerEl.querySelector(DATE_PICKER_CALENDAR);\n const toggleBtnEl = datePickerEl.querySelector(DATE_PICKER_BUTTON);\n const statusEl = datePickerEl.querySelector(DATE_PICKER_STATUS);\n const firstYearChunkEl = datePickerEl.querySelector(CALENDAR_YEAR);\n\n const inputDate = parseDateString(\n externalInputEl.value,\n DEFAULT_EXTERNAL_DATE_FORMAT,\n true,\n );\n const selectedDate = parseDateString(internalInputEl.value);\n\n const calendarDate = parseDateString(calendarEl.dataset.value);\n const minDate = parseDateString(datePickerEl.dataset.minDate);\n const maxDate = parseDateString(datePickerEl.dataset.maxDate);\n const rangeDate = parseDateString(datePickerEl.dataset.rangeDate);\n const defaultDate = parseDateString(datePickerEl.dataset.defaultDate);\n\n if (minDate && maxDate && minDate > maxDate) {\n throw new Error(\"Minimum date cannot be after maximum date\");\n }\n\n return {\n calendarDate,\n minDate,\n toggleBtnEl,\n selectedDate,\n maxDate,\n firstYearChunkEl,\n datePickerEl,\n inputDate,\n internalInputEl,\n externalInputEl,\n calendarEl,\n rangeDate,\n defaultDate,\n statusEl,\n };\n};\n\n/**\n * Disable the date picker component\n *\n * @param {HTMLElement} el An element within the date picker component\n */\nconst disable = (el) => {\n const { externalInputEl, toggleBtnEl } = getDatePickerContext(el);\n\n toggleBtnEl.disabled = true;\n externalInputEl.disabled = true;\n};\n\n/**\n * Add the readonly attribute to input element and the aria-disabled attribute to the toggle calendar button and external input elements.\n *\n * @param {HTMLElement} el - The date picker element\n */\nconst ariaDisable = (el) => {\n const { externalInputEl, toggleBtnEl } = getDatePickerContext(el);\n\n toggleBtnEl.setAttribute(\"aria-disabled\", true);\n externalInputEl.setAttribute(\"aria-disabled\", true);\n externalInputEl.setAttribute(\"readonly\", \"\");\n};\n\n/**\n * Enable the date picker component\n *\n * @param {HTMLElement} el An element within the date picker component\n */\nconst enable = (el) => {\n const { externalInputEl, toggleBtnEl } = getDatePickerContext(el);\n\n toggleBtnEl.disabled = false;\n toggleBtnEl.removeAttribute(\"aria-disabled\");\n\n externalInputEl.disabled = false;\n externalInputEl.removeAttribute(\"aria-disabled\");\n externalInputEl.removeAttribute(\"readonly\");\n};\n\n// #region Validation\n\n/**\n * Validate the value in the input as a valid date of format M/D/YYYY\n *\n * @param {HTMLElement} el An element within the date picker component\n */\nconst isDateInputInvalid = (el) => {\n const { externalInputEl, minDate, maxDate } = getDatePickerContext(el);\n\n const dateString = externalInputEl.value;\n let isInvalid = false;\n\n if (dateString) {\n isInvalid = true;\n\n const dateStringParts = dateString.split(\"/\");\n const [month, day, year] = dateStringParts.map((str) => {\n let value;\n const parsed = parseInt(str, 10);\n if (!Number.isNaN(parsed)) value = parsed;\n return value;\n });\n\n if (month && day && year != null) {\n const checkDate = setDate(year, month - 1, day);\n\n if (\n checkDate.getMonth() === month - 1 &&\n checkDate.getDate() === day &&\n checkDate.getFullYear() === year &&\n dateStringParts[2].length === 4 &&\n isDateWithinMinAndMax(checkDate, minDate, maxDate)\n ) {\n isInvalid = false;\n }\n }\n }\n\n return isInvalid;\n};\n\n/**\n * Validate the value in the input as a valid date of format M/D/YYYY\n *\n * @param {HTMLElement} el An element within the date picker component\n */\nconst validateDateInput = (el) => {\n const { externalInputEl } = getDatePickerContext(el);\n const isInvalid = isDateInputInvalid(externalInputEl);\n\n if (isInvalid && !externalInputEl.validationMessage) {\n externalInputEl.setCustomValidity(VALIDATION_MESSAGE);\n }\n\n if (!isInvalid && externalInputEl.validationMessage === VALIDATION_MESSAGE) {\n externalInputEl.setCustomValidity(\"\");\n }\n};\n\n// #endregion Validation\n\n/**\n * Enable the date picker component\n *\n * @param {HTMLElement} el An element within the date picker component\n */\nconst reconcileInputValues = (el) => {\n const { internalInputEl, inputDate } = getDatePickerContext(el);\n let newValue = \"\";\n\n if (inputDate && !isDateInputInvalid(el)) {\n newValue = formatDate(inputDate);\n }\n\n if (internalInputEl.value !== newValue) {\n changeElementValue(internalInputEl, newValue);\n }\n};\n\n/**\n * Select the value of the date picker inputs.\n *\n * @param {HTMLButtonElement} el An element within the date picker component\n * @param {string} dateString The date string to update in YYYY-MM-DD format\n */\nconst setCalendarValue = (el, dateString) => {\n const parsedDate = parseDateString(dateString);\n\n if (parsedDate) {\n const formattedDate = formatDate(parsedDate, DEFAULT_EXTERNAL_DATE_FORMAT);\n\n const { datePickerEl, internalInputEl, externalInputEl } =\n getDatePickerContext(el);\n\n changeElementValue(internalInputEl, dateString);\n changeElementValue(externalInputEl, formattedDate);\n\n validateDateInput(datePickerEl);\n }\n};\n\n/**\n * Enhance an input with the date picker elements\n *\n * @param {HTMLElement} el The initial wrapping element of the date picker component\n */\nconst enhanceDatePicker = (el) => {\n const datePickerEl = el.closest(DATE_PICKER);\n const { defaultValue } = datePickerEl.dataset;\n\n const internalInputEl = datePickerEl.querySelector(`input`);\n\n if (!internalInputEl) {\n throw new Error(`${DATE_PICKER} is missing inner input`);\n }\n\n if (internalInputEl.value) {\n internalInputEl.value = \"\";\n }\n\n const minDate = parseDateString(\n datePickerEl.dataset.minDate || internalInputEl.getAttribute(\"min\"),\n );\n datePickerEl.dataset.minDate = minDate\n ? formatDate(minDate)\n : DEFAULT_MIN_DATE;\n\n const maxDate = parseDateString(\n datePickerEl.dataset.maxDate || internalInputEl.getAttribute(\"max\"),\n );\n if (maxDate) {\n datePickerEl.dataset.maxDate = formatDate(maxDate);\n }\n\n const calendarWrapper = document.createElement(\"div\");\n calendarWrapper.classList.add(DATE_PICKER_WRAPPER_CLASS);\n\n const externalInputEl = internalInputEl.cloneNode();\n externalInputEl.classList.add(DATE_PICKER_EXTERNAL_INPUT_CLASS);\n externalInputEl.type = \"text\";\n\n calendarWrapper.appendChild(externalInputEl);\n calendarWrapper.insertAdjacentHTML(\n \"beforeend\",\n Sanitizer.escapeHTML`\n <button type=\"button\" class=\"${DATE_PICKER_BUTTON_CLASS}\" aria-haspopup=\"true\" aria-label=\"Toggle calendar\"></button>\n <div class=\"${DATE_PICKER_CALENDAR_CLASS}\" role=\"application\" hidden></div>\n <div class=\"usa-sr-only ${DATE_PICKER_STATUS_CLASS}\" role=\"status\" aria-live=\"polite\"></div>`,\n );\n\n internalInputEl.setAttribute(\"aria-hidden\", \"true\");\n internalInputEl.setAttribute(\"tabindex\", \"-1\");\n internalInputEl.style.display = \"none\";\n internalInputEl.classList.add(DATE_PICKER_INTERNAL_INPUT_CLASS);\n internalInputEl.removeAttribute(\"id\");\n internalInputEl.removeAttribute(\"name\");\n internalInputEl.required = false;\n\n datePickerEl.appendChild(calendarWrapper);\n datePickerEl.classList.add(DATE_PICKER_INITIALIZED_CLASS);\n\n if (defaultValue) {\n setCalendarValue(datePickerEl, defaultValue);\n }\n\n if (internalInputEl.disabled) {\n disable(datePickerEl);\n internalInputEl.disabled = false;\n }\n\n if (internalInputEl.hasAttribute(\"aria-disabled\")) {\n ariaDisable(datePickerEl);\n internalInputEl.removeAttribute(\"aria-disabled\");\n }\n};\n\n// #region Calendar - Date Selection View\n\n/**\n * render the calendar.\n *\n * @param {HTMLElement} el An element within the date picker component\n * @param {Date} _dateToDisplay a date to render on the calendar\n * @returns {HTMLElement} a reference to the new calendar element\n */\nconst renderCalendar = (el, _dateToDisplay) => {\n const {\n datePickerEl,\n calendarEl,\n statusEl,\n selectedDate,\n maxDate,\n minDate,\n rangeDate,\n } = getDatePickerContext(el);\n const todaysDate = today();\n let dateToDisplay = _dateToDisplay || todaysDate;\n\n const calendarWasHidden = calendarEl.hidden;\n\n const focusedDate = addDays(dateToDisplay, 0);\n const focusedMonth = dateToDisplay.getMonth();\n const focusedYear = dateToDisplay.getFullYear();\n\n const prevMonth = subMonths(dateToDisplay, 1);\n const nextMonth = addMonths(dateToDisplay, 1);\n\n const currentFormattedDate = formatDate(dateToDisplay);\n\n const firstOfMonth = startOfMonth(dateToDisplay);\n const prevButtonsDisabled = isSameMonth(dateToDisplay, minDate);\n const nextButtonsDisabled = isSameMonth(dateToDisplay, maxDate);\n\n const {\n rangeStartDate,\n rangeEndDate,\n withinRangeStartDate,\n withinRangeEndDate,\n } = setRangeDates(selectedDate || dateToDisplay, rangeDate);\n\n const monthLabel = MONTH_LABELS[focusedMonth];\n\n const generateDateHtml = (dateToRender) => {\n const classes = [CALENDAR_DATE_CLASS];\n const day = dateToRender.getDate();\n const month = dateToRender.getMonth();\n const year = dateToRender.getFullYear();\n const dayOfWeek = dateToRender.getDay();\n\n const formattedDate = formatDate(dateToRender);\n\n let tabindex = \"-1\";\n\n const isDisabled = !isDateWithinMinAndMax(dateToRender, minDate, maxDate);\n const isSelected = isSameDay(dateToRender, selectedDate);\n\n if (isSameMonth(dateToRender, prevMonth)) {\n classes.push(CALENDAR_DATE_PREVIOUS_MONTH_CLASS);\n }\n\n if (isSameMonth(dateToRender, focusedDate)) {\n classes.push(CALENDAR_DATE_CURRENT_MONTH_CLASS);\n }\n\n if (isSameMonth(dateToRender, nextMonth)) {\n classes.push(CALENDAR_DATE_NEXT_MONTH_CLASS);\n }\n\n if (isSelected) {\n classes.push(CALENDAR_DATE_SELECTED_CLASS);\n }\n\n if (isSameDay(dateToRender, todaysDate)) {\n classes.push(CALENDAR_DATE_TODAY_CLASS);\n }\n\n if (rangeDate) {\n if (isSameDay(dateToRender, rangeDate)) {\n classes.push(CALENDAR_DATE_RANGE_DATE_CLASS);\n }\n\n if (isSameDay(dateToRender, rangeStartDate)) {\n classes.push(CALENDAR_DATE_RANGE_DATE_START_CLASS);\n }\n\n if (isSameDay(dateToRender, rangeEndDate)) {\n classes.push(CALENDAR_DATE_RANGE_DATE_END_CLASS);\n }\n\n if (\n isDateWithinMinAndMax(\n dateToRender,\n withinRangeStartDate,\n withinRangeEndDate,\n )\n ) {\n classes.push(CALENDAR_DATE_WITHIN_RANGE_CLASS);\n }\n }\n\n if (isSameDay(dateToRender, focusedDate)) {\n tabindex = \"0\";\n classes.push(CALENDAR_DATE_FOCUSED_CLASS);\n }\n\n const monthStr = MONTH_LABELS[month];\n const dayStr = DAY_OF_WEEK_LABELS[dayOfWeek];\n\n const btn = document.createElement(\"button\");\n btn.setAttribute(\"type\", \"button\");\n btn.setAttribute(\"tabindex\", tabindex);\n btn.setAttribute(\"class\", classes.join(\" \"));\n btn.setAttribute(\"data-day\", day);\n btn.setAttribute(\"data-month\", month + 1);\n btn.setAttribute(\"data-year\", year);\n btn.setAttribute(\"data-value\", formattedDate);\n btn.setAttribute(\n \"aria-label\",\n Sanitizer.escapeHTML`${day} ${monthStr} ${year} ${dayStr}`,\n );\n btn.setAttribute(\"aria-selected\", isSelected ? \"true\" : \"false\");\n if (isDisabled === true) {\n btn.disabled = true;\n }\n btn.textContent = day;\n\n return btn;\n };\n\n // set date to first rendered day\n dateToDisplay = startOfWeek(firstOfMonth);\n\n const days = [];\n\n while (\n days.length < 28 ||\n dateToDisplay.getMonth() === focusedMonth ||\n days.length % 7 !== 0\n ) {\n days.push(generateDateHtml(dateToDisplay));\n dateToDisplay = addDays(dateToDisplay, 1);\n }\n\n const datesGrid = listToGridHtml(days, 7);\n\n const newCalendar = calendarEl.cloneNode();\n newCalendar.dataset.value = currentFormattedDate;\n newCalendar.style.top = `${datePickerEl.offsetHeight}px`;\n newCalendar.hidden = false;\n newCalendar.innerHTML = Sanitizer.escapeHTML`\n <div tabindex=\"-1\" class=\"${CALENDAR_DATE_PICKER_CLASS}\">\n <div class=\"${CALENDAR_ROW_CLASS}\">\n <div class=\"${CALENDAR_CELL_CLASS} ${CALENDAR_CELL_CENTER_ITEMS_CLASS}\">\n <button\n type=\"button\"\n class=\"${CALENDAR_PREVIOUS_YEAR_CLASS}\"\n aria-label=\"Navigate back one year\"\n ${prevButtonsDisabled ? `disabled=\"disabled\"` : \"\"}\n ></button>\n </div>\n <div class=\"${CALENDAR_CELL_CLASS} ${CALENDAR_CELL_CENTER_ITEMS_CLASS}\">\n <button\n type=\"button\"\n class=\"${CALENDAR_PREVIOUS_MONTH_CLASS}\"\n aria-label=\"Navigate back one month\"\n ${prevButtonsDisabled ? `disabled=\"disabled\"` : \"\"}\n ></button>\n </div>\n <div class=\"${CALENDAR_CELL_CLASS} ${CALENDAR_MONTH_LABEL_CLASS}\">\n <button\n type=\"button\"\n class=\"${CALENDAR_MONTH_SELECTION_CLASS}\" aria-label=\"${monthLabel}. Select month\"\n >${monthLabel}</button>\n <button\n type=\"button\"\n class=\"${CALENDAR_YEAR_SELECTION_CLASS}\" aria-label=\"${focusedYear}. Select year\"\n >${focusedYear}</button>\n </div>\n <div class=\"${CALENDAR_CELL_CLASS} ${CALENDAR_CELL_CENTER_ITEMS_CLASS}\">\n <button\n type=\"button\"\n class=\"${CALENDAR_NEXT_MONTH_CLASS}\"\n aria-label=\"Navigate forward one month\"\n ${nextButtonsDisabled ? `disabled=\"disabled\"` : \"\"}\n ></button>\n </div>\n <div class=\"${CALENDAR_CELL_CLASS} ${CALENDAR_CELL_CENTER_ITEMS_CLASS}\">\n <button\n type=\"button\"\n class=\"${CALENDAR_NEXT_YEAR_CLASS}\"\n aria-label=\"Navigate forward one year\"\n ${nextButtonsDisabled ? `disabled=\"disabled\"` : \"\"}\n ></button>\n </div>\n </div>\n </div>\n `;\n\n const table = document.createElement(\"table\");\n table.setAttribute(\"class\", CALENDAR_TABLE_CLASS);\n\n const tableHead = document.createElement(\"thead\");\n table.insertAdjacentElement(\"beforeend\", tableHead);\n const tableHeadRow = document.createElement(\"tr\");\n tableHead.insertAdjacentElement(\"beforeend\", tableHeadRow);\n\n const daysOfWeek = {\n Sunday: \"S\",\n Monday: \"M\",\n Tuesday: \"T\",\n Wednesday: \"W\",\n Thursday: \"Th\",\n Friday: \"Fr\",\n Saturday: \"S\",\n };\n\n Object.keys(daysOfWeek).forEach((key) => {\n const th = document.createElement(\"th\");\n th.setAttribute(\"class\", CALENDAR_DAY_OF_WEEK_CLASS);\n th.setAttribute(\"scope\", \"col\");\n th.setAttribute(\"aria-label\", key);\n th.textContent = daysOfWeek[key];\n tableHeadRow.insertAdjacentElement(\"beforeend\", th);\n });\n\n const tableBody = createTableBody(datesGrid);\n table.insertAdjacentElement(\"beforeend\", tableBody);\n\n // Container for Years, Months, and Days\n const datePickerCalendarContainer =\n newCalendar.querySelector(CALENDAR_DATE_PICKER);\n\n datePickerCalendarContainer.insertAdjacentElement(\"beforeend\", table);\n\n calendarEl.parentNode.replaceChild(newCalendar, calendarEl);\n\n datePickerEl.classList.add(DATE_PICKER_ACTIVE_CLASS);\n\n const statuses = [];\n\n if (isSameDay(selectedDate, focusedDate)) {\n statuses.push(\"Selected date\");\n }\n\n if (calendarWasHidden) {\n statuses.push(\n \"You can navigate by day using left and right arrows\",\n \"Weeks by using up and down arrows\",\n \"Months by using page up and page down keys\",\n \"Years by using shift plus page up and shift plus page down\",\n \"Home and end keys navigate to the beginning and end of a week\",\n );\n statusEl.textContent = \"\";\n } else {\n statuses.push(`${monthLabel} ${focusedYear}`);\n }\n statusEl.textContent = statuses.join(\". \");\n\n return newCalendar;\n};\n\n/**\n * Navigate back one year and display the calendar.\n *\n * @param {HTMLButtonElement} _buttonEl An element within the date picker component\n */\nconst displayPreviousYear = (_buttonEl) => {\n if (_buttonEl.disabled) return;\n const { calendarEl, calendarDate, minDate, maxDate } =\n getDatePickerContext(_buttonEl);\n let date = subYears(calendarDate, 1);\n date = keepDateBetweenMinAndMax(date, minDate, maxDate);\n const newCalendar = renderCalendar(calendarEl, date);\n\n let nextToFocus = newCalendar.querySelector(CALENDAR_PREVIOUS_YEAR);\n if (nextToFocus.disabled) {\n nextToFocus = newCalendar.querySelector(CALENDAR_DATE_PICKER);\n }\n nextToFocus.focus();\n};\n\n/**\n * Navigate back one month and display the calendar.\n *\n * @param {HTMLButtonElement} _buttonEl An element within the date picker component\n */\nconst displayPreviousMonth = (_buttonEl) => {\n if (_buttonEl.disabled) return;\n const { calendarEl, calendarDate, minDate, maxDate } =\n getDatePickerContext(_buttonEl);\n let date = subMonths(calendarDate, 1);\n date = keepDateBetweenMinAndMax(date, minDate, maxDate);\n const newCalendar = renderCalendar(calendarEl, date);\n\n let nextToFocus = newCalendar.querySelector(CALENDAR_PREVIOUS_MONTH);\n if (nextToFocus.disabled) {\n nextToFocus = newCalendar.querySelector(CALENDAR_DATE_PICKER);\n }\n nextToFocus.focus();\n};\n\n/**\n * Navigate forward one month and display the calendar.\n *\n * @param {HTMLButtonElement} _buttonEl An element within the date picker component\n */\nconst displayNextMonth = (_buttonEl) => {\n if (_buttonEl.disabled) return;\n const { calendarEl, calendarDate, minDate, maxDate } =\n getDatePickerContext(_buttonEl);\n let date = addMonths(calendarDate, 1);\n date = keepDateBetweenMinAndMax(date, minDate, maxDate);\n const newCalendar = renderCalendar(calendarEl, date);\n\n let nextToFocus = newCalendar.querySelector(CALENDAR_NEXT_MONTH);\n if (nextToFocus.disabled) {\n nextToFocus = newCalendar.querySelector(CALENDAR_DATE_PICKER);\n }\n nextToFocus.focus();\n};\n\n/**\n * Navigate forward one year and display the calendar.\n *\n * @param {HTMLButtonElement} _buttonEl An element within the date picker component\n */\nconst displayNextYear = (_buttonEl) => {\n if (_buttonEl.disabled) return;\n const { calendarEl, calendarDate, minDate, maxDate } =\n getDatePickerContext(_buttonEl);\n let date = addYears(calendarDate, 1);\n date = keepDateBetweenMinAndMax(date, minDate, maxDate);\n const newCalendar = renderCalendar(calendarEl, date);\n\n let nextToFocus = newCalendar.querySelector(CALENDAR_NEXT_YEAR);\n if (nextToFocus.disabled) {\n nextToFocus = newCalendar.querySelector(CALENDAR_DATE_PICKER);\n }\n nextToFocus.focus();\n};\n\n/**\n * Hide the calendar of a date picker component.\n *\n * @param {HTMLElement} el An element within the date picker component\n */\nconst hideCalendar = (el) => {\n const { datePickerEl, calendarEl, statusEl } = getDatePickerContext(el);\n\n datePickerEl.classList.remove(DATE_PICKER_ACTIVE_CLASS);\n calendarEl.hidden = true;\n statusEl.textContent = \"\";\n};\n\n/**\n * Select a date within the date picker component.\n *\n * @param {HTMLButtonElement} calendarDateEl A date element within the date picker component\n */\nconst selectDate = (calendarDateEl) => {\n if (calendarDateEl.disabled) return;\n\n const { datePickerEl, externalInputEl } =\n getDatePickerContext(calendarDateEl);\n\n setCalendarValue(calendarDateEl, calendarDateEl.dataset.value);\n hideCalendar(datePickerEl);\n\n externalInputEl.focus();\n};\n\n/**\n * Toggle the calendar.\n *\n * @param {HTMLButtonElement} el An element within the date picker component\n */\nconst toggleCalendar = (el) => {\n if (el.disabled || el.hasAttribute(\"aria-disabled\")) return;\n const { calendarEl, inputDate, minDate, maxDate, defaultDate } =\n getDatePickerContext(el);\n\n if (calendarEl.hidden) {\n const dateToDisplay = keepDateBetweenMinAndMax(\n inputDate || defaultDate || today(),\n minDate,\n maxDate,\n );\n const newCalendar = renderCalendar(calendarEl, dateToDisplay);\n newCalendar.querySelector(CALENDAR_DATE_FOCUSED).focus();\n } else {\n hideCalendar(el);\n }\n};\n\n/**\n * Update the calendar when visible.\n *\n * @param {HTMLElement} el an element within the date picker\n */\nconst updateCalendarIfVisible = (el) => {\n const { calendarEl, inputDate, minDate, maxDate } = getDatePickerContext(el);\n const calendarShown = !calendarEl.hidden;\n\n if (calendarShown && inputDate) {\n const dateToDisplay = keepDateBetweenMinAndMax(inputDate, minDate, maxDate);\n renderCalendar(calendarEl, dateToDisplay);\n }\n};\n\n// #endregion Calendar - Date Selection View\n\n// #region Calendar - Month Selection View\n/**\n * Display the month selection screen in the date picker.\n *\n * @param {HTMLButtonElement} el An element within the date picker component\n * @returns {HTMLElement} a reference to the new calendar element\n */\nconst displayMonthSelection = (el, monthToDisplay) => {\n const { calendarEl, statusEl, calendarDate, minDate, maxDate } =\n getDatePickerContext(el);\n\n const selectedMonth = calendarDate.getMonth();\n const focusedMonth = monthToDisplay == null ? selectedMonth : monthToDisplay;\n\n const months = MONTH_LABELS.map((month, index) => {\n const monthToCheck = setMonth(calendarDate, index);\n\n const isDisabled = isDatesMonthOutsideMinOrMax(\n monthToCheck,\n minDate,\n maxDate,\n );\n\n let tabindex = \"-1\";\n\n const classes = [CALENDAR_MONTH_CLASS];\n const isSelected = index === selectedMonth;\n\n if (index === focusedMonth) {\n tabindex = \"0\";\n classes.push(CALENDAR_MONTH_FOCUSED_CLASS);\n }\n\n if (isSelected) {\n classes.push(CALENDAR_MONTH_SELECTED_CLASS);\n }\n\n const btn = document.createElement(\"button\");\n btn.setAttribute(\"type\", \"button\");\n btn.setAttribute(\"tabindex\", tabindex);\n btn.setAttribute(\"class\", classes.join(\" \"));\n btn.setAttribute(\"data-value\", index);\n btn.setAttribute(\"data-label\", month);\n btn.setAttribute(\"aria-selected\", isSelected ? \"true\" : \"false\");\n if (isDisabled === true) {\n btn.disabled = true;\n }\n btn.textContent = month;\n\n return btn;\n });\n\n const monthsHtml = document.createElement(\"div\");\n monthsHtml.setAttribute(\"tabindex\", \"-1\");\n monthsHtml.setAttribute(\"class\", CALENDAR_MONTH_PICKER_CLASS);\n\n const table = document.createElement(\"table\");\n table.setAttribute(\"class\", CALENDAR_TABLE_CLASS);\n table.setAttribute(\"role\", \"presentation\");\n\n const monthsGrid = listToGridHtml(months, 3);\n const tableBody = createTableBody(monthsGrid);\n table.insertAdjacentElement(\"beforeend\", tableBody);\n monthsHtml.insertAdjacentElement(\"beforeend\", table);\n\n const newCalendar = calendarEl.cloneNode();\n newCalendar.insertAdjacentElement(\"beforeend\", monthsHtml);\n calendarEl.parentNode.replaceChild(newCalendar, calendarEl);\n\n statusEl.textContent = \"Select a month.\";\n\n return newCalendar;\n};\n\n/**\n * Select a month in the date picker component.\n *\n * @param {HTMLButtonElement} monthEl An month element within the date picker component\n */\nconst selectMonth = (monthEl) => {\n if (monthEl.disabled) return;\n const { calendarEl, calendarDate, minDate, maxDate } =\n getDatePickerContext(monthEl);\n const selectedMonth = parseInt(monthEl.dataset.value, 10);\n let date = setMonth(calendarDate, selectedMonth);\n date = keepDateBetweenMinAndMax(date, minDate, maxDate);\n const newCalendar = renderCalendar(calendarEl, date);\n newCalendar.querySelector(CALENDAR_DATE_FOCUSED).focus();\n};\n\n// #endregion Calendar - Month Selection View\n\n// #region Calendar - Year Selection View\n\n/**\n * Display the year selection screen in the date picker.\n *\n * @param {HTMLButtonElement} el An element within the date picker component\n * @param {number} yearToDisplay year to display in year selection\n * @returns {HTMLElement} a reference to the new calendar element\n */\nconst displayYearSelection = (el, yearToDisplay) => {\n const { calendarEl, statusEl, calendarDate, minDate, maxDate } =\n getDatePickerContext(el);\n\n const selectedYear = calendarDate.getFullYear();\n const focusedYear = yearToDisplay == null ? selectedYear : yearToDisplay;\n\n let yearToChunk = focusedYear;\n yearToChunk -= yearToChunk % YEAR_CHUNK;\n yearToChunk = Math.max(0, yearToChunk);\n\n const prevYearChunkDisabled = isDatesYearOutsideMinOrMax(\n setYear(calendarDate, yearToChunk - 1),\n minDate,\n maxDate,\n );\n\n const nextYearChunkDisabled = isDatesYearOutsideMinOrMax(\n setYear(calendarDate, yearToChunk + YEAR_CHUNK),\n minDate,\n maxDate,\n );\n\n const years = [];\n let yearIndex = yearToChunk;\n while (years.length < YEAR_CHUNK) {\n const isDisabled = isDatesYearOutsideMinOrMax(\n setYear(calendarDate, yearIndex),\n minDate,\n maxDate,\n );\n\n let tabindex = \"-1\";\n\n const classes = [CALENDAR_YEAR_CLASS];\n const isSelected = yearIndex === selectedYear;\n\n if (yearIndex === focusedYear) {\n tabindex = \"0\";\n classes.push(CALENDAR_YEAR_FOCUSED_CLASS);\n }\n\n if (isSelected) {\n classes.push(CALENDAR_YEAR_SELECTED_CLASS);\n }\n\n const btn = document.createElement(\"button\");\n btn.setAttribute(\"type\", \"button\");\n btn.setAttribute(\"tabindex\", tabindex);\n btn.setAttribute(\"class\", classes.join(\" \"));\n btn.setAttribute(\"data-value\", yearIndex);\n btn.setAttribute(\"aria-selected\", isSelected ? \"true\" : \"false\");\n if (isDisabled === true) {\n btn.disabled = true;\n }\n btn.textContent = yearIndex;\n\n years.push(btn);\n yearIndex += 1;\n }\n\n const newCalendar = calendarEl.cloneNode();\n\n // create the years calendar wrapper\n const yearsCalendarWrapper = document.createElement(\"div\");\n yearsCalendarWrapper.setAttribute(\"tabindex\", \"-1\");\n yearsCalendarWrapper.setAttribute(\"class\", CALENDAR_YEAR_PICKER_CLASS);\n\n // create table parent\n const yearsTableParent = document.createElement(\"table\");\n yearsTableParent.setAttribute(\"class\", CALENDAR_TABLE_CLASS);\n\n // create table body and table row\n const yearsHTMLTableBody = document.createElement(\"tbody\");\n const yearsHTMLTableBodyRow = document.createElement(\"tr\");\n\n // create previous button\n const previousYearsBtn = document.createElement(\"button\");\n previousYearsBtn.setAttribute(\"type\", \"button\");\n previousYearsBtn.setAttribute(\"class\", CALENDAR_PREVIOUS_YEAR_CHUNK_CLASS);\n previousYearsBtn.setAttribute(\n \"aria-label\",\n `Navigate back ${YEAR_CHUNK} years`,\n );\n if (prevYearChunkDisabled === true) {\n previousYearsBtn.disabled = true;\n }\n previousYearsBtn.innerHTML = Sanitizer.escapeHTML` `;\n\n // create next button\n const nextYearsBtn = document.createElement(\"button\");\n nextYearsBtn.setAttribute(\"type\", \"button\");\n nextYearsBtn.setAttribute(\"class\", CALENDAR_NEXT_YEAR_CHUNK_CLASS);\n nextYearsBtn.setAttribute(\n \"aria-label\",\n `Navigate forward ${YEAR_CHUNK} years`,\n );\n if (nextYearChunkDisabled === true) {\n nextYearsBtn.disabled = true;\n }\n nextYearsBtn.innerHTML = Sanitizer.escapeHTML` `;\n\n // create the actual years table\n const yearsTable = document.createElement(\"table\");\n yearsTable.setAttribute(\"class\", CALENDAR_TABLE_CLASS);\n yearsTable.setAttribute(\"role\", \"presentation\");\n\n // create the years child table\n const yearsGrid = listToGridHtml(years, 3);\n const yearsTableBody = createTableBody(yearsGrid);\n\n // append the grid to the years child table\n yearsTable.insertAdjacentElement(\"beforeend\", yearsTableBody);\n\n // create the prev button td and append the prev button\n const yearsHTMLTableBodyDetailPrev = document.createElement(\"td\");\n yearsHTMLTableBodyDetailPrev.insertAdjacentElement(\n \"beforeend\",\n previousYearsBtn,\n );\n\n // create the years td and append the years child table\n const yearsHTMLTableBodyYearsDetail = document.createElement(\"td\");\n yearsHTMLTableBodyYearsDetail.setAttribute(\"colspan\", \"3\");\n yearsHTMLTableBodyYearsDetail.insertAdjacentElement(\"beforeend\", yearsTable);\n\n // create the next button td and append the next button\n const yearsHTMLTableBodyDetailNext = document.createElement(\"td\");\n yearsHTMLTableBodyDetailNext.insertAdjacentElement(\"beforeend\", nextYearsBtn);\n\n // append the three td to the years child table row\n yearsHTMLTableBodyRow.insertAdjacentElement(\n \"beforeend\",\n yearsHTMLTableBodyDetailPrev,\n );\n yearsHTMLTableBodyRow.insertAdjacentElement(\n \"beforeend\",\n yearsHTMLTableBodyYearsDetail,\n );\n yearsHTMLTableBodyRow.insertAdjacentElement(\n \"beforeend\",\n yearsHTMLTableBodyDetailNext,\n );\n\n // append the table row to the years child table body\n yearsHTMLTableBody.insertAdjacentElement(\"beforeend\", yearsHTMLTableBodyRow);\n\n // append the years table body to the years parent table\n yearsTableParent.insertAdjacentElement(\"beforeend\", yearsHTMLTableBody);\n\n // append the parent table to the calendar wrapper\n yearsCalendarWrapper.insertAdjacentElement(\"beforeend\", yearsTableParent);\n\n // append the years calender to the new calendar\n newCalendar.insertAdjacentElement(\"beforeend\", yearsCalendarWrapper);\n\n // replace calendar\n calendarEl.parentNode.replaceChild(newCalendar, calendarEl);\n\n statusEl.textContent = Sanitizer.escapeHTML`Showing years ${yearToChunk} to ${\n yearToChunk + YEAR_CHUNK - 1\n }. Select a year.`;\n\n return newCalendar;\n};\n\n/**\n * Navigate back by years and display the year selection screen.\n *\n * @param {HTMLButtonElement} el An element within the date picker component\n */\nconst displayPreviousYearChunk = (el) => {\n if (el.disabled) return;\n\n const { calendarEl, calendarDate, minDate, maxDate } =\n getDatePickerContext(el);\n const yearEl = calendarEl.querySelector(CALENDAR_YEAR_FOCUSED);\n const selectedYear = parseInt(yearEl.textContent, 10);\n\n let adjustedYear = selectedYear - YEAR_CHUNK;\n adjustedYear = Math.max(0, adjustedYear);\n\n const date = setYear(calendarDate, adjustedYear);\n const cappedDate = keepDateBetweenMinAndMax(date, minDate, maxDate);\n const newCalendar = displayYearSelection(\n calendarEl,\n cappedDate.getFullYear(),\n );\n\n let nextToFocus = newCalendar.querySelector(CALENDAR_PREVIOUS_YEAR_CHUNK);\n if (nextToFocus.disabled) {\n nextToFocus = newCalendar.querySelector(CALENDAR_YEAR_PICKER);\n }\n nextToFocus.focus();\n};\n\n/**\n * Navigate forward by years and display the year selection screen.\n *\n * @param {HTMLButtonElement} el An element within the date picker component\n */\nconst displayNextYearChunk = (el) => {\n if (el.disabled) return;\n\n const { calendarEl, calendarDate, minDate, maxDate } =\n getDatePickerContext(el);\n const yearEl = calendarEl.querySelector(CALENDAR_YEAR_FOCUSED);\n const selectedYear = parseInt(yearEl.textContent, 10);\n\n let adjustedYear = selectedYear + YEAR_CHUNK;\n adjustedYear = Math.max(0, adjustedYear);\n\n const date = setYear(calendarDate, adjustedYear);\n const cappedDate = keepDateBetweenMinAndMax(date, minDate, maxDate);\n const newCalendar = displayYearSelection(\n calendarEl,\n cappedDate.getFullYear(),\n );\n\n let nextToFocus = newCalendar.querySelector(CALENDAR_NEXT_YEAR_CHUNK);\n if (nextToFocus.disabled) {\n nextToFocus = newCalendar.querySelector(CALENDAR_YEAR_PICKER);\n }\n nextToFocus.focus();\n};\n\n/**\n * Select a year in the date picker component.\n *\n * @param {HTMLButtonElement} yearEl A year element within the date picker component\n */\nconst selectYear = (yearEl) => {\n if (yearEl.disabled) return;\n const { calendarEl, calendarDate, minDate, maxDate } =\n getDatePickerContext(yearEl);\n const selectedYear = parseInt(yearEl.innerHTML, 10);\n let date = setYear(calendarDate, selectedYear);\n date = keepDateBetweenMinAndMax(date, minDate, maxDate);\n const newCalendar = renderCalendar(calendarEl, date);\n newCalendar.querySelector(CALENDAR_DATE_FOCUSED).focus();\n};\n\n// #endregion Calendar - Year Selection View\n\n// #region Calendar Event Handling\n\n/**\n * Hide the calendar.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleEscapeFromCalendar = (event) => {\n const { datePickerEl, externalInputEl } = getDatePickerContext(event.target);\n\n hideCalendar(datePickerEl);\n externalInputEl.focus();\n\n event.preventDefault();\n};\n\n// #endregion Calendar Event Handling\n\n// #region Calendar Date Event Handling\n\n/**\n * Adjust the date and display the calendar if needed.\n *\n * @param {function} adjustDateFn function that returns the adjusted date\n */\nconst adjustCalendar = (adjustDateFn) => (event) => {\n const { calendarEl, calendarDate, minDate, maxDate } = getDatePickerContext(\n event.target,\n );\n\n const date = adjustDateFn(calendarDate);\n\n const cappedDate = keepDateBetweenMinAndMax(date, minDate, maxDate);\n if (!isSameDay(calendarDate, cappedDate)) {\n const newCalendar = renderCalendar(calendarEl, cappedDate);\n newCalendar.querySelector(CALENDAR_DATE_FOCUSED).focus();\n }\n event.preventDefault();\n};\n\n/**\n * Navigate back one week and display the calendar.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleUpFromDate = adjustCalendar((date) => subWeeks(date, 1));\n\n/**\n * Navigate forward one week and display the calendar.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleDownFromDate = adjustCalendar((date) => addWeeks(date, 1));\n\n/**\n * Navigate back one day and display the calendar.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleLeftFromDate = adjustCalendar((date) => subDays(date, 1));\n\n/**\n * Navigate forward one day and display the calendar.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleRightFromDate = adjustCalendar((date) => addDays(date, 1));\n\n/**\n * Navigate to the start of the week and display the calendar.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleHomeFromDate = adjustCalendar((date) => startOfWeek(date));\n\n/**\n * Navigate to the end of the week and display the calendar.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleEndFromDate = adjustCalendar((date) => endOfWeek(date));\n\n/**\n * Navigate forward one month and display the calendar.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handlePageDownFromDate = adjustCalendar((date) => addMonths(date, 1));\n\n/**\n * Navigate back one month and display the calendar.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handlePageUpFromDate = adjustCalendar((date) => subMonths(date, 1));\n\n/**\n * Navigate forward one year and display the calendar.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleShiftPageDownFromDate = adjustCalendar((date) => addYears(date, 1));\n\n/**\n * Navigate back one year and display the calendar.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleShiftPageUpFromDate = adjustCalendar((date) => subYears(date, 1));\n\n/**\n * Set range date classes without re-rendering the calendar. Called when date button is hovered.\n * Returns early if the date hovered is disabled or if there is already a selected date.\n *\n * @param {HTMLElement} dateEl - Calendar date button within the date picker component.\n */\n\nconst handleMouseoverFromDate = (dateEl) => {\n if (dateEl.disabled) return;\n\n const hoverDate = parseDateString(dateEl.dataset.value);\n const { calendarEl, selectedDate, rangeDate } = getDatePickerContext(dateEl);\n\n if (selectedDate) return;\n\n const { withinRangeStartDate, withinRangeEndDate } = setRangeDates(\n hoverDate,\n rangeDate,\n );\n\n const dateButtons = calendarEl.querySelectorAll(\n `.${CALENDAR_DATE_CURRENT_MONTH_CLASS}`,\n );\n\n dateButtons.forEach((button) => {\n const buttonDate = parseDateString(button.dataset.value);\n if (\n isDateWithinMinAndMax(\n buttonDate,\n withinRangeStartDate,\n withinRangeEndDate,\n )\n ) {\n button.classList.add(CALENDAR_DATE_WITHIN_RANGE_CLASS);\n } else {\n button.classList.remove(CALENDAR_DATE_WITHIN_RANGE_CLASS);\n }\n });\n};\n\n// #endregion Calendar Date Event Handling\n\n// #region Calendar Month Event Handling\n\n/**\n * Adjust the month and display the month selection screen if needed.\n *\n * @param {function} adjustMonthFn function that returns the adjusted month\n */\nconst adjustMonthSelectionScreen = (adjustMonthFn) => (event) => {\n const monthEl = event.target;\n const selectedMonth = parseInt(monthEl.dataset.value, 10);\n const { calendarEl, calendarDate, minDate, maxDate } =\n getDatePickerContext(monthEl);\n const currentDate = setMonth(calendarDate, selectedMonth);\n\n let adjustedMonth = adjustMonthFn(selectedMonth);\n adjustedMonth = Math.max(0, Math.min(11, adjustedMonth));\n\n const date = setMonth(calendarDate, adjustedMonth);\n const cappedDate = keepDateBetweenMinAndMax(date, minDate, maxDate);\n if (!isSameMonth(currentDate, cappedDate)) {\n const newCalendar = displayMonthSelection(\n calendarEl,\n cappedDate.getMonth(),\n );\n newCalendar.querySelector(CALENDAR_MONTH_FOCUSED).focus();\n }\n event.preventDefault();\n};\n\n/**\n * Navigate back three months and display the month selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleUpFromMonth = adjustMonthSelectionScreen((month) => month - 3);\n\n/**\n * Navigate forward three months and display the month selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleDownFromMonth = adjustMonthSelectionScreen((month) => month + 3);\n\n/**\n * Navigate back one month and display the month selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleLeftFromMonth = adjustMonthSelectionScreen((month) => month - 1);\n\n/**\n * Navigate forward one month and display the month selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleRightFromMonth = adjustMonthSelectionScreen((month) => month + 1);\n\n/**\n * Navigate to the start of the row of months and display the month selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleHomeFromMonth = adjustMonthSelectionScreen(\n (month) => month - (month % 3),\n);\n\n/**\n * Navigate to the end of the row of months and display the month selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleEndFromMonth = adjustMonthSelectionScreen(\n (month) => month + 2 - (month % 3),\n);\n\n/**\n * Navigate to the last month (December) and display the month selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handlePageDownFromMonth = adjustMonthSelectionScreen(() => 11);\n\n/**\n * Navigate to the first month (January) and display the month selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handlePageUpFromMonth = adjustMonthSelectionScreen(() => 0);\n\n// #endregion Calendar Month Event Handling\n\n// #region Calendar Year Event Handling\n\n/**\n * Adjust the year and display the year selection screen if needed.\n *\n * @param {function} adjustYearFn function that returns the adjusted year\n */\nconst adjustYearSelectionScreen = (adjustYearFn) => (event) => {\n const yearEl = event.target;\n const selectedYear = parseInt(yearEl.dataset.value, 10);\n const { calendarEl, calendarDate, minDate, maxDate } =\n getDatePickerContext(yearEl);\n const currentDate = setYear(calendarDate, selectedYear);\n\n let adjustedYear = adjustYearFn(selectedYear);\n adjustedYear = Math.max(0, adjustedYear);\n\n const date = setYear(calendarDate, adjustedYear);\n const cappedDate = keepDateBetweenMinAndMax(date, minDate, maxDate);\n if (!isSameYear(currentDate, cappedDate)) {\n const newCalendar = displayYearSelection(\n calendarEl,\n cappedDate.getFullYear(),\n );\n newCalendar.querySelector(CALENDAR_YEAR_FOCUSED).focus();\n }\n event.preventDefault();\n};\n\n/**\n * Navigate back three years and display the year selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleUpFromYear = adjustYearSelectionScreen((year) => year - 3);\n\n/**\n * Navigate forward three years and display the year selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleDownFromYear = adjustYearSelectionScreen((year) => year + 3);\n\n/**\n * Navigate back one year and display the year selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleLeftFromYear = adjustYearSelectionScreen((year) => year - 1);\n\n/**\n * Navigate forward one year and display the year selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleRightFromYear = adjustYearSelectionScreen((year) => year + 1);\n\n/**\n * Navigate to the start of the row of years and display the year selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleHomeFromYear = adjustYearSelectionScreen(\n (year) => year - (year % 3),\n);\n\n/**\n * Navigate to the end of the row of years and display the year selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handleEndFromYear = adjustYearSelectionScreen(\n (year) => year + 2 - (year % 3),\n);\n\n/**\n * Navigate to back 12 years and display the year selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handlePageUpFromYear = adjustYearSelectionScreen(\n (year) => year - YEAR_CHUNK,\n);\n\n/**\n * Navigate forward 12 years and display the year selection screen.\n *\n * @param {KeyboardEvent} event the keydown event\n */\nconst handlePageDownFromYear = adjustYearSelectionScreen(\n (year) => year + YEAR_CHUNK,\n);\n\n// #endregion Calendar Year Event Handling\n\n// #region Focus Handling Event Handling\n\nconst tabHandler = (focusable) => {\n const getFocusableContext = (el) => {\n const { calendarEl } = getDatePickerContext(el);\n const focusableElements = select(focusable, calendarEl);\n\n const firstTabIndex = 0;\n const lastTabIndex = focusableElements.length - 1;\n const firstTabStop = focusableElements[firstTabIndex];\n const lastTabStop = focusableElements[lastTabIndex];\n const focusIndex = focusableElements.indexOf(activeElement());\n\n const isLastTab = focusIndex === lastTabIndex;\n const isFirstTab = focusIndex === firstTabIndex;\n const isNotFound = focusIndex === -1;\n\n return {\n focusableElements,\n isNotFound,\n firstTabStop,\n isFirstTab,\n lastTabStop,\n isLastTab,\n };\n };\n\n return {\n tabAhead(event) {\n const { firstTabStop, isLastTab, isNotFound } = getFocusableContext(\n event.target,\n );\n\n if (isLastTab || isNotFound) {\n event.preventDefault();\n firstTabStop.focus();\n }\n },\n tabBack(event) {\n const { lastTabStop, isFirstTab, isNotFound } = getFocusableContext(\n event.target,\n );\n\n if (isFirstTab || isNotFound) {\n event.preventDefault();\n lastTabStop.focus();\n }\n },\n };\n};\n\nconst datePickerTabEventHandler = tabHandler(DATE_PICKER_FOCUSABLE);\nconst monthPickerTabEventHandler = tabHandler(MONTH_PICKER_FOCUSABLE);\nconst yearPickerTabEventHandler = tabHandler(YEAR_PICKER_FOCUSABLE);\n\n// #endregion Focus Handling Event Handling\n\n// #region Date Picker Event Delegation Registration / Component\n\nconst datePickerEvents = {\n [CLICK]: {\n [DATE_PICKER_BUTTON]() {\n toggleCalendar(this);\n },\n [CALENDAR_DATE]() {\n selectDate(this);\n },\n [CALENDAR_MONTH]() {\n selectMonth(this);\n },\n [CALENDAR_YEAR]() {\n selectYear(this);\n },\n [CALENDAR_PREVIOUS_MONTH]() {\n displayPreviousMonth(this);\n },\n [CALENDAR_NEXT_MONTH]() {\n displayNextMonth(this);\n },\n [CALENDAR_PREVIOUS_YEAR]() {\n displayPreviousYear(this);\n },\n [CALENDAR_NEXT_YEAR]() {\n displayNextYear(this);\n },\n [CALENDAR_PREVIOUS_YEAR_CHUNK]() {\n displayPreviousYearChunk(this);\n },\n [CALENDAR_NEXT_YEAR_CHUNK]() {\n displayNextYearChunk(this);\n },\n [CALENDAR_MONTH_SELECTION]() {\n const newCalendar = displayMonthSelection(this);\n newCalendar.querySelector(CALENDAR_MONTH_FOCUSED).focus();\n },\n [CALENDAR_YEAR_SELECTION]() {\n const newCalendar = displayYearSelection(this);\n newCalendar.querySelector(CALENDAR_YEAR_FOCUSED).focus();\n },\n },\n keyup: {\n [DATE_PICKER_CALENDAR](event) {\n const keydown = this.dataset.keydownKeyCode;\n if (`${event.keyCode}` !== keydown) {\n event.preventDefault();\n }\n },\n },\n keydown: {\n [DATE_PICKER_EXTERNAL_INPUT](event) {\n if (event.keyCode === ENTER_KEYCODE) {\n validateDateInput(this);\n }\n },\n [CALENDAR_DATE]: keymap({\n Up: handleUpFromDate,\n ArrowUp: handleUpFromDate,\n Down: handleDownFromDate,\n ArrowDown: handleDownFromDate,\n Left: handleLeftFromDate,\n ArrowLeft: handleLeftFromDate,\n Right: handleRightFromDate,\n ArrowRight: handleRightFromDate,\n Home: handleHomeFromDate,\n End: handleEndFromDate,\n PageDown: handlePageDownFromDate,\n PageUp: handlePageUpFromDate,\n \"Shift+PageDown\": handleShiftPageDownFromDate,\n \"Shift+PageUp\": handleShiftPageUpFromDate,\n Tab: datePickerTabEventHandler.tabAhead,\n }),\n [CALENDAR_DATE_PICKER]: keymap({\n Tab: datePickerTabEventHandler.tabAhead,\n \"Shift+Tab\": datePickerTabEventHandler.tabBack,\n }),\n [CALENDAR_MONTH]: keymap({\n Up: handleUpFromMonth,\n ArrowUp: handleUpFromMonth,\n Down: handleDownFromMonth,\n ArrowDown: handleDownFromMonth,\n Left: handleLeftFromMonth,\n ArrowLeft: handleLeftFromMonth,\n Right: handleRightFromMonth,\n ArrowRight: handleRightFromMonth,\n Home: handleHomeFromMonth,\n End: handleEndFromMonth,\n PageDown: handlePageDownFromMonth,\n PageUp: handlePageUpFromMonth,\n }),\n [CALENDAR_MONTH_PICKER]: keymap({\n Tab: monthPickerTabEventHandler.tabAhead,\n \"Shift+Tab\": monthPickerTabEventHandler.tabBack,\n }),\n [CALENDAR_YEAR]: keymap({\n Up: handleUpFromYear,\n ArrowUp: handleUpFromYear,\n Down: handleDownFromYear,\n ArrowDown: handleDownFromYear,\n Left: handleLeftFromYear,\n ArrowLeft: handleLeftFromYear,\n Right: handleRightFromYear,\n ArrowRight: handleRightFromYear,\n Home: handleHomeFromYear,\n End: handleEndFromYear,\n PageDown: handlePageDownFromYear,\n PageUp: handlePageUpFromYear,\n }),\n [CALENDAR_YEAR_PICKER]: keymap({\n Tab: yearPickerTabEventHandler.tabAhead,\n \"Shift+Tab\": yearPickerTabEventHandler.tabBack,\n }),\n [DATE_PICKER_CALENDAR](event) {\n this.dataset.keydownKeyCode = event.keyCode;\n },\n [DATE_PICKER](event) {\n const keyMap = keymap({\n Escape: handleEscapeFromCalendar,\n });\n\n keyMap(event);\n },\n },\n focusout: {\n [DATE_PICKER_EXTERNAL_INPUT]() {\n validateDateInput(this);\n },\n [DATE_PICKER](event) {\n if (!this.contains(event.relatedTarget)) {\n hideCalendar(this);\n }\n },\n },\n input: {\n [DATE_PICKER_EXTERNAL_INPUT]() {\n reconcileInputValues(this);\n updateCalendarIfVisible(this);\n },\n },\n};\n\nif (!isIosDevice()) {\n datePickerEvents.mouseover = {\n [CALENDAR_DATE_CURRENT_MONTH]() {\n handleMouseoverFromDate(this);\n },\n };\n}\n\nconst datePicker = behavior(datePickerEvents, {\n init(root) {\n selectOrMatches(DATE_PICKER, root).forEach((datePickerEl) => {\n enhanceDatePicker(datePickerEl);\n });\n },\n getDatePickerContext,\n disable,\n ariaDisable,\n enable,\n isDateInputInvalid,\n setCalendarValue,\n validateDateInput,\n renderCalendar,\n updateCalendarIfVisible,\n});\n\n// #endregion Date Picker Event Delegation Registration / Component\n\nmodule.exports = datePicker;\n","const behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst select = require(\"../../uswds-core/src/js/utils/select\");\nconst selectOrMatches = require(\"../../uswds-core/src/js/utils/select-or-matches\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\nconst {\n getDatePickerContext,\n isDateInputInvalid,\n updateCalendarIfVisible,\n} = require(\"../../usa-date-picker/src/index\");\n\nconst DATE_PICKER_CLASS = `${PREFIX}-date-picker`;\nconst DATE_RANGE_PICKER_CLASS = `${PREFIX}-date-range-picker`;\nconst DATE_RANGE_PICKER_RANGE_START_CLASS = `${DATE_RANGE_PICKER_CLASS}__range-start`;\nconst DATE_RANGE_PICKER_RANGE_END_CLASS = `${DATE_RANGE_PICKER_CLASS}__range-end`;\n\nconst DATE_PICKER = `.${DATE_PICKER_CLASS}`;\nconst DATE_RANGE_PICKER = `.${DATE_RANGE_PICKER_CLASS}`;\nconst DATE_RANGE_PICKER_RANGE_START = `.${DATE_RANGE_PICKER_RANGE_START_CLASS}`;\nconst DATE_RANGE_PICKER_RANGE_END = `.${DATE_RANGE_PICKER_RANGE_END_CLASS}`;\n\nconst DEFAULT_MIN_DATE = \"0000-01-01\";\n\n/**\n * The properties and elements within the date range picker.\n * @typedef {Object} DateRangePickerContext\n * @property {HTMLElement} dateRangePickerEl\n * @property {HTMLElement} rangeStartEl\n * @property {HTMLElement} rangeEndEl\n */\n\n/**\n * Get an object of the properties and elements belonging directly to the given\n * date picker component.\n *\n * @param {HTMLElement} el the element within the date picker\n * @returns {DateRangePickerContext} elements\n */\nconst getDateRangePickerContext = (el) => {\n const dateRangePickerEl = el.closest(DATE_RANGE_PICKER);\n\n if (!dateRangePickerEl) {\n throw new Error(`Element is missing outer ${DATE_RANGE_PICKER}`);\n }\n\n const rangeStartEl = dateRangePickerEl.querySelector(\n DATE_RANGE_PICKER_RANGE_START,\n );\n const rangeEndEl = dateRangePickerEl.querySelector(\n DATE_RANGE_PICKER_RANGE_END,\n );\n\n return {\n dateRangePickerEl,\n rangeStartEl,\n rangeEndEl,\n };\n};\n\n/**\n * handle update from range start date picker\n *\n * @param {HTMLElement} el an element within the date range picker\n */\nconst handleRangeStartUpdate = (el) => {\n const { dateRangePickerEl, rangeStartEl, rangeEndEl } =\n getDateRangePickerContext(el);\n const { internalInputEl } = getDatePickerContext(rangeStartEl);\n const updatedDate = internalInputEl.value;\n\n if (updatedDate && !isDateInputInvalid(internalInputEl)) {\n rangeEndEl.dataset.minDate = updatedDate;\n rangeEndEl.dataset.rangeDate = updatedDate;\n rangeEndEl.dataset.defaultDate = updatedDate;\n } else {\n rangeEndEl.dataset.minDate = dateRangePickerEl.dataset.minDate || \"\";\n rangeEndEl.dataset.rangeDate = \"\";\n rangeEndEl.dataset.defaultDate = \"\";\n }\n\n updateCalendarIfVisible(rangeEndEl);\n};\n\n/**\n * handle update from range start date picker\n *\n * @param {HTMLElement} el an element within the date range picker\n */\nconst handleRangeEndUpdate = (el) => {\n const { dateRangePickerEl, rangeStartEl, rangeEndEl } =\n getDateRangePickerContext(el);\n const { internalInputEl } = getDatePickerContext(rangeEndEl);\n const updatedDate = internalInputEl.value;\n\n if (updatedDate && !isDateInputInvalid(internalInputEl)) {\n rangeStartEl.dataset.maxDate = updatedDate;\n rangeStartEl.dataset.rangeDate = updatedDate;\n rangeStartEl.dataset.defaultDate = updatedDate;\n } else {\n rangeStartEl.dataset.maxDate = dateRangePickerEl.dataset.maxDate || \"\";\n rangeStartEl.dataset.rangeDate = \"\";\n rangeStartEl.dataset.defaultDate = \"\";\n }\n\n updateCalendarIfVisible(rangeStartEl);\n};\n\n/**\n * Enhance an input with the date picker elements\n *\n * @param {HTMLElement} el The initial wrapping element of the date range picker component\n */\nconst enhanceDateRangePicker = (el) => {\n const dateRangePickerEl = el.closest(DATE_RANGE_PICKER);\n\n const [rangeStart, rangeEnd] = select(DATE_PICKER, dateRangePickerEl);\n\n if (!rangeStart) {\n throw new Error(\n `${DATE_RANGE_PICKER} is missing inner two '${DATE_PICKER}' elements`,\n );\n }\n\n if (!rangeEnd) {\n throw new Error(\n `${DATE_RANGE_PICKER} is missing second '${DATE_PICKER}' element`,\n );\n }\n\n rangeStart.classList.add(DATE_RANGE_PICKER_RANGE_START_CLASS);\n rangeEnd.classList.add(DATE_RANGE_PICKER_RANGE_END_CLASS);\n\n if (!dateRangePickerEl.dataset.minDate) {\n dateRangePickerEl.dataset.minDate = DEFAULT_MIN_DATE;\n }\n\n const { minDate } = dateRangePickerEl.dataset;\n rangeStart.dataset.minDate = minDate;\n rangeEnd.dataset.minDate = minDate;\n\n const { maxDate } = dateRangePickerEl.dataset;\n if (maxDate) {\n rangeStart.dataset.maxDate = maxDate;\n rangeEnd.dataset.maxDate = maxDate;\n }\n\n handleRangeStartUpdate(dateRangePickerEl);\n handleRangeEndUpdate(dateRangePickerEl);\n};\n\nconst dateRangePicker = behavior(\n {\n \"input change\": {\n [DATE_RANGE_PICKER_RANGE_START]() {\n handleRangeStartUpdate(this);\n },\n [DATE_RANGE_PICKER_RANGE_END]() {\n handleRangeEndUpdate(this);\n },\n },\n },\n {\n init(root) {\n selectOrMatches(DATE_RANGE_PICKER, root).forEach((dateRangePickerEl) => {\n enhanceDateRangePicker(dateRangePickerEl);\n });\n },\n },\n);\n\nmodule.exports = dateRangePicker;\n","const selectOrMatches = require(\"../../uswds-core/src/js/utils/select-or-matches\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst Sanitizer = require(\"../../uswds-core/src/js/utils/sanitizer\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\n\nconst DROPZONE_CLASS = `${PREFIX}-file-input`;\nconst DROPZONE = `.${DROPZONE_CLASS}`;\nconst INPUT_CLASS = `${PREFIX}-file-input__input`;\nconst TARGET_CLASS = `${PREFIX}-file-input__target`;\nconst INPUT = `.${INPUT_CLASS}`;\nconst BOX_CLASS = `${PREFIX}-file-input__box`;\nconst INSTRUCTIONS_CLASS = `${PREFIX}-file-input__instructions`;\nconst PREVIEW_CLASS = `${PREFIX}-file-input__preview`;\nconst PREVIEW_HEADING_CLASS = `${PREFIX}-file-input__preview-heading`;\nconst DISABLED_CLASS = `${PREFIX}-file-input--disabled`;\nconst CHOOSE_CLASS = `${PREFIX}-file-input__choose`;\nconst ACCEPTED_FILE_MESSAGE_CLASS = `${PREFIX}-file-input__accepted-files-message`;\nconst DRAG_TEXT_CLASS = `${PREFIX}-file-input__drag-text`;\nconst DRAG_CLASS = `${PREFIX}-file-input--drag`;\nconst LOADING_CLASS = \"is-loading\";\nconst INVALID_FILE_CLASS = \"has-invalid-file\";\nconst GENERIC_PREVIEW_CLASS_NAME = `${PREFIX}-file-input__preview-image`;\nconst GENERIC_PREVIEW_CLASS = `${GENERIC_PREVIEW_CLASS_NAME}--generic`;\nconst PDF_PREVIEW_CLASS = `${GENERIC_PREVIEW_CLASS_NAME}--pdf`;\nconst WORD_PREVIEW_CLASS = `${GENERIC_PREVIEW_CLASS_NAME}--word`;\nconst VIDEO_PREVIEW_CLASS = `${GENERIC_PREVIEW_CLASS_NAME}--video`;\nconst EXCEL_PREVIEW_CLASS = `${GENERIC_PREVIEW_CLASS_NAME}--excel`;\nconst SR_ONLY_CLASS = `${PREFIX}-sr-only`;\nconst SPACER_GIF =\n \"data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7\";\nconst DEFAULT_ERROR_LABEL_TEXT = \"Error: This is not a valid file type.\";\n\nlet TYPE_IS_VALID = Boolean(true); // logic gate for change listener\nlet DEFAULT_ARIA_LABEL_TEXT = \"\";\nlet DEFAULT_FILE_STATUS_TEXT = \"\";\n\n/**\n * The properties and elements within the file input.\n * @typedef {Object} FileInputContext\n * @property {HTMLDivElement} dropZoneEl\n * @property {HTMLInputElement} inputEl\n */\n\n/**\n * Get an object of the properties and elements belonging directly to the given\n * file input component.\n *\n * @param {HTMLElement} el the element within the file input\n * @returns {FileInputContext} elements\n */\nconst getFileInputContext = (el) => {\n const dropZoneEl = el.closest(DROPZONE);\n\n if (!dropZoneEl) {\n throw new Error(`Element is missing outer ${DROPZONE}`);\n }\n\n const inputEl = dropZoneEl.querySelector(INPUT);\n\n return {\n dropZoneEl,\n inputEl,\n };\n};\n\n/**\n * Disable the file input component\n *\n * @param {HTMLElement} el An element within the file input component\n */\nconst disable = (el) => {\n const { dropZoneEl, inputEl } = getFileInputContext(el);\n\n inputEl.disabled = true;\n dropZoneEl.classList.add(DISABLED_CLASS);\n};\n\n/**\n * Set aria-disabled attribute to file input component\n *\n * @param {HTMLElement} el An element within the file input component\n */\nconst ariaDisable = (el) => {\n const { dropZoneEl } = getFileInputContext(el);\n\n dropZoneEl.classList.add(DISABLED_CLASS);\n};\n\n/**\n * Enable the file input component\n *\n * @param {HTMLElement} el An element within the file input component\n */\nconst enable = (el) => {\n const { dropZoneEl, inputEl } = getFileInputContext(el);\n\n inputEl.disabled = false;\n dropZoneEl.classList.remove(DISABLED_CLASS);\n dropZoneEl.removeAttribute(\"aria-disabled\");\n};\n\n/**\n *\n * @param {String} s special characters\n * @returns {String} replaces specified values\n */\nconst replaceName = (s) => {\n const c = s.charCodeAt(0);\n if (c === 32) return \"-\";\n if (c >= 65 && c <= 90) return `img_${s.toLowerCase()}`;\n return `__${(\"000\", c.toString(16)).slice(-4)}`;\n};\n\n/**\n * Creates an ID name for each file that strips all invalid characters.\n * @param {String} name - name of the file added to file input (searchvalue)\n * @returns {String} same characters as the name with invalid chars removed (newvalue)\n */\nconst makeSafeForID = (name) => name.replace(/[^a-z0-9]/g, replaceName);\n\n// Takes a generated safe ID and creates a unique ID.\nconst createUniqueID = (name) =>\n `${name}-${Math.floor(Date.now().toString() / 1000)}`;\n\n/**\n * Determines if the singular or plural item label should be used\n * Determination is based on the presence of the `multiple` attribute\n *\n * @param {HTMLInputElement} fileInputEl - The input element.\n * @returns {HTMLDivElement} The singular or plural version of \"item\"\n */\nconst getItemsLabel = (fileInputEl) => {\n const acceptsMultiple = fileInputEl.hasAttribute(\"multiple\");\n const itemsLabel = acceptsMultiple ? \"files\" : \"file\";\n\n return itemsLabel;\n};\n\n/**\n * Scaffold the file input component with a parent wrapper and\n * Create a target area overlay for drag and drop functionality\n *\n * @param {HTMLInputElement} fileInputEl - The input element.\n * @returns {HTMLDivElement} The drag and drop target area.\n */\nconst createTargetArea = (fileInputEl) => {\n const fileInputParent = document.createElement(\"div\");\n const dropTarget = document.createElement(\"div\");\n const box = document.createElement(\"div\");\n\n // Adds class names and other attributes\n fileInputEl.classList.remove(DROPZONE_CLASS);\n fileInputEl.classList.add(INPUT_CLASS);\n fileInputParent.classList.add(DROPZONE_CLASS);\n box.classList.add(BOX_CLASS);\n dropTarget.classList.add(TARGET_CLASS);\n\n // Adds child elements to the DOM\n dropTarget.prepend(box);\n fileInputEl.parentNode.insertBefore(dropTarget, fileInputEl);\n fileInputEl.parentNode.insertBefore(fileInputParent, dropTarget);\n dropTarget.appendChild(fileInputEl);\n fileInputParent.appendChild(dropTarget);\n\n return dropTarget;\n};\n\n/**\n * Build the visible element with default interaction instructions.\n *\n * @param {HTMLInputElement} fileInputEl - The input element.\n * @returns {HTMLDivElement} The container for visible interaction instructions.\n */\nconst createVisibleInstructions = (fileInputEl) => {\n const fileInputParent = fileInputEl.closest(DROPZONE);\n const itemsLabel = getItemsLabel(fileInputEl);\n const instructions = document.createElement(\"div\");\n const dragText = `Drag ${itemsLabel} here or`;\n const chooseText = \"choose from folder\";\n\n // Create instructions text for aria-label\n DEFAULT_ARIA_LABEL_TEXT = `${dragText} ${chooseText}`;\n\n // Adds class names and other attributes\n instructions.classList.add(INSTRUCTIONS_CLASS);\n instructions.setAttribute(\"aria-hidden\", \"true\");\n\n // Add initial instructions for input usage\n fileInputEl.setAttribute(\"aria-label\", DEFAULT_ARIA_LABEL_TEXT);\n instructions.innerHTML = Sanitizer.escapeHTML`<span class=\"${DRAG_TEXT_CLASS}\">${dragText}</span> <span class=\"${CHOOSE_CLASS}\">${chooseText}</span>`;\n\n // Add the instructions element to the DOM\n fileInputEl.parentNode.insertBefore(instructions, fileInputEl);\n\n // IE11 and Edge do not support drop files on file inputs, so we've removed text that indicates that\n if (\n /rv:11.0/i.test(navigator.userAgent) ||\n /Edge\\/\\d./i.test(navigator.userAgent)\n ) {\n fileInputParent.querySelector(`.${DRAG_TEXT_CLASS}`).outerHTML = \"\";\n }\n\n return instructions;\n};\n\n/**\n * Build a screen reader-only message element that contains file status updates and\n * Create and set the default file status message\n *\n * @param {HTMLInputElement} fileInputEl - The input element.\n */\nconst createSROnlyStatus = (fileInputEl) => {\n const statusEl = document.createElement(\"div\");\n const itemsLabel = getItemsLabel(fileInputEl);\n const fileInputParent = fileInputEl.closest(DROPZONE);\n const fileInputTarget = fileInputEl.closest(`.${TARGET_CLASS}`);\n\n DEFAULT_FILE_STATUS_TEXT = `No ${itemsLabel} selected.`;\n\n // Adds class names and other attributes\n statusEl.classList.add(SR_ONLY_CLASS);\n statusEl.setAttribute(\"aria-live\", \"polite\");\n\n // Add initial file status message\n statusEl.textContent = DEFAULT_FILE_STATUS_TEXT;\n\n // Add the status element to the DOM\n fileInputParent.insertBefore(statusEl, fileInputTarget);\n};\n\n/**\n * Scaffold the component with all required elements\n *\n * @param {HTMLInputElement} fileInputEl - The original input element.\n */\nconst enhanceFileInput = (fileInputEl) => {\n const isInputDisabled =\n fileInputEl.hasAttribute(\"aria-disabled\") ||\n fileInputEl.hasAttribute(\"disabled\");\n const dropTarget = createTargetArea(fileInputEl);\n const instructions = createVisibleInstructions(fileInputEl);\n const { dropZoneEl } = getFileInputContext(fileInputEl);\n\n if (isInputDisabled) {\n dropZoneEl.classList.add(DISABLED_CLASS);\n } else {\n createSROnlyStatus(fileInputEl);\n }\n\n return { instructions, dropTarget };\n};\n\n/**\n * Removes image previews\n * We want to start with a clean list every time files are added to the file input\n *\n * @param {HTMLDivElement} dropTarget - The drag and drop target area.\n * @param {HTMLDivElement} instructions - The container for visible interaction instructions.\n */\nconst removeOldPreviews = (dropTarget, instructions) => {\n const filePreviews = dropTarget.querySelectorAll(`.${PREVIEW_CLASS}`);\n const currentPreviewHeading = dropTarget.querySelector(\n `.${PREVIEW_HEADING_CLASS}`,\n );\n const currentErrorMessage = dropTarget.querySelector(\n `.${ACCEPTED_FILE_MESSAGE_CLASS}`,\n );\n\n /**\n * finds the parent of the passed node and removes the child\n * @param {HTMLElement} node\n */\n const removeImages = (node) => {\n node.parentNode.removeChild(node);\n };\n\n // Remove the heading above the previews\n if (currentPreviewHeading) {\n currentPreviewHeading.outerHTML = \"\";\n }\n\n // Remove existing error messages\n if (currentErrorMessage) {\n currentErrorMessage.outerHTML = \"\";\n dropTarget.classList.remove(INVALID_FILE_CLASS);\n }\n\n // Get rid of existing previews if they exist, show instructions\n if (filePreviews !== null) {\n if (instructions) {\n instructions.removeAttribute(\"hidden\");\n }\n Array.prototype.forEach.call(filePreviews, removeImages);\n }\n};\n\n/**\n * Update the screen reader-only status message after interaction\n *\n * @param {HTMLDivElement} statusElement - The screen reader-only container for file status updates.\n * @param {Object} fileNames - The selected files found in the fileList object.\n * @param {Array} fileStore - The array of uploaded file names created from the fileNames object.\n */\nconst updateStatusMessage = (statusElement, fileNames, fileStore) => {\n const statusEl = statusElement;\n let statusMessage = DEFAULT_FILE_STATUS_TEXT;\n\n // If files added, update the status message with file name(s)\n if (fileNames.length === 1) {\n statusMessage = `You have selected the file: ${fileStore}`;\n } else if (fileNames.length > 1) {\n statusMessage = `You have selected ${\n fileNames.length\n } files: ${fileStore.join(\", \")}`;\n }\n\n // Add delay to encourage screen reader readout\n setTimeout(() => {\n statusEl.textContent = statusMessage;\n }, 1000);\n};\n\n/**\n * Show the preview heading, hide the initial instructions and\n * Update the aria-label with new instructions text\n *\n * @param {HTMLInputElement} fileInputEl - The input element.\n * @param {Object} fileNames - The selected files found in the fileList object.\n */\nconst addPreviewHeading = (fileInputEl, fileNames) => {\n const filePreviewsHeading = document.createElement(\"div\");\n const dropTarget = fileInputEl.closest(`.${TARGET_CLASS}`);\n const instructions = dropTarget.querySelector(`.${INSTRUCTIONS_CLASS}`);\n let changeItemText = \"Change file\";\n let previewHeadingText = \"\";\n\n if (fileNames.length === 1) {\n previewHeadingText = Sanitizer.escapeHTML`Selected file <span class=\"usa-file-input__choose\">${changeItemText}</span>`;\n } else if (fileNames.length > 1) {\n changeItemText = \"Change files\";\n previewHeadingText = Sanitizer.escapeHTML`${fileNames.length} files selected <span class=\"usa-file-input__choose\">${changeItemText}</span>`;\n }\n\n // Hides null state content and sets preview heading\n instructions.setAttribute(\"hidden\", \"true\");\n filePreviewsHeading.classList.add(PREVIEW_HEADING_CLASS);\n filePreviewsHeading.innerHTML = previewHeadingText;\n dropTarget.insertBefore(filePreviewsHeading, instructions);\n\n // Update aria label to match the visible action text\n fileInputEl.setAttribute(\"aria-label\", changeItemText);\n};\n\n/** Add an error listener to the image preview to set a fallback image\n * @param {HTMLImageElement} previewImage - The image element\n * @param {String} fallbackClass - The CSS class of the fallback image\n */\nconst setPreviewFallback = (previewImage, fallbackClass) => {\n previewImage.addEventListener(\n \"error\",\n () => {\n const localPreviewImage = previewImage; // to avoid no-param-reassign from ESLint\n localPreviewImage.src = SPACER_GIF;\n localPreviewImage.classList.add(fallbackClass);\n },\n { once: true },\n );\n};\n\n/**\n * When new files are applied to file input, this function generates previews\n * and removes old ones.\n *\n * @param {event} e\n * @param {HTMLInputElement} fileInputEl - The input element.\n * @param {HTMLDivElement} instructions - The container for visible interaction instructions.\n * @param {HTMLDivElement} dropTarget - The drag and drop target area.\n */\n\nconst handleChange = (e, fileInputEl, instructions, dropTarget) => {\n const fileNames = e.target.files;\n const inputParent = dropTarget.closest(`.${DROPZONE_CLASS}`);\n const statusElement = inputParent.querySelector(`.${SR_ONLY_CLASS}`);\n const fileStore = [];\n\n // First, get rid of existing previews\n removeOldPreviews(dropTarget, instructions);\n\n // Then, iterate through files list and create previews\n for (let i = 0; i < fileNames.length; i += 1) {\n const reader = new FileReader();\n const fileName = fileNames[i].name;\n let imageId;\n\n // Push updated file names into the store array\n fileStore.push(fileName);\n\n // Starts with a loading image while preview is created\n reader.onloadstart = function createLoadingImage() {\n imageId = createUniqueID(makeSafeForID(fileName));\n\n instructions.insertAdjacentHTML(\n \"afterend\",\n Sanitizer.escapeHTML`<div class=\"${PREVIEW_CLASS}\" aria-hidden=\"true\">\n <img id=\"${imageId}\" src=\"${SPACER_GIF}\" alt=\"\" class=\"${GENERIC_PREVIEW_CLASS_NAME} ${LOADING_CLASS}\"/>${fileName}\n <div>`,\n );\n };\n\n // Not all files will be able to generate previews. In case this happens, we provide several types \"generic previews\" based on the file extension.\n reader.onloadend = function createFilePreview() {\n const previewImage = document.getElementById(imageId);\n const fileExtension = fileName.split(\".\").pop();\n if (fileExtension === \"pdf\") {\n setPreviewFallback(previewImage, PDF_PREVIEW_CLASS);\n } else if (\n fileExtension === \"doc\" ||\n fileExtension === \"docx\" ||\n fileExtension === \"pages\"\n ) {\n setPreviewFallback(previewImage, WORD_PREVIEW_CLASS);\n } else if (\n fileExtension === \"xls\" ||\n fileExtension === \"xlsx\" ||\n fileExtension === \"numbers\"\n ) {\n setPreviewFallback(previewImage, EXCEL_PREVIEW_CLASS);\n } else if (fileExtension === \"mov\" || fileExtension === \"mp4\") {\n setPreviewFallback(previewImage, VIDEO_PREVIEW_CLASS);\n } else {\n setPreviewFallback(previewImage, GENERIC_PREVIEW_CLASS);\n }\n\n // Removes loader and displays preview\n previewImage.classList.remove(LOADING_CLASS);\n previewImage.src = reader.result;\n };\n\n if (fileNames[i]) {\n reader.readAsDataURL(fileNames[i]);\n }\n }\n\n if (fileNames.length === 0) {\n // Reset input aria-label with default message\n fileInputEl.setAttribute(\"aria-label\", DEFAULT_ARIA_LABEL_TEXT);\n } else {\n addPreviewHeading(fileInputEl, fileNames);\n }\n\n updateStatusMessage(statusElement, fileNames, fileStore);\n};\n\n/**\n * When using an Accept attribute, invalid files will be hidden from\n * file browser, but they can still be dragged to the input. This\n * function prevents them from being dragged and removes error states\n * when correct files are added.\n *\n * @param {event} e\n * @param {HTMLInputElement} fileInputEl - The input element.\n * @param {HTMLDivElement} instructions - The container for visible interaction instructions.\n * @param {HTMLDivElement} dropTarget - The drag and drop target area.\n */\nconst preventInvalidFiles = (e, fileInputEl, instructions, dropTarget) => {\n const acceptedFilesAttr = fileInputEl.getAttribute(\"accept\");\n dropTarget.classList.remove(INVALID_FILE_CLASS);\n\n /**\n * We can probably move away from this once IE11 support stops, and replace\n * with a simple es `.includes`\n * check if element is in array\n * check if 1 or more alphabets are in string\n * if element is present return the position value and -1 otherwise\n * @param {Object} file\n * @param {String} value\n * @returns {Boolean}\n */\n const isIncluded = (file, value) => {\n let returnValue = false;\n const pos = file.indexOf(value);\n if (pos >= 0) {\n returnValue = true;\n }\n return returnValue;\n };\n\n // Runs if only specific files are accepted\n if (acceptedFilesAttr) {\n const acceptedFiles = acceptedFilesAttr.split(\",\");\n const errorMessage = document.createElement(\"div\");\n const userErrorText = fileInputEl.dataset.errormessage;\n const errorMessageText = userErrorText || DEFAULT_ERROR_LABEL_TEXT;\n\n errorMessage.setAttribute(\"aria-hidden\", true);\n\n // If multiple files are dragged, this iterates through them and look for any files that are not accepted.\n let allFilesAllowed = true;\n const scannedFiles = e.target.files || e.dataTransfer.files;\n for (let i = 0; i < scannedFiles.length; i += 1) {\n const file = scannedFiles[i];\n if (allFilesAllowed) {\n for (let j = 0; j < acceptedFiles.length; j += 1) {\n const fileType = acceptedFiles[j];\n allFilesAllowed =\n file.name.indexOf(fileType) > 0 ||\n isIncluded(file.type, fileType.replace(/\\*/g, \"\"));\n if (allFilesAllowed) {\n TYPE_IS_VALID = true;\n break;\n }\n }\n } else break;\n }\n\n // If dragged files are not accepted, this removes them from the value of the input and creates and error state\n if (!allFilesAllowed) {\n removeOldPreviews(dropTarget, instructions);\n fileInputEl.value = \"\"; // eslint-disable-line no-param-reassign\n errorMessage.textContent = errorMessageText;\n dropTarget.insertBefore(errorMessage, fileInputEl);\n\n const ariaLabelText = `${errorMessageText} ${DEFAULT_ARIA_LABEL_TEXT}`;\n\n fileInputEl.setAttribute(\"aria-label\", ariaLabelText);\n errorMessage.classList.add(ACCEPTED_FILE_MESSAGE_CLASS);\n dropTarget.classList.add(INVALID_FILE_CLASS);\n TYPE_IS_VALID = false;\n e.preventDefault();\n e.stopPropagation();\n }\n }\n};\n\n/**\n * 1. passes through gate for preventing invalid files\n * 2. handles updates if file is valid\n *\n * @param {event} event\n * @param {HTMLInputElement} fileInputEl - The input element.\n * @param {HTMLDivElement} instructions - The container for visible interaction instructions.\n * @param {HTMLDivElement} dropTarget - The drag and drop target area.\n */\nconst handleUpload = (event, fileInputEl, instructions, dropTarget) => {\n preventInvalidFiles(event, fileInputEl, instructions, dropTarget);\n if (TYPE_IS_VALID === true) {\n handleChange(event, fileInputEl, instructions, dropTarget);\n }\n};\n\nconst fileInput = behavior(\n {},\n {\n init(root) {\n selectOrMatches(DROPZONE, root).forEach((fileInputEl) => {\n const { instructions, dropTarget } = enhanceFileInput(fileInputEl);\n\n dropTarget.addEventListener(\n \"dragover\",\n function handleDragOver() {\n this.classList.add(DRAG_CLASS);\n },\n false,\n );\n\n dropTarget.addEventListener(\n \"dragleave\",\n function handleDragLeave() {\n this.classList.remove(DRAG_CLASS);\n },\n false,\n );\n\n dropTarget.addEventListener(\n \"drop\",\n function handleDrop() {\n this.classList.remove(DRAG_CLASS);\n },\n false,\n );\n\n fileInputEl.addEventListener(\n \"change\",\n (e) => handleUpload(e, fileInputEl, instructions, dropTarget),\n false,\n );\n });\n },\n teardown(root) {\n selectOrMatches(INPUT, root).forEach((fileInputEl) => {\n const fileInputTopElement = fileInputEl.parentElement.parentElement;\n fileInputTopElement.parentElement.replaceChild(\n fileInputEl,\n fileInputTopElement,\n );\n // eslint-disable-next-line no-param-reassign\n fileInputEl.className = DROPZONE_CLASS;\n });\n },\n getFileInputContext,\n disable,\n ariaDisable,\n enable,\n },\n);\n\nmodule.exports = fileInput;\n","const behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst { CLICK } = require(\"../../uswds-core/src/js/events\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\n\nconst SCOPE = `.${PREFIX}-footer--big`;\nconst NAV = `${SCOPE} nav`;\nconst BUTTON = `${NAV} .${PREFIX}-footer__primary-link`;\nconst HIDE_MAX_WIDTH = 480;\n\n/**\n * Expands selected footer menu panel, while collapsing others\n */\nfunction showPanel() {\n if (window.innerWidth < HIDE_MAX_WIDTH) {\n const isOpen = this.getAttribute(\"aria-expanded\") === \"true\";\n const thisFooter = this.closest(SCOPE);\n\n // Close all other menus\n thisFooter.querySelectorAll(BUTTON).forEach((button) => {\n button.setAttribute(\"aria-expanded\", false);\n });\n\n this.setAttribute(\"aria-expanded\", !isOpen);\n }\n}\n\n/**\n * Swaps the <h4> element for a <button> element (and vice-versa) and sets id\n * of menu list\n *\n * @param {Boolean} isMobile - If the footer is in mobile configuration\n */\nfunction toggleHtmlTag(isMobile) {\n const bigFooter = document.querySelector(SCOPE);\n\n if (!bigFooter) {\n return;\n }\n\n const primaryLinks = bigFooter.querySelectorAll(BUTTON);\n\n primaryLinks.forEach((currentElement) => {\n const currentElementClasses = currentElement.getAttribute(\"class\");\n const preservedHtmlTag =\n currentElement.getAttribute(\"data-tag\") || currentElement.tagName;\n\n const newElementType = isMobile ? \"button\" : preservedHtmlTag;\n\n // Create the new element\n const newElement = document.createElement(newElementType);\n newElement.setAttribute(\"class\", currentElementClasses);\n newElement.classList.toggle(\n `${PREFIX}-footer__primary-link--button`,\n isMobile,\n );\n newElement.textContent = currentElement.textContent;\n\n if (isMobile) {\n newElement.setAttribute(\"data-tag\", currentElement.tagName);\n const menuId = `${PREFIX}-footer-menu-list-${Math.floor(\n Math.random() * 100000,\n )}`;\n\n newElement.setAttribute(\"aria-controls\", menuId);\n newElement.setAttribute(\"aria-expanded\", \"false\");\n currentElement.nextElementSibling.setAttribute(\"id\", menuId);\n newElement.setAttribute(\"type\", \"button\");\n }\n\n // Insert the new element and delete the old\n currentElement.after(newElement);\n currentElement.remove();\n });\n}\n\nconst resize = (event) => {\n toggleHtmlTag(event.matches);\n};\n\nmodule.exports = behavior(\n {\n [CLICK]: {\n [BUTTON]: showPanel,\n },\n },\n {\n // export for use elsewhere\n HIDE_MAX_WIDTH,\n\n init() {\n toggleHtmlTag(window.innerWidth < HIDE_MAX_WIDTH);\n this.mediaQueryList = window.matchMedia(\n `(max-width: ${HIDE_MAX_WIDTH - 0.1}px)`,\n );\n this.mediaQueryList.addListener(resize);\n },\n\n teardown() {\n this.mediaQueryList.removeListener(resize);\n },\n },\n);\n","const keymap = require(\"receptor/keymap\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst select = require(\"../../uswds-core/src/js/utils/select\");\nconst toggle = require(\"../../uswds-core/src/js/utils/toggle\");\nconst FocusTrap = require(\"../../uswds-core/src/js/utils/focus-trap\");\nconst accordion = require(\"../../usa-accordion/src/index\");\nconst ScrollBarWidth = require(\"../../uswds-core/src/js/utils/scrollbar-width\");\n\nconst { CLICK } = require(\"../../uswds-core/src/js/events\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\n\nconst BODY = \"body\";\nconst HEADER = `.${PREFIX}-header`;\nconst NAV = `.${PREFIX}-nav`;\nconst NAV_CONTAINER = `.${PREFIX}-nav-container`;\nconst NAV_PRIMARY = `.${PREFIX}-nav__primary`;\nconst NAV_PRIMARY_ITEM = `.${PREFIX}-nav__primary-item`;\nconst NAV_CONTROL = `button.${PREFIX}-nav__link`;\nconst NAV_LINKS = `${NAV} a`;\nconst NON_NAV_HIDDEN_ATTRIBUTE = `data-nav-hidden`;\nconst OPENERS = `.${PREFIX}-menu-btn`;\nconst CLOSE_BUTTON = `.${PREFIX}-nav__close`;\nconst OVERLAY = `.${PREFIX}-overlay`;\nconst CLOSERS = `${CLOSE_BUTTON}, .${PREFIX}-overlay`;\nconst TOGGLES = [NAV, OVERLAY].join(\", \");\nconst NON_NAV_ELEMENTS = `body *:not(${HEADER}, ${NAV_CONTAINER}, ${NAV}, ${NAV} *):not([aria-hidden])`;\nconst NON_NAV_HIDDEN = `[${NON_NAV_HIDDEN_ATTRIBUTE}]`;\n\nconst ACTIVE_CLASS = \"usa-js-mobile-nav--active\";\nconst VISIBLE_CLASS = \"is-visible\";\n\nlet navigation;\nlet navActive;\nlet nonNavElements;\n\nconst isActive = () => document.body.classList.contains(ACTIVE_CLASS);\n// Detect Safari\n// Note: Chrome also reports the Safari userAgent so this specifically excludes Chrome.\nconst isSafari =\n navigator.userAgent.includes(\"Safari\") &&\n !navigator.userAgent.includes(\"Chrome\");\nconst SCROLLBAR_WIDTH = ScrollBarWidth();\nconst INITIAL_PADDING = window\n .getComputedStyle(document.body)\n .getPropertyValue(\"padding-right\");\nconst TEMPORARY_PADDING = `${\n parseInt(INITIAL_PADDING.replace(/px/, \"\"), 10) +\n parseInt(SCROLLBAR_WIDTH.replace(/px/, \"\"), 10)\n}px`;\n\nconst hideNonNavItems = () => {\n const headerParent = document.querySelector(`${HEADER}`).parentNode;\n nonNavElements = document.querySelectorAll(NON_NAV_ELEMENTS);\n\n nonNavElements.forEach((nonNavElement) => {\n if (nonNavElement !== headerParent) {\n nonNavElement.setAttribute(\"aria-hidden\", true);\n nonNavElement.setAttribute(NON_NAV_HIDDEN_ATTRIBUTE, \"\");\n }\n });\n};\n\nconst showNonNavItems = () => {\n nonNavElements = document.querySelectorAll(NON_NAV_HIDDEN);\n\n if (!nonNavElements) {\n return;\n }\n\n // Remove aria-hidden from non-header elements\n nonNavElements.forEach((nonNavElement) => {\n nonNavElement.removeAttribute(\"aria-hidden\");\n nonNavElement.removeAttribute(NON_NAV_HIDDEN_ATTRIBUTE);\n });\n};\n\n// Toggle all non-header elements #3527.\nconst toggleNonNavItems = (active) => {\n if (active) {\n hideNonNavItems();\n } else {\n showNonNavItems();\n }\n};\n\n/**\n * Detect Safari and add body class for a Safari-only CSS bug fix.\n * More details in https://github.com/uswds/uswds/pull/5443\n */\nconst addSafariClass = () => {\n if (isSafari) {\n document.body.classList.add(\"is-safari\");\n }\n};\n\n/**\n * Set the value for the --scrolltop CSS var when the mobile menu is open.\n * This allows the CSS to lock the current scroll position in Safari\n * when overflow-y is set to scroll.\n * More details in https://github.com/uswds/uswds/pull/5443\n */\nconst setSafariScrollPosition = (body) => {\n const currentScrollPosition = `-${window.scrollY}px`;\n if (isSafari) {\n body.style.setProperty(\"--scrolltop\", currentScrollPosition);\n }\n};\n\nconst toggleNav = (active) => {\n const { body } = document;\n const safeActive = typeof active === \"boolean\" ? active : !isActive();\n\n setSafariScrollPosition(body);\n\n body.classList.toggle(ACTIVE_CLASS, safeActive);\n\n select(TOGGLES).forEach((el) =>\n el.classList.toggle(VISIBLE_CLASS, safeActive),\n );\n\n navigation.focusTrap.update(safeActive);\n\n const closeButton = body.querySelector(CLOSE_BUTTON);\n const menuButton = document.querySelector(OPENERS);\n\n body.style.paddingRight =\n body.style.paddingRight === TEMPORARY_PADDING\n ? INITIAL_PADDING\n : TEMPORARY_PADDING;\n\n toggleNonNavItems(safeActive);\n\n if (safeActive && closeButton) {\n // The mobile nav was just activated. Focus on the close button, which is\n // just before all the nav elements in the tab order.\n closeButton.focus();\n } else if (\n !safeActive &&\n menuButton &&\n getComputedStyle(menuButton).display !== \"none\"\n ) {\n // The mobile nav was just deactivated. We don't want the focus to\n // disappear into the void, so focus on the menu button if it's\n // visible (this may have been what the user was just focused on,\n // if they triggered the mobile nav by mistake).\n menuButton.focus();\n }\n\n return safeActive;\n};\n\nconst resize = () => {\n const closer = document.body.querySelector(CLOSE_BUTTON);\n\n if (isActive() && closer && closer.getBoundingClientRect().width === 0) {\n // When the mobile nav is active, and the close box isn't visible,\n // we know the user's viewport has been resized to be larger.\n // Let's make the page state consistent by deactivating the mobile nav.\n navigation.toggleNav.call(closer, false);\n }\n};\n\nconst onMenuClose = () => navigation.toggleNav.call(navigation, false);\n\nconst hideActiveNavDropdown = () => {\n if (!navActive) {\n return;\n }\n\n toggle(navActive, false);\n navActive = null;\n};\n\nconst focusNavButton = (event) => {\n const parentNavItem = event.target.closest(NAV_PRIMARY_ITEM);\n\n // Only shift focus if within dropdown\n if (!event.target.matches(NAV_CONTROL)) {\n const navControl = parentNavItem.querySelector(NAV_CONTROL);\n if (navControl) {\n navControl.focus();\n }\n }\n};\n\nconst handleEscape = (event) => {\n hideActiveNavDropdown();\n focusNavButton(event);\n};\n\nnavigation = behavior(\n {\n [CLICK]: {\n [NAV_CONTROL]() {\n // If another nav is open, close it\n if (navActive !== this) {\n hideActiveNavDropdown();\n }\n // store a reference to the last clicked nav link element, so we\n // can hide the dropdown if another element on the page is clicked\n if (!navActive) {\n navActive = this;\n toggle(navActive, true);\n }\n\n // Do this so the event handler on the body doesn't fire\n return false;\n },\n [BODY]: hideActiveNavDropdown,\n [OPENERS]: toggleNav,\n [CLOSERS]: toggleNav,\n [NAV_LINKS]() {\n // A navigation link has been clicked! We want to collapse any\n // hierarchical navigation UI it's a part of, so that the user\n // can focus on whatever they've just selected.\n\n // Some navigation links are inside accordions; when they're\n // clicked, we want to collapse those accordions.\n const acc = this.closest(accordion.ACCORDION);\n\n if (acc) {\n accordion.getButtons(acc).forEach((btn) => accordion.hide(btn));\n }\n\n // If the mobile navigation menu is active, we want to hide it.\n if (isActive()) {\n navigation.toggleNav.call(navigation, false);\n }\n },\n },\n keydown: {\n [NAV_PRIMARY]: keymap({ Escape: handleEscape }),\n },\n focusout: {\n [NAV_PRIMARY](event) {\n const nav = event.target.closest(NAV_PRIMARY);\n\n if (!nav.contains(event.relatedTarget)) {\n hideActiveNavDropdown();\n }\n },\n },\n },\n {\n init(root) {\n const trapContainer = root.matches(NAV) ? root : root.querySelector(NAV);\n\n if (trapContainer) {\n navigation.focusTrap = FocusTrap(trapContainer, {\n Escape: onMenuClose,\n });\n }\n\n addSafariClass();\n resize();\n window.addEventListener(\"resize\", resize, false);\n },\n teardown() {\n window.removeEventListener(\"resize\", resize, false);\n navActive = false;\n },\n focusTrap: null,\n toggleNav,\n },\n);\n\nmodule.exports = navigation;\n","const once = require(\"receptor/once\");\nconst keymap = require(\"receptor/keymap\");\nconst selectOrMatches = require(\"../../uswds-core/src/js/utils/select-or-matches\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\nconst { CLICK } = require(\"../../uswds-core/src/js/events\");\nconst Sanitizer = require(\"../../uswds-core/src/js/utils/sanitizer\");\n\nconst CURRENT_CLASS = `${PREFIX}-current`;\nconst IN_PAGE_NAV_HEADINGS = \"h2 h3\";\nconst IN_PAGE_NAV_VALID_HEADINGS = [\"h1\", \"h2\", \"h3\", \"h4\", \"h5\", \"h6\"];\nconst IN_PAGE_NAV_TITLE_TEXT = \"On this page\";\nconst IN_PAGE_NAV_TITLE_HEADING_LEVEL = \"h4\";\nconst IN_PAGE_NAV_SCROLL_OFFSET = 0;\nconst IN_PAGE_NAV_ROOT_MARGIN = \"0px 0px 0px 0px\";\nconst IN_PAGE_NAV_THRESHOLD = \"1\";\nconst IN_PAGE_NAV_CLASS = `${PREFIX}-in-page-nav`;\nconst IN_PAGE_NAV_ANCHOR_CLASS = `${PREFIX}-anchor`;\nconst IN_PAGE_NAV_NAV_CLASS = `${IN_PAGE_NAV_CLASS}__nav`;\nconst IN_PAGE_NAV_LIST_CLASS = `${IN_PAGE_NAV_CLASS}__list`;\nconst IN_PAGE_NAV_ITEM_CLASS = `${IN_PAGE_NAV_CLASS}__item`;\nconst IN_PAGE_NAV_PRIMARY_ITEM_CLASS = `${IN_PAGE_NAV_ITEM_CLASS}--primary`;\nconst IN_PAGE_NAV_LINK_CLASS = `${IN_PAGE_NAV_CLASS}__link`;\nconst IN_PAGE_NAV_TITLE_CLASS = `${IN_PAGE_NAV_CLASS}__heading`;\nconst MAIN_ELEMENT = \"main\";\n\n/**\n * Set the active link state for the currently observed section\n *\n * @param {HTMLElement} el An element within the in-page nav component\n */\nconst setActive = (el) => {\n const allLinks = document.querySelectorAll(`.${IN_PAGE_NAV_LINK_CLASS}`);\n el.map((i) => {\n if (i.isIntersecting === true && i.intersectionRatio >= 1) {\n allLinks.forEach((link) => link.classList.remove(CURRENT_CLASS));\n document\n .querySelector(`a[href=\"#${i.target.id}\"]`)\n .classList.add(CURRENT_CLASS);\n return true;\n }\n return false;\n });\n};\n\n/**\n * Return an array of the designated heading types found in the designated content region.\n * Throw an error if an invalid header element is designated.\n *\n * @param {HTMLElement} selectedContentRegion The content region the component should pull headers from\n * @param {String} selectedHeadingTypes The list of heading types that should be included in the nav list\n *\n * @return {Array} - An array of designated heading types from the designated content region\n */\nconst createSectionHeadingsArray = (\n selectedContentRegion,\n selectedHeadingTypes,\n) => {\n // Convert designated headings list to an array\n const selectedHeadingTypesArray = selectedHeadingTypes.indexOf(\" \")\n ? selectedHeadingTypes.split(\" \")\n : selectedHeadingTypes;\n const contentRegion = document.querySelector(selectedContentRegion);\n\n selectedHeadingTypesArray.forEach((headingType) => {\n if (!IN_PAGE_NAV_VALID_HEADINGS.includes(headingType)) {\n throw new Error(\n `In-page navigation: data-heading-elements attribute defined with an invalid heading type: \"${headingType}\".\n Define the attribute with one or more of the following: \"${IN_PAGE_NAV_VALID_HEADINGS}\".\n Do not use commas or other punctuation in the attribute definition.`,\n );\n }\n });\n\n const sectionHeadingsArray = Array.from(\n contentRegion.querySelectorAll(selectedHeadingTypesArray),\n );\n\n return sectionHeadingsArray;\n};\n\n/**\n * Return an array of the visible headings from sectionHeadingsArray.\n * This function removes headings that are hidden with display:none or visibility:none style rules.\n * These items will be added to the component nav list.\n *\n * @param {HTMLElement} selectedContentRegion The content region the component should pull headers from\n * @param {String} selectedHeadingTypes The list of heading types that should be included in the nav list\n *\n * @return {Array} - An array of visible headings from the designated content region\n */\nconst getVisibleSectionHeadings = (\n selectedContentRegion,\n selectedHeadingTypes,\n) => {\n const sectionHeadings = createSectionHeadingsArray(\n selectedContentRegion,\n selectedHeadingTypes,\n );\n\n // Find all headings with hidden styling and remove them from the array\n const visibleSectionHeadings = sectionHeadings.filter((heading) => {\n const headingStyle = window.getComputedStyle(heading);\n const visibleHeading =\n headingStyle.getPropertyValue(\"display\") !== \"none\" &&\n headingStyle.getPropertyValue(\"visibility\") !== \"hidden\";\n\n return visibleHeading;\n });\n\n return visibleSectionHeadings;\n};\n\n/**\n * Return the highest-level header tag included in the link list\n *\n * @param {HTMLElement} sectionHeadings The array of headings selected for inclusion in the link list\n *\n * @return {tagName} - The tag name for the highest level of header in the link list\n */\n\nconst getTopLevelHeading = (sectionHeadings) => {\n const topHeading = sectionHeadings[0].tagName.toLowerCase();\n return topHeading;\n};\n\n/**\n * Return a node list of section anchor tags\n *\n * @return {HTMLElement[]} - An array of DOM nodes\n */\nconst getSectionAnchors = () => {\n const sectionAnchors = document.querySelectorAll(\n `.${IN_PAGE_NAV_ANCHOR_CLASS}`,\n );\n return sectionAnchors;\n};\n\n/**\n * Generates a unique ID for the given heading element.\n *\n * @param {HTMLHeadingElement} heading\n *\n * @return {string} - Unique ID\n */\nconst getHeadingId = (heading) => {\n const baseId = heading.textContent\n .toLowerCase()\n // Replace non-alphanumeric characters with dashes\n .replace(/[^a-z\\d]/g, \"-\")\n // Replace a sequence of two or more dashes with a single dash\n .replace(/-{2,}/g, \"-\")\n // Trim leading or trailing dash (there should only ever be one)\n .replace(/^-|-$/g, \"\");\n\n let id;\n let suffix = 0;\n do {\n id = baseId;\n\n // To avoid conflicts with existing IDs on the page, loop and append an\n // incremented suffix until a unique ID is found.\n suffix += 1;\n if (suffix > 1) {\n id += `-${suffix}`;\n }\n } while (document.getElementById(id));\n\n return id;\n};\n\n/**\n * Return a section id/anchor hash without the number sign\n *\n * @return {String} - Id value with the number sign removed\n */\nconst getSectionId = (value) => {\n let id;\n\n // Check if value is an event or element and get the cleaned up id\n if (value && value.nodeType === 1) {\n id = value.getAttribute(\"href\").replace(\"#\", \"\");\n } else {\n id = value.target.hash.replace(\"#\", \"\");\n }\n\n return id;\n};\n\n/**\n * Scroll smoothly to a section based on the passed in element\n *\n * @param {HTMLElement} - Id value with the number sign removed\n */\nconst handleScrollToSection = (el) => {\n const inPageNavEl = document.querySelector(`.${IN_PAGE_NAV_CLASS}`);\n const inPageNavScrollOffset =\n inPageNavEl.dataset.scrollOffset || IN_PAGE_NAV_SCROLL_OFFSET;\n\n window.scroll({\n behavior: \"smooth\",\n top: el.offsetTop - inPageNavScrollOffset,\n block: \"start\",\n });\n\n if (window.location.hash.slice(1) !== el.id) {\n window.history.pushState(null, \"\", `#${el.id}`);\n }\n};\n\n/**\n * Scrolls the page to the section corresponding to the current hash fragment, if one exists.\n */\nconst scrollToCurrentSection = () => {\n const hashFragment = window.location.hash.slice(1);\n if (hashFragment) {\n const anchorTag = document.getElementById(hashFragment);\n if (anchorTag) {\n handleScrollToSection(anchorTag);\n }\n }\n};\n\n/**\n * Create the in-page navigation component\n *\n * @param {HTMLElement} inPageNavEl The in-page nav element\n */\nconst createInPageNav = (inPageNavEl) => {\n const inPageNavTitleText = Sanitizer.escapeHTML`${\n inPageNavEl.dataset.titleText || IN_PAGE_NAV_TITLE_TEXT\n }`;\n const inPageNavTitleHeadingLevel = Sanitizer.escapeHTML`${\n inPageNavEl.dataset.titleHeadingLevel || IN_PAGE_NAV_TITLE_HEADING_LEVEL\n }`;\n const inPageNavRootMargin = Sanitizer.escapeHTML`${\n inPageNavEl.dataset.rootMargin || IN_PAGE_NAV_ROOT_MARGIN\n }`;\n const inPageNavThreshold = Sanitizer.escapeHTML`${\n inPageNavEl.dataset.threshold || IN_PAGE_NAV_THRESHOLD\n }`;\n const inPageNavContentSelector = Sanitizer.escapeHTML`${\n inPageNavEl.dataset.mainContentSelector || MAIN_ELEMENT\n }`;\n const inPageNavHeadingSelector = Sanitizer.escapeHTML`${\n inPageNavEl.dataset.headingElements || IN_PAGE_NAV_HEADINGS\n }`;\n\n const options = {\n root: null,\n rootMargin: inPageNavRootMargin,\n threshold: [inPageNavThreshold],\n };\n\n const sectionHeadings = getVisibleSectionHeadings(\n inPageNavContentSelector,\n inPageNavHeadingSelector,\n );\n const inPageNav = document.createElement(\"nav\");\n inPageNav.setAttribute(\"aria-label\", inPageNavTitleText);\n inPageNav.classList.add(IN_PAGE_NAV_NAV_CLASS);\n\n const inPageNavTitle = document.createElement(inPageNavTitleHeadingLevel);\n inPageNavTitle.classList.add(IN_PAGE_NAV_TITLE_CLASS);\n inPageNavTitle.setAttribute(\"tabindex\", \"0\");\n inPageNavTitle.textContent = inPageNavTitleText;\n inPageNav.appendChild(inPageNavTitle);\n\n const inPageNavList = document.createElement(\"ul\");\n inPageNavList.classList.add(IN_PAGE_NAV_LIST_CLASS);\n inPageNav.appendChild(inPageNavList);\n\n sectionHeadings.forEach((el) => {\n const listItem = document.createElement(\"li\");\n const navLinks = document.createElement(\"a\");\n const anchorTag = document.createElement(\"a\");\n const textContentOfLink = el.textContent;\n const tag = el.tagName.toLowerCase();\n const topHeadingLevel = getTopLevelHeading(sectionHeadings);\n const headingId = getHeadingId(el);\n\n listItem.classList.add(IN_PAGE_NAV_ITEM_CLASS);\n\n if (tag === topHeadingLevel) {\n listItem.classList.add(IN_PAGE_NAV_PRIMARY_ITEM_CLASS);\n }\n\n navLinks.setAttribute(\"href\", `#${headingId}`);\n navLinks.setAttribute(\"class\", IN_PAGE_NAV_LINK_CLASS);\n navLinks.textContent = textContentOfLink;\n\n anchorTag.setAttribute(\"id\", headingId);\n anchorTag.setAttribute(\"class\", IN_PAGE_NAV_ANCHOR_CLASS);\n el.insertAdjacentElement(\"afterbegin\", anchorTag);\n\n inPageNavList.appendChild(listItem);\n listItem.appendChild(navLinks);\n });\n\n inPageNavEl.appendChild(inPageNav);\n\n const anchorTags = getSectionAnchors();\n const observeSections = new window.IntersectionObserver(setActive, options);\n\n anchorTags.forEach((tag) => {\n observeSections.observe(tag);\n });\n};\n\n/**\n * Handle click from link\n *\n * @param {HTMLElement} el An element within the in-page nav component\n */\nconst handleClickFromLink = (el) => {\n const elementToScrollTo = document.getElementById(el.hash.slice(1));\n handleScrollToSection(elementToScrollTo);\n};\n\n/**\n * Handle the enter event from a link within the in-page nav component\n *\n * @param {KeyboardEvent} event An event within the in-page nav component\n */\nconst handleEnterFromLink = (event) => {\n const id = getSectionId(event);\n const targetAnchor = document.getElementById(id);\n const target = targetAnchor.parentElement;\n\n if (target) {\n target.setAttribute(\"tabindex\", 0);\n target.focus();\n target.addEventListener(\n \"blur\",\n once(() => {\n target.setAttribute(\"tabindex\", -1);\n }),\n );\n } else {\n // throw an error?\n }\n handleScrollToSection(targetAnchor);\n};\n\nconst inPageNavigation = behavior(\n {\n [CLICK]: {\n [`.${IN_PAGE_NAV_LINK_CLASS}`](event) {\n event.preventDefault();\n if (this.disabled) return;\n handleClickFromLink(this);\n },\n },\n keydown: {\n [`.${IN_PAGE_NAV_LINK_CLASS}`]: keymap({\n Enter: handleEnterFromLink,\n }),\n },\n },\n {\n init(root) {\n selectOrMatches(`.${IN_PAGE_NAV_CLASS}`, root).forEach((inPageNavEl) => {\n createInPageNav(inPageNavEl);\n scrollToCurrentSection();\n });\n },\n },\n);\n\nmodule.exports = inPageNavigation;\n","const selectOrMatches = require(\"../../uswds-core/src/js/utils/select-or-matches\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\n\nconst MASKED_CLASS = `${PREFIX}-masked`;\nconst MASKED = `.${MASKED_CLASS}`;\nconst MASK = `${PREFIX}-input-mask`;\nconst MASK_CONTENT = `${MASK}--content`;\nconst PLACEHOLDER = \"placeholder\";\n\n// User defined Values\nconst maskedNumber = \"_#dDmMyY9\";\nconst maskedLetter = \"A\";\n\n// replaces each masked input with a shell containing the input and it's mask.\nconst createMaskedInputShell = (input) => {\n const placeholder = input.getAttribute(`${PLACEHOLDER}`);\n if (placeholder) {\n input.setAttribute(\"maxlength\", placeholder.length);\n input.setAttribute(\"data-placeholder\", placeholder);\n input.removeAttribute(`${PLACEHOLDER}`);\n } else {\n return;\n }\n\n const shell = document.createElement(\"span\");\n shell.classList.add(MASK);\n shell.setAttribute(\"data-mask\", placeholder);\n\n const content = document.createElement(\"span\");\n content.classList.add(MASK_CONTENT);\n content.setAttribute(\"aria-hidden\", \"true\");\n content.id = `${input.id}Mask`;\n content.textContent = placeholder;\n\n shell.appendChild(content);\n input.parentNode.insertBefore(shell, input);\n shell.appendChild(input);\n};\n\nconst setValueOfMask = (el) => {\n const { value } = el;\n const placeholderVal = `${el.dataset.placeholder.substr(value.length)}`;\n\n const theIEl = document.createElement(\"i\");\n theIEl.textContent = value;\n return [theIEl, placeholderVal];\n};\n\nconst strippedValue = (isCharsetPresent, value) =>\n isCharsetPresent ? value.replace(/\\W/g, \"\") : value.replace(/\\D/g, \"\");\n\nconst isInteger = (value) => !Number.isNaN(parseInt(value, 10));\n\nconst isLetter = (value) => (value ? value.match(/[A-Z]/i) : false);\n\nconst handleCurrentValue = (el) => {\n const isCharsetPresent = el.dataset.charset;\n const placeholder = isCharsetPresent || el.dataset.placeholder;\n const { value } = el;\n const len = placeholder.length;\n let newValue = \"\";\n let i;\n let charIndex;\n\n const strippedVal = strippedValue(isCharsetPresent, value);\n\n for (i = 0, charIndex = 0; i < len; i += 1) {\n const isInt = isInteger(strippedVal[charIndex]);\n const isLet = isLetter(strippedVal[charIndex]);\n const matchesNumber = maskedNumber.indexOf(placeholder[i]) >= 0;\n const matchesLetter = maskedLetter.indexOf(placeholder[i]) >= 0;\n\n if (\n (matchesNumber && isInt) ||\n (isCharsetPresent && matchesLetter && isLet)\n ) {\n newValue += strippedVal[charIndex];\n charIndex += 1;\n } else if (\n (!isCharsetPresent && !isInt && matchesNumber) ||\n (isCharsetPresent &&\n ((matchesLetter && !isLet) || (matchesNumber && !isInt)))\n ) {\n return newValue;\n } else {\n newValue += placeholder[i];\n }\n // break if no characters left and the pattern is non-special character\n if (strippedVal[charIndex] === undefined) {\n break;\n }\n }\n\n return newValue;\n};\n\nconst handleValueChange = (el) => {\n const inputEl = el;\n const id = inputEl.getAttribute(\"id\");\n inputEl.value = handleCurrentValue(inputEl);\n\n const maskVal = setValueOfMask(el);\n const maskEl = document.getElementById(`${id}Mask`);\n maskEl.textContent = \"\";\n maskEl.replaceChildren(maskVal[0], maskVal[1]);\n};\n\nconst inputMaskEvents = {\n keyup: {\n [MASKED]() {\n handleValueChange(this);\n },\n },\n};\n\nconst inputMask = behavior(inputMaskEvents, {\n init(root) {\n selectOrMatches(MASKED, root).forEach((maskedInput) => {\n createMaskedInputShell(maskedInput);\n });\n },\n});\n\nmodule.exports = inputMask;\n","const keymap = require(\"receptor/keymap\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst toggle = require(\"../../uswds-core/src/js/utils/toggle\");\nconst FocusTrap = require(\"../../uswds-core/src/js/utils/focus-trap\");\nconst accordion = require(\"../../usa-accordion/src/index\");\n\nconst { CLICK } = require(\"../../uswds-core/src/js/events\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\n\nconst BODY = \"body\";\nconst LANGUAGE = `.${PREFIX}-language`;\nconst LANGUAGE_SUB = `.${PREFIX}-language__submenu`;\nconst LANGUAGE_PRIMARY = `.${PREFIX}-language__primary`;\nconst LANGUAGE_PRIMARY_ITEM = `.${PREFIX}-language__primary-item`;\nconst LANGUAGE_CONTROL = `button.${PREFIX}-language__link`;\nconst LANGUAGE_LINKS = `${LANGUAGE} a`;\n\nlet languageSelector;\nlet languageActive;\n\nconst onLanguageClose = () =>\n languageSelector.toggleLanguage.call(languageSelector, false);\n\nconst hideActiveLanguageDropdown = () => {\n if (!languageActive) {\n return;\n }\n\n toggle(languageActive, false);\n languageActive = null;\n};\n\nconst focusLanguageButton = (event) => {\n const parentLanguageItem = event.target.closest(LANGUAGE_PRIMARY_ITEM);\n\n if (!event.target.matches(LANGUAGE_CONTROL)) {\n parentLanguageItem.querySelector(LANGUAGE_CONTROL).focus();\n }\n};\n\nconst handleEscape = (event) => {\n hideActiveLanguageDropdown();\n focusLanguageButton(event);\n};\n\nlanguageSelector = behavior(\n {\n [CLICK]: {\n [LANGUAGE_CONTROL]() {\n if (languageActive !== this) {\n hideActiveLanguageDropdown();\n }\n if (languageActive === this) {\n hideActiveLanguageDropdown();\n return false;\n }\n if (!languageActive) {\n languageActive = this;\n toggle(languageActive, true);\n }\n\n return false;\n },\n [BODY]: hideActiveLanguageDropdown,\n [LANGUAGE_LINKS]() {\n const acc = this.closest(accordion.ACCORDION);\n\n if (acc) {\n accordion.getButtons(acc).forEach((btn) => accordion.hide(btn));\n }\n },\n },\n keydown: {\n [LANGUAGE_PRIMARY]: keymap({ Escape: handleEscape }),\n },\n focusout: {\n [LANGUAGE_PRIMARY](event) {\n const language = event.target.closest(LANGUAGE_PRIMARY);\n\n if (!language.contains(event.relatedTarget)) {\n hideActiveLanguageDropdown();\n }\n },\n },\n },\n {\n init(root) {\n const trapContainer = root.matches(LANGUAGE_SUB)\n ? root\n : root.querySelector(LANGUAGE_SUB);\n\n if (trapContainer) {\n languageSelector.focusTrap = FocusTrap(trapContainer, {\n Escape: onLanguageClose,\n });\n }\n },\n teardown() {\n languageActive = false;\n },\n focusTrap: null,\n },\n);\n\nmodule.exports = languageSelector;\n","const selectOrMatches = require(\"../../uswds-core/src/js/utils/select-or-matches\");\nconst FocusTrap = require(\"../../uswds-core/src/js/utils/focus-trap\");\nconst ScrollBarWidth = require(\"../../uswds-core/src/js/utils/scrollbar-width\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\n\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\n\nconst MODAL_CLASSNAME = `${PREFIX}-modal`;\nconst OVERLAY_CLASSNAME = `${MODAL_CLASSNAME}-overlay`;\nconst WRAPPER_CLASSNAME = `${MODAL_CLASSNAME}-wrapper`;\nconst OPENER_ATTRIBUTE = \"data-open-modal\";\nconst CLOSER_ATTRIBUTE = \"data-close-modal\";\nconst FORCE_ACTION_ATTRIBUTE = \"data-force-action\";\nconst NON_MODAL_HIDDEN_ATTRIBUTE = `data-modal-hidden`;\nconst MODAL = `.${MODAL_CLASSNAME}`;\nconst INITIAL_FOCUS = `.${WRAPPER_CLASSNAME} *[data-focus]`;\nconst CLOSE_BUTTON = `${WRAPPER_CLASSNAME} *[${CLOSER_ATTRIBUTE}]`;\nconst OPENERS = `*[${OPENER_ATTRIBUTE}][aria-controls]`;\nconst CLOSERS = `${CLOSE_BUTTON}, .${OVERLAY_CLASSNAME}:not([${FORCE_ACTION_ATTRIBUTE}])`;\nconst NON_MODALS = `body > *:not(.${WRAPPER_CLASSNAME}):not([aria-hidden])`;\nconst NON_MODALS_HIDDEN = `[${NON_MODAL_HIDDEN_ATTRIBUTE}]`;\n\nconst ACTIVE_CLASS = \"usa-js-modal--active\";\nconst PREVENT_CLICK_CLASS = \"usa-js-no-click\";\nconst VISIBLE_CLASS = \"is-visible\";\nconst HIDDEN_CLASS = \"is-hidden\";\n\nlet modal;\nlet INITIAL_BODY_PADDING;\nlet TEMPORARY_BODY_PADDING;\n\nconst isActive = () => document.body.classList.contains(ACTIVE_CLASS);\nconst SCROLLBAR_WIDTH = ScrollBarWidth();\n\n/**\n * Closes modal when bound to a button and pressed.\n */\nconst onMenuClose = () => {\n modal.toggleModal.call(modal, false);\n};\n\n/**\n * Set the value for temporary body padding that will be applied when the modal is open.\n * Value is created by checking for initial body padding and adding the width of the scrollbar.\n */\nconst setTemporaryBodyPadding = () => {\n INITIAL_BODY_PADDING = window\n .getComputedStyle(document.body)\n .getPropertyValue(\"padding-right\");\n TEMPORARY_BODY_PADDING = `${\n parseInt(INITIAL_BODY_PADDING.replace(/px/, \"\"), 10) +\n parseInt(SCROLLBAR_WIDTH.replace(/px/, \"\"), 10)\n }px`;\n};\n\n/**\n * Toggle the visibility of a modal window\n *\n * @param {KeyboardEvent} event the keydown event.\n * @returns {boolean} safeActive if mobile is open.\n */\nfunction toggleModal(event) {\n let originalOpener;\n let clickedElement = event.target;\n const { body } = document;\n const safeActive = !isActive();\n const modalId = clickedElement\n ? clickedElement.getAttribute(\"aria-controls\")\n : document.querySelector(`.${WRAPPER_CLASSNAME}.${VISIBLE_CLASS}`);\n const targetModal = safeActive\n ? document.getElementById(modalId)\n : document.querySelector(`.${WRAPPER_CLASSNAME}.${VISIBLE_CLASS}`);\n\n // if there is no modal we return early\n if (!targetModal) {\n return false;\n }\n\n const openFocusEl = targetModal.querySelector(INITIAL_FOCUS)\n ? targetModal.querySelector(INITIAL_FOCUS)\n : targetModal.querySelector(`.${MODAL_CLASSNAME}`);\n const returnFocus = document.getElementById(\n targetModal.getAttribute(\"data-opener\"),\n );\n const menuButton = body.querySelector(OPENERS);\n const forceUserAction = targetModal.getAttribute(FORCE_ACTION_ATTRIBUTE);\n\n // Sets the clicked element to the close button\n // so esc key always closes modal\n if (event.type === \"keydown\" && targetModal !== null) {\n clickedElement = targetModal.querySelector(CLOSE_BUTTON);\n }\n\n // When we're not hitting the escape key…\n if (clickedElement) {\n // Make sure we click the opener\n // If it doesn't have an ID, make one\n // Store id as data attribute on modal\n if (clickedElement.hasAttribute(OPENER_ATTRIBUTE)) {\n if (this.getAttribute(\"id\") === null) {\n originalOpener = `modal-${Math.floor(Math.random() * 900000) + 100000}`;\n this.setAttribute(\"id\", originalOpener);\n } else {\n originalOpener = this.getAttribute(\"id\");\n }\n targetModal.setAttribute(\"data-opener\", originalOpener);\n }\n\n // This basically stops the propagation if the element\n // is inside the modal and not a close button or\n // element inside a close button\n if (clickedElement.closest(`.${MODAL_CLASSNAME}`)) {\n if (\n clickedElement.hasAttribute(CLOSER_ATTRIBUTE) ||\n clickedElement.closest(`[${CLOSER_ATTRIBUTE}]`)\n ) {\n // do nothing. move on.\n } else {\n return false;\n }\n }\n }\n\n body.classList.toggle(ACTIVE_CLASS, safeActive);\n targetModal.classList.toggle(VISIBLE_CLASS, safeActive);\n targetModal.classList.toggle(HIDDEN_CLASS, !safeActive);\n\n // If user is forced to take an action, adding\n // a class to the body that prevents clicking underneath\n // overlay\n if (forceUserAction) {\n body.classList.toggle(PREVENT_CLICK_CLASS, safeActive);\n }\n\n // Temporarily increase body padding to include the width of the scrollbar.\n // This accounts for the content shift when the scrollbar is removed on modal open.\n if (body.style.paddingRight === TEMPORARY_BODY_PADDING) {\n body.style.removeProperty(\"padding-right\");\n } else {\n body.style.paddingRight = TEMPORARY_BODY_PADDING;\n }\n\n // Handle the focus actions\n if (safeActive && openFocusEl) {\n // The modal window is opened. Focus is set to close button.\n\n // Binds escape key if we're not forcing\n // the user to take an action\n if (forceUserAction) {\n modal.focusTrap = FocusTrap(targetModal);\n } else {\n modal.focusTrap = FocusTrap(targetModal, {\n Escape: onMenuClose,\n });\n }\n\n // Handles focus setting and interactions\n modal.focusTrap.update(safeActive);\n openFocusEl.focus();\n\n // Hides everything that is not the modal from screen readers\n document.querySelectorAll(NON_MODALS).forEach((nonModal) => {\n nonModal.setAttribute(\"aria-hidden\", \"true\");\n nonModal.setAttribute(NON_MODAL_HIDDEN_ATTRIBUTE, \"\");\n });\n } else if (!safeActive && menuButton && returnFocus) {\n // The modal window is closed.\n // Non-modals now accesible to screen reader\n document.querySelectorAll(NON_MODALS_HIDDEN).forEach((nonModal) => {\n nonModal.removeAttribute(\"aria-hidden\");\n nonModal.removeAttribute(NON_MODAL_HIDDEN_ATTRIBUTE);\n });\n\n // Focus is returned to the opener\n returnFocus.focus();\n modal.focusTrap.update(safeActive);\n }\n\n return safeActive;\n}\n\n/**\n * Creates a placeholder with data attributes for cleanup function.\n * The cleanup function uses this placeholder to easily restore the original Modal HTML on teardown.\n *\n * @param {HTMLDivElement} baseComponent - Modal HTML from the DOM.\n * @returns {HTMLDivElement} Placeholder used for cleanup function.\n */\nconst createPlaceHolder = (baseComponent) => {\n const modalID = baseComponent.getAttribute(\"id\");\n const originalLocationPlaceHolder = document.createElement(\"div\");\n const modalAttributes = Array.from(baseComponent.attributes);\n\n setTemporaryBodyPadding();\n\n originalLocationPlaceHolder.setAttribute(`data-placeholder-for`, modalID);\n originalLocationPlaceHolder.style.display = \"none\";\n originalLocationPlaceHolder.setAttribute(\"aria-hidden\", \"true\");\n\n modalAttributes.forEach((attribute) => {\n originalLocationPlaceHolder.setAttribute(\n `data-original-${attribute.name}`,\n attribute.value,\n );\n });\n\n return originalLocationPlaceHolder;\n};\n\n/**\n * Moves necessary attributes from Modal HTML to wrapper element.\n *\n * @param {HTMLDivElement} baseComponent - Modal HTML in the DOM.\n * @param {HTMLDivElement} modalContentWrapper - Modal component wrapper element.\n * @returns Modal wrapper with correct attributes.\n */\nconst setModalAttributes = (baseComponent, modalContentWrapper) => {\n const modalID = baseComponent.getAttribute(\"id\");\n const ariaLabelledBy = baseComponent.getAttribute(\"aria-labelledby\");\n const ariaDescribedBy = baseComponent.getAttribute(\"aria-describedby\");\n const forceUserAction = baseComponent.hasAttribute(FORCE_ACTION_ATTRIBUTE);\n\n if (!ariaLabelledBy)\n throw new Error(`${modalID} is missing aria-labelledby attribute`);\n\n if (!ariaDescribedBy)\n throw new Error(`${modalID} is missing aria-desribedby attribute`);\n\n // Set attributes\n modalContentWrapper.setAttribute(\"role\", \"dialog\");\n modalContentWrapper.setAttribute(\"id\", modalID);\n modalContentWrapper.setAttribute(\"aria-labelledby\", ariaLabelledBy);\n modalContentWrapper.setAttribute(\"aria-describedby\", ariaDescribedBy);\n\n if (forceUserAction) {\n modalContentWrapper.setAttribute(FORCE_ACTION_ATTRIBUTE, forceUserAction);\n }\n\n // Add aria-controls\n const modalClosers = modalContentWrapper.querySelectorAll(CLOSERS);\n modalClosers.forEach((el) => {\n el.setAttribute(\"aria-controls\", modalID);\n });\n\n // Update the base element HTML\n baseComponent.removeAttribute(\"id\");\n baseComponent.removeAttribute(\"aria-labelledby\");\n baseComponent.removeAttribute(\"aria-describedby\");\n baseComponent.setAttribute(\"tabindex\", \"-1\");\n\n return modalContentWrapper;\n};\n\n/**\n * Creates a hidden modal content wrapper.\n * Rebuilds the original Modal HTML in the new wrapper and adds a page overlay.\n * Then moves original Modal HTML attributes to the new wrapper.\n *\n * @param {HTMLDivElement} baseComponent - Original Modal HTML in the DOM.\n * @returns Modal component - Modal wrapper w/ nested Overlay and Modal Content.\n */\nconst rebuildModal = (baseComponent) => {\n const modalContent = baseComponent;\n const modalContentWrapper = document.createElement(\"div\");\n const overlayDiv = document.createElement(\"div\");\n\n // Add classes\n modalContentWrapper.classList.add(HIDDEN_CLASS, WRAPPER_CLASSNAME);\n overlayDiv.classList.add(OVERLAY_CLASSNAME);\n\n // Rebuild the modal element\n modalContentWrapper.append(overlayDiv);\n overlayDiv.append(modalContent);\n\n // Add attributes\n setModalAttributes(modalContent, modalContentWrapper);\n\n return modalContentWrapper;\n};\n\n/**\n * Builds modal window from base HTML and appends to the end of the DOM.\n *\n * @param {HTMLDivElement} baseComponent - The modal div element in the DOM.\n */\nconst setUpModal = (baseComponent) => {\n const modalID = baseComponent.getAttribute(\"id\");\n\n if (!modalID) {\n throw new Error(`Modal markup is missing ID`);\n }\n\n // Create placeholder where modal is for cleanup\n const originalLocationPlaceHolder = createPlaceHolder(baseComponent);\n baseComponent.after(originalLocationPlaceHolder);\n\n // Build modal component\n const modalComponent = rebuildModal(baseComponent);\n\n // Move all modals to the end of the DOM. Doing this allows us to\n // more easily find the elements to hide from screen readers\n // when the modal is open.\n document.body.appendChild(modalComponent);\n};\n\n/**\n * Removes dynamically created Modal and Wrapper elements and restores original Modal HTML.\n *\n * @param {HTMLDivElement} baseComponent - The modal div element in the DOM.\n */\nconst cleanUpModal = (baseComponent) => {\n const modalContent = baseComponent;\n const modalContentWrapper = modalContent.parentElement.parentElement;\n const modalID = modalContentWrapper.getAttribute(\"id\");\n\n // if there is no modalID, return early\n if (!modalID) {\n return;\n }\n\n const originalLocationPlaceHolder = document.querySelector(\n `[data-placeholder-for=\"${modalID}\"]`,\n );\n\n if (originalLocationPlaceHolder) {\n const modalAttributes = Array.from(originalLocationPlaceHolder.attributes);\n modalAttributes.forEach((attribute) => {\n if (attribute.name.startsWith(\"data-original-\")) {\n // data-original- is 14 long\n modalContent.setAttribute(attribute.name.substr(14), attribute.value);\n }\n });\n\n originalLocationPlaceHolder.after(modalContent);\n originalLocationPlaceHolder.parentElement.removeChild(\n originalLocationPlaceHolder,\n );\n }\n\n modalContentWrapper.parentElement.removeChild(modalContentWrapper);\n};\n\nmodal = behavior(\n {},\n {\n init(root) {\n selectOrMatches(MODAL, root).forEach((modalWindow) => {\n const modalId = modalWindow.id;\n\n setUpModal(modalWindow);\n\n // Query all openers and closers including the overlay\n selectOrMatches(`[aria-controls=\"${modalId}\"]`, document).forEach(\n (modalTrigger) => {\n // If modalTrigger is an anchor...\n if (modalTrigger.nodeName === \"A\") {\n // Turn anchor links into buttons for screen readers\n modalTrigger.setAttribute(\"role\", \"button\");\n\n // Prevent modal triggers from acting like links\n modalTrigger.addEventListener(\"click\", (e) => e.preventDefault());\n }\n\n // Can uncomment when aria-haspopup=\"dialog\" is supported\n // https://a11ysupport.io/tech/aria/aria-haspopup_attribute\n // Most screen readers support aria-haspopup, but might announce\n // as opening a menu if \"dialog\" is not supported.\n // modalTrigger.setAttribute(\"aria-haspopup\", \"dialog\");\n\n modalTrigger.addEventListener(\"click\", toggleModal);\n },\n );\n });\n },\n teardown(root) {\n selectOrMatches(MODAL, root).forEach((modalWindow) => {\n const modalId = modalWindow.id;\n cleanUpModal(modalWindow);\n\n selectOrMatches(`[aria-controls=\"${modalId}\"]`, document).forEach(\n (modalTrigger) =>\n modalTrigger.removeEventListener(\"click\", toggleModal),\n );\n });\n },\n focusTrap: null,\n toggleModal,\n },\n);\n\nmodule.exports = modal;\n","const selectOrMatches = require(\"../../uswds-core/src/js/utils/select-or-matches\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\n\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\n\nconst RANGE_CLASSNAME = `${PREFIX}-range`;\nconst RANGE = `.${RANGE_CLASSNAME}`;\n\n/**\n * Update range callout for screen readers using the optional data attributes.\n *\n * Get optional data attributes, construct and appends aria-valuetext attribute.\n *\n * @example\n *\n * <input id=\"usa-range\" class=\"usa-range\" type=\"range\" min=\"0\" max=\"100\" step=\"10\" value=\"20\" data-text-unit=\"degrees\">\n *\n * Callout returns \"20 degrees of 100.\"\n *\n * <input id=\"usa-range\" class=\"usa-range\" type=\"range\" min=\"0\" max=\"100\" step=\"10\" value=\"20\" data-text-preposition=\"de\">\n *\n * Callout returns \"20 de 100.\"\n *\n * @param {HTMLInputElement} targetRange - The range slider input element\n */\nconst updateCallout = (targetRange) => {\n const rangeSlider = targetRange;\n const defaultPrep = \"of\";\n const optionalPrep = rangeSlider.dataset.textPreposition;\n const prep = optionalPrep || defaultPrep;\n const unit = rangeSlider.dataset.textUnit;\n const val = rangeSlider.value;\n // Note: 100 is the max attribute's native default value on range inputs\n // Reference: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/range#validation\n const max = rangeSlider.getAttribute(\"max\") || 100;\n\n let callout;\n\n if (unit) {\n callout = `${val} ${unit} ${prep} ${max}`;\n } else {\n callout = `${val} ${prep} ${max}`;\n }\n\n rangeSlider.setAttribute(\"aria-valuetext\", callout);\n};\n\nconst rangeEvents = {\n change: {\n [RANGE]() {\n updateCallout(this);\n },\n },\n};\n\nconst range = behavior(rangeEvents, {\n init(root) {\n selectOrMatches(RANGE, root).forEach((rangeSlider) => {\n updateCallout(rangeSlider);\n });\n },\n updateCallout,\n});\n\nmodule.exports = range;\n","const ignore = require(\"receptor/ignore\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst select = require(\"../../uswds-core/src/js/utils/select\");\n\nconst { CLICK } = require(\"../../uswds-core/src/js/events\");\n\nconst BUTTON = \".js-search-button\";\nconst FORM = \".js-search-form\";\nconst INPUT = \"[type=search]\";\nconst CONTEXT = \"header\"; // XXX\n\nlet lastButton;\n\nconst getForm = (button) => {\n const context = button.closest(CONTEXT);\n return context ? context.querySelector(FORM) : document.querySelector(FORM);\n};\n\nconst toggleSearch = (button, active) => {\n const form = getForm(button);\n\n if (!form) {\n throw new Error(`No ${FORM} found for search toggle in ${CONTEXT}!`);\n }\n\n /* eslint-disable no-param-reassign */\n button.hidden = active;\n form.hidden = !active;\n /* eslint-enable */\n\n if (!active) {\n return;\n }\n\n const input = form.querySelector(INPUT);\n\n if (input) {\n input.focus();\n }\n // when the user clicks _outside_ of the form w/ignore(): hide the\n // search, then remove the listener\n const listener = ignore(form, () => {\n if (lastButton) {\n hideSearch.call(lastButton); // eslint-disable-line no-use-before-define\n }\n\n document.body.removeEventListener(CLICK, listener);\n });\n\n // Normally we would just run this code without a timeout, but\n // IE11 and Edge will actually call the listener *immediately* because\n // they are currently handling this exact type of event, so we'll\n // make sure the browser is done handling the current click event,\n // if any, before we attach the listener.\n setTimeout(() => {\n document.body.addEventListener(CLICK, listener);\n }, 0);\n};\n\nfunction showSearch() {\n toggleSearch(this, true);\n lastButton = this;\n}\n\nfunction hideSearch() {\n toggleSearch(this, false);\n lastButton = undefined;\n}\n\nconst search = behavior(\n {\n [CLICK]: {\n [BUTTON]: showSearch,\n },\n },\n {\n init(target) {\n select(BUTTON, target).forEach((button) => {\n toggleSearch(button, false);\n });\n },\n teardown() {\n // forget the last button clicked\n lastButton = undefined;\n },\n },\n);\n\nmodule.exports = search;\n","const once = require(\"receptor/once\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst { CLICK } = require(\"../../uswds-core/src/js/events\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\n\nconst LINK = `.${PREFIX}-skipnav[href^=\"#\"], .${PREFIX}-footer__return-to-top [href^=\"#\"]`;\nconst MAINCONTENT = \"main-content\";\n\nfunction setTabindex() {\n // NB: we know because of the selector we're delegating to below that the\n // href already begins with '#'\n const id = encodeURI(this.getAttribute(\"href\"));\n const target = document.getElementById(\n id === \"#\" ? MAINCONTENT : id.slice(1),\n );\n\n if (target) {\n target.style.outline = \"0\";\n target.setAttribute(\"tabindex\", 0);\n target.focus();\n target.addEventListener(\n \"blur\",\n once(() => {\n target.setAttribute(\"tabindex\", -1);\n }),\n );\n } else {\n // throw an error?\n }\n}\n\nmodule.exports = behavior({\n [CLICK]: {\n [LINK]: setTabindex,\n },\n});\n","const select = require(\"../../uswds-core/src/js/utils/select\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst { CLICK } = require(\"../../uswds-core/src/js/events\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\nconst Sanitizer = require(\"../../uswds-core/src/js/utils/sanitizer\");\n\nconst TABLE = `.${PREFIX}-table`;\nconst SORTED = \"aria-sort\";\nconst ASCENDING = \"ascending\";\nconst DESCENDING = \"descending\";\nconst SORT_OVERRIDE = \"data-sort-value\";\nconst SORT_BUTTON_CLASS = `${PREFIX}-table__header__button`;\nconst SORT_BUTTON = `.${SORT_BUTTON_CLASS}`;\nconst SORTABLE_HEADER = `th[data-sortable]`;\nconst ANNOUNCEMENT_REGION = `.${PREFIX}-table__announcement-region[aria-live=\"polite\"]`;\n\n/** Gets the data-sort-value attribute value, if provided — otherwise, gets\n * the innerText or textContent — of the child element (HTMLTableCellElement)\n * at the specified index of the given table row\n *\n * @param {number} index\n * @param {array<HTMLTableRowElement>} tr\n * @return {boolean}\n */\nconst getCellValue = (tr, index) =>\n tr.children[index].getAttribute(SORT_OVERRIDE) ||\n tr.children[index].innerText ||\n tr.children[index].textContent;\n\n/**\n * Compares the values of two row array items at the given index, then sorts by the given direction\n * @param {number} index\n * @param {string} direction\n * @return {boolean}\n */\nconst compareFunction = (index, isAscending) => (thisRow, nextRow) => {\n // get values to compare from data attribute or cell content\n const value1 = getCellValue(isAscending ? thisRow : nextRow, index);\n const value2 = getCellValue(isAscending ? nextRow : thisRow, index);\n\n // if neither value is empty, and if both values are already numbers, compare numerically\n if (\n value1 &&\n value2 &&\n !Number.isNaN(Number(value1)) &&\n !Number.isNaN(Number(value2))\n ) {\n return value1 - value2;\n }\n // Otherwise, compare alphabetically based on current user locale\n return value1.toString().localeCompare(value2, navigator.language, {\n numeric: true,\n ignorePunctuation: true,\n });\n};\n\n/**\n * Get an Array of column headers elements belonging directly to the given\n * table element.\n * @param {HTMLTableElement} table\n * @return {array<HTMLTableHeaderCellElement>}\n */\nconst getColumnHeaders = (table) => {\n const headers = select(SORTABLE_HEADER, table);\n return headers.filter((header) => header.closest(TABLE) === table);\n};\n\n/**\n * Update the button label within the given header element, resetting it\n * to the default state (ready to sort ascending) if it's no longer sorted\n * @param {HTMLTableHeaderCellElement} header\n */\nconst updateSortLabel = (header) => {\n const headerName = header.innerText;\n const sortedAscending = header.getAttribute(SORTED) === ASCENDING;\n const isSorted =\n header.getAttribute(SORTED) === ASCENDING ||\n header.getAttribute(SORTED) === DESCENDING ||\n false;\n const headerLabel = `${headerName}, sortable column, currently ${\n isSorted\n ? `${sortedAscending ? `sorted ${ASCENDING}` : `sorted ${DESCENDING}`}`\n : \"unsorted\"\n }`;\n const headerButtonLabel = `Click to sort by ${headerName} in ${\n sortedAscending ? DESCENDING : ASCENDING\n } order.`;\n header.setAttribute(\"aria-label\", headerLabel);\n header.querySelector(SORT_BUTTON).setAttribute(\"title\", headerButtonLabel);\n};\n\n/**\n * Remove the aria-sort attribute on the given header element, and reset the label and button icon\n * @param {HTMLTableHeaderCellElement} header\n */\nconst unsetSort = (header) => {\n header.removeAttribute(SORTED);\n updateSortLabel(header);\n};\n\n/**\n * Sort rows either ascending or descending, based on a given header's aria-sort attribute\n * @param {HTMLTableHeaderCellElement} header\n * @param {boolean} isAscending\n * @return {boolean} true\n */\nconst sortRows = (header, isAscending) => {\n header.setAttribute(SORTED, isAscending === true ? DESCENDING : ASCENDING);\n updateSortLabel(header);\n\n const tbody = header.closest(TABLE).querySelector(\"tbody\");\n\n // We can use Array.from() and Array.sort() instead once we drop IE11 support, likely in the summer of 2021\n //\n // Array.from(tbody.querySelectorAll('tr').sort(\n // compareFunction(\n // Array.from(header.parentNode.children).indexOf(header),\n // !isAscending)\n // )\n // .forEach(tr => tbody.appendChild(tr) );\n\n // [].slice.call() turns array-like sets into true arrays so that we can sort them\n const allRows = [].slice.call(tbody.querySelectorAll(\"tr\"));\n const allHeaders = [].slice.call(header.parentNode.children);\n const thisHeaderIndex = allHeaders.indexOf(header);\n allRows.sort(compareFunction(thisHeaderIndex, !isAscending)).forEach((tr) => {\n [].slice\n .call(tr.children)\n .forEach((td) => td.removeAttribute(\"data-sort-active\"));\n tr.children[thisHeaderIndex].setAttribute(\"data-sort-active\", true);\n tbody.appendChild(tr);\n });\n\n return true;\n};\n\n/**\n * Update the live region immediately following the table whenever sort changes.\n * @param {HTMLTableElement} table\n * @param {HTMLTableHeaderCellElement} sortedHeader\n */\n\nconst updateLiveRegion = (table, sortedHeader) => {\n const caption = table.querySelector(\"caption\").innerText;\n const sortedAscending = sortedHeader.getAttribute(SORTED) === ASCENDING;\n const headerLabel = sortedHeader.innerText;\n const liveRegion = table.nextElementSibling;\n if (liveRegion && liveRegion.matches(ANNOUNCEMENT_REGION)) {\n const sortAnnouncement = `The table named \"${caption}\" is now sorted by ${headerLabel} in ${\n sortedAscending ? ASCENDING : DESCENDING\n } order.`;\n liveRegion.innerText = sortAnnouncement;\n } else {\n throw new Error(\n `Table containing a sortable column header is not followed by an aria-live region.`,\n );\n }\n};\n\n/**\n * Toggle a header's sort state, optionally providing a target\n * state.\n *\n * @param {HTMLTableHeaderCellElement} header\n * @param {boolean?} isAscending If no state is provided, the current\n * state will be toggled (from false to true, and vice-versa).\n */\nconst toggleSort = (header, isAscending) => {\n const table = header.closest(TABLE);\n let safeAscending = isAscending;\n if (typeof safeAscending !== \"boolean\") {\n safeAscending = header.getAttribute(SORTED) === ASCENDING;\n }\n\n if (!table) {\n throw new Error(`${SORTABLE_HEADER} is missing outer ${TABLE}`);\n }\n\n safeAscending = sortRows(header, isAscending);\n\n if (safeAscending) {\n getColumnHeaders(table).forEach((otherHeader) => {\n if (otherHeader !== header) {\n unsetSort(otherHeader);\n }\n });\n updateLiveRegion(table, header);\n }\n};\n\n/**\n ** Inserts a button with icon inside a sortable header\n * @param {HTMLTableHeaderCellElement} header\n */\n\nconst createHeaderButton = (header) => {\n const buttonEl = document.createElement(\"button\");\n buttonEl.setAttribute(\"tabindex\", \"0\");\n buttonEl.classList.add(SORT_BUTTON_CLASS);\n // ICON_SOURCE\n buttonEl.innerHTML = Sanitizer.escapeHTML`\n <svg class=\"${PREFIX}-icon\" xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\">\n <g class=\"descending\" fill=\"transparent\">\n <path d=\"M17 17L15.59 15.59L12.9999 18.17V2H10.9999V18.17L8.41 15.58L7 17L11.9999 22L17 17Z\" />\n </g>\n <g class=\"ascending\" fill=\"transparent\">\n <path transform=\"rotate(180, 12, 12)\" d=\"M17 17L15.59 15.59L12.9999 18.17V2H10.9999V18.17L8.41 15.58L7 17L11.9999 22L17 17Z\" />\n </g>\n <g class=\"unsorted\" fill=\"transparent\">\n <polygon points=\"15.17 15 13 17.17 13 6.83 15.17 9 16.58 7.59 12 3 7.41 7.59 8.83 9 11 6.83 11 17.17 8.83 15 7.42 16.41 12 21 16.59 16.41 15.17 15\"/>\n </g>\n </svg>\n `;\n header.appendChild(buttonEl);\n updateSortLabel(header);\n};\n\nconst table = behavior(\n {\n [CLICK]: {\n [SORT_BUTTON](event) {\n event.preventDefault();\n toggleSort(\n event.target.closest(SORTABLE_HEADER),\n event.target.closest(SORTABLE_HEADER).getAttribute(SORTED) ===\n ASCENDING,\n );\n },\n },\n },\n {\n init(root) {\n const sortableHeaders = select(SORTABLE_HEADER, root);\n sortableHeaders.forEach((header) => createHeaderButton(header));\n\n const firstSorted = sortableHeaders.filter(\n (header) =>\n header.getAttribute(SORTED) === ASCENDING ||\n header.getAttribute(SORTED) === DESCENDING,\n )[0];\n if (typeof firstSorted === \"undefined\") {\n // no sortable headers found\n return;\n }\n const sortDir = firstSorted.getAttribute(SORTED);\n if (sortDir === ASCENDING) {\n toggleSort(firstSorted, true);\n } else if (sortDir === DESCENDING) {\n toggleSort(firstSorted, false);\n }\n },\n TABLE,\n SORTABLE_HEADER,\n SORT_BUTTON,\n },\n);\n\nmodule.exports = table;\n","const behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst selectOrMatches = require(\"../../uswds-core/src/js/utils/select-or-matches\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\nconst {\n COMBO_BOX_CLASS,\n enhanceComboBox,\n} = require(\"../../usa-combo-box/src/index\");\n\nconst TIME_PICKER_CLASS = `${PREFIX}-time-picker`;\nconst TIME_PICKER = `.${TIME_PICKER_CLASS}`;\nconst MAX_TIME = 60 * 24 - 1;\nconst MIN_TIME = 0;\nconst DEFAULT_STEP = 30;\nconst MIN_STEP = 1;\n\nconst FILTER_DATASET = {\n filter:\n \"0?{{ hourQueryFilter }}:{{minuteQueryFilter}}.*{{ apQueryFilter }}m?\",\n apQueryFilter: \"([ap])\",\n hourQueryFilter: \"([1-9][0-2]?)\",\n minuteQueryFilter: \"[\\\\d]+:([0-9]{0,2})\",\n};\n\n/**\n * Parse a string of hh:mm into minutes\n *\n * @param {string} timeStr the time string to parse\n * @returns {number} the number of minutes\n */\nconst parseTimeString = (timeStr) => {\n let minutes;\n\n if (timeStr) {\n const [hours, mins] = timeStr.split(\":\").map((str) => {\n let value;\n const parsed = parseInt(str, 10);\n if (!Number.isNaN(parsed)) value = parsed;\n return value;\n });\n\n if (hours != null && mins != null) {\n minutes = hours * 60 + mins;\n }\n }\n\n return minutes;\n};\n\n/**\n * Enhance an input with the date picker elements\n *\n * @param {HTMLElement} el The initial wrapping element of the date picker component\n */\nconst transformTimePicker = (el) => {\n const timePickerEl = el.closest(TIME_PICKER);\n\n const initialInputEl = timePickerEl.querySelector(`input`);\n\n if (!initialInputEl) {\n throw new Error(`${TIME_PICKER} is missing inner input`);\n }\n\n const selectEl = document.createElement(\"select\");\n\n [\n \"id\",\n \"name\",\n \"required\",\n \"aria-label\",\n \"aria-labelledby\",\n \"disabled\",\n \"aria-disabled\",\n ].forEach((name) => {\n if (initialInputEl.hasAttribute(name)) {\n const value = initialInputEl.getAttribute(name);\n selectEl.setAttribute(name, value);\n initialInputEl.removeAttribute(name);\n }\n });\n\n const padZeros = (value, length) => `0000${value}`.slice(-length);\n\n const getTimeContext = (minutes) => {\n const minute = minutes % 60;\n const hour24 = Math.floor(minutes / 60);\n const hour12 = hour24 % 12 || 12;\n const ampm = hour24 < 12 ? \"am\" : \"pm\";\n\n return {\n minute,\n hour24,\n hour12,\n ampm,\n };\n };\n\n const minTime = Math.max(\n MIN_TIME,\n parseTimeString(timePickerEl.dataset.minTime) || MIN_TIME,\n );\n const maxTime = Math.min(\n MAX_TIME,\n parseTimeString(timePickerEl.dataset.maxTime) || MAX_TIME,\n );\n const step = Math.floor(\n Math.max(MIN_STEP, timePickerEl.dataset.step || DEFAULT_STEP),\n );\n\n let defaultValue;\n for (let time = minTime; time <= maxTime; time += step) {\n const { minute, hour24, hour12, ampm } = getTimeContext(time);\n\n const option = document.createElement(\"option\");\n option.value = `${padZeros(hour24, 2)}:${padZeros(minute, 2)}`;\n option.text = `${hour12}:${padZeros(minute, 2)}${ampm}`;\n if (option.text === initialInputEl.value) {\n defaultValue = option.value;\n }\n selectEl.appendChild(option);\n }\n\n timePickerEl.classList.add(COMBO_BOX_CLASS);\n\n // combo box properties\n Object.keys(FILTER_DATASET).forEach((key) => {\n timePickerEl.dataset[key] = FILTER_DATASET[key];\n });\n timePickerEl.dataset.disableFiltering = \"true\";\n timePickerEl.dataset.defaultValue = defaultValue;\n\n timePickerEl.appendChild(selectEl);\n initialInputEl.remove();\n};\n\nconst timePicker = behavior(\n {},\n {\n init(root) {\n selectOrMatches(TIME_PICKER, root).forEach((timePickerEl) => {\n transformTimePicker(timePickerEl);\n enhanceComboBox(timePickerEl);\n });\n },\n FILTER_DATASET,\n },\n);\n\nmodule.exports = timePicker;\n","// Tooltips\nconst keymap = require(\"receptor/keymap\");\nconst selectOrMatches = require(\"../../uswds-core/src/js/utils/select-or-matches\");\nconst behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\nconst isElementInViewport = require(\"../../uswds-core/src/js/utils/is-in-viewport\");\n\nconst BODY = \"body\";\nconst TOOLTIP = `.${PREFIX}-tooltip`;\nconst TOOLTIP_TRIGGER = `.${PREFIX}-tooltip__trigger`;\nconst TOOLTIP_TRIGGER_CLASS = `${PREFIX}-tooltip__trigger`;\nconst TOOLTIP_CLASS = `${PREFIX}-tooltip`;\nconst TOOLTIP_BODY_CLASS = `${PREFIX}-tooltip__body`;\nconst SET_CLASS = \"is-set\";\nconst VISIBLE_CLASS = \"is-visible\";\nconst TRIANGLE_SIZE = 5;\nconst ADJUST_WIDTH_CLASS = `${PREFIX}-tooltip__body--wrap`;\n\n/**\n *\n * @param {DOMElement} trigger - The tooltip trigger\n * @returns {object} Elements for initialized tooltip; includes trigger, wrapper, and body\n */\nconst getTooltipElements = (trigger) => {\n const wrapper = trigger.parentNode;\n const body = wrapper.querySelector(`.${TOOLTIP_BODY_CLASS}`);\n\n return { trigger, wrapper, body };\n};\n\n/**\n * Shows the tooltip\n * @param {HTMLElement} tooltipTrigger - the element that initializes the tooltip\n */\nconst showToolTip = (tooltipBody, tooltipTrigger, position) => {\n tooltipBody.setAttribute(\"aria-hidden\", \"false\");\n\n // This sets up the tooltip body. The opacity is 0, but\n // we can begin running the calculations below.\n tooltipBody.classList.add(SET_CLASS);\n\n /**\n * Position the tooltip body when the trigger is hovered\n * Removes old positioning classnames and reapplies. This allows\n * positioning to change in case the user resizes browser or DOM manipulation\n * causes tooltip to get clipped from viewport\n *\n * @param {string} setPos - can be \"top\", \"bottom\", \"right\", \"left\"\n */\n const setPositionClass = (setPos) => {\n tooltipBody.classList.remove(`${TOOLTIP_BODY_CLASS}--top`);\n tooltipBody.classList.remove(`${TOOLTIP_BODY_CLASS}--bottom`);\n tooltipBody.classList.remove(`${TOOLTIP_BODY_CLASS}--right`);\n tooltipBody.classList.remove(`${TOOLTIP_BODY_CLASS}--left`);\n tooltipBody.classList.add(`${TOOLTIP_BODY_CLASS}--${setPos}`);\n };\n\n /**\n * Removes old positioning styles. This allows\n * re-positioning to change without inheriting other\n * dynamic styles\n *\n * @param {HTMLElement} e - this is the tooltip body\n */\n const resetPositionStyles = (e) => {\n // we don't override anything in the stylesheet when finding alt positions\n e.style.top = null;\n e.style.bottom = null;\n e.style.right = null;\n e.style.left = null;\n e.style.margin = null;\n };\n\n /**\n * get margin offset calculations\n *\n * @param {HTMLElement} target - this is the tooltip body\n * @param {String} propertyValue - this is the tooltip body\n */\n\n const offsetMargin = (target, propertyValue) =>\n parseInt(\n window.getComputedStyle(target).getPropertyValue(propertyValue),\n 10,\n );\n\n // offsetLeft = the left position, and margin of the element, the left\n // padding, scrollbar and border of the offsetParent element\n // offsetWidth = The offsetWidth property returns the viewable width of an\n // element in pixels, including padding, border and scrollbar, but not\n // the margin.\n\n /**\n * Calculate margin offset\n * tooltip trigger margin(position) offset + tooltipBody offsetWidth\n * @param {String} marginPosition\n * @param {Number} tooltipBodyOffset\n * @param {HTMLElement} trigger\n */\n const calculateMarginOffset = (\n marginPosition,\n tooltipBodyOffset,\n trigger,\n ) => {\n const offset =\n offsetMargin(trigger, `margin-${marginPosition}`) > 0\n ? tooltipBodyOffset - offsetMargin(trigger, `margin-${marginPosition}`)\n : tooltipBodyOffset;\n\n return offset;\n };\n\n /**\n * Positions tooltip at the top\n * @param {HTMLElement} e - this is the tooltip body\n */\n const positionTop = (e) => {\n resetPositionStyles(e); // ensures we start from the same point\n // get details on the elements object with\n\n const topMargin = calculateMarginOffset(\n \"top\",\n e.offsetHeight,\n tooltipTrigger,\n );\n\n const leftMargin = calculateMarginOffset(\n \"left\",\n e.offsetWidth,\n tooltipTrigger,\n );\n\n setPositionClass(\"top\");\n e.style.left = `50%`; // center the element\n e.style.top = `-${TRIANGLE_SIZE}px`; // consider the pseudo element\n // apply our margins based on the offset\n e.style.margin = `-${topMargin}px 0 0 -${leftMargin / 2}px`;\n };\n\n /**\n * Positions tooltip at the bottom\n * @param {HTMLElement} e - this is the tooltip body\n */\n const positionBottom = (e) => {\n resetPositionStyles(e);\n\n const leftMargin = calculateMarginOffset(\n \"left\",\n e.offsetWidth,\n tooltipTrigger,\n );\n\n setPositionClass(\"bottom\");\n e.style.left = `50%`;\n e.style.margin = `${TRIANGLE_SIZE}px 0 0 -${leftMargin / 2}px`;\n };\n\n /**\n * Positions tooltip at the right\n * @param {HTMLElement} e - this is the tooltip body\n */\n const positionRight = (e) => {\n resetPositionStyles(e);\n\n const topMargin = calculateMarginOffset(\n \"top\",\n e.offsetHeight,\n tooltipTrigger,\n );\n\n setPositionClass(\"right\");\n e.style.top = `50%`;\n e.style.left = `${\n tooltipTrigger.offsetLeft + tooltipTrigger.offsetWidth + TRIANGLE_SIZE\n }px`;\n e.style.margin = `-${topMargin / 2}px 0 0 0`;\n };\n\n /**\n * Positions tooltip at the right\n * @param {HTMLElement} e - this is the tooltip body\n */\n const positionLeft = (e) => {\n resetPositionStyles(e);\n\n const topMargin = calculateMarginOffset(\n \"top\",\n e.offsetHeight,\n tooltipTrigger,\n );\n\n // we have to check for some utility margins\n const leftMargin = calculateMarginOffset(\n \"left\",\n tooltipTrigger.offsetLeft > e.offsetWidth\n ? tooltipTrigger.offsetLeft - e.offsetWidth\n : e.offsetWidth,\n tooltipTrigger,\n );\n\n setPositionClass(\"left\");\n e.style.top = `50%`;\n e.style.left = `-${TRIANGLE_SIZE}px`;\n e.style.margin = `-${topMargin / 2}px 0 0 ${\n tooltipTrigger.offsetLeft > e.offsetWidth ? leftMargin : -leftMargin\n }px`; // adjust the margin\n };\n\n /**\n * We try to set the position based on the\n * original intention, but make adjustments\n * if the element is clipped out of the viewport\n * we constrain the width only as a last resort\n * @param {HTMLElement} element(alias tooltipBody)\n * @param {Number} attempt (--flag)\n */\n\n const maxAttempts = 2;\n\n function findBestPosition(element, attempt = 1) {\n // create array of optional positions\n const positions = [\n positionTop,\n positionBottom,\n positionRight,\n positionLeft,\n ];\n\n let hasVisiblePosition = false;\n\n // we take a recursive approach\n function tryPositions(i) {\n if (i < positions.length) {\n const pos = positions[i];\n pos(element);\n\n if (!isElementInViewport(element)) {\n // eslint-disable-next-line no-param-reassign\n tryPositions((i += 1));\n } else {\n hasVisiblePosition = true;\n }\n }\n }\n\n tryPositions(0);\n // if we can't find a position we compress it and try again\n if (!hasVisiblePosition) {\n element.classList.add(ADJUST_WIDTH_CLASS);\n if (attempt <= maxAttempts) {\n // eslint-disable-next-line no-param-reassign\n findBestPosition(element, (attempt += 1));\n }\n }\n }\n\n switch (position) {\n case \"top\":\n positionTop(tooltipBody);\n if (!isElementInViewport(tooltipBody)) {\n findBestPosition(tooltipBody);\n }\n break;\n case \"bottom\":\n positionBottom(tooltipBody);\n if (!isElementInViewport(tooltipBody)) {\n findBestPosition(tooltipBody);\n }\n break;\n case \"right\":\n positionRight(tooltipBody);\n if (!isElementInViewport(tooltipBody)) {\n findBestPosition(tooltipBody);\n }\n break;\n case \"left\":\n positionLeft(tooltipBody);\n if (!isElementInViewport(tooltipBody)) {\n findBestPosition(tooltipBody);\n }\n break;\n\n default:\n // skip default case\n break;\n }\n\n /**\n * Actually show the tooltip. The VISIBLE_CLASS\n * will change the opacity to 1\n */\n setTimeout(() => {\n tooltipBody.classList.add(VISIBLE_CLASS);\n }, 20);\n};\n\n/**\n * Removes all the properties to show and position the tooltip,\n * and resets the tooltip position to the original intention\n * in case the window is resized or the element is moved through\n * DOM manipulation.\n * @param {HTMLElement} tooltipBody - The body of the tooltip\n */\nconst hideToolTip = (tooltipBody) => {\n tooltipBody.classList.remove(VISIBLE_CLASS);\n tooltipBody.classList.remove(SET_CLASS);\n tooltipBody.classList.remove(ADJUST_WIDTH_CLASS);\n tooltipBody.setAttribute(\"aria-hidden\", \"true\");\n};\n\n/**\n * Setup the tooltip component\n * @param {HTMLElement} tooltipTrigger The element that creates the tooltip\n */\nconst setUpAttributes = (tooltipTrigger) => {\n const tooltipID = `tooltip-${Math.floor(Math.random() * 900000) + 100000}`;\n const tooltipContent = tooltipTrigger.getAttribute(\"title\");\n const wrapper = document.createElement(\"span\");\n const tooltipBody = document.createElement(\"span\");\n const additionalClasses = tooltipTrigger.getAttribute(\"data-classes\");\n let position = tooltipTrigger.getAttribute(\"data-position\");\n\n // Apply default position if not set as attribute\n if (!position) {\n position = \"top\";\n tooltipTrigger.setAttribute(\"data-position\", position);\n }\n\n // Set up tooltip attributes\n tooltipTrigger.setAttribute(\"aria-describedby\", tooltipID);\n tooltipTrigger.setAttribute(\"tabindex\", \"0\");\n tooltipTrigger.removeAttribute(\"title\");\n tooltipTrigger.classList.remove(TOOLTIP_CLASS);\n tooltipTrigger.classList.add(TOOLTIP_TRIGGER_CLASS);\n\n // insert wrapper before el in the DOM tree\n tooltipTrigger.parentNode.insertBefore(wrapper, tooltipTrigger);\n\n // set up the wrapper\n wrapper.appendChild(tooltipTrigger);\n wrapper.classList.add(TOOLTIP_CLASS);\n wrapper.appendChild(tooltipBody);\n\n // Apply additional class names to wrapper element\n if (additionalClasses) {\n const classesArray = additionalClasses.split(\" \");\n classesArray.forEach((classname) => wrapper.classList.add(classname));\n }\n\n // set up the tooltip body\n tooltipBody.classList.add(TOOLTIP_BODY_CLASS);\n tooltipBody.setAttribute(\"id\", tooltipID);\n tooltipBody.setAttribute(\"role\", \"tooltip\");\n tooltipBody.setAttribute(\"aria-hidden\", \"true\");\n\n // place the text in the tooltip\n tooltipBody.textContent = tooltipContent;\n\n return { tooltipBody, position, tooltipContent, wrapper };\n};\n\n/**\n * Hide all active tooltips when escape key is pressed.\n */\n\nconst handleEscape = () => {\n const activeTooltips = selectOrMatches(`.${TOOLTIP_BODY_CLASS}.${SET_CLASS}`);\n\n if (!activeTooltips) {\n return;\n }\n\n activeTooltips.forEach((activeTooltip) => hideToolTip(activeTooltip));\n};\n\n// Setup our function to run on various events\nconst tooltip = behavior(\n {\n \"mouseover focusin\": {\n [TOOLTIP](e) {\n const trigger = e.target;\n const elementType = trigger.nodeName;\n\n // Initialize tooltip if it hasn't already\n if (elementType === \"BUTTON\" && trigger.hasAttribute(\"title\")) {\n setUpAttributes(trigger);\n }\n },\n [TOOLTIP_TRIGGER](e) {\n const { trigger, body } = getTooltipElements(e.target);\n\n showToolTip(body, trigger, trigger.dataset.position);\n },\n },\n focusout: {\n [TOOLTIP_TRIGGER](e) {\n const { body } = getTooltipElements(e.target);\n\n hideToolTip(body);\n },\n },\n keydown: {\n [BODY]: keymap({ Escape: handleEscape }),\n },\n },\n {\n init(root) {\n selectOrMatches(TOOLTIP, root).forEach((tooltipTrigger) => {\n setUpAttributes(tooltipTrigger);\n\n const { body, wrapper } = getTooltipElements(tooltipTrigger);\n wrapper.addEventListener(\"mouseleave\", () => hideToolTip(body));\n });\n },\n teardown(root) {\n selectOrMatches(TOOLTIP, root).forEach((tooltipWrapper) => {\n tooltipWrapper.removeEventListener(\"mouseleave\", hideToolTip);\n });\n },\n setup: setUpAttributes,\n getTooltipElements,\n show: showToolTip,\n hide: hideToolTip,\n },\n);\n\nmodule.exports = tooltip;\n","const behavior = require(\"../../uswds-core/src/js/utils/behavior\");\nconst validate = require(\"../../uswds-core/src/js/utils/validate-input\");\nconst { prefix: PREFIX } = require(\"../../uswds-core/src/js/config\");\nconst selectOrMatches = require(\"../../uswds-core/src/js/utils/select-or-matches\");\n\nconst VALIDATE_INPUT =\n \"input[data-validation-element],textarea[data-validation-element]\";\nconst CHECKLIST_ITEM = `.${PREFIX}-checklist__item`;\n\n// Trigger validation on input change\nconst handleChange = (el) => validate(el);\n\n// Create container to hold aria readout\nconst createStatusElement = (input) => {\n const validationContainer = input.parentNode;\n const inputID = input.getAttribute(\"id\");\n const statusSummaryID = `${inputID}-sr-summary`;\n input.setAttribute(\"aria-describedby\", statusSummaryID);\n\n const statusSummaryContainer = document.createElement(\"span\");\n\n statusSummaryContainer.setAttribute(\"data-validation-status\", \"\");\n statusSummaryContainer.classList.add(\"usa-sr-only\");\n statusSummaryContainer.setAttribute(\"aria-live\", \"polite\");\n statusSummaryContainer.setAttribute(\"aria-atomic\", true);\n statusSummaryContainer.setAttribute(\"id\", statusSummaryID);\n validationContainer.append(statusSummaryContainer);\n};\n\n// Set up checklist items with initial aria-label (incomplete) values\nconst createInitialStatus = (input) => {\n const validationContainer = input.parentNode;\n const checklistItems = validationContainer.querySelectorAll(CHECKLIST_ITEM);\n const validationElement = input.getAttribute(\"data-validation-element\");\n\n input.setAttribute(\"aria-controls\", validationElement);\n\n checklistItems.forEach((listItem) => {\n let currentStatus = \"status incomplete\";\n if (input.hasAttribute(\"data-validation-incomplete\")) {\n currentStatus = input.getAttribute(\"data-validation-incomplete\");\n }\n const itemStatus = `${listItem.textContent} ${currentStatus} `;\n listItem.setAttribute(\"aria-label\", itemStatus);\n });\n};\n\nconst enhanceValidation = (input) => {\n createStatusElement(input);\n createInitialStatus(input);\n};\n\nconst validator = behavior(\n {\n \"input change\": {\n [VALIDATE_INPUT](event) {\n handleChange(event.target);\n },\n },\n },\n {\n init(root) {\n selectOrMatches(VALIDATE_INPUT, root).forEach((input) =>\n enhanceValidation(input),\n );\n },\n },\n);\n\nmodule.exports = validator;\n","module.exports = {\n prefix: \"usa\",\n};\n","module.exports = {\n // This used to be conditionally dependent on whether the\n // browser supported touch events; if it did, `CLICK` was set to\n // `touchstart`. However, this had downsides:\n //\n // * It pre-empted mobile browsers' default behavior of detecting\n // whether a touch turned into a scroll, thereby preventing\n // users from using some of our components as scroll surfaces.\n //\n // * Some devices, such as the Microsoft Surface Pro, support *both*\n // touch and clicks. This meant the conditional effectively dropped\n // support for the user's mouse, frustrating users who preferred\n // it on those systems.\n CLICK: \"click\",\n};\n","const accordion = require(\"../../../usa-accordion/src/index\");\nconst banner = require(\"../../../usa-banner/src/index\");\nconst button = require(\"../../../usa-button/src/index\");\nconst characterCount = require(\"../../../usa-character-count/src/index\");\nconst comboBox = require(\"../../../usa-combo-box/src/index\");\nconst datePicker = require(\"../../../usa-date-picker/src/index\");\nconst dateRangePicker = require(\"../../../usa-date-range-picker/src/index\");\nconst fileInput = require(\"../../../usa-file-input/src/index\");\nconst footer = require(\"../../../usa-footer/src/index\");\nconst inPageNavigation = require(\"../../../usa-in-page-navigation/src/index\");\nconst inputMask = require(\"../../../usa-input-mask/src/index\");\nconst languageSelector = require(\"../../../usa-language-selector/src/index\");\nconst modal = require(\"../../../usa-modal/src/index\");\nconst navigation = require(\"../../../usa-header/src/index\");\nconst password = require(\"../../../_usa-password/src/index\");\nconst range = require(\"../../../usa-range/src/index\");\nconst search = require(\"../../../usa-search/src/index\");\nconst skipnav = require(\"../../../usa-skipnav/src/index\");\nconst table = require(\"../../../usa-table/src/index\");\nconst timePicker = require(\"../../../usa-time-picker/src/index\");\nconst tooltip = require(\"../../../usa-tooltip/src/index\");\nconst validator = require(\"../../../usa-validation/src/index\");\n\nmodule.exports = {\n accordion,\n banner,\n button,\n characterCount,\n comboBox,\n datePicker,\n dateRangePicker,\n fileInput,\n footer,\n inPageNavigation,\n inputMask,\n languageSelector,\n modal,\n navigation,\n password,\n range,\n search,\n skipnav,\n table,\n timePicker,\n tooltip,\n validator,\n};\n","window.uswdsPresent = true; // GLOBAL variable to indicate that the uswds.js has loaded in the DOM.\n\nconst uswds = require(\"./config\");\n\nconst components = require(\"./index\");\n\nuswds.components = components;\n\nconst initComponents = () => {\n const target = document.body;\n Object.keys(components).forEach((key) => {\n const behavior = components[key];\n behavior.on(target);\n });\n};\n\nif (document.readyState === \"loading\") {\n document.addEventListener(\"DOMContentLoaded\", initComponents, { once: true });\n} else {\n initComponents();\n}\n\nexports.default = uswds;\nexports.initComponents = initComponents;\n","module.exports = (htmlDocument = document) => htmlDocument.activeElement;\n","const Behavior = require(\"receptor/behavior\");\n\n/**\n * @name sequence\n * @param {...Function} seq an array of functions\n * @return { closure } callHooks\n */\n// We use a named function here because we want it to inherit its lexical scope\n// from the behavior props object, not from the module\nconst sequence = (...seq) =>\n function callHooks(target = document.body) {\n seq.forEach((method) => {\n if (typeof this[method] === \"function\") {\n this[method].call(this, target);\n }\n });\n };\n\n/**\n * @name behavior\n * @param {object} events\n * @param {object?} props\n * @return {receptor.behavior}\n */\nmodule.exports = (events, props) =>\n Behavior(events, {\n on: sequence(\"init\", \"add\"),\n off: sequence(\"teardown\", \"remove\"),\n ...props,\n });\n","/**\n * Call a function every X amount of milliseconds.\n *\n * @param {Function} callback - A callback function to be debounced\n * @param {number} delay - Milliseconds to wait before calling function\n * @returns {Function} A debounced function\n * @example const updateStatus = debounce((string) => console.log(string), 2000)\n */\n\nmodule.exports = function debounce(callback, delay = 500) {\n let timer = null;\n return (...args) => {\n window.clearTimeout(timer);\n timer = window.setTimeout(() => {\n callback.apply(this, args);\n }, delay);\n };\n};\n","const { keymap } = require(\"receptor\");\nconst behavior = require(\"./behavior\");\nconst select = require(\"./select\");\nconst activeElement = require(\"./active-element\");\n\nconst FOCUSABLE =\n 'a[href], area[href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), button:not([disabled]), iframe, object, embed, [tabindex=\"0\"], [contenteditable]';\n\nconst tabHandler = (context) => {\n const focusableElements = select(FOCUSABLE, context);\n const firstTabStop = focusableElements[0];\n const lastTabStop = focusableElements[focusableElements.length - 1];\n\n // Special rules for when the user is tabbing forward from the last focusable element,\n // or when tabbing backwards from the first focusable element\n function tabAhead(event) {\n if (activeElement() === lastTabStop) {\n event.preventDefault();\n firstTabStop.focus();\n }\n }\n\n function tabBack(event) {\n if (activeElement() === firstTabStop) {\n event.preventDefault();\n lastTabStop.focus();\n }\n // This checks if you want to set the initial focus to a container\n // instead of an element within, and the user tabs back.\n // Then we set the focus to the first\n else if (!focusableElements.includes(activeElement())) {\n event.preventDefault();\n firstTabStop.focus();\n }\n }\n\n return {\n firstTabStop,\n lastTabStop,\n tabAhead,\n tabBack,\n };\n};\n\nmodule.exports = (context, additionalKeyBindings = {}) => {\n const tabEventHandler = tabHandler(context);\n const bindings = additionalKeyBindings;\n const { Esc, Escape } = bindings;\n\n if (Escape && !Esc) bindings.Esc = Escape;\n\n // TODO: In the future, loop over additional keybindings and pass an array\n // of functions, if necessary, to the map keys. Then people implementing\n // the focus trap could pass callbacks to fire when tabbing\n const keyMappings = keymap({\n Tab: tabEventHandler.tabAhead,\n \"Shift+Tab\": tabEventHandler.tabBack,\n ...additionalKeyBindings,\n });\n\n const focusTrap = behavior(\n {\n keydown: keyMappings,\n },\n {\n init() {\n // TODO: is this desireable behavior? Should the trap always do this by default or should\n // the component getting decorated handle this?\n if (tabEventHandler.firstTabStop) {\n tabEventHandler.firstTabStop.focus();\n }\n },\n update(isActive) {\n if (isActive) {\n this.on();\n } else {\n this.off();\n }\n },\n },\n );\n\n return focusTrap;\n};\n","// https://stackoverflow.com/a/7557433\nfunction isElementInViewport(\n el,\n win = window,\n docEl = document.documentElement,\n) {\n const rect = el.getBoundingClientRect();\n\n return (\n rect.top >= 0 &&\n rect.left >= 0 &&\n rect.bottom <= (win.innerHeight || docEl.clientHeight) &&\n rect.right <= (win.innerWidth || docEl.clientWidth)\n );\n}\n\nmodule.exports = isElementInViewport;\n","// iOS detection from: http://stackoverflow.com/a/9039885/177710\nfunction isIosDevice() {\n return (\n typeof navigator !== \"undefined\" &&\n (navigator.userAgent.match(/(iPod|iPhone|iPad)/g) ||\n (navigator.platform === \"MacIntel\" && navigator.maxTouchPoints > 1)) &&\n !window.MSStream\n );\n}\n\nmodule.exports = isIosDevice;\n","/* eslint-disable */\n/* globals define, module */\n\n/**\n * A simple library to help you escape HTML using template strings.\n *\n * It's the counterpart to our eslint \"no-unsafe-innerhtml\" plugin that helps us\n * avoid unsafe coding practices.\n * A full write-up of the Hows and Whys are documented\n * for developers at\n * https://developer.mozilla.org/en-US/Firefox_OS/Security/Security_Automation\n * with additional background information and design docs at\n * https://wiki.mozilla.org/User:Fbraun/Gaia/SafeinnerHTMLRoadmap\n *\n */\n\n!(function (factory) {\n module.exports = factory();\n})(function () {\n \"use strict\";\n\n var Sanitizer = {\n _entity: /[&<>\"'/]/g,\n\n _entities: {\n \"&\": \"&\",\n \"<\": \"<\",\n \">\": \">\",\n '\"': \""\",\n \"'\": \"'\",\n \"/\": \"/\",\n },\n\n getEntity: function (s) {\n return Sanitizer._entities[s];\n },\n\n /**\n * Escapes HTML for all values in a tagged template string.\n */\n escapeHTML: function (strings) {\n var result = \"\";\n\n for (var i = 0; i < strings.length; i++) {\n result += strings[i];\n if (i + 1 < arguments.length) {\n var value = arguments[i + 1] || \"\";\n result += String(value).replace(\n Sanitizer._entity,\n Sanitizer.getEntity,\n );\n }\n }\n\n return result;\n },\n /**\n * Escapes HTML and returns a wrapped object to be used during DOM insertion\n */\n createSafeHTML: function (strings) {\n var _len = arguments.length;\n var values = new Array(_len > 1 ? _len - 1 : 0);\n for (var _key = 1; _key < _len; _key++) {\n values[_key - 1] = arguments[_key];\n }\n\n var escaped = Sanitizer.escapeHTML.apply(\n Sanitizer,\n [strings].concat(values),\n );\n return {\n __html: escaped,\n toString: function () {\n return \"[object WrappedHTMLObject]\";\n },\n info:\n \"This is a wrapped HTML object. See https://developer.mozilla.or\" +\n \"g/en-US/Firefox_OS/Security/Security_Automation for more.\",\n };\n },\n /**\n * Unwrap safe HTML created by createSafeHTML or a custom replacement that\n * underwent security review.\n */\n unwrapSafeHTML: function () {\n var _len = arguments.length;\n var htmlObjects = new Array(_len);\n for (var _key = 0; _key < _len; _key++) {\n htmlObjects[_key] = arguments[_key];\n }\n\n var markupList = htmlObjects.map(function (obj) {\n return obj.__html;\n });\n return markupList.join(\"\");\n },\n };\n\n return Sanitizer;\n});\n","module.exports = function getScrollbarWidth() {\n // Creating invisible container\n const outer = document.createElement(\"div\");\n outer.style.visibility = \"hidden\";\n outer.style.overflow = \"scroll\"; // forcing scrollbar to appear\n outer.style.msOverflowStyle = \"scrollbar\"; // needed for WinJS apps\n document.body.appendChild(outer);\n\n // Creating inner element and placing it in the container\n const inner = document.createElement(\"div\");\n outer.appendChild(inner);\n\n // Calculating difference between container's full width and the child width\n const scrollbarWidth = `${outer.offsetWidth - inner.offsetWidth}px`;\n\n // Removing temporary elements from the DOM\n outer.parentNode.removeChild(outer);\n\n return scrollbarWidth;\n};\n","const select = require(\"./select\");\n/**\n * @name isElement\n * @desc returns whether or not the given argument is a DOM element.\n * @param {any} value\n * @return {boolean}\n */\nconst isElement = (value) =>\n value && typeof value === \"object\" && value.nodeType === 1;\n\n/**\n * @name selectOrMatches\n * @desc selects elements from the DOM by class selector or ID selector.\n * @param {string} selector - The selector to traverse the DOM with.\n * @param {Document|HTMLElement?} context - The context to traverse the DOM\n * in. If not provided, it defaults to the document.\n * @return {HTMLElement[]} - An array of DOM nodes or an empty array.\n */\nmodule.exports = (selector, context) => {\n const selection = select(selector, context);\n if (typeof selector !== \"string\") {\n return selection;\n }\n\n if (isElement(context) && context.matches(selector)) {\n selection.push(context);\n }\n\n return selection;\n};\n","/**\n * @name isElement\n * @desc returns whether or not the given argument is a DOM element.\n * @param {any} value\n * @return {boolean}\n */\nconst isElement = (value) =>\n value && typeof value === \"object\" && value.nodeType === 1;\n\n/**\n * @name select\n * @desc selects elements from the DOM by class selector or ID selector.\n * @param {string} selector - The selector to traverse the DOM with.\n * @param {Document|HTMLElement?} context - The context to traverse the DOM\n * in. If not provided, it defaults to the document.\n * @return {HTMLElement[]} - An array of DOM nodes or an empty array.\n */\nmodule.exports = (selector, context) => {\n if (typeof selector !== \"string\") {\n return [];\n }\n\n if (!context || !isElement(context)) {\n context = window.document; // eslint-disable-line no-param-reassign\n }\n\n const selection = context.querySelectorAll(selector);\n return Array.prototype.slice.call(selection);\n};\n","/**\n * Flips given INPUT elements between masked (hiding the field value) and unmasked\n * @param {Array.HTMLElement} fields - An array of INPUT elements\n * @param {Boolean} mask - Whether the mask should be applied, hiding the field value\n */\nmodule.exports = (field, mask) => {\n field.setAttribute(\"autocapitalize\", \"off\");\n field.setAttribute(\"autocorrect\", \"off\");\n field.setAttribute(\"type\", mask ? \"password\" : \"text\");\n};\n","const resolveIdRefs = require(\"resolve-id-refs\");\nconst toggleFieldMask = require(\"./toggle-field-mask\");\n\nconst CONTROLS = \"aria-controls\";\nconst PRESSED = \"aria-pressed\";\nconst SHOW_ATTR = \"data-show-text\";\nconst HIDE_ATTR = \"data-hide-text\";\n\n/**\n * Replace the word \"Show\" (or \"show\") with \"Hide\" (or \"hide\") in a string.\n * @param {string} showText\n * @return {strong} hideText\n */\nconst getHideText = (showText) =>\n showText.replace(/\\bShow\\b/i, (show) => `${show[0] === \"S\" ? \"H\" : \"h\"}ide`);\n\n/**\n * Component that decorates an HTML element with the ability to toggle the\n * masked state of an input field (like a password) when clicked.\n * The ids of the fields to be masked will be pulled directly from the button's\n * `aria-controls` attribute.\n *\n * @param {HTMLElement} el Parent element containing the fields to be masked\n * @return {boolean}\n */\nmodule.exports = (el) => {\n // this is the *target* state:\n // * if the element has the attr and it's !== \"true\", pressed is true\n // * otherwise, pressed is false\n const pressed =\n el.hasAttribute(PRESSED) && el.getAttribute(PRESSED) !== \"true\";\n\n const fields = resolveIdRefs(el.getAttribute(CONTROLS));\n fields.forEach((field) => toggleFieldMask(field, pressed));\n\n if (!el.hasAttribute(SHOW_ATTR)) {\n el.setAttribute(SHOW_ATTR, el.textContent);\n }\n\n const showText = el.getAttribute(SHOW_ATTR);\n const hideText = el.getAttribute(HIDE_ATTR) || getHideText(showText);\n\n el.textContent = pressed ? showText : hideText; // eslint-disable-line no-param-reassign\n el.setAttribute(PRESSED, pressed);\n return pressed;\n};\n","const EXPANDED = \"aria-expanded\";\nconst CONTROLS = \"aria-controls\";\nconst HIDDEN = \"hidden\";\n\nmodule.exports = (button, expanded) => {\n let safeExpanded = expanded;\n\n if (typeof safeExpanded !== \"boolean\") {\n safeExpanded = button.getAttribute(EXPANDED) === \"false\";\n }\n\n button.setAttribute(EXPANDED, safeExpanded);\n\n const id = button.getAttribute(CONTROLS);\n const controls = document.getElementById(id);\n if (!controls) {\n throw new Error(`No toggle target found with id: \"${id}\"`);\n }\n\n if (safeExpanded) {\n controls.removeAttribute(HIDDEN);\n } else {\n controls.setAttribute(HIDDEN, \"\");\n }\n\n return safeExpanded;\n};\n","const debounce = require(\"./debounce\");\nconst { prefix: PREFIX } = require(\"../config\");\n\nconst CHECKED_CLASS = `${PREFIX}-checklist__item--checked`;\n\nmodule.exports = function validate(el) {\n const id = el.dataset.validationElement;\n const checkList =\n id.charAt(0) === \"#\"\n ? document.querySelector(id)\n : document.getElementById(id);\n\n if (!checkList) {\n throw new Error(`No validation element found with id: \"${id}\"`);\n }\n\n let statusSummary = \"\";\n Object.entries(el.dataset).forEach(([key, value]) => {\n if (key.startsWith(\"validate\")) {\n const validatorName = key.substr(\"validate\".length).toLowerCase();\n const validatorPattern = new RegExp(value);\n const validatorSelector = `[data-validator=\"${validatorName}\"]`;\n const validatorCheckbox = checkList.querySelector(validatorSelector);\n const validatorParent = el.parentNode;\n const statusSummaryContainer = validatorParent.querySelector(\n `[data-validation-status]`,\n );\n\n const checked = validatorPattern.test(el.value);\n validatorCheckbox.classList.toggle(CHECKED_CLASS, checked);\n\n if (!validatorCheckbox) {\n throw new Error(`No validator checkbox found for: \"${validatorName}\"`);\n }\n\n // Create status reports for checklist items\n const statusComplete = el.dataset.validationComplete || \"status complete\";\n const statusIncomplete =\n el.dataset.validationIncomplete || \"status incomplete\";\n let checkboxContent = `${validatorCheckbox.textContent} `;\n\n if (validatorCheckbox.classList.contains(CHECKED_CLASS)) {\n checkboxContent += statusComplete;\n } else {\n checkboxContent += statusIncomplete;\n }\n\n // move status updates to aria-label on checklist item\n validatorCheckbox.setAttribute(\"aria-label\", checkboxContent);\n\n // Create a summary of status for all checklist items\n statusSummary += `${checkboxContent}. `;\n\n // Add summary to screen reader summary container, after a delay\n const srUpdateStatus = debounce(() => {\n statusSummaryContainer.textContent = statusSummary;\n }, 1000);\n\n srUpdateStatus();\n }\n });\n};\n"]} \ No newline at end of file |