diff --git a/.jshintrc b/.jshintrc
index 368bcf310..7e2549ace 100644
--- a/.jshintrc
+++ b/.jshintrc
@@ -1 +1 @@
-{"esversion": 6, "esnext": false}
+{"esversion": 11, "esnext": false}
diff --git a/.nvmrc b/.nvmrc
index 8326e27f9..21651351e 100644
--- a/.nvmrc
+++ b/.nvmrc
@@ -1 +1 @@
-22.3.0
+24.10.0
diff --git a/README.md b/README.md
index 42d25aaf6..6748f7da8 100644
--- a/README.md
+++ b/README.md
@@ -24,25 +24,15 @@ Our other repositories are:
 
 ## Before You Start
 
-You will need the following items:
+### Pre-requisites
 
-- An active cloud.gov account with the correct permissions - speak with your
-  onboarding buddy for help with
-  [setting up an account](https://cloud.gov/sign-up/) (requires a `.mil`,
-  `.gov`, or `.fed.us` email address) and getting access to the
-  `notify-local-dev` and `notify-staging` spaces.
-- Admin privileges and SSH access on your machine; you may need to work with
-  your organization's IT support staff if you're not sure or don't currently
-  have this access.
+Before setting up the Admin UI, you must complete the following:
 
-**In addition, you should set up the Notify.gov API first!**
+1. **Set up the Notify.gov API first** - [Follow the complete API setup instructions here](https://github.com/GSA/notifications-api#before-you-start). The API is required for the Admin UI to run and handles most of the system dependencies (Homebrew, Python, Poetry, Terraform, etc.).
 
-[Follow the instructions here to set up the Notify.gov API.](https://github.com/GSA/notifications-api#before-you-start)
+2. **Cloud.gov account** - An active cloud.gov account with access to the `notify-local-dev` and `notify-staging` spaces. Contact your onboarding buddy for help with [setting up an account](https://cloud.gov/sign-up/) (requires a `.mil`, `.gov`, or `.fed.us` email address).
 
-The Notify.gov API is required in order for the Notify.gov Admin UI to run, and
-it will also take care of many of the steps that are listed here. The sections
-that are a repeat from the API setup are flagged with an **[API Step]** label
-in front of them.
+3. **Admin privileges** - Admin privileges and SSH access on your machine. Work with your organization's IT support staff if you need help with this.
 
 ## Local Environment Setup
 
@@ -50,187 +40,19 @@ This project is set up to work with
 [nvm (Node Version Manager)](https://github.com/nvm-sh/nvm#installing-and-updating)
 for managing and using Node.js (version 22.3.0) and the `npm` package manager.
 
-These instructions will walk you through how to set your machine up with all of
-the required tools for this project.
-
 ### Docker installation
 
 If you are using VS Code, there are also instructions for
 [running inside Docker](./docs/docker-remote-containers.md).
 
-### [API Step] Project Pre-Requisite Setup
-
-On MacOS, using [Homebrew](https://brew.sh/) for package management is highly
-recommended. This helps avoid some known installation issues. Start by following
-the installation instructions on the Homebrew homepage.
-
-**Note:** You will also need Xcode or the Xcode Command Line Tools installed. The
-quickest way to do this is is by installing the command line tools in the shell:
-
-```sh
-xcode-select –-install
-```
-
-#### [API Step] Homebrew Setup
-
-If this is your first time installing Homebrew on your machine, you may need to
-add its binaries to your system's `$PATH` environment variable so that you can
-use the `brew` command. Try running `brew help` to see if Homebrew is
-recognized and runs properly. If that fails, then you'll need to add a
-configuration line to wherever your `$PATH` environment variable is set.
-
-Your system `$PATH` environment variable is likely set in one of these
-locations:
-
-For BASH shells:
-
-- `~/.bashrc`
-- `~/.bash_profile`
-- `~/.profile`
-
-For ZSH shells:
-
-- `~/.zshrc`
-- `~/.zprofile`
-
-There may be different files that you need to modify for other shell
-environments.
-
-Which file you need to modify depends on whether or not you are running an
-interactive shell or a login shell
-(see [this Stack Overflow post](https://stackoverflow.com/questions/18186929/what-are-the-differences-between-a-login-shell-and-interactive-shell)
-for an explanation of the differences). If you're still not sure, please ask
-the team for help!
-
-Once you determine which file you'll need to modify, add these lines before any
-lines that add or modify the `$PATH` environment variable; near or at the top
-of the file is appropriate:
-
-```sh
-# Homebrew setup
-eval "$(/opt/homebrew/bin/brew shellenv)"
-```
-
-This will make sure Homebrew gets setup correctly. Once you make these changes,
-either start a new shell session or source the file
-(`source ~/.FILE-YOU-MODIFIED`) you modified to have your system recognize the
-changes.
-
-Verify that Homebrew is now working by trying to run `brew help` again.
-
-### [API Step] System-Level Package Installation
-
-There are several packages you will need to install for your system in order to
-get the app running (and these are good to have in general for any software
-development).
-
-Start off with these packages since they're quick and don't require additional
-configuration after installation to get working out of the box:
-
-- [jq](https://stedolan.github.io/jq/) - for working with JSON in the command
-  line
-- [git](https://git-scm.com/) - for version control management
-- [tenv](https://github.com/tofuutils/tenv) - for managing
-  [Terraform](https://www.terraform.io/) installations
-- [cf-cli@8](https://docs.cloudfoundry.org/cf-cli/install-go-cli.html) - for
-  working with a Cloud Foundry platform (e.g., cloud.gov)
-- [vim](https://www.vim.org/) - for editing files more easily in the command
-  line
-- [wget](https://www.gnu.org/software/wget/) - for retrieving files in the
-  command line
-
-You can install them by running the following:
-
-```sh
-brew install jq git tenv cloudfoundry/tap/cf-cli@8 vim wget
-```
-
-#### [API Step] Terraform Installation
-
-As a part of the installation above, you just installed `tenv` to manage
-Terraform installations. This is great, but you still need to install Terraform
-itself, which can be done with this command:
-
-```sh
-tenv
-```
-
-This will open a menu for you; choose Terraform, then choose the latest stable
-version.
-
-_NOTE: This project currently uses the latest `1.12.x release of Terraform._
-
-#### [API Step] Python Installation
-
-Now we're going to install a tool to help us manage Python versions and
-virtual environments on our system. First, we'll install
-[pyenv](https://github.com/pyenv/pyenv) and one of its plugins,
-[pyenv-virtualenv](https://github.com/pyenv/pyenv-virtualenv), with Homebrew:
-
-```sh
-brew install pyenv pyenv-virtualenv
-```
-
-When these finish installing, you'll need to make another adjustment in the
-file that you adjusted for your `$PATH` environment variable and Homebrew's
-setup. Open the file, and add these lines to it:
-
-```
-# pyenv setup
-export PYENV_ROOT="$HOME/.pyenv"
-command -v pyenv >/dev/null || export PATH="$PYENV_ROOT/bin:$PATH"
-eval "$(pyenv init -)"
-eval "$(pyenv virtualenv-init -)"
-```
-
-Once again, start a new shell session or source the file in your current shell
-session to make the changes take effect.
-
-Now we're ready to install the Python version we need with `pyenv`, like so:
-
-```sh
-pyenv install 3.13
-```
-
-This will install the latest version of Python 3.13.
-
-_NOTE: This project currently runs on Python 3.13.x._
-
-#### [API Step] Python Dependency Installation
-
-Lastly, we need to install the tool we use to manage Python dependencies within
-the project, which is [poetry](https://python-poetry.org/).
-
-Visit the
-[official installer instructions page](https://python-poetry.org/docs/#installing-with-the-official-installer)
-and follow the steps to install Poetry directly with the script.
-
-This will ensure `poetry` doesn't conflict with any project virtual environments
-and can update itself properly.
-
-#### Node.js and npm Installation
+### Node.js and npm Installation
 
 The project will manage most of the Node.js pieces for you, but you will need to
-install
-[nvm (Node Version Manager)](https://github.com/nvm-sh/nvm#installing-and-updating)
-in order for things to work.
+install [nvm (Node Version Manager)](https://github.com/nvm-sh/nvm#installing-and-updating).
 
-Follow the steps in the installation instructions to get `nvm` installed with
-the install script they provide, and double check that the file that you
-adjusted for your `$PATH` environment variable and Homebrew's setup is properly
-updated with the `nvm` setup as well.
-
-Open the file and check for the `nvm` setup lines; if they're not there, then
-add the lines found in the
-[nvm installation instructions](https://github.com/nvm-sh/nvm#install--update-script)
-to to the file after the `pyenv` section you created, e.g.:
-
-```
-# nvm setup
-export NVM_DIR="$HOME/.nvm"
-[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"  # This loads nvm
-[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"  # This loads nvm bash_completion
-```
+Follow the [nvm installation instructions](https://github.com/nvm-sh/nvm#installing-and-updating)
+to install it with the provided script. The installation will automatically set up
+your shell configuration.
 
 ### First-Time Project Setup
 
@@ -255,7 +77,7 @@ pyenv virtualenv 3.13.2 notify-admin
 pyenv local notify-admin
 ```
 
-_If you're not sure which version of Python was installed with `pyenv`, you can check by running `pyenv versions` and it'll list everything available currently._
+_NOTE: If you're not sure which version of Python was installed with `pyenv`, you can check by running `pyenv versions` and it'll list everything available currently._
 
 Now [log into cloud.gov](https://cloud.gov/docs/getting-started/setup/#set-up-the-command-line)
 in the command line by using this command:
@@ -309,7 +131,7 @@ pyenv local notify-admin
 At this point, proceed with the rest of the instructions here in the README and
 you'll be set with an upgraded version of Python.
 
-_If you're not sure about the details of your current virtual environment, you can run `poetry env info` to get more information. If you've been using `pyenv` for everything, you can also see all available virtual environments with `pyenv virtualenvs`._
+_NOTE: If you're not sure about the details of your current virtual environment, you can run `poetry env info` to get more information. If you've been using `pyenv` for everything, you can also see all available virtual environments with `pyenv virtualenvs`._
 
 
 #### Poetry upgrades ####
@@ -373,7 +195,7 @@ make bootstrap
 This command is handled by the `Makefile` file in the root project directory, as
 are a few others.
 
-_NOTE: You'll want to occasionally run `make bootstrap` to keep your project up-to-date, especially when there are dependency updates._
+_NOTE: Run `make bootstrap` again whenever you pull new changes that include dependency updates or when you encounter issues with your development environment. This ensures your project stays up-to-date._
 
 Now you can run the web server and background workers for asynchronous jobs:
 
@@ -387,9 +209,8 @@ API is running as well!
 
 ## Creating a 'First User' in the database
 
-After you have completed all setup steps, you will be unable to log in, because there
-will not be a user in the database to link to the login.gov account you are using. So
-you will need to create that user in your database using the 'create-test-user' command.
+To login as a user in the database, first create that user with the `create-test-user`
+command. There will then be a user to link to your login.gov account.
 
 Open a terminal pointing to the api project and then run this command.
 
@@ -413,23 +234,34 @@ adding a new hook), use `poetry run pre-commit run --all-files`.
 
 The configuration is stored in `.pre-commit-config.yaml`. In that config, there
 are links to the repos from which the hooks are pulled, so hop through there if
-ou want a detailed description of what each one is doing.
+you want a detailed description of what each one is doing.
 
 We do not maintain any hooks in this repository.
 
 ## Python Dependency Management
 
 We're using [`Poetry`](https://python-poetry.org/) for managing our Python
-dependencies and local virtual environments. When it comes to managing the
-Python dependencies, there are a couple of things to bear in mind.
+dependencies and local virtual environments.
 
-For situations where you manually manipulate the `pyproject.toml` file, you
-should use the `make py-lock` command to sync the `poetry.lock` file. This will
+This project has two key dependency files that must be managed together:
+
+- `pyproject.toml` - Contains the dependency specifications
+- `poetry.lock` - Contains the exact versions of all dependencies (including transitive ones)
+
+### Managing Dependencies
+
+There are two approaches for updating dependencies:
+
+#### 1. Manual manipulation of `pyproject.toml`
+
+If you manually edit the `pyproject.toml` file, you should use the `make py-lock` command to sync the `poetry.lock` file. This will
 ensure that you don't inadvertently bring in other transitive dependency updates
 that have not been fully tested with the project yet.
 
-If you're just trying to update a dependency to a newer (or the latest) version,
-you should let Poetry take care of that for you by running the following:
+#### 2. Using Poetry to update dependencies (recommended)
+
+If you're updating a dependency to a newer (or the latest) version,
+let Poetry handle it by running:
 
 ```sh
 poetry update <dependency> [<dependency>...]
@@ -490,7 +322,7 @@ the VSCode dev container.
 - [JavaScript documentation](https://github.com/alphagov/notifications-manuals/wiki/JavaScript-Documentation)
 - [Updating dependencies](https://github.com/alphagov/notifications-manuals/wiki/Dependencies)
 
-## License && public domain
+## License & public domain
 
 Work through
 [commit `543be77`](https://github.com/GSA/notifications-admin/commit/543be77776b64fddb6ba70fbb015ecd81a372478)
diff --git a/app/assets/javascripts/collapsibleCheckboxes.js b/app/assets/javascripts/collapsibleCheckboxes.js
index 7139e9a1b..eca642eb1 100644
--- a/app/assets/javascripts/collapsibleCheckboxes.js
+++ b/app/assets/javascripts/collapsibleCheckboxes.js
@@ -1,11 +1,9 @@
 (function (window) {
   "use strict";
 
-  const USWDS = window.USWDS || {};
-
   function Summary (module) {
     this.module = module;
-    this.$el = module.$formGroup.find('.selection-summary').first();
+    this.el = module.formGroup.querySelector('.selection-summary');
     this.fieldLabel = module.fieldLabel;
     this.total = module.total;
     this.addContent();
@@ -20,14 +18,17 @@
     }[field] || `No ${field}s`)
   };
   Summary.prototype.addContent = function() {
-    const $hint = this.module.$formGroup.find('.usa-hint');
-    this.$text = $(`<p class="selection-summary__text" />`);
+    const hint = this.module.formGroup.querySelector('.usa-hint');
+    this.text = document.createElement('p');
+    this.text.className = 'selection-summary__text';
 
-    if (this.fieldLabel === 'folder') { this.$text.addClass('selection-summary__text--folders'); }
+    if (this.fieldLabel === 'folder') { this.text.classList.add('selection-summary__text--folders'); }
 
-    this.$el.attr('id', $hint.attr('id'));
-    this.$el.append(this.$text);
-    $hint.remove();
+    if (hint) {
+      this.el.setAttribute('id', hint.getAttribute('id'));
+      hint.remove();
+    }
+    this.el.appendChild(this.text);
   };
   Summary.prototype.update = function(selection) {
     let template;
@@ -40,19 +41,19 @@
       template = 'none';
     }
 
-    this.$text.html(this.templates[template](selection, this.total, this.fieldLabel));
+    this.text.innerHTML = this.templates[template](selection, this.total, this.fieldLabel);
   };
   Summary.prototype.bindEvents = function () {
     // take summary out of tab order when focus moves
-    this.$el.on('blur', (e) => $(this).attr('tabindex', '-1'));
+    this.el.addEventListener('blur', (e) => e.target.setAttribute('tabindex', '-1'));
   };
 
   function Footer (module) {
     this.module = module;
     this.fieldLabel = module.fieldLabel;
-    this.fieldsetId = module.$fieldset.attr('id');
-    this.$el = this.getEl(this.module.expanded);
-    this.module.$formGroup.append(this.$el);
+    this.fieldsetId = module.fieldset.getAttribute('id');
+    this.el = this.getEl(this.module.expanded);
+    this.module.formGroup.appendChild(this.el);
   }
   Footer.prototype.buttonContent = {
     change: (fieldLabel) => `Choose ${fieldLabel}s`,
@@ -63,37 +64,37 @@
     const buttonContent = this.buttonContent[buttonState](this.fieldLabel);
     const stickyClass = expanded ? ' js-stick-at-bottom-when-scrolling' : '';
 
-    return $(`<div class="selection-footer${stickyClass} margin-top-2">
-              <button
+    const div = document.createElement('div');
+    div.className = `selection-footer${stickyClass} margin-top-2`;
+    div.innerHTML = `<button
                 class="usa-button usa-button--outline selection-footer__button"
                 aria-expanded="${expanded ? 'true' : 'false'}"
                 aria-controls="${this.fieldsetId}">
               ${buttonContent}
-              </button>
-            </div>`);
+              </button>`;
+    return div;
   };
   Footer.prototype.update = function (expanded) {
-    this.$el.remove();
-    this.$el = this.getEl(expanded);
+    this.el.remove();
+    this.el = this.getEl(expanded);
 
-    this.module.$formGroup.append(this.$el);
+    this.module.formGroup.appendChild(this.el);
 
   };
 
   function CollapsibleCheckboxes () {}
-  CollapsibleCheckboxes.prototype._focusTextElement = ($el) => {
-    $el
-      .attr('tabindex', '-1')
-      .focus();
+  CollapsibleCheckboxes.prototype._focusTextElement = (el) => {
+    el.setAttribute('tabindex', '-1');
+    el.focus();
   };
   CollapsibleCheckboxes.prototype.start = function(component) {
-    this.$component = $(component);
-    this.$formGroup = this.$component.find('.usa-form-group').first();
-    this.$fieldset = this.$formGroup.find('fieldset').first();
-    this.$checkboxes = this.$fieldset.find('input[type=checkbox]');
-    this.fieldLabel = this.$component.data('fieldLabel');
-    this.total = this.$checkboxes.length;
-    this.legendText = this.$fieldset.find('legend').first().text().trim();
+    this.component = component;
+    this.formGroup = component.querySelector('.usa-form-group');
+    this.fieldset = this.formGroup.querySelector('fieldset');
+    this.checkboxes = this.fieldset.querySelectorAll('input[type=checkbox]');
+    this.fieldLabel = component.dataset.fieldLabel;
+    this.total = this.checkboxes.length;
+    this.legendText = this.fieldset.querySelector('legend').textContent.trim();
     this.expanded = false;
     this.checkUncheckButtonsAdded = false;
 
@@ -103,71 +104,78 @@
     this.footer = new Footer(this);
     this.summary = new Summary(this);
 
-    this.$fieldset.before(this.summary.$el);
+    this.fieldset.insertAdjacentElement('beforebegin', this.summary.el);
 
     // add custom classes
-    this.$formGroup.addClass('selection-wrapper');
-    this.$fieldset.addClass('selection-content');
+    this.formGroup.classList.add('selection-wrapper');
+    this.fieldset.classList.add('selection-content');
 
     // hide checkboxes
-    this.$fieldset.hide();
+    this.fieldset.style.display = 'none';
 
     this.bindEvents();
   };
-  CollapsibleCheckboxes.prototype.getSelection = function() { return this.$checkboxes.filter(':checked').length; };
+  CollapsibleCheckboxes.prototype.getSelection = function() {
+    return Array.from(this.checkboxes).filter(cb => cb.checked).length;
+  };
   CollapsibleCheckboxes.prototype.addHeadingHideLegend = function() {
-    const headingLevel = this.$component.data('heading-level') || '2';
+    const headingLevel = this.component.dataset.headingLevel || '2';
 
-    this.$heading = $(`<h${headingLevel} class="heading-small"></h${headingLevel}>`);
-    this.$heading.text(this.legendText);
-    this.$fieldset.before(this.$heading);
+    this.heading = document.createElement(`h${headingLevel}`);
+    this.heading.className = 'heading-small';
+    this.heading.textContent = this.legendText;
+    this.fieldset.insertAdjacentElement('beforebegin', this.heading);
 
-    this.$fieldset.find('legend').addClass('usa-sr-only');
+    this.fieldset.querySelector('legend').classList.add('usa-sr-only');
   };
   CollapsibleCheckboxes.prototype.addCheckUncheckAllButtons = function() {
-    const $buttonsContainer = $('<div class="check-uncheck-all-buttons margin-bottom-2"></div>');
+    const buttonsContainer = document.createElement('div');
+    buttonsContainer.className = 'check-uncheck-all-buttons margin-bottom-2';
 
-    this.$toggleAllButton = $('<button type="button" class="usa-button usa-button--outline usa-button--small">Select all</button>');
+    this.toggleAllButton = document.createElement('button');
+    this.toggleAllButton.type = 'button';
+    this.toggleAllButton.className = 'usa-button usa-button--outline usa-button--small';
+    this.toggleAllButton.textContent = 'Select all';
 
-    $buttonsContainer.append(this.$toggleAllButton);
+    buttonsContainer.appendChild(this.toggleAllButton);
 
-    this.summary.$el.after($buttonsContainer);
+    this.summary.el.insertAdjacentElement('afterend', buttonsContainer);
 
-    this.$toggleAllButton.on('click', this.toggleAll.bind(this));
+    this.toggleAllButton.addEventListener('click', this.toggleAll.bind(this));
 
     this.updateToggleButtonText();
   };
   CollapsibleCheckboxes.prototype.toggleAll = function(e) {
     e.preventDefault();
     e.stopPropagation();
-    const allChecked = this.$checkboxes.filter(':checked').length === this.$checkboxes.length;
+    const allChecked = Array.from(this.checkboxes).filter(cb => cb.checked).length === this.checkboxes.length;
 
     if (allChecked) {
-      this.$checkboxes.prop('checked', false);
+      this.checkboxes.forEach(cb => cb.checked = false);
     } else {
-      this.$checkboxes.prop('checked', true);
+      this.checkboxes.forEach(cb => cb.checked = true);
     }
 
     this.handleSelection();
     this.updateToggleButtonText();
   };
   CollapsibleCheckboxes.prototype.updateToggleButtonText = function() {
-    if (!this.$toggleAllButton) return;
+    if (!this.toggleAllButton) return;
 
-    const checkedCount = this.$checkboxes.filter(':checked').length;
-    const allChecked = checkedCount === this.$checkboxes.length;
+    const checkedCount = Array.from(this.checkboxes).filter(cb => cb.checked).length;
+    const allChecked = checkedCount === this.checkboxes.length;
 
     if (allChecked) {
-      this.$toggleAllButton.text('Deselect all');
+      this.toggleAllButton.textContent = 'Deselect all';
     } else {
-      this.$toggleAllButton.text('Select all');
+      this.toggleAllButton.textContent = 'Select all';
     }
   };
   CollapsibleCheckboxes.prototype.expand = function(e) {
     if (e !== undefined) { e.preventDefault(); }
 
     if (!this.expanded) {
-      this.$fieldset.show();
+      this.fieldset.style.display = '';
       this.expanded = true;
       this.summary.update(this.getSelection());
       this.footer.update(this.expanded);
@@ -176,31 +184,31 @@
         this.addCheckUncheckAllButtons();
         this.checkUncheckButtonsAdded = true;
       } else {
-        if (this.$toggleAllButton) {
-          this.$toggleAllButton.parent().show();
+        if (this.toggleAllButton) {
+          this.toggleAllButton.parentElement.style.display = '';
         }
       }
     }
 
     // shift focus whether expanded or not
-    this._focusTextElement(this.$fieldset);
+    this._focusTextElement(this.fieldset);
   };
   CollapsibleCheckboxes.prototype.collapse = function(e) {
     if (e !== undefined) { e.preventDefault(); }
 
     if (this.expanded) {
-      this.$fieldset.hide();
+      this.fieldset.style.display = 'none';
       this.expanded = false;
       this.summary.update(this.getSelection());
       this.footer.update(this.expanded);
 
-      if (this.$toggleAllButton) {
-        this.$toggleAllButton.parent().hide();
+      if (this.toggleAllButton) {
+        this.toggleAllButton.parentElement.style.display = 'none';
       }
     }
 
     // shift focus whether expanded or not
-    this._focusTextElement(this.summary.$text);
+    this._focusTextElement(this.summary.text);
   };
   CollapsibleCheckboxes.prototype.handleClick = function(e) {
     if (this.expanded) {
@@ -214,10 +222,15 @@
     this.updateToggleButtonText();
   };
   CollapsibleCheckboxes.prototype.bindEvents = function() {
-    const self = this;
+    this.formGroup.addEventListener('click', (e) => {
+      if (e.target.closest('.usa-button')) {
+        this.handleClick.call(this, e);
+      }
+    });
 
-    this.$formGroup.on('click', '.usa-button', this.handleClick.bind(this));
-    this.$checkboxes.on('click', this.handleSelection.bind(this));
+    this.checkboxes.forEach(cb => {
+      cb.addEventListener('click', this.handleSelection.bind(this));
+    });
 
     this.summary.bindEvents(this);
   };
diff --git a/app/assets/javascripts/copyToClipboard.js b/app/assets/javascripts/copyToClipboard.js
index a8126f09f..c4d10b4f7 100644
--- a/app/assets/javascripts/copyToClipboard.js
+++ b/app/assets/javascripts/copyToClipboard.js
@@ -1,98 +1,70 @@
 (function(window) {
   "use strict";
 
-  if (!document.queryCommandSupported('copy')) return;
+  // Only initialize if modern Clipboard API is available
+  if (!navigator.clipboard) return;
 
   window.NotifyModules['copy-to-clipboard'] = function() {
 
-    const states = {
-      'valueVisible': (options) => `
-        <span class="copy-to-clipboard__value margin-bottom-1">${options.valueLabel ? '<span class="usa-sr-only">' + options.thing + ': </span>' : ''}${options.value}</span>
-        <span class="copy-to-clipboard__notice" aria-live="assertive">
-          ${options.onload ? '' : options.thing + ' returned to page, press button to copy to clipboard'}
-        </span>
-        <button class="usa-button usa-button--outline copy-to-clipboard__button--copy">
-          Copy ${options.thing} to clipboard${options.name ? '<span class="usa-sr-only"> for ' + options.name + '</span>' : ''}
-        </button>
-      `,
-      'valueCopied': (options) => `
-        <span class="copy-to-clipboard__notice" aria-live="assertive">
-          <span class="usa-sr-only">${options.thing} </span>Copied to clipboard<span class="usa-sr-only">, press button to show in page</span>
-        </span>
-        <button class="usa-button copy-to-clipboard__button--show">
-          Show ${options.thing}${options.name ? '<span class="usa-sr-only"> for ' + options.name + '</span>' : ''}
-        </button>
-      `
-    };
-
-    this.getRangeFromElement = function (copyableElement) {
-      const range = document.createRange();
-      const childNodes = Array.prototype.slice.call(copyableElement.childNodes);
-      let prefixIndex = -1;
-
-      childNodes.forEach((el, idx) => {
-        if ((el.nodeType === 1) && el.classList.contains('usa-sr-only')) {
-          prefixIndex = idx;
-        }
-      });
-
-      range.selectNodeContents(copyableElement);
-      if (prefixIndex !== -1) { range.setStart(copyableElement, prefixIndex + 1); }
-
-      return range;
-    };
-
-    this.copyValueToClipboard = function(copyableElement, callback) {
-      var selection = window.getSelection ? window.getSelection() : document.selection,
-          range = this.getRangeFromElement(copyableElement);
-
-      selection.removeAllRanges();
-      selection.addRange(range);
-      document.execCommand('copy');
-      selection.removeAllRanges();
-      callback();
+    /**
+     * Copy text to clipboard using modern Clipboard API
+     * @param {string} text - The text to copy
+     * @param {Function} callback - Called after successful copy
+     */
+    this.copyValueToClipboard = async function(text, callback) {
+      try {
+        await navigator.clipboard.writeText(text);
+        callback();
+      } catch (err) {
+        console.error('Failed to copy to clipboard:', err);
+      }
     };
 
     this.start = function(component) {
 
-      const $component = $(component),
-            stateOptions = {
-              value: $component.data('value'),
-              thing: $component.data('thing')
-            },
-            name = $component.data('name');
+      const value = component.dataset.value;
+      const thing = component.dataset.thing;
+      const name = component.dataset.name;
 
-      // if the name is distinct from the thing:
-      // - it will be used in the rendering
-      // - the value won't be identified by a heading so needs its own label
-      if (name !== stateOptions.thing) {
-        stateOptions.name = name;
-        stateOptions.valueLabel = true;
-      }
+      // Determine button label
+      const isMultiple = name !== thing;
+      const buttonLabel = isMultiple
+        ? `Copy ${thing}`
+        : `Copy ${thing} to clipboard`;
+      const srSuffix = isMultiple ? ` for ${name}` : '';
 
-      $component
-        .addClass('copy-to-clipboard')
-        .css('min-height', $component.height())
-        .html(states.valueVisible($.extend({ 'onload': true }, stateOptions)))
-        .on(
-          'click', '.copy-to-clipboard__button--copy', () =>
-            this.copyValueToClipboard(
-              $('.copy-to-clipboard__value', component)[0], () =>
-                $component
-                  .html(states.valueCopied(stateOptions))
-                  .find('.usa-button').focus()
-            )
-        )
-        .on(
-          'click', '.copy-to-clipboard__button--show', () =>
-            $component
-              .html(states.valueVisible(stateOptions))
-              .find('.usa-button').focus()
-        );
+      // Create simple HTML structure
+      component.classList.add('copy-to-clipboard');
+      component.innerHTML = `
+        <div class="copy-to-clipboard__value">${value}</div>
+        <button class="usa-button usa-button--outline copy-to-clipboard__button" type="button">
+          ${buttonLabel}<span class="usa-sr-only">${srSuffix}</span>
+        </button>
+        <span class="usa-sr-only" aria-live="polite" aria-atomic="true"></span>
+      `;
 
-      if ('stickAtBottomWhenScrolling' in window.NotifyModules) {
-        window.NotifyModules.stickAtBottomWhenScrolling.recalculate();
-      }
+      const button = component.querySelector('.copy-to-clipboard__button');
+      const srAnnouncement = component.querySelector('[aria-live]');
+
+      // Handle copy button click
+      button.addEventListener('click', () => {
+        this.copyValueToClipboard(value, () => {
+          // Change button text to "Copied!"
+          const originalText = button.innerHTML;
+          button.innerHTML = `Copied!<span class="usa-sr-only">${srSuffix}</span>`;
+          button.disabled = true;
+
+          // Announce to screen readers
+          srAnnouncement.textContent = `${thing} copied to clipboard`;
+
+          // Reset button after 2 seconds
+          setTimeout(() => {
+            button.innerHTML = originalText;
+            button.disabled = false;
+            srAnnouncement.textContent = '';
+          }, 2000);
+        });
+      });
 
     };
   };
diff --git a/app/assets/javascripts/enhancedTextbox.js b/app/assets/javascripts/enhancedTextbox.js
index 300afc03d..7a279034f 100644
--- a/app/assets/javascripts/enhancedTextbox.js
+++ b/app/assets/javascripts/enhancedTextbox.js
@@ -11,61 +11,71 @@
 
     this.start = function(element) {
 
-      let textarea = $(element);
+      let textarea = element;
       let visibleTextbox;
 
       this.highlightPlaceholders = (
-        typeof textarea.data('highlightPlaceholders') === 'undefined' ||
-        !!textarea.data('highlightPlaceholders')
+        typeof textarea.dataset.highlightPlaceholders === 'undefined' ||
+        textarea.dataset.highlightPlaceholders !== 'false'
       );
 
-      this.$textbox = textarea
-        .wrap(`
-          <div class='textbox-highlight-wrapper' />
-        `)
-        .after(this.$background = $(`
-          <div class="textbox-highlight-background" aria-hidden="true" />
-        `))
-        .on("input", this.update);
+      // Create wrapper div
+      const wrapper = document.createElement('div');
+      wrapper.className = 'textbox-highlight-wrapper';
 
-      $(window).on("resize", this.resize);
+      // Insert wrapper before textarea and move textarea into it
+      textarea.parentNode.insertBefore(wrapper, textarea);
+      wrapper.appendChild(textarea);
 
-      visibleTextbox = this.$textbox.clone().appendTo("body").css({
-        position: 'absolute',
-        visibility: 'hidden',
-        display: 'block'
-      });
-      this.initialHeight = visibleTextbox.height();
+      // Create background div
+      this.background = document.createElement('div');
+      this.background.className = 'textbox-highlight-background';
+      this.background.setAttribute('aria-hidden', 'true');
 
-      this.$background.css({
-        'border-width': this.$textbox.css('border-width')
-      });
+      // Insert background after textarea
+      textarea.parentNode.insertBefore(this.background, textarea.nextSibling);
+
+      this.textbox = textarea;
+
+      this.textbox.addEventListener("input", this.update);
+      window.addEventListener("resize", this.resize);
+
+      // Clone textbox to measure initial height
+      visibleTextbox = this.textbox.cloneNode(true);
+      visibleTextbox.style.position = 'absolute';
+      visibleTextbox.style.visibility = 'hidden';
+      visibleTextbox.style.display = 'block';
+      document.body.appendChild(visibleTextbox);
+
+      this.initialHeight = visibleTextbox.offsetHeight;
+
+      const borderWidth = window.getComputedStyle(this.textbox).borderWidth;
+      this.background.style.borderWidth = borderWidth;
 
       visibleTextbox.remove();
 
-      this.$textbox
-        .trigger("input");
+      this.textbox.dispatchEvent(new Event("input"));
 
     };
 
     this.resize = () => {
 
-      this.$background.width(this.$textbox.width());
+      const computedStyle = window.getComputedStyle(this.textbox);
+      const width = parseFloat(computedStyle.width);
+      this.background.style.width = width + 'px';
 
-      this.$textbox.height(
-        Math.max(
-          this.initialHeight,
-          this.$background.outerHeight()
-        )
-      );
+      const backgroundHeight = this.background.offsetHeight;
+
+      this.textbox.style.height = Math.max(this.initialHeight, backgroundHeight) + 'px';
 
-      if ('stickAtBottomWhenScrolling' in window.NotifyModules) {
-        window.NotifyModules.stickAtBottomWhenScrolling.recalculate();
-      }
 
     };
 
-    this.contentEscaped = () => $('<div/>').text(this.$textbox.val()).html();
+    this.contentEscaped = () => {
+      const div = document.createElement('div');
+      div.textContent = this.textbox.value;
+      return div.innerHTML;
+    };
 
     this.contentReplaced = () => this.contentEscaped().replace(
       tagPattern, (match, name, separator, value) => value && separator ?
@@ -75,9 +85,8 @@
 
     this.update = () => {
 
-      this.$background.html(
-        this.highlightPlaceholders ? this.contentReplaced() : this.contentEscaped()
-      );
+      this.background.innerHTML =
+        this.highlightPlaceholders ? this.contentReplaced() : this.contentEscaped();
 
       this.resize();
 
diff --git a/app/assets/javascripts/errorBanner.js b/app/assets/javascripts/errorBanner.js
index 71e55e75d..2423c8c75 100644
--- a/app/assets/javascripts/errorBanner.js
+++ b/app/assets/javascripts/errorBanner.js
@@ -1,6 +1,10 @@
 export const ErrorBanner = {
-  hideBanner: () => $('.banner-dangerous').addClass('display-none'),
-  showBanner: () => $('.banner-dangerous').removeClass('display-none')
+  hideBanner: () => {
+    document.querySelectorAll('.banner-dangerous').forEach(el => el.classList.add('display-none'));
+  },
+  showBanner: () => {
+    document.querySelectorAll('.banner-dangerous').forEach(el => el.classList.remove('display-none'));
+  }
 };
 
 window.NotifyModules = window.NotifyModules || {};
diff --git a/app/assets/javascripts/errorTracking.js b/app/assets/javascripts/errorTracking.js
index d69620f60..fcb8da669 100644
--- a/app/assets/javascripts/errorTracking.js
+++ b/app/assets/javascripts/errorTracking.js
@@ -4,15 +4,13 @@
   window.NotifyModules['track-error'] = function() {
 
     this.start = function(element) {
-      var component = $(element);
-
       // Track error to analytics if available
       if (window.NotifyModules && window.NotifyModules.analytics && window.NotifyModules.analytics.trackEvent) {
         window.NotifyModules.analytics.trackEvent(
           'Error',
-          component.data('error-type'),
+          element.dataset.errorType,
           {
-            'label': component.data('error-label')
+            'label': element.dataset.errorLabel
           }
         );
       }
diff --git a/app/assets/javascripts/fileUpload.js b/app/assets/javascripts/fileUpload.js
index 2af760a6e..0ae83c4b3 100644
--- a/app/assets/javascripts/fileUpload.js
+++ b/app/assets/javascripts/fileUpload.js
@@ -28,30 +28,38 @@ function initUploadStatusAnnouncer() {
   "use strict";
 
   window.NotifyModules['file-upload'] = function() {
-    this.submit = () => this.$form.trigger('submit');
+    this.submit = () => this.form.submit();
 
     this.showCancelButton = () => {
-      $('.file-upload-button', this.$form).replaceWith(`
-        <button class='usa-button uploading-button' aria-disabled="true" tabindex="0">
-          Uploading<span class="loading-spinner" role="status" aria-label="Uploading"></span>
-        </button>
-      `);
+      const uploadButton = this.form.querySelector('.file-upload-button');
+      if (uploadButton) {
+        uploadButton.outerHTML = `
+          <button class='usa-button uploading-button' aria-disabled="true" tabindex="0">
+            Uploading<span class="loading-spinner" role="status" aria-label="Uploading"></span>
+          </button>
+        `;
+      }
     };
 
     this.start = function(component) {
-      this.$form = $(component);
+      this.form = component;
 
-      this.$form.on('click', '[data-module="upload-trigger"]', function () {
-        const inputId = $(this).data('file-input-id');
-        const fileInput = document.getElementById(inputId);
-        if (fileInput) fileInput.click();
+      this.form.addEventListener('click', (event) => {
+        const trigger = event.target.closest('[data-module="upload-trigger"]');
+        if (trigger) {
+          const inputId = trigger.dataset.fileInputId;
+          const fileInput = document.getElementById(inputId);
+          if (fileInput) fileInput.click();
+        }
       });
 
-      $(window).on("pageshow", () => this.$form[0].reset());
+      window.addEventListener("pageshow", () => this.form.reset());
 
-      this.$form.on('change', '.file-upload-field', () => {
-        this.submit();
-        this.showCancelButton();
+      this.form.addEventListener('change', (event) => {
+        if (event.target.closest('.file-upload-field')) {
+          this.submit();
+          this.showCancelButton();
+        }
       });
     };
   };
diff --git a/app/assets/javascripts/index.js b/app/assets/javascripts/index.js
index f451de399..a7cd56fbb 100644
--- a/app/assets/javascripts/index.js
+++ b/app/assets/javascripts/index.js
@@ -1,10 +1,6 @@
 // Webpack Entry Point
 
 // Vendor libraries
-import $ from 'jquery';
-window.jQuery = window.$ = $;
-
-import './jquery-expose.js';
 import 'query-command-supported';
 import 'textarea-caret';
 import * as cbor from 'cbor-js';
@@ -74,11 +70,9 @@ import './fileUpload.js';
 import './errorTracking.js';
 import './templateFolderForm.js';
 import './collapsibleCheckboxes.js';
-import './radioSlider.js';
 import './updateStatus.js';
 import './main.js';
 import './listEntry.js';
-import './stick-to-window-when-scrolling.js';
 import './totalMessagesChart.js';
 import './activityChart.js';
 import './job-polling.js';
diff --git a/app/assets/javascripts/jquery-expose.js b/app/assets/javascripts/jquery-expose.js
deleted file mode 100644
index 11eb53e1a..000000000
--- a/app/assets/javascripts/jquery-expose.js
+++ /dev/null
@@ -1,7 +0,0 @@
-// Expose jQuery and other libraries to window for legacy code
-if (typeof jQuery !== 'undefined') {
-  window.jQuery = window.$ = jQuery;
-}
-if (typeof getCaretCoordinates !== 'undefined') {
-  window.getCaretCoordinates = getCaretCoordinates;
-}
diff --git a/app/assets/javascripts/listEntry.js b/app/assets/javascripts/listEntry.js
index 6a6087efa..9161b22d2 100644
--- a/app/assets/javascripts/listEntry.js
+++ b/app/assets/javascripts/listEntry.js
@@ -1,22 +1,28 @@
 (function (window) {
   'use strict';
 
+  // This module creates dynamic add/remove input lists. It lets users add multiple entries
+  // (like email addresses or domains) with "Add another" and "Remove" buttons. It handles
+  // min/max entry limits, focus management, and preserves input attributes.
+  // We're keeping this for now but it's not currently being used in the application.
+
   var Modules = window.NotifyModules;
   var lists = [],
       listEntry,
       ListEntry;
 
   ListEntry = function (elm) {
-    var $elm = $(elm),
-        idPattern = $elm.prop('id');
+    var idPattern = elm.id;
 
-    if (!idPattern) { return false; }
+    if (!idPattern) {
+      return false;
+    }
     this.idPattern = idPattern;
     this.elementSelector = '.list-entry, .input-list__button--remove, .input-list__button--add';
     this.entries = [];
-    this.$wrapper = $elm;
+    this.wrapper = elm;
     this.minEntries = 2;
-    this.listItemName = this.$wrapper.data('listItemName');
+    this.listItemName = this.wrapper.dataset.listItemName;
     this.getSharedAttributes();
     this.getOriginalClasses();
 
@@ -26,33 +32,43 @@
     this.render();
     this.bindEvents();
   };
-  ListEntry.optionalAttributes = ['aria-describedby'];
+  ListEntry.escapeHtml = function(unsafe) {
+    if (!unsafe) return '';
+    return String(unsafe)
+      .replace(/&/g, "&amp;")
+      .replace(/</g, "&lt;")
+      .replace(/>/g, "&gt;")
+      .replace(/"/g, "&quot;")
+      .replace(/'/g, "&#039;");
+  };
   ListEntry.prototype.renderEntry = function(data) {
+    var escapeHtml = ListEntry.escapeHtml;
     return `
       <div class="list-entry">
-        <label for="${data.id}" class="usa-label">
-          <span class="usa-sr-only">${data.listItemName} number </span>${data.number}.
+        <label for="${escapeHtml(data.id)}" class="usa-label">
+          <span class="usa-sr-only">${escapeHtml(data.listItemName)} number </span>${escapeHtml(data.number)}.
         </label>
         <input
-          class="usa-input ${data.classes || ''}"
-          name="${data.name}"
-          id="${data.id}"
-          ${data.value ? `value="${data.value}"` : ''}
+          class="usa-input ${escapeHtml(data.classes || '')}"
+          name="${escapeHtml(data.name)}"
+          id="${escapeHtml(data.id)}"
+          ${data.value ? `value="${escapeHtml(data.value)}"` : ''}
           ${data.sharedAttributes}
         />
         ${data.button ? `
           <button type="button" class="usa-button usa-button--unstyled input-list__button--remove">
-            Remove<span class="usa-sr-only"> ${data.listItemName} number ${data.number}</span>
+            Remove<span class="usa-sr-only"> ${escapeHtml(data.listItemName)} number ${escapeHtml(data.number)}</span>
           </button>
         ` : ''}
       </div>
     `;
   };
   ListEntry.prototype.renderAddButton = function(data) {
-    return `<button type="button" class="usa-button usa-button--outline input-list__button--add margin-top-4">Add another ${data.listItemName} (${data.entriesLeft} remaining)</button>`;
+    var escapeHtml = ListEntry.escapeHtml;
+    return `<button type="button" class="usa-button usa-button--outline input-list__button--add margin-top-4">Add another ${escapeHtml(data.listItemName)} (${escapeHtml(data.entriesLeft)} remaining)</button>`;
   };
   ListEntry.prototype.getSharedAttributes = function () {
-    var $inputs = this.$wrapper.find('input'),
+    var inputs = this.wrapper.querySelectorAll('input'),
         generatedAttributes = ['id', 'name', 'value', 'class'],
         attributes = [],
         attrIdx,
@@ -64,15 +80,16 @@
           elmIdx = attrsByElm.length,
           existingAttributes = [],
           elmAttrs,
-          attrIdx;
+          attrIdx,
+          escapeHtml = ListEntry.escapeHtml;
 
       while (elmIdx--) {
         elmAttrs = attrsByElm[elmIdx];
         attrIdx = elmAttrs.length;
         while (attrIdx--) {
           // prevent duplicates
-          if ($.inArray(elmAttrs[attrIdx].name, existingAttributes) === -1) {
-            attrStr += ` ${elmAttrs[attrIdx].name}="${elmAttrs[attrIdx].value}"`;
+          if (existingAttributes.indexOf(elmAttrs[attrIdx].name) === -1) {
+            attrStr += ` ${escapeHtml(elmAttrs[attrIdx].name)}="${escapeHtml(elmAttrs[attrIdx].value)}"`;
             existingAttributes.push(elmAttrs[attrIdx].name);
           }
         }
@@ -80,11 +97,11 @@
       return attrStr;
     };
 
-    $inputs.each(function (idx, elm) {
+    inputs.forEach(function (elm) {
       attrIdx = elm.attributes.length;
       elmAttributes = [];
       while(attrIdx--) {
-        if ($.inArray(elm.attributes[attrIdx].name, generatedAttributes) === -1) {
+        if (generatedAttributes.indexOf(elm.attributes[attrIdx].name) === -1) {
           elmAttributes.push({
             'name': elm.attributes[attrIdx].name,
             'value': elm.attributes[attrIdx].value
@@ -99,9 +116,9 @@
     this.sharedAttributes = (attributes.length) ? getAttributesHTML(attributes) : '';
   };
   ListEntry.prototype.getOriginalClasses = function () {
-    var $firstInput = this.$wrapper.find('input').first();
-    if ($firstInput.length) {
-      var classList = $firstInput.attr('class');
+    var firstInput = this.wrapper.querySelector('input');
+    if (firstInput) {
+      var classList = firstInput.getAttribute('class');
       if (classList) {
         // Preserve any additional classes from the original input
         this.additionalClasses = classList;
@@ -114,8 +131,8 @@
   };
   ListEntry.prototype.getValues = function () {
     this.entries = [];
-    this.$wrapper.find('input').each(function (idx, elm) {
-      var val = $(elm).val();
+    this.wrapper.querySelectorAll('input').forEach(function (elm) {
+      var val = elm.value;
 
       this.entries.push(val);
     }.bind(this));
@@ -144,11 +161,12 @@
     }
   };
   ListEntry.prototype.bindEvents = function () {
-    this.$wrapper.on('click', '.input-list__button--remove', function (e) {
-      this.removeEntry($(e.target));
-    }.bind(this));
-    this.$wrapper.on('click', '.input-list__button--add', function (e) {
-      this.addEntry();
+    this.wrapper.addEventListener('click', function (e) {
+      if (e.target.closest('.input-list__button--remove')) {
+        this.removeEntry(e.target);
+      } else if (e.target.closest('.input-list__button--add')) {
+        this.addEntry();
+      }
     }.bind(this));
   };
   ListEntry.prototype.shiftFocus = function (opts) {
@@ -159,7 +177,13 @@
     } else { // opts.action === 'add'
       numberTargeted = opts.entryNumberFocused + 1;
     }
-    this.$wrapper.find('.list-entry').eq(numberTargeted - 1).find('input').focus();
+    var entries = this.wrapper.querySelectorAll('.list-entry');
+    if (entries[numberTargeted - 1]) {
+      var input = entries[numberTargeted - 1].querySelector('input');
+      if (input) {
+        input.focus();
+      }
+    }
   };
   ListEntry.prototype.removeEntryFromEntries = function (entryNumber) {
     var idx,
@@ -173,7 +197,7 @@
     }
     this.entries = newEntries;
   };
-  ListEntry.prototype.addEntry = function ($removeButton) {
+  ListEntry.prototype.addEntry = function () {
     var currentLastEntryNumber = this.entries.length;
 
     this.getValues();
@@ -181,8 +205,23 @@
     this.render();
     this.shiftFocus({ 'action' : 'add', 'entryNumberFocused' : currentLastEntryNumber });
   };
-  ListEntry.prototype.removeEntry = function ($removeButton) {
-    var entryNumber = parseInt($removeButton.find('span').text().match(/\d+/)[0], 10);
+  ListEntry.prototype.removeEntry = function (removeButton) {
+    var button = removeButton.closest('.input-list__button--remove');
+    if (!button) {
+      console.error('ListEntry: Remove button not found');
+      return;
+    }
+    var span = button.querySelector('span');
+    if (!span) {
+      console.error('ListEntry: Entry number span not found in remove button');
+      return;
+    }
+    var match = span.textContent.match(/\d+/);
+    if (!match) {
+      console.error('ListEntry: Could not find entry number in remove button');
+      return;
+    }
+    var entryNumber = parseInt(match[0], 10);
 
     this.getValues();
     this.removeEntryFromEntries(entryNumber);
@@ -190,8 +229,10 @@
     this.shiftFocus({ 'action' : 'remove', 'entryNumberFocused' : entryNumber });
   };
   ListEntry.prototype.render = function () {
-    this.$wrapper.find(this.elementSelector).remove();
-    $.each(this.entries, function (idx, entry) {
+    this.wrapper.querySelectorAll(this.elementSelector).forEach(function(el) {
+      el.remove();
+    });
+    this.entries.forEach(function (entry, idx) {
       var entryNumber = idx + 1,
           dataObj = {
             'id' : this.getId(entryNumber),
@@ -207,10 +248,10 @@
       if (entryNumber > 1) {
         dataObj.button = true;
       }
-      this.$wrapper.append(this.renderEntry(dataObj));
+      this.wrapper.insertAdjacentHTML('beforeend', this.renderEntry(dataObj));
     }.bind(this));
     if (this.entries.length < this.maxEntries) {
-      this.$wrapper.append(this.renderAddButton({
+      this.wrapper.insertAdjacentHTML('beforeend', this.renderAddButton({
         'listItemName' : this.listItemName,
         'entriesLeft' : (this.maxEntries - this.entries.length)
       }));
@@ -219,7 +260,7 @@
 
   Modules['list-entry'] = function () {
 
-    this.start = component => lists.push(new ListEntry($(component)));
+    this.start = component => lists.push(new ListEntry(component));
 
   };
 
diff --git a/app/assets/javascripts/liveSearch.js b/app/assets/javascripts/liveSearch.js
index 99243504e..01e44ead7 100644
--- a/app/assets/javascripts/liveSearch.js
+++ b/app/assets/javascripts/liveSearch.js
@@ -12,24 +12,25 @@
     }
   };
 
-  let filter = ($searchBox, $searchLabel, $liveRegion, $targets) => () => {
+  let filter = (searchBox, searchLabel, liveRegion, targets) => () => {
 
-    let query = normalize($searchBox.val());
+    let query = normalize(searchBox.value);
     let results = 0;
-    let $noResultsMessage = $('.js-live-search-no-results');
+    let noResultsMessage = document.querySelector('.js-live-search-no-results');
 
-    $targets.each(function() {
+    targets.forEach(function(target) {
 
-      let content = $('.live-search-relevant', this).text() || $(this).text();
+      let relevantElement = target.querySelector('.live-search-relevant');
+      let content = relevantElement ? relevantElement.textContent : target.textContent;
 
-      if ($(this).has(':checked').length) {
-        $(this).show();
+      if (target.querySelector(':checked')) {
+        target.classList.remove('js-hidden');
         results++;
         return;
       }
 
       if (query == '') {
-        $(this).removeClass('js-hidden');
+        target.classList.remove('js-hidden');
         results++;
         return;
       }
@@ -37,34 +38,31 @@
       let isMatch = normalize(content).includes(normalize(query));
 
       if (isMatch) {
-        $(this).removeClass('js-hidden');
+        target.classList.remove('js-hidden');
         results++;
       } else {
-        $(this).addClass('js-hidden');
+        target.classList.add('js-hidden');
       }
     });
 
-    if (query !== '' && results === 0) {
-      $noResultsMessage.removeClass('js-hidden');
-    } else {
-      $noResultsMessage.addClass('js-hidden');
+    if (noResultsMessage) {
+      if (query !== '' && results === 0) {
+        noResultsMessage.classList.remove('js-hidden');
+      } else {
+        noResultsMessage.classList.add('js-hidden');
+      }
     }
 
     if (state === 'loaded') {
       if (query !== '') {
-        $searchBox.attr('aria-label', $searchLabel.text().trim() + ', ' + resultsSummary(results));
+        searchBox.setAttribute('aria-label', searchLabel.textContent.trim() + ', ' + resultsSummary(results));
       }
       state = 'active';
     } else {
-      $searchBox.removeAttr('aria-label');
-      $liveRegion.text(resultsSummary(results));
+      searchBox.removeAttribute('aria-label');
+      liveRegion.textContent = resultsSummary(results);
     }
 
-    // make sticky JS recalculate its cache of the element's position
-    // because live search can change the height document
-    if (window.NotifyModules && 'stickAtBottomWhenScrolling' in window.NotifyModules) {
-      window.NotifyModules.stickAtBottomWhenScrolling.recalculate();
-    }
 
   };
 
@@ -73,22 +71,24 @@
 
     this.start = function(component) {
 
-      let $component = $(component);
+      let searchBox = component.querySelector('input');
+      let searchLabel = component.querySelector('label');
+      let liveRegion = component.querySelector('.live-search__status');
 
-      let $searchBox = $('input', $component);
-      let $searchLabel = $('label', $component);
-      let $liveRegion = $('.live-search__status', $component);
+      let targetsSelector = component.dataset.targets;
+      let targets = Array.from(document.querySelectorAll(targetsSelector));
 
       let filterFunc = filter(
-        $searchBox,
-        $searchLabel,
-        $liveRegion,
-        $($component.data('targets'))
+        searchBox,
+        searchLabel,
+        liveRegion,
+        targets
       );
 
       state = 'loaded';
 
-      $searchBox.on('keyup input', filterFunc);
+      searchBox.addEventListener('keyup', filterFunc);
+      searchBox.addEventListener('input', filterFunc);
 
       filterFunc();
 
diff --git a/app/assets/javascripts/modules/show-hide-content.js b/app/assets/javascripts/modules/show-hide-content.js
index 6ad60b316..6c1e949ed 100644
--- a/app/assets/javascripts/modules/show-hide-content.js
+++ b/app/assets/javascripts/modules/show-hide-content.js
@@ -1,10 +1,11 @@
 (function (window) {
   'use strict';
 
-  var $ = window.jQuery;
-
+  // this javascript could be removed in the future since it is only being used
+  // on the page "send-files-by-email". which is not currently in use.
   function ShowHideContent () {
     var self = this;
+    var eventHandlers = new Map();
 
     var selectors = {
       namespace: 'ShowHideContent',
@@ -12,126 +13,159 @@
       checkbox: '[data-target] > input[type="checkbox"]'
     };
 
-    function initToggledContent () {
-      var $control = $(this);
-      var $content = getToggledContent($control);
+    function initToggledContent (control) {
+      var content = getToggledContent(control);
 
-      if ($content.length) {
-        $control.attr('aria-controls', $content.attr('id'));
-        $control.attr('aria-expanded', 'false');
-        $content.attr('aria-hidden', 'true');
+      if (content) {
+        control.setAttribute('aria-controls', content.getAttribute('id'));
+        control.setAttribute('aria-expanded', 'false');
+        content.setAttribute('aria-hidden', 'true');
       }
     }
 
-    function getToggledContent ($control) {
+    function getToggledContent (control) {
       try {
-        var id = $control.attr('aria-controls');
+        var id = control.getAttribute('aria-controls');
 
         if (!id) {
-          id = $control.closest('[data-target]').data('target');
+          var parent = control.closest('[data-target]');
+          id = parent ? parent.dataset.target : null;
         }
 
         if (!id || !/^[\w-]+$/.test(id)) {
           console.warn('Invalid element ID:', id);
-          return $();
+          return null;
         }
 
-        return $('#' + id);
+        return document.getElementById(id);
       } catch (error) {
         console.error('Error getting toggled content:', error);
-        return $();
+        return null;
       }
     }
 
-    function showToggledContent ($control, $content) {
-      if ($content.hasClass('display-none')) {
-        $content.removeClass('display-none');
-        $content.attr('aria-hidden', 'false');
+    function showToggledContent (control, content) {
+      if (content.classList.contains('display-none')) {
+        content.classList.remove('display-none');
+        content.setAttribute('aria-hidden', 'false');
 
-        if ($control.attr('aria-controls')) {
-          $control.attr('aria-expanded', 'true');
+        if (control.getAttribute('aria-controls')) {
+          control.setAttribute('aria-expanded', 'true');
         }
       }
     }
 
-    function hideToggledContent ($control, $content) {
-      $content.addClass('display-none');
-      $content.attr('aria-hidden', 'true');
+    function hideToggledContent (control, content) {
+      content.classList.add('display-none');
+      content.setAttribute('aria-hidden', 'true');
 
-      if ($control.attr('aria-controls')) {
-        $control.attr('aria-expanded', 'false');
+      if (control.getAttribute('aria-controls')) {
+        control.setAttribute('aria-expanded', 'false');
       }
     }
 
-    function handleRadioContent ($control, $content) {
-      var selector = selectors.radio + '[name=' + escapeElementName($control.attr('name')) + ']';
-      var $radios = $(selector);
+    function handleRadioContent (control, content) {
+      var selector = selectors.radio + '[name=' + escapeElementName(control.getAttribute('name')) + ']';
+      var radios = document.querySelectorAll(selector);
 
-      $radios.each(function () {
-        hideToggledContent($(this), getToggledContent($(this)));
+      radios.forEach(function (radio) {
+        var radioContent = getToggledContent(radio);
+        if (radioContent) {
+          hideToggledContent(radio, radioContent);
+        }
       });
 
-      showToggledContent($control, $content);
+      if (content) {
+        showToggledContent(control, content);
+      }
     }
 
-    function handleCheckboxContent ($control, $content) {
-      if ($control.is(':checked')) {
-        showToggledContent($control, $content);
+    function handleCheckboxContent (control, content) {
+      if (!content) {
+        return;
+      }
+      if (control.checked) {
+        showToggledContent(control, content);
       } else {
-        hideToggledContent($control, $content);
+        hideToggledContent(control, content);
       }
     }
 
     function escapeElementName (str) {
       // First escape backslashes, then escape other special characters
       // This prevents double-escaping issues identified by CodeQL
-      return str
-        ? str.replace(/\\/g, '\\\\').replace(/([!"#$%&'()*+,./:;<=>?@[\]^`{|}~])/g, '\\$1')
-        : str;
+      return str ? str.replace(/\\/g, '\\\\').replace(/([!"#$%&'()*+,./:;<=>?@[\]^`{|}~])/g, '\\$1') : str;
     }
 
     function setupHandlers () {
-      var $controls = $(selectors.radio + ', ' + selectors.checkbox);
+      var radios = document.querySelectorAll(selectors.radio);
+      var checkboxes = document.querySelectorAll(selectors.checkbox);
 
-      $(selectors.radio).on('click.' + selectors.namespace, function () {
-        handleRadioContent($(this), getToggledContent($(this)));
+      radios.forEach(function (radio) {
+        var handler = function () {
+          handleRadioContent(radio, getToggledContent(radio));
+        };
+        radio.addEventListener('click', handler);
+        eventHandlers.set(radio, handler);
       });
 
-      $(selectors.checkbox).on('click.' + selectors.namespace, function () {
-        handleCheckboxContent($(this), getToggledContent($(this)));
+      checkboxes.forEach(function (checkbox) {
+        var handler = function () {
+          handleCheckboxContent(checkbox, getToggledContent(checkbox));
+        };
+        checkbox.addEventListener('click', handler);
+        eventHandlers.set(checkbox, handler);
       });
-      if ($controls.filter(':checked').length) {
-        $controls.filter(':checked').each(function () {
-          var $control = $(this);
-          var $content = getToggledContent($control);
 
-          if ($control.is('[type=radio]')) {
-            handleRadioContent($control, $content);
-          } else {
-            handleCheckboxContent($control, $content);
+      var allControls = Array.from(radios).concat(Array.from(checkboxes));
+      var checkedControls = allControls.filter(function (control) {
+        return control.checked;
+      });
+
+      if (checkedControls.length) {
+        checkedControls.forEach(function (control) {
+          var content = getToggledContent(control);
+
+          if (content) {
+            if (control.type === 'radio') {
+              handleRadioContent(control, content);
+            } else {
+              handleCheckboxContent(control, content);
+            }
           }
         });
       }
     }
 
     self.destroy = function () {
-      var $controls = $(selectors.radio + ', ' + selectors.checkbox);
+      var radios = document.querySelectorAll(selectors.radio);
+      var checkboxes = document.querySelectorAll(selectors.checkbox);
+      var allControls = Array.from(radios).concat(Array.from(checkboxes));
 
-      $controls.each(function () {
-        var $control = $(this);
-        var $content = getToggledContent($control);
+      allControls.forEach(function (control) {
+        var content = getToggledContent(control);
 
-        $control.removeAttr('aria-controls aria-expanded');
-        $content.removeAttr('aria-hidden');
+        control.removeAttribute('aria-controls');
+        control.removeAttribute('aria-expanded');
+        if (content) {
+          content.removeAttribute('aria-hidden');
+        }
+
+        var handler = eventHandlers.get(control);
+        if (handler) {
+          control.removeEventListener('click', handler);
+          eventHandlers.delete(control);
+        }
       });
-
-      $(selectors.radio).off('.' + selectors.namespace);
-      $(selectors.checkbox).off('.' + selectors.namespace);
     };
 
     self.init = function () {
       try {
-        $(selectors.radio + ', ' + selectors.checkbox).each(initToggledContent);
+        var radios = document.querySelectorAll(selectors.radio);
+        var checkboxes = document.querySelectorAll(selectors.checkbox);
+        var allControls = Array.from(radios).concat(Array.from(checkboxes));
+
+        allControls.forEach(initToggledContent);
         setupHandlers();
 
       } catch (error) {
diff --git a/app/assets/javascripts/modules/uswds-modules.js b/app/assets/javascripts/modules/uswds-modules.js
index cd10ec27b..0274eee41 100644
--- a/app/assets/javascripts/modules/uswds-modules.js
+++ b/app/assets/javascripts/modules/uswds-modules.js
@@ -1,19 +1,23 @@
 (function (window) {
   'use strict';
 
-  var $ = window.jQuery;
-
   window.NotifyModules.moduleSystem = {
     find: function (container) {
-      container = container || $('body');
+      container = container || document.body;
 
       var modules;
       var moduleSelector = '[data-module]';
 
-      modules = container.find(moduleSelector);
+      // If container is already an element, use it directly
+      if (container instanceof Element) {
+        modules = Array.from(container.querySelectorAll(moduleSelector));
 
-      if (container.is(moduleSelector)) {
-        modules = modules.add(container);
+        // If the container itself is a module, include it
+        if (container.matches && container.matches(moduleSelector)) {
+          modules.unshift(container);
+        }
+      } else {
+        modules = Array.from(document.querySelectorAll(moduleSelector));
       }
 
       return modules;
@@ -25,16 +29,16 @@
       for (var i = 0, l = modules.length; i < l; i++) {
         try {
           var module;
-          var element = $(modules[i]);
-          var type = this.camelCaseAndCapitalise(element.data('module'));
-          var started = element.data('module-started');
+          var element = modules[i];
+          var type = this.camelCaseAndCapitalise(element.dataset.module);
+          var started = element.dataset.moduleStarted;
 
           if (typeof window.NotifyModules[type] === 'function' && !started) {
             module = new window.NotifyModules[type]();
             if (module.start) {
               module.start(element);
             }
-            element.data('module-started', true);
+            element.dataset.moduleStarted = 'true';
           }
         } catch (error) {
           console.error('Failed to initialize module:', type || 'unknown', error);
diff --git a/app/assets/javascripts/preventDuplicateFormSubmissions.js b/app/assets/javascripts/preventDuplicateFormSubmissions.js
index c18a99c37..213b67170 100644
--- a/app/assets/javascripts/preventDuplicateFormSubmissions.js
+++ b/app/assets/javascripts/preventDuplicateFormSubmissions.js
@@ -2,45 +2,51 @@
   "use strict";
 
   const disableSubmitButtons = function (event) {
-    const $submitButton = $(this).find(':submit');
+    const form = event.currentTarget;
+    const submitButton = form.querySelector('input[type="submit"], button[type="submit"]');
 
-    if ($submitButton.data('clicked') === 'true') {
+    if (!submitButton) return;
+
+    if (submitButton.dataset.clicked === 'true') {
       event.preventDefault();
       return;
     }
 
-    $submitButton.data('clicked', 'true');
+    submitButton.dataset.clicked = 'true';
 
     // Add loading spinner for Send/Schedule/Cancel buttons
-    const buttonName = $submitButton.attr('name')?.toLowerCase();
+    const buttonName = submitButton.getAttribute('name')?.toLowerCase();
     if (["send", "schedule", "cancel"].includes(buttonName)) {
       // Use setTimeout with minimal delay to allow form submission to proceed first
       setTimeout(() => {
-        $submitButton.prop('disabled', true);
+        submitButton.disabled = true;
 
         // Add loading spinner and aria-busy attribute for accessibility
-        if ($submitButton.find('.loading-spinner').length === 0) {
-          $submitButton.attr('aria-busy', 'true');
-          $submitButton.append('<span class="loading-spinner" role="status" aria-label="Sending"></span>');
+        if (submitButton.querySelector('.loading-spinner') === null) {
+          submitButton.setAttribute('aria-busy', 'true');
+          submitButton.insertAdjacentHTML('beforeend', '<span class="loading-spinner" role="status" aria-label="Sending"></span>');
         }
 
         // Disable Cancel button too
-        const $cancelButton = $('button[name]').filter(function () {
-          return $(this).attr('name')?.toLowerCase() === 'cancel';
+        const cancelButtons = Array.from(document.querySelectorAll('button[name]')).filter(button => {
+          return button.getAttribute('name')?.toLowerCase() === 'cancel';
         });
-        $cancelButton.prop('disabled', true);
+        cancelButtons.forEach(button => button.disabled = true);
       }, 50); // Small delay to ensure form submits first
     } else {
-      setTimeout(() => renableSubmitButton($submitButton)(), 1500);
+      setTimeout(() => renableSubmitButton(submitButton)(), 1500);
     }
   };
 
-  const renableSubmitButton = ($submitButton) => () => {
-    $submitButton.data('clicked', '');
-    $submitButton.prop('disabled', false);
-    $submitButton.attr('aria-busy', 'false');
-    $submitButton.find('.loading-spinner').remove(); // clean up spinner
+  const renableSubmitButton = (submitButton) => () => {
+    submitButton.dataset.clicked = '';
+    submitButton.disabled = false;
+    submitButton.setAttribute('aria-busy', 'false');
+    const spinner = submitButton.querySelector('.loading-spinner');
+    if (spinner) spinner.remove(); // clean up spinner
   };
 
-  $('form').on('submit', disableSubmitButtons);
+  document.querySelectorAll('form').forEach(form => {
+    form.addEventListener('submit', disableSubmitButtons);
+  });
 })();
diff --git a/app/assets/javascripts/radioSelect.js b/app/assets/javascripts/radioSelect.js
index 93bccd390..f944937b3 100644
--- a/app/assets/javascripts/radioSelect.js
+++ b/app/assets/javascripts/radioSelect.js
@@ -4,6 +4,16 @@
 
   var Modules = window.NotifyModules;
 
+  const escapeHtml = (unsafe) => {
+    if (!unsafe) return '';
+    return String(unsafe)
+      .replace(/&/g, "&amp;")
+      .replace(/</g, "&lt;")
+      .replace(/>/g, "&gt;")
+      .replace(/"/g, "&quot;")
+      .replace(/'/g, "&#039;");
+  };
+
   // Template functions for rendering component states
   let renderStates = {
     'initial': function(data) {
@@ -11,14 +21,14 @@
         ${data.showNowAsDefault ? `
           <div class="radio-select__column margin-y-2">
             <div class="usa-radio">
-              <input class="usa-radio__input" checked="checked" id="${data.name}-0" name="${data.name}" type="radio" value="">
-              <label class="usa-radio__label" for="${data.name}-0">Now</label>
+              <input class="usa-radio__input" checked="checked" id="${escapeHtml(data.name)}-0" name="${escapeHtml(data.name)}" type="radio" value="">
+              <label class="usa-radio__label" for="${escapeHtml(data.name)}-0">Now</label>
             </div>
           </div>
         ` : ''}
         <div class="radio-select__column margin-y-2">
           ${data.categories.map(category =>
-            `<input type='button' class='usa-button usa-button--outline radio-select__button--category' aria-expanded="false" value='${category}' />`
+            `<input type='button' class='usa-button usa-button--outline radio-select__button--category' aria-expanded="false" value='${escapeHtml(category)}' />`
           ).join('')}
         </div>
       `;
@@ -28,16 +38,16 @@
         ${data.showNowAsDefault ? `
           <div class="radio-select__column margin-y-2">
             <div class="usa-radio">
-              <input class="usa-radio__input" checked="checked" id="${data.name}-0" name="${data.name}" type="radio" value="">
-              <label class="usa-radio__label" for="${data.name}-0">Now</label>
+              <input class="usa-radio__input" checked="checked" id="${escapeHtml(data.name)}-0" name="${escapeHtml(data.name)}" type="radio" value="">
+              <label class="usa-radio__label" for="${escapeHtml(data.name)}-0">Now</label>
             </div>
           </div>
         ` : ''}
         <div class="radio-select__column margin-y-2">
           ${data.choices.map(choice => `
             <div class="usa-radio js-option">
-              <input class="usa-radio__input" type="radio" value="${choice.value}" id="${choice.id}" name="${data.name}" />
-              <label class="usa-radio__label" for="${choice.id}">${choice.label}</label>
+              <input class="usa-radio__input" type="radio" value="${escapeHtml(choice.value)}" id="${escapeHtml(choice.id)}" name="${escapeHtml(data.name)}" />
+              <label class="usa-radio__label" for="${escapeHtml(choice.id)}">${escapeHtml(choice.label)}</label>
             </div>
           `).join('')}
           <input type='button' class='usa-button usa-button--outline radio-select__button--done margin-top-4' aria-expanded='true' value='Back to select a new time' />
@@ -49,16 +59,16 @@
         ${data.showNowAsDefault ? `
           <div class="radio-select__column margin-y-2">
             <div class="usa-radio">
-              <input class="usa-radio__input" id="${data.name}-0" name="${data.name}" type="radio" value="">
-              <label class="usa-radio__label" for="${data.name}-0">Now</label>
+              <input class="usa-radio__input" id="${escapeHtml(data.name)}-0" name="${escapeHtml(data.name)}" type="radio" value="">
+              <label class="usa-radio__label" for="${escapeHtml(data.name)}-0">Now</label>
             </div>
           </div>
         ` : ''}
         <div class="radio-select__column margin-y-2">
           ${data.choices.map(choice => `
             <div class="usa-radio">
-              <input class="usa-radio__input" checked="checked" type="radio" value="${choice.value}" id="${choice.id}" name="${data.name}" />
-              <label class="usa-radio__label" for="${choice.id}">${choice.label}</label>
+              <input class="usa-radio__input" checked="checked" type="radio" value="${escapeHtml(choice.value)}" id="${escapeHtml(choice.id)}" name="${escapeHtml(data.name)}" />
+              <label class="usa-radio__label" for="${escapeHtml(choice.id)}">${escapeHtml(choice.label)}</label>
             </div>
           `).join('')}
         </div>
@@ -70,12 +80,13 @@
   };
 
   let shiftFocus = function(elementToFocus, component) {
+    const radios = component.querySelectorAll('[type=radio]');
     // The first option is always the default
-    if (elementToFocus === 'default') {
-      $('[type=radio]', component).eq(0).focus();
+    if (elementToFocus === 'default' && radios[0]) {
+      radios[0].focus();
     }
-    if (elementToFocus === 'option') {
-      $('[type=radio]', component).eq(1).focus();
+    if (elementToFocus === 'option' && radios[1]) {
+      radios[1].focus();
     }
   };
 
@@ -83,24 +94,22 @@
 
     this.start = function(component) {
 
-      let $component = $(component);
       let render = (state, data) => {
-        $component.html(renderStates[state](data));
+        component.innerHTML = renderStates[state](data);
       };
       // store array of all options in component
-      let choices = $('label', $component).toArray().map(function(element) {
-        let $element = $(element);
+      let choices = Array.from(component.querySelectorAll('label')).map(function(element) {
         return {
-          'id': $element.attr('for'),
-          'label': $.trim($element.text()),
-          'value': $element.prev('input').attr('value')
+          'id': element.htmlFor,
+          'label': element.textContent.trim(),
+          'value': element.previousElementSibling.value
         };
       });
-      let categories = $component.data('categories').split(',');
-      let name = $component.find('input').eq(0).attr('name');
+      let categories = component.dataset.categories.split(',');
+      let name = component.querySelector('input').name;
       let mousedownOption = null;
       let showNowAsDefault = (
-        $component.data('show-now-as-default').toString() === 'true' ?
+        component.dataset.showNowAsDefault === 'true' ?
         {'name': name} : false
       );
 
@@ -129,22 +138,23 @@
         const parentNode = event.target.parentNode;
 
         if (parentNode === mousedownOption) {
-          const value = $('input', parentNode).attr('value');
+          const input = parentNode.querySelector('input');
+          const value = input ? input.value : '';
 
           selectOption(value);
 
           // clear tracking
           mousedownOption = null;
-          $(document).off('mouseup', trackMouseup);
+          document.removeEventListener('mouseup', trackMouseup);
         }
       };
 
-      // set events
-      $component
-        .on('click', '.radio-select__button--category', function(event) {
-
+      // set events using event delegation
+      component.addEventListener('click', function(event) {
+        // Handle category button clicks
+        if (event.target.classList.contains('radio-select__button--category')) {
           event.preventDefault();
-          let wordsInDay = $(this).attr('value').split(' ');
+          let wordsInDay = event.target.value.split(' ');
           let day = wordsInDay[wordsInDay.length - 1].toLowerCase();
           render('choose', {
             'choices': choices.filter(
@@ -154,57 +164,58 @@
             'showNowAsDefault': showNowAsDefault
           });
           shiftFocus('option', component);
+        }
 
-        })
-        .on('mousedown', '.js-option', function(event) {
-          mousedownOption = this;
-
-          // mouseup on the same option completes the click action
-          $(document).on('mouseup', trackMouseup);
-        })
-        // space and enter, clicked on a radio confirm that option was selected
-        .on('keydown', 'input[type=radio]', function(event) {
-
-          // allow keypresses which aren’t enter or space through
-          if (event.which !== 13 && event.which !== 32) {
-            return true;
-          }
-
+        // Handle done button clicks
+        if (event.target.classList.contains('radio-select__button--done')) {
           event.preventDefault();
-          let value = $(this).attr('value');
-          selectOption(value);
-
-        })
-        .on('click', '.radio-select__button--done', function(event) {
-
-          event.preventDefault();
-          let $selection = $('input[type=radio]:checked', this.parentNode);
-          if ($selection.length) {
-
+          let selection = event.target.parentNode.querySelector('input[type=radio]:checked');
+          if (selection) {
             render('chosen', {
               'choices': choices.filter(
-                element => element.value == $selection.eq(0).attr('value')
+                element => element.value == selection.value
               ),
               'name': name,
               'showNowAsDefault': showNowAsDefault
             });
             shiftFocus('option', component);
-
           } else {
-
             reset();
             shiftFocus('default', component);
-
           }
+        }
 
-        })
-        .on('click', '.radio-select__button--reset', function(event) {
-
+        // Handle reset button clicks
+        if (event.target.classList.contains('radio-select__button--reset')) {
           event.preventDefault();
           reset();
           shiftFocus('default', component);
+        }
+      });
 
-        });
+      component.addEventListener('mousedown', function(event) {
+        // Handle option mousedown
+        const option = event.target.closest('.js-option');
+        if (option) {
+          mousedownOption = option;
+          // mouseup on the same option completes the click action
+          document.addEventListener('mouseup', trackMouseup);
+        }
+      });
+
+      component.addEventListener('keydown', function(event) {
+        // Handle radio keydown (space and enter)
+        if (event.target.type === 'radio') {
+          // allow keypresses which aren't enter or space through
+          if (event.which !== 13 && event.which !== 32) {
+            return true;
+          }
+
+          event.preventDefault();
+          let value = event.target.value;
+          selectOption(value);
+        }
+      });
 
       // set HTML to initial state
       render('initial', {
@@ -213,7 +224,7 @@
         'showNowAsDefault': showNowAsDefault
       });
 
-      $component.css({'height': 'auto'});
+      component.style.height = 'auto';
 
     };
 
diff --git a/app/assets/javascripts/radioSlider.js b/app/assets/javascripts/radioSlider.js
deleted file mode 100644
index a1d28aa9c..000000000
--- a/app/assets/javascripts/radioSlider.js
+++ /dev/null
@@ -1,28 +0,0 @@
-(function(window) {
-
-  "use strict";
-
-  window.NotifyModules['radio-slider'] = function() {
-
-    this.start = function(component) {
-
-      $(component)
-        .on('click', function() {
-
-          valuesInLabel = $(this).find(':checked').next('label').text().split('/');
-
-          if (valuesInLabel.length === 2) {
-            leftValue = valuesInLabel[0];
-            rightValue = valuesInLabel[1];
-            $(this).find('.radio-slider-left-value').text(leftValue);
-            $(this).find('.radio-slider-right-value').text(rightValue);
-          }
-
-        })
-        .trigger('click');
-
-    };
-
-  };
-
-})(window);
diff --git a/app/assets/javascripts/stick-to-window-when-scrolling.js b/app/assets/javascripts/stick-to-window-when-scrolling.js
deleted file mode 100644
index f04dc8058..000000000
--- a/app/assets/javascripts/stick-to-window-when-scrolling.js
+++ /dev/null
@@ -1,995 +0,0 @@
-;(function (window) {
-  'use strict';
-
-  var $ = window.jQuery;
-  var NotifyModules = window.NotifyModules || {};
-  var _mode = 'default';
-
-  // Constructor to make objects representing the area sticky elements can scroll in
-  var ScrollArea = function (el, edge, selector) {
-    var $el = el.$fixedEl;
-    var $scrollArea = $el.closest('.sticky-scroll-area');
-
-    if($scrollArea.length === 0) {
-      $scrollArea = $el.parent();
-      $scrollArea.addClass('sticky-scroll-area');
-    }
-
-    this._els = [el];
-    this.edge = edge;
-    this.selector = selector;
-    this.node = $scrollArea.get(0);
-    this.setEvents();
-  };
-  ScrollArea.prototype.addEl = function (el) {
-    this._els.push(el);
-  };
-  ScrollArea.prototype.hasEl = function (el) {
-    return $.inArray(el, this._els) !== -1;
-  };
-  ScrollArea.prototype.updateEls = function (usedEls) {
-    this._els = usedEls;
-  };
-  ScrollArea.prototype.setEvents = function () {
-    this.node.addEventListener('focus', this.focusHandler.bind(this), true);
-    $(this.node).on('keyup', 'textarea', this.focusHandler.bind(this));
-  };
-  ScrollArea.prototype.removeEvents = function () {
-    this.node.removeEventListener('focus', this.focusHandler.bind(this));
-    $(this.node).find('textarea').off('keyup', 'textarea', this.focusHandler.bind(this));
-  };
-  ScrollArea.prototype.getFocusedDetails = {
-    forElement: function ($focusedElement) {
-      var focused = {
-        'top': $focusedElement.offset().top,
-        'height': $focusedElement.outerHeight(),
-        'type': 'element'
-      };
-      focused.bottom = focused.top + focused.height;
-
-      return focused;
-    },
-    forCaret: function ($textarea) {
-      var textarea = $textarea.get(0);
-      var caretCoordinates = window.getCaretCoordinates(textarea, textarea.selectionEnd);
-      var focused = {
-        'top': $textarea.offset().top + caretCoordinates.top,
-        'height': caretCoordinates.height,
-        'type': 'caret'
-      };
-
-      focused.bottom = focused.top + focused.height;
-
-      return focused;
-    }
-  };
-  ScrollArea.prototype.focusHandler = function (e) {
-    this.scrollToRevealElement($(document.activeElement));
-  };
-  ScrollArea.prototype.scrollToRevealElement = function ($el) {
-    var nodeName = $el.get(0).nodeName.toLowerCase();
-    var endOfFurthestEl = focusOverlap.endOfFurthestEl(this._els, this.edge);
-    var isInSticky = function () {
-      return $el.closest(this.selector).length > 0;
-    }.bind(this);
-    var focused;
-    var overlap;
-
-    // if textarea is focused, we care about checking the caret, not the whole element
-    if (nodeName === 'textarea') {
-      focused = this.getFocusedDetails.forCaret($el);
-    } else {
-      if (isInSticky()) { return; }
-      focused = this.getFocusedDetails.forElement($el);
-    }
-
-    overlap = focusOverlap.getOverlap(focused, this.edge, endOfFurthestEl);
-
-    if (overlap > 0) {
-      focusOverlap.adjustForOverlap(focused, this.edge, overlap);
-    }
-  };
-  ScrollArea.prototype.destroy = function () {
-    this.removeEvents();
-  };
-
-  // Object collecting together methods for interacting with scrollareas
-  var scrollAreas = {
-    _scrollAreas: [],
-    getAreaForEl: function (el) {
-      var loopIdx = this._scrollAreas.length;
-
-      while(loopIdx--) {
-        if (this._scrollAreas[loopIdx].hasEl(el)) {
-          return this._scrollAreas[loopIdx];
-        }
-      }
-
-      return false;
-    },
-    getAreaByEl: function (el) {
-      var matches = $.grep(this._scrollAreas, function (area) {
-        return $.inArray(el, area.els) !== -1;
-      });
-
-      return matches[0] || false;
-    },
-    addEl: function (el, edge, selector) {
-      var scrollArea = this.getAreaForEl(el);
-
-      if (!scrollArea) {
-        this._scrollAreas.push(new ScrollArea(el, edge, selector));
-      } else {
-        scrollArea.addEl(el);
-      }
-    },
-    syncEls: function (elsInDOM) {
-      var self = this;
-      var unusedAreas = [];
-
-      var getUsed = function (area) {
-        var used = [];
-
-        $.each(elsInDOM, function (elIdx, el) {
-          if (area.hasEl(el)) {
-            used.push(el);
-          }
-        });
-
-        return used;
-      };
-
-      var deleteUnused = function (idx, areaIdx) {
-        // remove any events for overlap checking bound to the scrollArea
-        self._scrollAreas[areaIdx].destroy();
-        self._scrollAreas.splice(areaIdx, 1);
-      };
-
-      // update any scroll areas with els still in the DOM and track any with none
-      $.each(this._scrollAreas, function (areaIdx, area) {
-        var used = getUsed(area);
-
-        if (!used.length) {
-          unusedAreas.push(areaIdx);
-        }
-
-        area.updateEls(used);
-      });
-
-      // delete any scroll areas with no els still in DOM
-      $.each(unusedAreas, deleteUnused);
-    }
-  };
-
-  // Object collecting together methods for stopping sticky overlapping focused elements
-  var focusOverlap = {
-    getOverlap: function (focused, edge, endOfFurthestEl) {
-      if (!endOfFurthestEl) { return 0; }
-
-      if (edge === 'top') {
-        return endOfFurthestEl - focused.top;
-      } else {
-        return focused.bottom - endOfFurthestEl;
-      }
-    },
-    endOfFurthestEl: function (els, edge) {
-      var stuckEls = $.grep(els, function (el) { return el.isStuck(); });
-      var edgeOfEl;
-      var offsets;
-
-      if (edge === 'bottom') {
-        edgeOfEl = function (el) {
-          return el.$fixedEl.offset().top;
-        };
-      } else {
-        edgeOfEl = function (el) {
-          return el.$fixedEl.offset().top + el.height;
-        };
-      }
-
-      if (!stuckEls.length) { return false; }
-
-      offsets = $.map(stuckEls, function (el) { return edgeOfEl(el); });
-
-      return offsets.reduce(function (accumulator, offset) {
-        return (accumulator < offset) ? offset: accumulator;
-      });
-    },
-    adjustForOverlap: function (focused, edge, overlap) {
-      var scrollTop = $(window).scrollTop();
-
-      // scroll so element becomes visible
-      if (edge === 'top') {
-        $(window).scrollTop(scrollTop - overlap);
-      } else {
-        $(window).scrollTop(scrollTop + overlap);
-      }
-    }
-  };
-
-  // Object collecting together methods for dealing with marking the edge of a sticky, or group of
-  // sticky elements (as seen in dialog mode)
-  var oppositeEdge = {
-    _classes: {
-      'top': 'content-fixed__top',
-      'bottom': 'content-fixed__bottom'
-    },
-    _getClassForEdge: function (edge) {
-      return this._classes[edge];
-    },
-    mark: function (sticky) {
-      var edgeClass = this._getClassForEdge(sticky.edge);
-      var els;
-
-      if (_mode === 'dialog') {
-        els = [dialog.getElementAtOppositeEnd(sticky)];
-      } else {
-        els = sticky._els;
-      }
-
-      els = $.grep(els, function (el) { return el.isStuck(); });
-
-      $.each(els, function (i, el) {
-        el.$fixedEl.addClass(edgeClass);
-      });
-    },
-    unmark: function (sticky) {
-      var edgeClass = this._getClassForEdge(sticky.edge);
-
-      $.each(sticky._els, function (i, el) {
-        el.$fixedEl.removeClass(edgeClass);
-      });
-    }
-  };
-
-  // Constructor for objects holding data for each element to have sticky behaviour
-  var StickyElement = function ($el, sticky) {
-    this._sticky = sticky;
-    this.$fixedEl = $el;
-    this._initialFixedClass = 'content-fixed-onload';
-    this._fixedClass = 'content-fixed';
-    this._appliedClass = null;
-    this._$shim = null;
-    this._stopped = false;
-    this._hasLoaded = false;
-    this._canBeStuck = true;
-    this.verticalMargins = {
-      'top': parseInt(this.$fixedEl.css('margin-top'), 10),
-      'bottom': parseInt(this.$fixedEl.css('margin-bottom'), 10),
-    };
-  };
-  StickyElement.prototype._getShimCSS = function () {
-    return {
-      'width': this.horizontalSpace + 'px',
-      'height': this.height + 'px',
-      'margin-top': this.verticalMargins.top + 'px',
-      'margin-bottom': this.verticalMargins.bottom + 'px'
-    };
-  };
-  StickyElement.prototype.stickyClass = function () {
-    return (this._sticky._initialPositionsSet) ? this._fixedClass : this._initialFixedClass;
-  };
-  StickyElement.prototype.appliedClass = function () {
-    return this._appliedClass;
-  };
-  StickyElement.prototype.removeStickyClasses = function (sticky) {
-    this.$fixedEl.removeClass([
-      this._initialFixedClass,
-      this._fixedClass
-    ].join(' '));
-  };
-  StickyElement.prototype.isStuck = function () {
-    return this._appliedClass !== null;
-  };
-  StickyElement.prototype.stick = function (sticky) {
-    this._appliedClass = this.stickyClass();
-    this.$fixedEl.addClass(this._appliedClass);
-    this._hasBeenCalled = true;
-  };
-  StickyElement.prototype.release = function (sticky) {
-    this._appliedClass = null;
-    this.removeStickyClasses(sticky);
-    this._hasBeenCalled = true;
-  };
-  // When a sticky element is moved into the 'stuck' state, a shim is inserted into the
-  // page to preserve the space the element occupies in the flow.
-  StickyElement.prototype.addShim = function (position) {
-    this._$shim = $('<div class="shim">&nbsp</div>');
-    this._$shim.css(this._getShimCSS());
-    this.$fixedEl[position](this._$shim);
-  };
-  StickyElement.prototype.removeShim = function () {
-    if (this._$shim !== null) {
-      this._$shim.remove();
-      this._$shim = null;
-    }
-  };
-  // Changes to the dimensions of a sticky element with a shim need to be passed on to the shim
-  StickyElement.prototype.updateShim = function () {
-    if (this._$shim) {
-      this._$shim.css(this._getShimCSS());
-    }
-  };
-  StickyElement.prototype.stop = function () {
-    this._stopped = true;
-  };
-  StickyElement.prototype.unstop = function () {
-    this._stopped = false;
-  };
-  StickyElement.prototype.isStopped = function () {
-    return this._stopped;
-  };
-  StickyElement.prototype.isInPage = function () {
-    var node = this.$fixedEl.get(0);
-
-    return (node === document.body) ? false : document.body.contains(node);
-  };
-  StickyElement.prototype.canBeStuck = function (val) {
-    if (val !== undefined) {
-      this._canBeStuck = val;
-    } else {
-      return this._canBeStuck;
-    }
-  };
-  StickyElement.prototype.hasLoaded = function (val) {
-    if (val !== undefined) {
-      this._hasLoaded = val;
-    } else {
-      return this._hasLoaded;
-    }
-  };
-
-  // Object collecting together methods for treating sticky elements as if they
-  // were wrapped by a dialog component
-  var dialog = {
-    hasResized: false,
-    spaceBetweenStickys: 40,
-    // we add padding of 20px around each sticky to give some space between it and the rest of the page
-    // this shouldn't apply between stickys in a stack
-    // (the in-page CSS handles this by each subsequent sticky in a sequence having margin: -40px)
-    _getPaddingBetweenEls: function (els) {
-      if (els.length <= 1) { return 0; }
-
-      return (els.length - 1) * this.spaceBetweenStickys;
-    },
-    _getTotalHeight: function (els) {
-      var reducer = function (accumulator, currentValue) {
-        return accumulator + currentValue;
-      };
-      var combinedHeight = $.map(els, function (el) { return el.height; }).reduce(reducer);
-
-      return combinedHeight - this._getPaddingBetweenEls(els);
-    },
-    _elsThatCanBeStuck: function (els) {
-      return $.grep(els, function (el) { return el.canBeStuck(); });
-    },
-    getOffsetFromEdge: function (el, sticky) {
-      var els = this._elsThatCanBeStuck(sticky._els).slice();
-      var elIdx;
-
-      // els must be arranged furtherest from window edge is stuck to first
-      // default direction is order in document
-      if (sticky.edge === 'top') {
-        els.reverse();
-      }
-
-      elIdx = els.indexOf(el);
-
-      // if next to window edge the dialog is stuck to, no offset
-      if (elIdx === (els.length - 1)) { return 0; }
-
-      // make els all those from this one to the window edge
-      els = els.slice(elIdx + 1);
-
-      // remove the space between those els and the one on the edge
-      return this._getTotalHeight(els) - this.spaceBetweenStickys;
-    },
-    getOffsetFromEnd: function (el, sticky) {
-      var els = this._elsThatCanBeStuck(sticky._els).slice();
-      var elIdx;
-
-      // els must be arranged furtherest from window edge is stuck to first
-      // default direction is order in document
-      if (sticky.edge === 'bottom') {
-        els.reverse();
-      }
-
-      elIdx = els.indexOf(el);
-
-      // if next to opposite edge to the one the dialog is stuck to, no offset
-      if (elIdx === (els.length - 1)) { return 0; }
-
-      // make els all those from this one to the window edge
-      els = els.slice(elIdx + 1);
-
-      return this._getTotalHeight(els) - this.spaceBetweenStickys;
-    },
-    // checks total height of all this._sticky elements against a height
-    // unsticks each that won't fit and marks them as unstickable
-    fitToHeight: function (sticky) {
-      var self = this;
-      var els = sticky._els.slice();
-      var height = sticky.getWindowDimensions().height;
-      var totalStickyHeight = function () {
-        return self._getTotalHeight(self._elsThatCanBeStuck(els));
-      };
-      var dialogFitsHeight = function () {
-        return totalStickyHeight() <= height;
-      };
-
-      // els must be arranged furtherest from window edge is stuck to first
-      // default direction is order in document
-      if (sticky.edge === 'top') {
-        els.reverse();
-      }
-
-      // reset elements
-      $.each(els, function (i, el) { el.canBeStuck(true); });
-
-      while (self._elsThatCanBeStuck(els).length && !dialogFitsHeight()) {
-        var currentEl = self._elsThatCanBeStuck(els)[0];
-
-        sticky.reset(currentEl);
-        currentEl.canBeStuck(false);
-
-        if (!self.hasResized) { self.hasResized = true; }
-      }
-    },
-    getElementAtStickyEdge: function (sticky) {
-      var els = this._elsThatCanBeStuck(sticky._els);
-      var idx = (sticky.edge === 'top') ? 0 : els.length - 1;
-
-      return els[idx];
-    },
-    // get element at the end opposite the sticky edge
-    getElementAtOppositeEnd: function (sticky) {
-      var els = this._elsThatCanBeStuck(sticky._els);
-      var idx = (sticky.edge === 'top') ? els.length - 1 : 0;
-
-      return els[idx];
-    },
-    getInPageEdgePosition: function (sticky) {
-      return this.getElementAtStickyEdge(sticky).inPageEdgePosition;
-    },
-    getHeight: function (els) {
-      return this._getTotalHeight(this._elsThatCanBeStuck(els));
-    },
-    adjustForResize: function (sticky) {
-      var windowHeight = sticky.getWindowDimensions().height;
-
-      if (sticky.edge === 'top') {
-        $(window).scrollTop(this.getInPageEdgePosition(sticky));
-      } else {
-        $(window).scrollTop(this.getInPageEdgePosition(sticky) - windowHeight);
-      }
-
-      this.hasResized = false;
-    },
-    releaseEl: function (el, sticky) {
-      el.$fixedEl.css(sticky.edge, '');
-    }
-  };
-
-  // Constructor for objects collecting together all generic behaviour for controlling the state of
-  // sticky elements
-  var Sticky = function (selector) {
-    this._hasScrolled = false;
-    this._scrollTimeout = false;
-    this._windowHasResized = false;
-    this._resizeTimeout = false;
-    this._elsLoaded = false;
-    this._initialPositionsSet = false;
-    this._els = [];
-
-    this.CSS_SELECTOR = selector;
-    this.STOP_PADDING = 10;
-  };
-  Sticky.prototype.setMode = function (mode) {
-    _mode = mode;
-  };
-  Sticky.prototype.getWindowDimensions = function () {
-    return {
-      height: $(global).height(),
-      width: $(global).width()
-    };
-  };
-  Sticky.prototype.getWindowPositions = function () {
-    return {
-      scrollTop: $(global).scrollTop()
-    };
-  };
-  // Change state of sticky elements based on their position relative to the window
-  Sticky.prototype.setElementPositions = function () {
-    var self = this,
-        windowDimensions = self.getWindowDimensions(),
-        windowTop = self.getWindowPositions().scrollTop,
-        windowPositions = {
-          'top': windowTop,
-          'bottom':  windowTop + windowDimensions.height
-        };
-
-    var _setElementPosition = function (el) {
-      if (self.viewportIsWideEnough(windowDimensions.width)) {
-
-        if (self.windowNotPastScrolledFrom(windowPositions, self.getScrolledFrom(el))) {
-          self.reset(el);
-        } else { // past the point it sits in the document
-          if (self.windowNotPastScrollingTo(windowPositions, self.getScrollingTo(el))) {
-            self.stick(el);
-            if (el.isStopped()) {
-              self.unstop(el);
-            }
-          } else { // window past scrollingTo position
-            if (!el.isStuck()) {
-              self.stick(el);
-            }
-            self.stop(el);
-          }
-        }
-
-      } else {
-
-        self.reset(el);
-
-      }
-    };
-
-    // clean up any existing styles marking the edges of sticky elements
-    oppositeEdge.unmark(self);
-
-    $.each(self._els, function (i, el) {
-      if (el.canBeStuck()) {
-        _setElementPosition(el);
-      }
-    });
-
-    // add styles to mark the edge of sticky elements opposite to that stuck to the window
-    oppositeEdge.mark(self);
-
-    if (self._initialPositionsSet === false) { self._initialPositionsSet = true; }
-  };
-  // Store all the dimensions for a sticky element to limit DOM queries
-  Sticky.prototype.setElementDimensions = function (el, callback) {
-    var self = this;
-    var $el = el.$fixedEl;
-    var onHeightSet = function () {
-      // if element is shim'ed, pass changes in dimension on to the shim
-      if (el._$shim) {
-        el.updateShim();
-      }
-      if (callback !== undefined) {
-        callback();
-      }
-    };
-
-    this.setElWidth(el);
-    this.setElHeight(el, onHeightSet);
-  };
-  // Reset element to original state in the page
-  Sticky.prototype.reset = function (el) {
-    if (el.isStopped()) {
-      this.unstop(el);
-    }
-    if (el.isStuck()) {
-      this.release(el);
-    }
-  };
-  // Recalculate stored dimensions for all sticky elements
-  Sticky.prototype.recalculate = function () {
-    var self = this;
-    var onSyncComplete = function () {
-      scrollAreas.syncEls(self._els);
-      self.setEvents();
-      if (_mode === 'dialog') {
-        dialog.fitToHeight(self);
-        if (dialog.hasResized) {
-          dialog.adjustForResize(self);
-        }
-      }
-      self.setElementPositions();
-    };
-
-    this.syncWithDOM(onSyncComplete);
-  };
-  // Public method to scroll so an element isn't covered by the sticky nav
-  Sticky.prototype.scrollToRevealElement = function (el) {
-    var $el = $(el);
-    var scrollAreaNode = $el.closest('.sticky-scroll-area').get(0);
-    var matches = $.grep(scrollAreas._scrollAreas, function (scrollArea) {
-      return scrollArea.node === scrollAreaNode;
-    });
-
-    if (matches.length) {
-      matches[0].scrollToRevealElement($el);
-    }
-  };
-  Sticky.prototype.setElWidth = function (el) {
-    var $el = el.$fixedEl;
-    var scrollArea = scrollAreas.getAreaByEl(el);
-    var width = $(scrollArea.node).width();
-
-    el.horizontalSpace = width;
-    // if stuck, element won't inherit width from parent so set explicitly
-    if (el._$shim) {
-      $el.width(width);
-    }
-  };
-  Sticky.prototype.setElHeight = function (el, callback) {
-    var self = this;
-    var $el = el.$fixedEl;
-    var $img = $el.find('img');
-    var onload = function () {
-      el.height = $el.outerHeight();
-      // if element has a shim, the shim's offset represents the element's in-page position
-      if (el._$shim) {
-        el.inPageEdgePosition = self.getInPageEdgePosition(el._$shim);
-      } else {
-        el.inPageEdgePosition = self.getInPageEdgePosition($el);
-      }
-      callback();
-    };
-
-    if ((!el.hasLoaded()) && ($img.length > 0)) {
-      var image = new window.Image();
-      image.onload = function () {
-        onload();
-      };
-      image.src = $img.attr('src');
-    } else {
-      onload();
-    }
-  };
-  Sticky.prototype.allElementsLoaded = function (totalEls) {
-    return this._els.length === totalEls;
-  };
-  Sticky.prototype.getElForNode = function (node) {
-    var matches = $.grep(this._els, function (el) { return el.$fixedEl.is(node); });
-
-    return !!matches.length ? matches[0] : false;
-  };
-  Sticky.prototype.add = function (el, setPositions, cb) {
-    var self = this;
-    var $el = $(el);
-    var onDimensionsSet;
-    var elObj = this.getElForNode(el);
-    var exists = !!elObj;
-
-    onDimensionsSet = function () {
-      elObj.hasLoaded(true);
-
-      // guard against adding elements already stored
-      if (!exists) {
-        self._els.push(elObj);
-      }
-
-      if (setPositions) {
-        self.setElementPositions();
-      }
-
-      if (cb !== undefined) {
-        cb();
-      }
-    };
-
-    if (!exists) {
-      elObj = new StickyElement($el, self);
-      scrollAreas.addEl(elObj, self.edge, self.CSS_SELECTOR);
-    }
-
-    self.setElementDimensions(elObj, onDimensionsSet);
-  };
-  Sticky.prototype.remove = function (el) {
-    if ($.inArray(el, this._els) !== -1) {
-
-      // reset DOM node to original state
-      this.reset(el);
-
-      // remove sticky element object
-      this._els = $.grep(this._els, function (_el) { return _el !== el; });
-    }
-  };
-  // gets all sticky elements in the DOM and removes any in this._els no longer in attached to it
-  Sticky.prototype.syncWithDOM = function (callback) {
-    var self = this;
-    var $els = $(self.CSS_SELECTOR);
-    var numOfEls = $els.length;
-    var onLoaded;
-
-    onLoaded = function () {
-      if (self._els.length === numOfEls) {
-        self.endOfScrollArea = self.getEndOfScrollArea();
-        if (callback !== undefined) {
-          callback();
-        }
-      }
-    };
-
-    // remove any els no longer in the DOM
-    if (this._els.length) {
-      $.each(this._els, function (i, el) {
-        if (!el.isInPage()) {
-          self.remove(el);
-        }
-      });
-    }
-
-    if (numOfEls) {
-      // reset flag marking page load
-      this._initialPositionsSet = false;
-
-      $els.each(function (i, el) {
-        // delay setting position until all stickys are loaded
-        self.add(el, false, onLoaded);
-      });
-    }
-  };
-  Sticky.prototype.init = function () {
-    this.recalculate();
-  };
-  Sticky.prototype.setEvents = function () {
-    this._scrollEvent = this.onScroll.bind(this);
-    this._resizeEvent = this.onResize.bind(this);
-
-    // flag when scrolling takes place and check (and re-position) sticky elements relative to
-    // window position
-    if (this._scrollTimeout === false) {
-      $(global).scroll(this._scrollEvent);
-      this._scrollTimeout = window.setInterval(this.checkScroll.bind(this), 50);
-    }
-
-    // Recalculate all dimensions when the window resizes
-    if (this._resizeTimeout === false) {
-      $(global).resize(this._resizeEvent);
-      this._resizeTimeout = window.setInterval(this.checkResize.bind(this), 50);
-    }
-  };
-  Sticky.prototype.clearEvents = function () {
-    if (this._scrollTimeout !== false) {
-      $(global).off('scroll', this._scrollEvent);
-      window.clearInterval(this._scrollTimeout);
-      this._scrollTimeout = false;
-    }
-
-    if (this._resizeTimeout !== false) {
-      $(global).off('resize', this._resizeEvent);
-      window.clearInterval(this._resizeTimeout);
-      this._resizeTimeout = false;
-    }
-
-  };
-  Sticky.prototype.viewportIsWideEnough = function (windowWidth) {
-    return windowWidth > 768;
-  };
-  Sticky.prototype.onScroll = function () {
-    this._hasScrolled = true;
-  };
-  Sticky.prototype.onResize = function () {
-    this._windowHasResized = true;
-  };
-  Sticky.prototype.checkScroll = function () {
-    var self = this;
-
-    if (self._hasScrolled === true) {
-      self._hasScrolled = false;
-      self.setElementPositions();
-    }
-  };
-  Sticky.prototype.checkResize = function () {
-    var self = this,
-        windowWidth = self.getWindowDimensions().width;
-
-    if (self._windowHasResized === true) {
-      self._windowHasResized = false;
-
-      $.each(self._els, function (i, el) {
-        if (!self.viewportIsWideEnough(windowWidth)) {
-          self.reset(el);
-        } else {
-          self.setElementDimensions(el);
-        }
-      });
-
-      if (self.viewportIsWideEnough(windowWidth)) {
-        if (_mode === 'dialog') {
-          dialog.fitToHeight(self);
-          if (dialog.hasResized) {
-            dialog.adjustForResize(self);
-          }
-        }
-        self.setElementPositions();
-      }
-    }
-  };
-  Sticky.prototype.release = function (el) {
-    if (el.isStuck()) {
-      var $el = el.$fixedEl;
-
-      el.removeStickyClasses(this);
-      $el.css('width', '');
-      // clear styles from any elements stuck while in a dialog mode
-      dialog.releaseEl(el, this);
-      el.removeShim();
-      el.release(this);
-    }
-  };
-
-  // Extension of sticky object to add behaviours specific to sticking to top of window
-  var stickAtTop = new Sticky('.js-stick-at-top-when-scrolling');
-  stickAtTop.edge = 'top';
-  // Store furthest point sticky elements are allowed
-  stickAtTop.getEndOfScrollArea = function () {
-    var footer = $('.js-footer:eq(0)');
-    if (footer.length === 0) {
-      return 0;
-    }
-    return footer.offset().top - this.STOP_PADDING;
-  };
-  // position of the bottom edge when in the page flow
-  stickAtTop.getInPageEdgePosition = function ($el) {
-    return $el.offset().top;
-  };
-  stickAtTop.getScrolledFrom = function (el) {
-    if (_mode === 'dialog') {
-      return dialog.getInPageEdgePosition(this);
-    } else {
-      return el.inPageEdgePosition;
-    }
-  };
-  stickAtTop.getScrollingTo = function (el) {
-    var height = el.height;
-
-    if (_mode === 'dialog') {
-      height = dialog.getHeight(this._els);
-    }
-
-    return this.endOfScrollArea - height;
-  };
-  stickAtTop.getStoppingPosition = function (el) {
-    var offset = 0;
-
-    if (_mode === 'dialog') {
-      offset = dialog.getOffsetFromEnd(el, this);
-    }
-
-    return (this.endOfScrollArea - offset) - el.height;
-  };
-  stickAtTop.windowNotPastScrolledFrom = function (windowPositions, scrolledFrom) {
-    return scrolledFrom > windowPositions.top;
-  };
-  stickAtTop.windowNotPastScrollingTo = function (windowPositions, scrollingTo) {
-    return windowPositions.top < scrollingTo;
-  };
-  stickAtTop.stick = function (el) {
-    if (!el.isStuck()) {
-      var $el = el.$fixedEl;
-      var offset = 0;
-
-      if (_mode === 'dialog') {
-        offset = dialog.getOffsetFromEdge(el, this);
-      }
-
-      el.addShim('before');
-      $el.css({
-        // element will be absolutely positioned so cannot rely on parent element for width
-        'width': $el.width() + 'px',
-        'top': offset + 'px'
-      });
-      el.stick(this);
-    }
-  };
-  stickAtTop.stop = function (el) {
-    if (!el.isStopped()) {
-      el.$fixedEl.css({
-        'position': 'absolute',
-        'top': this.getStoppingPosition(el)
-      });
-      el.stop();
-    }
-  };
-  stickAtTop.unstop = function (el) {
-    var offset = 0;
-
-    if (_mode === 'dialog') {
-      offset = dialog.getOffsetFromEdge(el, this);
-    }
-
-    el.$fixedEl.css({
-      'position': '',
-      'top': offset + 'px'
-    });
-    el.unstop();
-  };
-
-  // Extension of sticky object to add behaviours specific to sticking to bottom of window
-  var stickAtBottom = new Sticky('.js-stick-at-bottom-when-scrolling');
-  stickAtBottom.edge = 'bottom';
-  // Store furthest point sticky elements are allowed
-  stickAtBottom.getEndOfScrollArea = function () {
-    var header = $('.js-header:eq(0)');
-    if (header.length === 0) {
-      return 0;
-    }
-    return (header.offset().top + header.outerHeight()) + this.STOP_PADDING;
-  };
-  // position of the bottom edge when in the page flow
-  stickAtBottom.getInPageEdgePosition = function ($el) {
-    return $el.offset().top + $el.outerHeight();
-  };
-  stickAtBottom.getScrolledFrom = function (el) {
-    if (_mode === 'dialog') {
-      return dialog.getInPageEdgePosition(this);
-    } else {
-      return el.inPageEdgePosition;
-    }
-  };
-  stickAtBottom.getScrollingTo = function (el) {
-    var height = el.height;
-
-    if (_mode === 'dialog') {
-      height = dialog.getHeight(this._els);
-    }
-
-    return this.endOfScrollArea + height;
-  };
-  stickAtBottom.getStoppingPosition = function (el) {
-    var offset = 0;
-
-    if (_mode === 'dialog') {
-      offset = dialog.getOffsetFromEnd(el, this);
-    }
-
-    return this.endOfScrollArea + offset;
-  };
-  stickAtBottom.windowNotPastScrolledFrom = function (windowPositions, scrolledFrom) {
-    return scrolledFrom < windowPositions.bottom;
-  };
-  stickAtBottom.windowNotPastScrollingTo = function (windowPositions, scrollingTo) {
-    return windowPositions.bottom > scrollingTo;
-  };
-  stickAtBottom.stick = function (el) {
-    if (!el.isStuck()) {
-      var $el = el.$fixedEl;
-      var offset = 0;
-
-      if (_mode === 'dialog') {
-        offset = dialog.getOffsetFromEdge(el, this);
-      }
-
-      el.addShim('after');
-      $el.css({
-        // element will be absolutely positioned so cannot rely on parent element for width
-        'width': $el.width() + 'px',
-        'bottom': offset + 'px'
-      });
-      el.stick(this);
-    }
-  };
-  stickAtBottom.stop = function (el) {
-    if (!el.isStopped()) {
-      el.$fixedEl.css({
-        'position': 'absolute',
-        'top': this.getStoppingPosition(el),
-        'bottom': 'auto'
-      });
-      el.stop();
-    }
-  };
-  stickAtBottom.unstop = function (el) {
-    var offset = 0;
-
-    if (_mode === 'dialog') {
-      offset = dialog.getOffsetFromEdge(el, this);
-    }
-
-    el.$fixedEl.css({
-      'position': '',
-      'top': '',
-      'bottom': offset + 'px'
-    });
-    el.unstop();
-  };
-
-  NotifyModules.stickAtTopWhenScrolling = stickAtTop;
-  NotifyModules.stickAtBottomWhenScrolling = stickAtBottom;
-  window.NotifyModules = NotifyModules;
-})(window);
diff --git a/app/assets/javascripts/templateFolderForm.js b/app/assets/javascripts/templateFolderForm.js
index 464a2af43..65d4c332d 100644
--- a/app/assets/javascripts/templateFolderForm.js
+++ b/app/assets/javascripts/templateFolderForm.js
@@ -1,66 +1,98 @@
 (function(window) {
   "use strict";
 
+  // HTML escaping utility to prevent XSS
+  const escapeHtml = (unsafe) => {
+    if (!unsafe) return '';
+    return String(unsafe)
+      .replace(/&/g, "&amp;")
+      .replace(/</g, "&lt;")
+      .replace(/>/g, "&gt;")
+      .replace(/"/g, "&quot;")
+      .replace(/'/g, "&#039;");
+  };
+
   window.NotifyModules['template-folder-form'] = function() {
 
     this.start = function(templateFolderForm) {
-      this.$form = $(templateFolderForm);
+      this.form = templateFolderForm;
 
       // remove the hidden unknown button - if you've got JS enabled then the action you want to do is implied by
       // which field is visible.
-      this.$form.find('button[value=unknown]').remove();
+      const unknownButton = this.form.querySelector('button[value=unknown]');
+      if (unknownButton) {
+        unknownButton.remove();
+      }
 
-      this.$liveRegionCounter = this.$form.find('.selection-counter');
+      this.liveRegionCounter = this.form.querySelector('.selection-counter');
+
+      // Critical: Verify live region counter exists before proceeding
+      if (!this.liveRegionCounter) {
+        console.error('templateFolderForm: .selection-counter element not found');
+        return;
+      }
 
       // Get single channel data from DOM (must happen after DOM is ready)
       const addNewTemplateForm = document.querySelector('div[id=add_new_template_form]');
-      this.$singleNotificationChannel = addNewTemplateForm ? addNewTemplateForm.getAttribute("data-channel") : null;
-      this.$singleChannelService = addNewTemplateForm ? addNewTemplateForm.getAttribute("data-service") : null;
+      this.singleNotificationChannel = addNewTemplateForm ? addNewTemplateForm.getAttribute("data-channel") : null;
+      this.singleChannelService = addNewTemplateForm ? addNewTemplateForm.getAttribute("data-service") : null;
 
-      this.$liveRegionCounter.before(this.nothingSelectedButtons);
-      this.$liveRegionCounter.before(this.itemsSelectedButtons);
+      this.liveRegionCounter.insertAdjacentElement('beforebegin', this.nothingSelectedButtons);
+      this.liveRegionCounter.insertAdjacentElement('beforebegin', this.itemsSelectedButtons);
 
-      // all the diff states that we want to show or hide
+      // all the diff states that we want to show or hide - using Map for better performance
       this.states = [
         {
           key: 'nothing-selected-buttons',
-          $el: this.$form.find('#nothing_selected'),
+          el: this.form.querySelector('#nothing_selected'),
           cancellable: false
         },
         {
           key: 'items-selected-buttons',
-          $el: this.$form.find('#items_selected'),
+          el: this.form.querySelector('#items_selected'),
           cancellable: false
         },
         {
           key: 'move-to-existing-folder',
-          $el: this.$form.find('#move_to_folder_radios'),
+          el: this.form.querySelector('#move_to_folder_radios'),
           cancellable: true,
-          setFocus: () => $('#move_to_folder_radios').focus(),
+          setFocus: () => {
+            const el = document.getElementById('move_to_folder_radios');
+            if (el) el.focus();
+          },
           action: 'move to folder',
           description: 'Press move to confirm or cancel to close'
         },
         {
           key: 'move-to-new-folder',
-          $el: this.$form.find('#move_to_new_folder_form'),
+          el: this.form.querySelector('#move_to_new_folder_form'),
           cancellable: true,
-          setFocus: () => $('#move_to_new_folder_form').focus(),
+          setFocus: () => {
+            const el = document.getElementById('move_to_new_folder_form');
+            if (el) el.focus();
+          },
           action: 'move to new folder',
           description: 'Press add to new folder to confirm name or cancel to close'
         },
         {
           key: 'add-new-folder',
-          $el: this.$form.find('#add_new_folder_form'),
+          el: this.form.querySelector('#add_new_folder_form'),
           cancellable: true,
-          setFocus: () => $('#add_new_folder_form').focus(),
+          setFocus: () => {
+            const el = document.getElementById('add_new_folder_form');
+            if (el) el.focus();
+          },
           action: 'new folder',
           description: 'Press add new folder to confirm name or cancel to close'
         },
         {
           key: 'add-new-template',
-          $el: this.$form.find('#add_new_template_form'),
+          el: this.form.querySelector('#add_new_template_form'),
           cancellable: true,
-          setFocus: () => $('#add_new_template_form').focus(),
+          setFocus: () => {
+            const el = document.getElementById('add_new_template_form');
+            if (el) el.focus();
+          },
           action: 'new template',
           description: 'Press continue to confirm selection or cancel to close'
         }
@@ -70,8 +102,12 @@
       this.states.filter(state => state.cancellable).forEach((x) => this.addCancelButton(x));
       this.states.filter(state => state.key === 'items-selected-buttons').forEach(x => this.addClearButton(x));
 
-      // make elements focusabled
-      this.states.filter(state => state.setFocus).forEach(x => x.$el.attr('tabindex', '0'));
+      // make elements focusable
+      this.states.filter(state => state.setFocus).forEach(x => {
+        if (x.el) {
+          x.el.setAttribute('tabindex', '0');
+        }
+      });
 
       this.addDescriptionsToStates();
 
@@ -79,7 +115,7 @@
       this.activateStickyElements();
 
       // first off show the new template / new folder buttons
-      this._lastState = this.$form.data('prev-state');
+      this._lastState = this.form.dataset.prevState;
       if (this._lastState === undefined) {
         this.selectActionButtons();
       } else {
@@ -87,43 +123,55 @@
         this.render();
       }
 
-      this.$form.on('click', 'button.usa-button', (event) => this.actionButtonClicked(event));
-      this.$form.on('change', 'input[type=checkbox]', () => this.templateFolderCheckboxChanged());
-      this.$form.on('change', 'input[name="add_template_by_template_type"]', () => this.templateTypeChanged());
+      this.form.addEventListener('click', (event) => {
+        const button = event.target.closest('button.usa-button');
+        if (button) {
+          this.actionButtonClicked(event);
+        }
+      });
+      this.form.addEventListener('change', (event) => {
+        if (event.target.matches('input[type=checkbox]')) {
+          this.templateFolderCheckboxChanged();
+        } else if (event.target.matches('input[name="add_template_by_template_type"]')) {
+          this.templateTypeChanged();
+        }
+      });
     };
 
     this.addDescriptionsToStates = function () {
-      let id, description;
-
-      $.each(this.states.filter(state => 'description' in state), (_, state) => {
-        id = `${state.key}__description`;
-        description = `<p class="usa-sr-only" id="${id}">${state.description}</p>`;
-        state.$el
-          .prepend(description)
-          .attr('aria-describedby', id);
+      this.states.filter(state => 'description' in state).forEach(state => {
+        const id = `${escapeHtml(state.key)}__description`;
+        const description = `<p class="usa-sr-only" id="${id}">${escapeHtml(state.description)}</p>`;
+        if (state.el) {
+          state.el.insertAdjacentHTML('afterbegin', description);
+          state.el.setAttribute('aria-describedby', id);
+        }
       });
     };
 
     this.activateStickyElements = function() {
-      var oldClass = 'js-will-stick-at-bottom-when-scrolling';
-      var newClass = 'js-stick-at-bottom-when-scrolling';
+      const oldClass = 'js-will-stick-at-bottom-when-scrolling';
+      const newClass = 'js-stick-at-bottom-when-scrolling';
 
       this.states.forEach(state => {
-        state.$el
-          .find('.' + oldClass)
-          .removeClass(oldClass)
-          .addClass(newClass);
+        if (state.el) {
+          state.el.querySelectorAll('.' + oldClass).forEach(el => {
+            el.classList.remove(oldClass);
+            el.classList.add(newClass);
+          });
+        }
       });
     };
 
     this.addCancelButton = function(state) {
-      let selector = `[value=${state.key}]`;
-      let $cancel = this.makeButton('Cancel', {
+      const selector = `[value=${state.key}]`;
+      const cancel = this.makeButton('Cancel', {
         'onclick': () => {
-
           // clear existing data
-          state.$el.find('input:radio').prop('checked', false);
-          state.$el.find('input:text').val('');
+          if (state.el) {
+            state.el.querySelectorAll('input[type="radio"]').forEach(input => input.checked = false);
+            state.el.querySelectorAll('input[type="text"]').forEach(input => input.value = '');
+          }
 
           // go back to action buttons
           this.selectActionButtons(selector);
@@ -132,16 +180,20 @@
         'nonvisualText': state.action
       });
 
-      state.$el.find('[type=submit]').after($cancel);
+      if (state.el) {
+        const submitButton = state.el.querySelector('[type=submit]');
+        if (submitButton) {
+          submitButton.insertAdjacentElement('afterend', cancel);
+        }
+      }
     };
 
     this.addClearButton = function(state) {
-      let selector = 'button[value=add-new-template]';
-      let $clear = this.makeButton('Clear', {
+      const selector = 'button[value=add-new-template]';
+      const clear = this.makeButton('Clear', {
         'onclick': () => {
-
           // uncheck all templates and folders
-          this.$form.find('input:checkbox').prop('checked', false);
+          this.form.querySelectorAll('input[type="checkbox"]').forEach(input => input.checked = false);
 
           // go back to action buttons
           this.selectActionButtons(selector);
@@ -149,29 +201,47 @@
         'nonvisualText': "selection"
       });
 
-      state.$el.find('.template-list-selected-counter').append($clear);
+      if (state.el) {
+        const counter = state.el.querySelector('.template-list-selected-counter');
+        if (counter) {
+          counter.appendChild(clear);
+        }
+      }
     };
 
     this.makeButton = (text, opts) => {
-      let $btn = $('<a href=""></a>')
-                    .html(text)
-                    .addClass('usa-link js-cancel')
-                    // isn't set if cancelSelector is undefined
-                    .data('target', opts.cancelSelector || undefined)
-                    .attr('tabindex', '0')
-                    .on('click keydown', event => {
-                      // space, enter or no keyCode (must be mouse input)
-                      if ([13, 32, undefined].indexOf(event.keyCode) > -1) {
-                        event.preventDefault();
-                        if (opts.hasOwnProperty('onclick')) { opts.onclick(); }
-                      }
-                    });
+      const btn = document.createElement('a');
+      btn.href = '';
+      btn.textContent = text;
+      btn.classList.add('usa-link', 'js-cancel');
 
-        if (opts.hasOwnProperty('nonvisualText')) {
-          $btn.append(`<span class="usa-sr-only"> ${opts.nonvisualText}</span>`);
+      // isn't set if cancelSelector is undefined
+      if (opts.cancelSelector) {
+        btn.dataset.target = opts.cancelSelector;
+      }
+      btn.setAttribute('tabindex', '0');
+
+      const handler = event => {
+        // space, enter or no keyCode (must be mouse input)
+        if ([13, 32, undefined].indexOf(event.keyCode) > -1) {
+          event.preventDefault();
+          if (opts.hasOwnProperty('onclick')) {
+            opts.onclick();
+          }
         }
+      };
 
-        return $btn;
+      btn.addEventListener('click', handler);
+      btn.addEventListener('keydown', handler);
+
+      if (opts.hasOwnProperty('nonvisualText')) {
+        const span = document.createElement('span');
+        span.className = 'usa-sr-only';
+        span.textContent = ' ' + opts.nonvisualText;
+        btn.appendChild(span);
+      }
+
+      return btn;
     };
 
     this.selectActionButtons = function (targetSelector) {
@@ -181,7 +251,10 @@
       this.currentState = 'nothing-selected-buttons';
       this.templateFolderCheckboxChanged();
       if (targetSelector) {
-        $(targetSelector).focus();
+        const target = document.querySelector(targetSelector);
+        if (target) {
+          target.focus();
+        }
       }
     };
 
@@ -194,14 +267,16 @@
     };
 
     this.actionButtonClicked = function(event) {
-      this.currentState = $(event.currentTarget).val();
+      const button = event.target.closest('button.usa-button') || event.target;
+      this.currentState = button.value;
 
-      if (event.currentTarget.value === 'add-new-template' && this.$singleNotificationChannel) {
+      if (this.currentState === 'add-new-template' && this.singleNotificationChannel) {
         event.preventDefault();
-        window.location = "/services/" + this.$singleChannelService + "/templates/add-" + this.$singleNotificationChannel;
+        window.location = "/services/" + encodeURIComponent(this.singleChannelService) + "/templates/add-" + encodeURIComponent(this.singleNotificationChannel);
       } else if (this.currentState === 'add-new-template') {
         // Check if a template type is selected
-        const selectedTemplateType = this.$form.find('input[name="add_template_by_template_type"]:checked').val();
+        const selectedInput = this.form.querySelector('input[name="add_template_by_template_type"]:checked');
+        const selectedTemplateType = selectedInput ? selectedInput.value : null;
 
         if (selectedTemplateType) {
           // Template type is selected, let the form submit normally
@@ -209,7 +284,7 @@
         } else {
           // No template type selected, show the selection UI
           event.preventDefault();
-          this.$form.find('input[type=checkbox]').prop('checked', false);
+          this.form.querySelectorAll('input[type=checkbox]').forEach(input => input.checked = false);
           this.selectionStatus.update({ total: 0, templates: 0, folders: 0 });
 
           if (this.stateChanged()) {
@@ -254,15 +329,19 @@
         return results.join(', ') + ' selected';
       },
       'update': numSelected => {
-        let message = (numSelected.total > 0) ? this.selectionStatus.selected(numSelected) : this.selectionStatus.default;
+        const message = (numSelected.total > 0) ? this.selectionStatus.selected(numSelected) : this.selectionStatus.default;
 
-        $('.template-list-selected-counter__count').html(message);
-        this.$liveRegionCounter.html(message);
+        const counters = document.querySelectorAll('.template-list-selected-counter__count');
+        counters.forEach(counter => counter.textContent = message);
+
+        if (this.liveRegionCounter) {
+          this.liveRegionCounter.textContent = message;
+        }
       }
     };
 
     this.templateFolderCheckboxChanged = function() {
-      let numSelected = this.countSelectedCheckboxes();
+      const numSelected = this.countSelectedCheckboxes();
 
       if (this.currentState === 'nothing-selected-buttons' && numSelected.total !== 0) {
         // user has just selected first item
@@ -278,8 +357,11 @@
 
       this.selectionStatus.update(numSelected);
 
-      $('.template-list-selected-counter').toggle(this.hasCheckboxes());
-
+      const counters = document.querySelectorAll('.template-list-selected-counter');
+      const shouldShow = this.hasCheckboxes();
+      counters.forEach(counter => {
+        counter.style.display = shouldShow ? '' : 'none';
+      });
     };
 
     this.templateTypeChanged = function() {
@@ -287,24 +369,31 @@
     };
 
     this.updateContinueButtonState = function() {
-      const selectedTemplateType = this.$form.find('input[name="add_template_by_template_type"]:checked').val();
-      const continueButton = this.$form.find('#add_new_template_form button[value="add-new-template"]');
+      const selectedInput = this.form.querySelector('input[name="add_template_by_template_type"]:checked');
+      const selectedTemplateType = selectedInput ? selectedInput.value : null;
+      const continueButton = this.form.querySelector('#add_new_template_form button[value="add-new-template"]');
 
-      if (selectedTemplateType) {
-        continueButton.prop('disabled', false);
-      } else {
-        continueButton.prop('disabled', true);
+      if (continueButton) {
+        continueButton.disabled = !selectedTemplateType;
       }
     };
 
     this.hasCheckboxes = function() {
-      return !!this.$form.find('input:checkbox').length;
+      return this.form.querySelectorAll('input[type="checkbox"]').length > 0;
     };
 
     this.countSelectedCheckboxes = function() {
-      const allSelected = this.$form.find('input:checkbox:checked');
-      const templates = allSelected.filter((_, el) => $(el).siblings('.template-list-template').length > 0).length;
-      const folders = allSelected.filter((_, el) => $(el).siblings('.template-list-folder').length > 0).length;
+      const allSelected = Array.from(this.form.querySelectorAll('input[type="checkbox"]:checked'));
+      // Check for sibling elements to determine if checkbox is for template or folder
+      // This matches the original jQuery logic: $(el).siblings('.template-list-template')
+      const templates = allSelected.filter(el => {
+        if (!el.parentElement) return false;
+        return el.parentElement.querySelector('.template-list-template') !== null;
+      }).length;
+      const folders = allSelected.filter(el => {
+        if (!el.parentElement) return false;
+        return el.parentElement.querySelector('.template-list-folder') !== null;
+      }).length;
       const results = {
         'templates': templates,
         'folders': folders,
@@ -314,48 +403,79 @@
     };
 
     this.render = function() {
-      let currentStateObj = this.states.filter(state => { return (state.key === this.currentState); })[0];
+      const currentStateObj = this.states.find(state => state.key === this.currentState);
       let scrollTop;
 
       // detach everything, unless they are the currentState
-      this.states.forEach(
-        state => (state.key === this.currentState ? this.$liveRegionCounter.before(state.$el) : state.$el.detach())
-      );
+      this.states.forEach(state => {
+        if (state.key === this.currentState) {
+          if (state.el) {
+            this.liveRegionCounter.insertAdjacentElement('beforebegin', state.el);
+          }
+        } else {
+          if (state.el && state.el.parentElement) {
+            state.el.remove();
+          }
+        }
+      });
 
       if (this.currentState === 'add-new-template') {
-        this.$form.find('.template-list-item').addClass('js-hidden');
-        $('.live-search').addClass('js-hidden');
-        $('#breadcrumb-template-folders').addClass('js-hidden');
-        $('#template-list').addClass('js-hidden');
-        this.$form.find('input[type=checkbox]').prop('checked', false);
+        this.form.querySelectorAll('.template-list-item').forEach(el => el.classList.add('js-hidden'));
+
+        const liveSearch = document.querySelector('.live-search');
+        if (liveSearch) liveSearch.classList.add('js-hidden');
+
+        const breadcrumb = document.getElementById('breadcrumb-template-folders');
+        if (breadcrumb) breadcrumb.classList.add('js-hidden');
+
+        const templateList = document.getElementById('template-list');
+        if (templateList) templateList.classList.add('js-hidden');
+
+        this.form.querySelectorAll('input[type=checkbox]').forEach(input => input.checked = false);
         this.selectionStatus.update({ total: 0, templates: 0, folders: 0 });
 
-        $('#page-title').text('New Template');
-        $('#page-description').text('Every message starts with a template. Choose to start with a blank template or copy an existing template.');
+        const pageTitle = document.getElementById('page-title');
+        if (pageTitle) pageTitle.textContent = 'New Template';
+
+        const pageDescription = document.getElementById('page-description');
+        if (pageDescription) pageDescription.textContent = 'Every message starts with a template. Choose to start with a blank template or copy an existing template.';
+
         document.title = 'New Templates';
 
         // Disable Continue button initially and update based on selection
         this.updateContinueButtonState();
       } else {
-        this.$form.find('.template-list-item').removeClass('js-hidden');
-        $('.live-search').removeClass('js-hidden');
-        $('#breadcrumb-template-folders').removeClass('js-hidden');
-        $('#template-list').removeClass('js-hidden');
+        this.form.querySelectorAll('.template-list-item').forEach(el => el.classList.remove('js-hidden'));
+
+        const liveSearch = document.querySelector('.live-search');
+        if (liveSearch) liveSearch.classList.remove('js-hidden');
+
+        const breadcrumb = document.getElementById('breadcrumb-template-folders');
+        if (breadcrumb) breadcrumb.classList.remove('js-hidden');
+
+        const templateList = document.getElementById('template-list');
+        if (templateList) templateList.classList.remove('js-hidden');
+
+        const pageTitle = document.getElementById('page-title');
+        if (pageTitle) pageTitle.textContent = 'Select or create a template';
+
+        const pageDescription = document.getElementById('page-description');
+        if (pageDescription) pageDescription.textContent = 'Every message starts with a template. To send, choose or create a template.';
 
-        $('#page-title').text('Select or create a template');
-        $('#page-description').text('Every message starts with a template. To send, choose or create a template.');
         document.title = 'Select or create a template';
       }
 
       if (currentStateObj && 'setFocus' in currentStateObj) {
-        scrollTop = $(window).scrollTop();
+        scrollTop = window.scrollY;
         currentStateObj.setFocus();
-        $(window).scrollTop(scrollTop);
+        window.scrollTo(window.scrollX, scrollTop);
       }
     };
 
-    this.nothingSelectedButtons = $(`
-      <div id="nothing_selected">
+    const createNothingSelectedButtons = () => {
+      const div = document.createElement('div');
+      div.id = 'nothing_selected';
+      div.innerHTML = `
         <div class="js-stick-at-bottom-when-scrolling">
           <div class="usa-button-group">
             <button class="usa-button" value="add-new-template" aria-expanded="false" role="button">
@@ -371,11 +491,14 @@
             </span>
           </div>
         </div>
-      </div>
-    `).get(0);
+      `;
+      return div;
+    };
 
-    this.itemsSelectedButtons = $(`
-      <div id="items_selected">
+    const createItemsSelectedButtons = () => {
+      const div = document.createElement('div');
+      div.id = 'items_selected';
+      div.innerHTML = `
         <div class="js-stick-at-bottom-when-scrolling">
           <div class="usa-button-group">
             <button class="usa-button" value="move-to-existing-folder" aria-expanded="false" role="button">
@@ -387,12 +510,16 @@
           </div>
           <div class="template-list-selected-counter" aria-hidden="true">
             <span class="template-list-selected-counter__count text-base" aria-hidden="true">
-              ${this.selectionStatus.selected(1)}
+              ${this.selectionStatus.selected({ templates: 1, folders: 0, total: 1 })}
             </span>
           </div>
         </div>
-      </div>
-    `).get(0);
+      `;
+      return div;
+    };
+
+    this.nothingSelectedButtons = createNothingSelectedButtons();
+    this.itemsSelectedButtons = createItemsSelectedButtons();
   };
 
 })(window);
diff --git a/app/assets/javascripts/updateStatus.js b/app/assets/javascripts/updateStatus.js
index ce6aff6ce..fc690be97 100644
--- a/app/assets/javascripts/updateStatus.js
+++ b/app/assets/javascripts/updateStatus.js
@@ -3,9 +3,9 @@
 
   window.NotifyModules['update-status'] = function() {
 
-    const getRenderer = $component => response => $component.html(
-      response.html
-    );
+    const getRenderer = component => response => {
+      component.innerHTML = response.html;
+    };
 
     const throttle = (func, limit) => {
 
@@ -41,39 +41,38 @@
 
       let id = 'update-status';
 
-      this.$component = $(component);
-      this.$textbox = $('#' + this.$component.data('target'));
+      this.component = component;
+      this.textbox = document.getElementById(this.component.dataset.target);
 
-      this.$component
-        .attr('id', id);
+      this.component.setAttribute('id', id);
 
-      this.$textbox
-        .attr(
-          'aria-describedby',
-          (
-            this.$textbox.attr('aria-describedby') || ''
-          ) + (
-            this.$textbox.attr('aria-describedby') ? ' ' : ''
-          ) + id
-        )
-        .on('input', throttle(this.update, 150))
-        .trigger('input');
+      const currentAriaDescribedBy = this.textbox.getAttribute('aria-describedby') || '';
+      const newAriaDescribedBy = currentAriaDescribedBy + (currentAriaDescribedBy ? ' ' : '') + id;
+      this.textbox.setAttribute('aria-describedby', newAriaDescribedBy);
+
+      this.textbox.addEventListener('input', throttle(this.update, 150));
+      this.textbox.dispatchEvent(new Event('input'));
 
     };
 
     this.update = () => {
 
-      $.ajax(
-        this.$component.data('updates-url'),
-        {
-          'method': 'post',
-          'data': this.$textbox.parents('form').serialize()
-        }
-      ).done(
-        getRenderer(this.$component)
-      ).fail(
-        () => {}
-      );
+      const form = this.textbox.closest('form');
+      const formData = new FormData(form);
+
+      fetch(this.component.dataset.updatesUrl, {
+        method: 'POST',
+        body: formData,
+        credentials: 'same-origin'
+      })
+        .then(response => {
+          if (!response.ok) {
+            throw new Error('HTTP error');
+          }
+          return response.json();
+        })
+        .then(getRenderer(this.component))
+        .catch(() => {});
 
     };
 
diff --git a/app/assets/js/init.uswds.js b/app/assets/js/init.uswds.js
deleted file mode 100644
index 688fff06f..000000000
--- a/app/assets/js/init.uswds.js
+++ /dev/null
@@ -1,8 +0,0 @@
-document.addEventListener("DOMContentLoaded", function () {
-    if (window.uswds && typeof window.uswds.init === 'function') {
-      console.log("Calling USWDS init");
-      window.uswds.init();
-    } else {
-      console.error("USWDS not found or init is not a function");
-    }
-  });
diff --git a/app/assets/js/uswds-init.js b/app/assets/js/uswds-init.js
deleted file mode 100644
index 014c68d06..000000000
--- a/app/assets/js/uswds-init.js
+++ /dev/null
@@ -1,24 +0,0 @@
-/* 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/app/assets/js/uswds-init.min.js b/app/assets/js/uswds-init.min.js
deleted file mode 100644
index 20e490fc3..000000000
--- a/app/assets/js/uswds-init.min.js
+++ /dev/null
@@ -1,2 +0,0 @@
-!function(){"use strict";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/app/content/get-started.md b/app/content/get-started.md
index c97b9efc6..00444d544 100644
--- a/app/content/get-started.md
+++ b/app/content/get-started.md
@@ -14,8 +14,8 @@ Learn how to [personalize messages](/using-notify/how-to) to increase response.
 Learn about message _parts_ and [how limits are calculated](/using-notify/pricing).
 
 5. ## Start sending messages
-To remove the restrictions of Trial Mode and begin sending messages to clients complete the <a class="usa-link usa-link--external" href="https://docs.google.com/forms/d/1fnaBtxuGf3q-OdGVyt2LqBKvp9_P21kmKJa0yIK8rWM/edit">Go-Live Form</a>.
-We’ll respond within one business day.
+To remove the restrictions of Trial Mode and begin sending messages to people complete the <a class="usa-link usa-link--external" href="https://docs.google.com/forms/d/1fnaBtxuGf3q-OdGVyt2LqBKvp9_P21kmKJa0yIK8rWM/edit">Go-Live Form</a>.
+We'll respond within one business day.
 
 ### Questions?
 [Contact the Notify team](/support)
diff --git a/app/templates/views/guides/benchmark-performance.html b/app/templates/views/guides/benchmark-performance.html
index 39ca69700..87bf11b93 100644
--- a/app/templates/views/guides/benchmark-performance.html
+++ b/app/templates/views/guides/benchmark-performance.html
@@ -80,14 +80,14 @@
     document submission, and maintenance reminders.
   </p>
   <h3>Appointment reminders</h3>
-  <p class="text-light">Benchmark: Clients were <span class="text-bold">79%</span> more
+  <p class="text-light">Benchmark: People were <span class="text-bold">79%</span> more
     likely to keep their appointment after receiving a text reminder.</p>
   <ul>
     <li>
       <p>You will likely see more completed appointments.</p>
     </li>
   </ul>
-  <p class="text-light">Benchmark: Clients were <span class="text-bold">55%</span> more
+  <p class="text-light">Benchmark: People were <span class="text-bold">55%</span> more
     likely to complete an interview after receiving an interview reminder</p>
   <ul>
     <li>
@@ -97,7 +97,7 @@
 
   <h3>Document submission</h3>
     <p class="text-light">
-      Benchmark: Clients were <span class="text-bold">6%</span> more likely to complete document submission after
+      Benchmark: People were <span class="text-bold">6%</span> more likely to complete document submission after
       receiving a customized list of required documents via text
     </p>
   <ul>
diff --git a/app/templates/views/guides/establish-trust.html b/app/templates/views/guides/establish-trust.html
index 5d72f66b4..6259b97ac 100644
--- a/app/templates/views/guides/establish-trust.html
+++ b/app/templates/views/guides/establish-trust.html
@@ -189,7 +189,7 @@
   "image_src": asset_url('images/project-management.svg'),
   "card_heading": "Case management systems",
   "alt_text": "Graphic representing project management",
-  "p_text": "When it makes sense, include information about texts being sent to specific clients on individual splash
+  "p_text": "When it makes sense, include information about texts being sent to specific people on individual splash
   pages or within case management notes.",
   },
   ] %}
diff --git a/backstop.config.js b/backstop.config.js
index d9af97d0f..0ff009948 100644
--- a/backstop.config.js
+++ b/backstop.config.js
@@ -1,6 +1,6 @@
 const { urls, baseUrl } = require('./urls');
 
-const MISMATCH_THRESHOLD = .5;
+const MISMATCH_THRESHOLD = .2;
 const SCREENSHOT_DELAY = 2000;
 
 const createScenariosFromUrls = (urls, delay = SCREENSHOT_DELAY) => {
diff --git a/backstop_data/bitmaps_reference/backstop_test_About_0_document_0_desktop.png b/backstop_data/bitmaps_reference/backstop_test_About_0_document_0_desktop.png
index bbb57ee41..b1f93282c 100644
Binary files a/backstop_data/bitmaps_reference/backstop_test_About_0_document_0_desktop.png and b/backstop_data/bitmaps_reference/backstop_test_About_0_document_0_desktop.png differ
diff --git a/backstop_data/bitmaps_reference/backstop_test_Benchmark_Performance_0_document_0_desktop.png b/backstop_data/bitmaps_reference/backstop_test_Benchmark_Performance_0_document_0_desktop.png
index 54fc6c196..815fd6e48 100644
Binary files a/backstop_data/bitmaps_reference/backstop_test_Benchmark_Performance_0_document_0_desktop.png and b/backstop_data/bitmaps_reference/backstop_test_Benchmark_Performance_0_document_0_desktop.png differ
diff --git a/backstop_data/bitmaps_reference/backstop_test_Choose_Service_-_Accounts_1_ausa-buttonhrefadd-service_0_desktop.png b/backstop_data/bitmaps_reference/backstop_test_Choose_Service_-_Accounts_1_ausa-buttonhrefadd-service_0_desktop.png
index d480a6ac7..0c32191b4 100644
Binary files a/backstop_data/bitmaps_reference/backstop_test_Choose_Service_-_Accounts_1_ausa-buttonhrefadd-service_0_desktop.png and b/backstop_data/bitmaps_reference/backstop_test_Choose_Service_-_Accounts_1_ausa-buttonhrefadd-service_0_desktop.png differ
diff --git a/backstop_data/bitmaps_reference/backstop_test_Email_Not_Received_0_document_0_desktop.png b/backstop_data/bitmaps_reference/backstop_test_Email_Not_Received_0_document_0_desktop.png
index 2d19d048a..57756c84f 100644
Binary files a/backstop_data/bitmaps_reference/backstop_test_Email_Not_Received_0_document_0_desktop.png and b/backstop_data/bitmaps_reference/backstop_test_Email_Not_Received_0_document_0_desktop.png differ
diff --git a/backstop_data/bitmaps_reference/backstop_test_Establish_Trust_0_document_0_desktop.png b/backstop_data/bitmaps_reference/backstop_test_Establish_Trust_0_document_0_desktop.png
index 61073a54f..810c0f416 100644
Binary files a/backstop_data/bitmaps_reference/backstop_test_Establish_Trust_0_document_0_desktop.png and b/backstop_data/bitmaps_reference/backstop_test_Establish_Trust_0_document_0_desktop.png differ
diff --git a/backstop_data/bitmaps_reference/backstop_test_Get_Started_0_document_0_desktop.png b/backstop_data/bitmaps_reference/backstop_test_Get_Started_0_document_0_desktop.png
index 0e5cc83e1..016cfc95c 100644
Binary files a/backstop_data/bitmaps_reference/backstop_test_Get_Started_0_document_0_desktop.png and b/backstop_data/bitmaps_reference/backstop_test_Get_Started_0_document_0_desktop.png differ
diff --git a/backstop_data/bitmaps_reference/backstop_test_Get_Started_Page_-_Highlight_Trial_Mode_0_document_0_desktop.png b/backstop_data/bitmaps_reference/backstop_test_Get_Started_Page_-_Highlight_Trial_Mode_0_document_0_desktop.png
index 0e5cc83e1..016cfc95c 100644
Binary files a/backstop_data/bitmaps_reference/backstop_test_Get_Started_Page_-_Highlight_Trial_Mode_0_document_0_desktop.png and b/backstop_data/bitmaps_reference/backstop_test_Get_Started_Page_-_Highlight_Trial_Mode_0_document_0_desktop.png differ
diff --git a/backstop_data/bitmaps_reference/backstop_test_Performance_0_document_0_desktop.png b/backstop_data/bitmaps_reference/backstop_test_Performance_0_document_0_desktop.png
index 39878f79c..45fa9747a 100644
Binary files a/backstop_data/bitmaps_reference/backstop_test_Performance_0_document_0_desktop.png and b/backstop_data/bitmaps_reference/backstop_test_Performance_0_document_0_desktop.png differ
diff --git a/backstop_data/bitmaps_reference/backstop_test_Platform_Admin_Trial_Services_0_document_0_desktop.png b/backstop_data/bitmaps_reference/backstop_test_Platform_Admin_Trial_Services_0_document_0_desktop.png
index ed4903a90..7f937fe99 100644
Binary files a/backstop_data/bitmaps_reference/backstop_test_Platform_Admin_Trial_Services_0_document_0_desktop.png and b/backstop_data/bitmaps_reference/backstop_test_Platform_Admin_Trial_Services_0_document_0_desktop.png differ
diff --git a/backstop_data/bitmaps_reference/backstop_test_Service_Notifications_0_document_0_desktop.png b/backstop_data/bitmaps_reference/backstop_test_Service_Notifications_0_document_0_desktop.png
deleted file mode 100644
index 82ece6d30..000000000
Binary files a/backstop_data/bitmaps_reference/backstop_test_Service_Notifications_0_document_0_desktop.png and /dev/null differ
diff --git a/backstop_data/bitmaps_reference/backstop_test_Sign_In_0_document_0_desktop.png b/backstop_data/bitmaps_reference/backstop_test_Sign_In_0_document_0_desktop.png
index 2d19d048a..57756c84f 100644
Binary files a/backstop_data/bitmaps_reference/backstop_test_Sign_In_0_document_0_desktop.png and b/backstop_data/bitmaps_reference/backstop_test_Sign_In_0_document_0_desktop.png differ
diff --git a/backstop_data/bitmaps_reference/backstop_test_Template_Copy_0_document_0_desktop.png b/backstop_data/bitmaps_reference/backstop_test_Template_Copy_0_document_0_desktop.png
index e1222dfb6..dc677211d 100644
Binary files a/backstop_data/bitmaps_reference/backstop_test_Template_Copy_0_document_0_desktop.png and b/backstop_data/bitmaps_reference/backstop_test_Template_Copy_0_document_0_desktop.png differ
diff --git a/backstop_data/bitmaps_reference/backstop_test_Text_Not_Received_0_document_0_desktop.png b/backstop_data/bitmaps_reference/backstop_test_Text_Not_Received_0_document_0_desktop.png
index 2d19d048a..57756c84f 100644
Binary files a/backstop_data/bitmaps_reference/backstop_test_Text_Not_Received_0_document_0_desktop.png and b/backstop_data/bitmaps_reference/backstop_test_Text_Not_Received_0_document_0_desktop.png differ
diff --git a/gulpfile.js b/gulpfile.js
index 53d701469..6737950c7 100644
--- a/gulpfile.js
+++ b/gulpfile.js
@@ -58,7 +58,6 @@ const javascripts = () => {
 
   const notifyModules2 = src([
     paths.src + 'javascripts/collapsibleCheckboxes.js',
-    paths.src + 'javascripts/radioSlider.js',
     paths.src + 'javascripts/updateStatus.js',
     paths.src + 'javascripts/timeoutPopup.js',
     paths.src + 'javascripts/main.js',
diff --git a/package-lock.json b/package-lock.json
index 231c82cdf..b8dd561ad 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -15,7 +15,6 @@
         "@uswds/uswds": "^3.13.0",
         "cbor-js": "0.1.0",
         "d3": "^7.9.0",
-        "jquery": "3.7.1",
         "playwright": "^1.56.1",
         "python": "^0.0.4",
         "query-command-supported": "1.0.0",
@@ -46,7 +45,7 @@
         "webpack-cli": "^6.0.1"
       },
       "engines": {
-        "node": ">=22.0.0"
+        "node": ">=24.0.0"
       }
     },
     "node_modules/@asamuzakjp/css-color": {
@@ -101,6 +100,7 @@
       "integrity": "sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@babel/code-frame": "^7.27.1",
         "@babel/generator": "^7.28.5",
@@ -1917,6 +1917,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=18"
       },
@@ -1940,6 +1941,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=18"
       }
@@ -1954,6 +1956,40 @@
         "node": ">=14.17.0"
       }
     },
+    "node_modules/@emnapi/core": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.6.0.tgz",
+      "integrity": "sha512-zq/ay+9fNIJJtJiZxdTnXS20PllcYMX3OE23ESc4HK/bdYu3cOWYVhsOhVnXALfU/uqJIxn5NBPd9z4v+SfoSg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/wasi-threads": "1.1.0",
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@emnapi/runtime": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.6.0.tgz",
+      "integrity": "sha512-obtUmAHTMjll499P+D9A3axeJFlhdjOWdKUNs/U6QIGT7V5RjcUW1xToAzjvmgTSQhDbYn/NwfTRoJcQ2rNBxA==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@emnapi/wasi-threads": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.1.0.tgz",
+      "integrity": "sha512-WI0DdZ8xFSbgMjR1sFsKABJ/C5OnRrjT06JXbZKexJGrDuPTzZdDYfFlsgcCXCyf+suG5QU2e/y1Wo2V/OapLQ==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
     "node_modules/@isaacs/cliui": {
       "version": "8.0.2",
       "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz",
@@ -3133,6 +3169,19 @@
         "pngjs": "^6.0.0"
       }
     },
+    "node_modules/@napi-rs/wasm-runtime": {
+      "version": "0.2.12",
+      "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-0.2.12.tgz",
+      "integrity": "sha512-ZVWUcfwY4E/yPitQJl481FjFo3K22D6qF0DuFH6Y/nbnE11GY5uguDxZMGXPQ8WQ0128MXQD7TnfHyK4oWoIJQ==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/core": "^1.4.3",
+        "@emnapi/runtime": "^1.4.3",
+        "@tybys/wasm-util": "^0.10.0"
+      }
+    },
     "node_modules/@parcel/watcher": {
       "version": "2.5.1",
       "resolved": "https://registry.npmjs.org/@parcel/watcher/-/watcher-2.5.1.tgz",
@@ -3169,6 +3218,26 @@
         "@parcel/watcher-win32-x64": "2.5.1"
       }
     },
+    "node_modules/@parcel/watcher-android-arm64": {
+      "version": "2.5.1",
+      "resolved": "https://registry.npmjs.org/@parcel/watcher-android-arm64/-/watcher-android-arm64-2.5.1.tgz",
+      "integrity": "sha512-KF8+j9nNbUN8vzOFDpRMsaKBHZ/mcjEjMToVMJOhTozkDonQFFrRcfdLWn6yWKCmJKmdVxSgHiYvTCef4/qcBA==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">= 10.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
     "node_modules/@parcel/watcher-darwin-arm64": {
       "version": "2.5.1",
       "resolved": "https://registry.npmjs.org/@parcel/watcher-darwin-arm64/-/watcher-darwin-arm64-2.5.1.tgz",
@@ -3189,6 +3258,226 @@
         "url": "https://opencollective.com/parcel"
       }
     },
+    "node_modules/@parcel/watcher-darwin-x64": {
+      "version": "2.5.1",
+      "resolved": "https://registry.npmjs.org/@parcel/watcher-darwin-x64/-/watcher-darwin-x64-2.5.1.tgz",
+      "integrity": "sha512-1ZXDthrnNmwv10A0/3AJNZ9JGlzrF82i3gNQcWOzd7nJ8aj+ILyW1MTxVk35Db0u91oD5Nlk9MBiujMlwmeXZg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 10.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/@parcel/watcher-freebsd-x64": {
+      "version": "2.5.1",
+      "resolved": "https://registry.npmjs.org/@parcel/watcher-freebsd-x64/-/watcher-freebsd-x64-2.5.1.tgz",
+      "integrity": "sha512-SI4eljM7Flp9yPuKi8W0ird8TI/JK6CSxju3NojVI6BjHsTyK7zxA9urjVjEKJ5MBYC+bLmMcbAWlZ+rFkLpJQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">= 10.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/@parcel/watcher-linux-arm-glibc": {
+      "version": "2.5.1",
+      "resolved": "https://registry.npmjs.org/@parcel/watcher-linux-arm-glibc/-/watcher-linux-arm-glibc-2.5.1.tgz",
+      "integrity": "sha512-RCdZlEyTs8geyBkkcnPWvtXLY44BCeZKmGYRtSgtwwnHR4dxfHRG3gR99XdMEdQ7KeiDdasJwwvNSF5jKtDwdA==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/@parcel/watcher-linux-arm-musl": {
+      "version": "2.5.1",
+      "resolved": "https://registry.npmjs.org/@parcel/watcher-linux-arm-musl/-/watcher-linux-arm-musl-2.5.1.tgz",
+      "integrity": "sha512-6E+m/Mm1t1yhB8X412stiKFG3XykmgdIOqhjWj+VL8oHkKABfu/gjFj8DvLrYVHSBNC+/u5PeNrujiSQ1zwd1Q==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/@parcel/watcher-linux-arm64-glibc": {
+      "version": "2.5.1",
+      "resolved": "https://registry.npmjs.org/@parcel/watcher-linux-arm64-glibc/-/watcher-linux-arm64-glibc-2.5.1.tgz",
+      "integrity": "sha512-LrGp+f02yU3BN9A+DGuY3v3bmnFUggAITBGriZHUREfNEzZh/GO06FF5u2kx8x+GBEUYfyTGamol4j3m9ANe8w==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/@parcel/watcher-linux-arm64-musl": {
+      "version": "2.5.1",
+      "resolved": "https://registry.npmjs.org/@parcel/watcher-linux-arm64-musl/-/watcher-linux-arm64-musl-2.5.1.tgz",
+      "integrity": "sha512-cFOjABi92pMYRXS7AcQv9/M1YuKRw8SZniCDw0ssQb/noPkRzA+HBDkwmyOJYp5wXcsTrhxO0zq1U11cK9jsFg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/@parcel/watcher-linux-x64-glibc": {
+      "version": "2.5.1",
+      "resolved": "https://registry.npmjs.org/@parcel/watcher-linux-x64-glibc/-/watcher-linux-x64-glibc-2.5.1.tgz",
+      "integrity": "sha512-GcESn8NZySmfwlTsIur+49yDqSny2IhPeZfXunQi48DMugKeZ7uy1FX83pO0X22sHntJ4Ub+9k34XQCX+oHt2A==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/@parcel/watcher-linux-x64-musl": {
+      "version": "2.5.1",
+      "resolved": "https://registry.npmjs.org/@parcel/watcher-linux-x64-musl/-/watcher-linux-x64-musl-2.5.1.tgz",
+      "integrity": "sha512-n0E2EQbatQ3bXhcH2D1XIAANAcTZkQICBPVaxMeaCVBtOpBZpWJuf7LwyWPSBDITb7In8mqQgJ7gH8CILCURXg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/@parcel/watcher-win32-arm64": {
+      "version": "2.5.1",
+      "resolved": "https://registry.npmjs.org/@parcel/watcher-win32-arm64/-/watcher-win32-arm64-2.5.1.tgz",
+      "integrity": "sha512-RFzklRvmc3PkjKjry3hLF9wD7ppR4AKcWNzH7kXR7GUe0Igb3Nz8fyPwtZCSquGrhU5HhUNDr/mKBqj7tqA2Vw==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 10.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/@parcel/watcher-win32-ia32": {
+      "version": "2.5.1",
+      "resolved": "https://registry.npmjs.org/@parcel/watcher-win32-ia32/-/watcher-win32-ia32-2.5.1.tgz",
+      "integrity": "sha512-c2KkcVN+NJmuA7CGlaGD1qJh1cLfDnQsHjE89E60vUEMlqduHGCdCLJCID5geFVM0dOtA3ZiIO8BoEQmzQVfpQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 10.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/@parcel/watcher-win32-x64": {
+      "version": "2.5.1",
+      "resolved": "https://registry.npmjs.org/@parcel/watcher-win32-x64/-/watcher-win32-x64-2.5.1.tgz",
+      "integrity": "sha512-9lHBdJITeNR++EvSQVUcaZoWupyHfXe1jZvGZ06O/5MflPcuPLtEphScIBL+AiCWBO46tDSHzWyD0uDmmZqsgA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 10.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
     "node_modules/@pkgjs/parseargs": {
       "version": "0.11.0",
       "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz",
@@ -3400,8 +3689,7 @@
       "optional": true,
       "os": [
         "android"
-      ],
-      "peer": true
+      ]
     },
     "node_modules/@rollup/rollup-android-arm64": {
       "version": "4.52.4",
@@ -3414,8 +3702,7 @@
       "optional": true,
       "os": [
         "android"
-      ],
-      "peer": true
+      ]
     },
     "node_modules/@rollup/rollup-darwin-arm64": {
       "version": "4.52.4",
@@ -3428,8 +3715,7 @@
       "optional": true,
       "os": [
         "darwin"
-      ],
-      "peer": true
+      ]
     },
     "node_modules/@rollup/rollup-darwin-x64": {
       "version": "4.52.4",
@@ -3442,8 +3728,7 @@
       "optional": true,
       "os": [
         "darwin"
-      ],
-      "peer": true
+      ]
     },
     "node_modules/@rollup/rollup-freebsd-arm64": {
       "version": "4.52.4",
@@ -3456,8 +3741,7 @@
       "optional": true,
       "os": [
         "freebsd"
-      ],
-      "peer": true
+      ]
     },
     "node_modules/@rollup/rollup-freebsd-x64": {
       "version": "4.52.4",
@@ -3470,8 +3754,7 @@
       "optional": true,
       "os": [
         "freebsd"
-      ],
-      "peer": true
+      ]
     },
     "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
       "version": "4.52.4",
@@ -3484,8 +3767,7 @@
       "optional": true,
       "os": [
         "linux"
-      ],
-      "peer": true
+      ]
     },
     "node_modules/@rollup/rollup-linux-arm-musleabihf": {
       "version": "4.52.4",
@@ -3498,8 +3780,7 @@
       "optional": true,
       "os": [
         "linux"
-      ],
-      "peer": true
+      ]
     },
     "node_modules/@rollup/rollup-linux-arm64-gnu": {
       "version": "4.52.4",
@@ -3512,8 +3793,7 @@
       "optional": true,
       "os": [
         "linux"
-      ],
-      "peer": true
+      ]
     },
     "node_modules/@rollup/rollup-linux-arm64-musl": {
       "version": "4.52.4",
@@ -3526,8 +3806,7 @@
       "optional": true,
       "os": [
         "linux"
-      ],
-      "peer": true
+      ]
     },
     "node_modules/@rollup/rollup-linux-loong64-gnu": {
       "version": "4.52.4",
@@ -3540,8 +3819,7 @@
       "optional": true,
       "os": [
         "linux"
-      ],
-      "peer": true
+      ]
     },
     "node_modules/@rollup/rollup-linux-ppc64-gnu": {
       "version": "4.52.4",
@@ -3554,8 +3832,7 @@
       "optional": true,
       "os": [
         "linux"
-      ],
-      "peer": true
+      ]
     },
     "node_modules/@rollup/rollup-linux-riscv64-gnu": {
       "version": "4.52.4",
@@ -3568,8 +3845,7 @@
       "optional": true,
       "os": [
         "linux"
-      ],
-      "peer": true
+      ]
     },
     "node_modules/@rollup/rollup-linux-riscv64-musl": {
       "version": "4.52.4",
@@ -3582,8 +3858,7 @@
       "optional": true,
       "os": [
         "linux"
-      ],
-      "peer": true
+      ]
     },
     "node_modules/@rollup/rollup-linux-s390x-gnu": {
       "version": "4.52.4",
@@ -3596,8 +3871,7 @@
       "optional": true,
       "os": [
         "linux"
-      ],
-      "peer": true
+      ]
     },
     "node_modules/@rollup/rollup-linux-x64-gnu": {
       "version": "4.52.4",
@@ -3610,8 +3884,7 @@
       "optional": true,
       "os": [
         "linux"
-      ],
-      "peer": true
+      ]
     },
     "node_modules/@rollup/rollup-linux-x64-musl": {
       "version": "4.52.4",
@@ -3624,8 +3897,7 @@
       "optional": true,
       "os": [
         "linux"
-      ],
-      "peer": true
+      ]
     },
     "node_modules/@rollup/rollup-openharmony-arm64": {
       "version": "4.52.4",
@@ -3638,8 +3910,7 @@
       "optional": true,
       "os": [
         "openharmony"
-      ],
-      "peer": true
+      ]
     },
     "node_modules/@rollup/rollup-win32-arm64-msvc": {
       "version": "4.52.4",
@@ -3652,8 +3923,7 @@
       "optional": true,
       "os": [
         "win32"
-      ],
-      "peer": true
+      ]
     },
     "node_modules/@rollup/rollup-win32-ia32-msvc": {
       "version": "4.52.4",
@@ -3666,8 +3936,7 @@
       "optional": true,
       "os": [
         "win32"
-      ],
-      "peer": true
+      ]
     },
     "node_modules/@rollup/rollup-win32-x64-gnu": {
       "version": "4.52.4",
@@ -3680,8 +3949,7 @@
       "optional": true,
       "os": [
         "win32"
-      ],
-      "peer": true
+      ]
     },
     "node_modules/@rollup/rollup-win32-x64-msvc": {
       "version": "4.52.4",
@@ -3694,8 +3962,7 @@
       "optional": true,
       "os": [
         "win32"
-      ],
-      "peer": true
+      ]
     },
     "node_modules/@rollup/stream": {
       "version": "3.0.1",
@@ -3742,6 +4009,17 @@
       "integrity": "sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA==",
       "dev": true
     },
+    "node_modules/@tybys/wasm-util": {
+      "version": "0.10.1",
+      "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.1.tgz",
+      "integrity": "sha512-9tTaPJLSiejZKx+Bmog4uSubteqTvFrVrURwkmHixBo0G4seD0zUxp98E1DzUBJxLQ3NPwXrGKDiVjwx/DpPsg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
     "node_modules/@types/babel__core": {
       "version": "7.20.5",
       "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
@@ -3919,6 +4197,34 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/@unrs/resolver-binding-android-arm-eabi": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-android-arm-eabi/-/resolver-binding-android-arm-eabi-1.11.1.tgz",
+      "integrity": "sha512-ppLRUgHVaGRWUx0R0Ut06Mjo9gBaBkg3v/8AxusGLhsIotbBLuRk51rAzqLC8gq6NyyAojEXglNjzf6R948DNw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-android-arm64": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-android-arm64/-/resolver-binding-android-arm64-1.11.1.tgz",
+      "integrity": "sha512-lCxkVtb4wp1v+EoN+HjIG9cIIzPkX5OtM03pQYkG+U5O/wL53LC4QbIeazgiKqluGeVEeBlZahHalCaBvU1a2g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
     "node_modules/@unrs/resolver-binding-darwin-arm64": {
       "version": "1.11.1",
       "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-darwin-arm64/-/resolver-binding-darwin-arm64-1.11.1.tgz",
@@ -3933,6 +4239,233 @@
         "darwin"
       ]
     },
+    "node_modules/@unrs/resolver-binding-darwin-x64": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-darwin-x64/-/resolver-binding-darwin-x64-1.11.1.tgz",
+      "integrity": "sha512-cFzP7rWKd3lZaCsDze07QX1SC24lO8mPty9vdP+YVa3MGdVgPmFc59317b2ioXtgCMKGiCLxJ4HQs62oz6GfRQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-freebsd-x64": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-freebsd-x64/-/resolver-binding-freebsd-x64-1.11.1.tgz",
+      "integrity": "sha512-fqtGgak3zX4DCB6PFpsH5+Kmt/8CIi4Bry4rb1ho6Av2QHTREM+47y282Uqiu3ZRF5IQioJQ5qWRV6jduA+iGw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-arm-gnueabihf": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-arm-gnueabihf/-/resolver-binding-linux-arm-gnueabihf-1.11.1.tgz",
+      "integrity": "sha512-u92mvlcYtp9MRKmP+ZvMmtPN34+/3lMHlyMj7wXJDeXxuM0Vgzz0+PPJNsro1m3IZPYChIkn944wW8TYgGKFHw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-arm-musleabihf": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-arm-musleabihf/-/resolver-binding-linux-arm-musleabihf-1.11.1.tgz",
+      "integrity": "sha512-cINaoY2z7LVCrfHkIcmvj7osTOtm6VVT16b5oQdS4beibX2SYBwgYLmqhBjA1t51CarSaBuX5YNsWLjsqfW5Cw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-arm64-gnu": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-arm64-gnu/-/resolver-binding-linux-arm64-gnu-1.11.1.tgz",
+      "integrity": "sha512-34gw7PjDGB9JgePJEmhEqBhWvCiiWCuXsL9hYphDF7crW7UgI05gyBAi6MF58uGcMOiOqSJ2ybEeCvHcq0BCmQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-arm64-musl": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-arm64-musl/-/resolver-binding-linux-arm64-musl-1.11.1.tgz",
+      "integrity": "sha512-RyMIx6Uf53hhOtJDIamSbTskA99sPHS96wxVE/bJtePJJtpdKGXO1wY90oRdXuYOGOTuqjT8ACccMc4K6QmT3w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-ppc64-gnu": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-ppc64-gnu/-/resolver-binding-linux-ppc64-gnu-1.11.1.tgz",
+      "integrity": "sha512-D8Vae74A4/a+mZH0FbOkFJL9DSK2R6TFPC9M+jCWYia/q2einCubX10pecpDiTmkJVUH+y8K3BZClycD8nCShA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-riscv64-gnu": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-riscv64-gnu/-/resolver-binding-linux-riscv64-gnu-1.11.1.tgz",
+      "integrity": "sha512-frxL4OrzOWVVsOc96+V3aqTIQl1O2TjgExV4EKgRY09AJ9leZpEg8Ak9phadbuX0BA4k8U5qtvMSQQGGmaJqcQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-riscv64-musl": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-riscv64-musl/-/resolver-binding-linux-riscv64-musl-1.11.1.tgz",
+      "integrity": "sha512-mJ5vuDaIZ+l/acv01sHoXfpnyrNKOk/3aDoEdLO/Xtn9HuZlDD6jKxHlkN8ZhWyLJsRBxfv9GYM2utQ1SChKew==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-s390x-gnu": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-s390x-gnu/-/resolver-binding-linux-s390x-gnu-1.11.1.tgz",
+      "integrity": "sha512-kELo8ebBVtb9sA7rMe1Cph4QHreByhaZ2QEADd9NzIQsYNQpt9UkM9iqr2lhGr5afh885d/cB5QeTXSbZHTYPg==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-x64-gnu": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-x64-gnu/-/resolver-binding-linux-x64-gnu-1.11.1.tgz",
+      "integrity": "sha512-C3ZAHugKgovV5YvAMsxhq0gtXuwESUKc5MhEtjBpLoHPLYM+iuwSj3lflFwK3DPm68660rZ7G8BMcwSro7hD5w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-x64-musl": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-x64-musl/-/resolver-binding-linux-x64-musl-1.11.1.tgz",
+      "integrity": "sha512-rV0YSoyhK2nZ4vEswT/QwqzqQXw5I6CjoaYMOX0TqBlWhojUf8P94mvI7nuJTeaCkkds3QE4+zS8Ko+GdXuZtA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-wasm32-wasi": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-wasm32-wasi/-/resolver-binding-wasm32-wasi-1.11.1.tgz",
+      "integrity": "sha512-5u4RkfxJm+Ng7IWgkzi3qrFOvLvQYnPBmjmZQ8+szTK/b31fQCnleNl1GgEt7nIsZRIf5PLhPwT0WM+q45x/UQ==",
+      "cpu": [
+        "wasm32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@napi-rs/wasm-runtime": "^0.2.11"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/@unrs/resolver-binding-win32-arm64-msvc": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-win32-arm64-msvc/-/resolver-binding-win32-arm64-msvc-1.11.1.tgz",
+      "integrity": "sha512-nRcz5Il4ln0kMhfL8S3hLkxI85BXs3o8EYoattsJNdsX4YUU89iOkVn7g0VHSRxFuVMdM4Q1jEpIId1Ihim/Uw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-win32-ia32-msvc": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-win32-ia32-msvc/-/resolver-binding-win32-ia32-msvc-1.11.1.tgz",
+      "integrity": "sha512-DCEI6t5i1NmAZp6pFonpD5m7i6aFrpofcp4LA2i8IIq60Jyo28hamKBxNrZcyOwVOZkgsRp9O2sXWBWP8MnvIQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-win32-x64-msvc": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-win32-x64-msvc/-/resolver-binding-win32-x64-msvc-1.11.1.tgz",
+      "integrity": "sha512-lrW200hZdbfRtztbygyaq/6jP6AKE8qQN2KvPcJ+x7wiD038YtnYtZ82IMNJ69GJibV7bwL3y9FgK+5w/pYt6g==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
     "node_modules/@uswds/uswds": {
       "version": "3.13.0",
       "resolved": "https://registry.npmjs.org/@uswds/uswds/-/uswds-3.13.0.tgz",
@@ -4190,6 +4723,7 @@
       "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -4238,6 +4772,7 @@
       "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.16.0.tgz",
       "integrity": "sha512-F0twR8U1ZU67JIEtekUcLkXkoO5mMMmgGD8sK/xUFzJ805jxHQl92hImFAqqXMyMYjSPOyUPAwHYhB72g5sTXw==",
       "dev": true,
+      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.3",
         "json-schema-traverse": "^1.0.0",
@@ -4934,6 +5469,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "baseline-browser-mapping": "^2.8.9",
         "caniuse-lite": "^1.0.30001746",
@@ -5828,6 +6364,7 @@
       "resolved": "https://registry.npmjs.org/d3-selection/-/d3-selection-3.0.0.tgz",
       "integrity": "sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ==",
       "license": "ISC",
+      "peer": true,
       "engines": {
         "node": ">=12"
       }
@@ -6089,7 +6626,8 @@
       "version": "0.0.1312386",
       "resolved": "https://registry.npmjs.org/devtools-protocol/-/devtools-protocol-0.0.1312386.tgz",
       "integrity": "sha512-DPnhUXvmvKT2dFA/j7B+riVLUt9Q6RKJlcppojL5CoRywJJKLDYnRlw0gTFKfgDPHP5E04UoB71SxoJlVZy8FA==",
-      "dev": true
+      "dev": true,
+      "peer": true
     },
     "node_modules/diff": {
       "version": "3.5.0",
@@ -9569,11 +10107,6 @@
       "integrity": "sha512-WZzeDOEtTOBK4Mdsar0IqEU5sMr3vSV2RqkAIzUEV2BHnUfKGyswWFPFwK5EeDo93K3FohSHbLAjj0s1Wzd+dg==",
       "dev": true
     },
-    "node_modules/jquery": {
-      "version": "3.7.1",
-      "resolved": "https://registry.npmjs.org/jquery/-/jquery-3.7.1.tgz",
-      "integrity": "sha512-m4avr8yL8kmFN8psrbFFFmB/If14iN5o9nw/NgnnM+kybDJpRsAynV2BsfpTYrTRysYUdADVD7CkUUizgkpLfg=="
-    },
     "node_modules/js-tokens": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
@@ -9606,6 +10139,7 @@
       "integrity": "sha512-Cvc9WUhxSMEo4McES3P7oK3QaXldCfNWp7pl2NNeiIFlCoLr3kfq9kb1fxftiwk1FLV7CvpvDfonxtzUDeSOPg==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "cssstyle": "^4.2.1",
         "data-urls": "^5.0.0",
@@ -11006,6 +11540,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "nanoid": "^3.3.8",
         "picocolors": "^1.1.1",
@@ -11614,6 +12149,7 @@
       "resolved": "https://registry.npmjs.org/sass-embedded/-/sass-embedded-1.93.2.tgz",
       "integrity": "sha512-FvQdkn2dZ8DGiLgi0Uf4zsj7r/BsiLImNa5QJ10eZalY6NfZyjrmWGFcuCN5jNwlDlXFJnftauv+UtvBKLvepQ==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@bufbuild/protobuf": "^2.5.0",
         "buffer-builder": "^0.2.0",
@@ -13171,6 +13707,7 @@
       "integrity": "sha512-7h/weGm9d/ywQ6qzJ+Xy+r9n/3qgp/thalBbpOi5i223dPXKi04IBtqPN9nTd+jBc7QKfvDbaBnFipYp4sJAUQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@types/eslint-scope": "^3.7.7",
         "@types/estree": "^1.0.8",
@@ -13220,6 +13757,7 @@
       "integrity": "sha512-MfwFQ6SfwinsUVi0rNJm7rHZ31GyTcpVE5pgVA3hwFRb7COD4TzjUUwhGWKfO50+xdc2MQPuEBBJoqIMGt3JDw==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@discoveryjs/json-ext": "^0.6.1",
         "@webpack-cli/configtest": "^3.0.1",
diff --git a/package.json b/package.json
index 134c57f6a..6d4c01d41 100644
--- a/package.json
+++ b/package.json
@@ -3,7 +3,7 @@
   "version": "0.0.1",
   "description": "Admin front end for Notify",
   "engines": {
-    "node": ">=22.0.0"
+    "node": ">=24.0.0"
   },
   "scripts": {
     "lint": "jshint app/assets/javascripts",
@@ -36,7 +36,6 @@
     "@uswds/uswds": "^3.13.0",
     "cbor-js": "0.1.0",
     "d3": "^7.9.0",
-    "jquery": "3.7.1",
     "playwright": "^1.56.1",
     "python": "^0.0.4",
     "query-command-supported": "1.0.0",
diff --git a/tests/end_to_end/conftest.py b/tests/end_to_end/conftest.py
index eb90086ce..f8365cd74 100644
--- a/tests/end_to_end/conftest.py
+++ b/tests/end_to_end/conftest.py
@@ -1,7 +1,9 @@
+import datetime
 import os
 
 import pytest
 from axe_core_python.sync_playwright import Axe
+from playwright.sync_api import Page
 
 E2E_TEST_URI = os.getenv("NOTIFY_E2E_TEST_URI")
 
@@ -14,13 +16,9 @@ def end_to_end_context(browser):
 
 @pytest.fixture
 def authenticated_page(end_to_end_context):
-    # Open a new page and go to the site.
     page = end_to_end_context.new_page()
     page.goto(f"{E2E_TEST_URI}/sign-in")
-
-    # Wait for the next page to fully load.
     page.wait_for_load_state("domcontentloaded")
-
     return page
 
 
@@ -64,3 +62,100 @@ def _mock_common_api_calls(mocker):
 
     # Optional: silence New Relic or other external integrations
     mocker.patch("newrelic.agent.initialize", return_value=None)
+
+
+@pytest.fixture
+def e2e_test_service(authenticated_page: Page, end_to_end_context):
+    """
+    Creates a test service for E2E tests with guaranteed cleanup.
+
+    This fixture ensures services are deleted even if tests fail, preventing
+    database pollution from abandoned E2E test services.
+    """
+    page = authenticated_page
+    current_date_time = datetime.datetime.now()
+    service_name = "E2E Federal Test Service {now} - {browser_type}".format(
+        now=current_date_time.strftime("%m/%d/%Y %H:%M:%S"),
+        browser_type=end_to_end_context.browser.browser_type.name,
+    )
+
+    service_info = {
+        "name": service_name,
+        "page": page,
+    }
+
+    yield service_info
+
+    # runs even if test fails
+    try:
+        _cleanup_test_service(page, service_name)
+    except Exception as e:
+        print(f"Warning: Failed to cleanup service '{service_name}': {e}")  # noqa: T201
+
+
+@pytest.fixture
+def e2e_created_service(e2e_test_service):  # noqa: PT022
+    """
+    Creates a test service AND completes the service creation workflow.
+
+    This fixture not only generates a unique service name but also creates
+    the service through the UI, providing a ready-to-use service for tests.
+    """
+    service_info = e2e_test_service
+    page = service_info["page"]
+    service_name = service_info["name"]
+
+    page.goto(f"{E2E_TEST_URI}/accounts")
+    page.wait_for_load_state("domcontentloaded")
+
+    add_service_button = page.get_by_role("button", name="Add a new service")
+    add_service_button.click()
+    page.wait_for_load_state("domcontentloaded")
+
+    service_name_input = page.locator('xpath=//input[@name="name"]')
+    service_name_input.fill(service_name)
+
+    add_button = page.get_by_role("button", name="Add service")
+    add_button.click()
+    page.wait_for_load_state("domcontentloaded")
+
+    service_info["url"] = page.url
+
+    yield service_info
+
+
+def _cleanup_test_service(page: Page, service_name: str):
+    """
+    Delete a test service by navigating to its settings and clicking delete.
+
+    Args:
+        page: Playwright page object
+        service_name: Name of the service to delete
+    """
+    try:
+        page.goto(f"{E2E_TEST_URI}/accounts")
+        page.wait_for_load_state("domcontentloaded")
+
+        service_link = page.get_by_role("link", name=service_name)
+
+        if service_link.count() > 0:
+            service_link.click()
+            page.wait_for_load_state("domcontentloaded")
+
+            page.click("text='Settings'")
+            page.wait_for_load_state("domcontentloaded")
+
+            page.click("text='Delete this service'")
+            page.wait_for_load_state("domcontentloaded")
+
+            page.click("text='Yes, delete'")
+            page.wait_for_load_state("domcontentloaded")
+
+            print(f"Successfully cleaned up test service: {service_name}")  # noqa: T201
+        else:
+            print(  # noqa: T201
+                f"Service '{service_name}' not found, may have been deleted already"
+            )
+
+    except Exception as e:
+        raise Exception(f"Failed to cleanup service '{service_name}': {str(e)}")
diff --git a/tests/end_to_end/test_accounts_page.py b/tests/end_to_end/test_accounts_page.py
index 5bebc64e6..d2d5706a1 100644
--- a/tests/end_to_end/test_accounts_page.py
+++ b/tests/end_to_end/test_accounts_page.py
@@ -1,4 +1,3 @@
-import datetime
 import os
 import re
 
@@ -9,15 +8,11 @@ from tests.end_to_end.conftest import check_axe_report
 E2E_TEST_URI = os.getenv("NOTIFY_E2E_TEST_URI")
 
 
-def test_add_new_service_workflow(authenticated_page, end_to_end_context):
-    page = authenticated_page
-
-    # Prepare for adding a new service later in the test.
-    current_date_time = datetime.datetime.now()
-    new_service_name = "E2E Federal Test Service {now} - {browser_type}".format(
-        now=current_date_time.strftime("%m/%d/%Y %H:%M:%S"),
-        browser_type=end_to_end_context.browser.browser_type.name,
-    )
+def test_add_new_service_workflow(e2e_test_service):
+    """Test creating and deleting a service with automatic cleanup."""
+    # Get service info from fixture (cleanup is automatic)
+    new_service_name = e2e_test_service["name"]
+    page = e2e_test_service["page"]
 
     page.goto(f"{E2E_TEST_URI}/accounts")
 
@@ -81,24 +76,5 @@ def test_add_new_service_workflow(authenticated_page, end_to_end_context):
     # expect(service_heading).to_be_visible()
     expect(page).to_have_title(re.compile(new_service_name))
 
-    page.click("text='Settings'")
-
-    # Check to make sure that we've arrived at the next page.
-    page.wait_for_load_state("domcontentloaded")
-    check_axe_report(page)
-
-    page.click("text='Delete this service'")
-
-    # Check to make sure that we've arrived at the next page.
-    page.wait_for_load_state("domcontentloaded")
-    check_axe_report(page)
-
-    page.click("text='Yes, delete'")
-
-    # Check to make sure that we've arrived at the next page.
-    page.wait_for_load_state("domcontentloaded")
-    check_axe_report(page)
-
-    # Check to make sure that we've arrived at the next page.
-    # Check the page title exists and matches what we expect.
-    expect(page).to_have_title(re.compile("Choose service"))
+    # Service will be automatically cleaned up by the e2e_test_service fixture
+    # even if the test fails before reaching this point
diff --git a/tests/javascripts/collapsibleCheckboxes.test.js b/tests/javascripts/collapsibleCheckboxes.test.js
index af572565b..1a6ee66bb 100644
--- a/tests/javascripts/collapsibleCheckboxes.test.js
+++ b/tests/javascripts/collapsibleCheckboxes.test.js
@@ -1,9 +1,6 @@
 const helpers = require('./support/helpers');
 
 beforeAll(() => {
-  // TODO: remove this when tests for sticky JS are written
-  require('../../app/assets/javascripts/stick-to-window-when-scrolling.js');
-
   require('../../app/assets/javascripts/collapsibleCheckboxes.js');
 });
 
@@ -661,4 +658,40 @@ describe('Collapsible fieldset', () => {
 
   });
 
+  describe("When there is no hint element", () => {
+
+    beforeEach(() => {
+
+      document.body.innerHTML =
+        `<div class="selection-wrapper" data-module="collapsible-checkboxes" data-field-label="folder">
+          <div class="usa-form-group">
+            <fieldset class="usa-fieldset" id="folder_permissions">
+              <legend class="usa-fieldset__legend usa-fieldset__legend--s">
+                Folders this team member can see
+                <span class="selection-summary" role="region" aria-live="polite"></span>
+              </legend>
+              <ul class="usa-checkbox-group">
+                ${_checkboxes(1, 3)}
+              </ul>
+            </fieldset>
+          </div>
+        </div>`;
+
+      wrapper = document.querySelector('.selection-wrapper');
+      formGroup = wrapper.querySelector('.usa-form-group');
+
+      window.NotifyModules.start();
+
+    });
+
+    test("should initialize without errors", () => {
+
+      const summary = formGroup.querySelector('.selection-summary');
+      expect(summary).not.toBeNull();
+      expect(summary.querySelector('.selection-summary__text')).not.toBeNull();
+
+    });
+
+  });
+
 });
diff --git a/tests/javascripts/copyToClipboard.test.js b/tests/javascripts/copyToClipboard.test.js
index 76bad7a7e..479a447fc 100644
--- a/tests/javascripts/copyToClipboard.test.js
+++ b/tests/javascripts/copyToClipboard.test.js
@@ -5,45 +5,30 @@ afterAll(() => {
   require('./support/teardown.js');
 
   // clear up methods in the global space
-  document.queryCommandSupported = undefined;
+  navigator.clipboard = undefined;
 
 });
 
 describe('copy to clipboard', () => {
 
   let apiKey = '00000000-0000-0000-0000-000000000000';
-  let thing;
   let component;
-  let selectionMock;
-  let rangeMock;
-  let screenMock;
+  let clipboardWriteTextMock;
 
   const setUpDOM = function (options) {
 
     // set up DOM
     document.body.innerHTML =`
-      <h2 class="copy-to-clipboard__name">
-        ${options.thing}
-      </h2>
-      <div data-module="copy-to-clipboard" data-value="${apiKey}" data-thing="${options.thing}" data-name="${options.name}">
-        <span class="copy-to-clipboard__value" aria-live="assertive">${(options.name === options.thing) ? '<span class="usa-sr-only">' + options.thing + ': </span>' : ''}${apiKey}</span>
-        <span class="copy-to-clipboard__notice" aria-live="assertive"></span>
-      </div>`;
+      <div data-module="copy-to-clipboard" data-value="${apiKey}" data-thing="${options.thing}" data-name="${options.name}"></div>`;
 
   };
 
   beforeEach(() => {
 
-    // mock objects used to manipulate the page selection
-    selectionMock = new helpers.SelectionMock(jest);
-    rangeMock = new helpers.RangeMock(jest);
-
-    // plug gaps in JSDOM's API for manipulation of selections
-    window.getSelection = jest.fn(() => selectionMock);
-    document.createRange = jest.fn(() => rangeMock);
-
-    // plug JSDOM not having execCommand
-    document.execCommand = jest.fn(() => {});
+    // Reset the clipboard mock for each test
+    if (clipboardWriteTextMock) {
+      clipboardWriteTextMock.mockClear();
+    }
 
     // mock sticky JS
     window.NotifyModules.stickAtBottomWhenScrolling = {
@@ -52,10 +37,10 @@ describe('copy to clipboard', () => {
 
   });
 
-  test("If copy command isn't available, nothing should happen", () => {
+  test("If Clipboard API isn't available, nothing should happen", () => {
 
-    // fake support for the copy command not being available
-    document.queryCommandSupported = jest.fn(command => false);
+    // Remove clipboard API
+    navigator.clipboard = undefined;
 
     require('../../app/assets/javascripts/copyToClipboard.js');
 
@@ -70,14 +55,15 @@ describe('copy to clipboard', () => {
 
   });
 
-  describe("If copy command is available", () => {
-
-    let componentHeightOnLoad;
+  describe("If Clipboard API is available", () => {
 
     beforeAll(() => {
 
-      // assume copy command is available
-      document.queryCommandSupported = jest.fn(command => command === 'copy');
+      // Mock modern Clipboard API BEFORE loading the module
+      clipboardWriteTextMock = jest.fn(() => Promise.resolve());
+      navigator.clipboard = {
+        writeText: clipboardWriteTextMock
+      };
 
       // force module require to not come from cache
       jest.resetModules();
@@ -86,10 +72,6 @@ describe('copy to clipboard', () => {
 
     });
 
-    afterEach(() => {
-      screenMock.reset();
-    });
-
     describe("On page load", () => {
 
       describe("For all variations of the initial HTML", () => {
@@ -100,26 +82,6 @@ describe('copy to clipboard', () => {
 
           component = document.querySelector('[data-module=copy-to-clipboard]');
 
-          // set default style for component height (queried by jQuery before checking DOM APIs)
-          const stylesheet = document.createElement('style');
-          stylesheet.innerHTML = '[data-module=copy-to-clipboard] { height: auto; }'; // set to browser default
-          document.getElementsByTagName('head')[0].appendChild(stylesheet);
-
-          componentHeightOnLoad = 50;
-
-          // mock the DOM APIs called for the position & dimension of the component
-          screenMock = new helpers.ScreenMock(jest);
-          screenMock.setWindow({
-            width: 1990,
-            height: 940,
-            scrollTop: 0
-          });
-          screenMock.mockPositionAndDimension('component', component, {
-            offsetHeight: componentHeightOnLoad,
-            offsetWidth: 641,
-            offsetTop: 0
-          });
-
           // start the module
           window.NotifyModules.start();
 
@@ -128,6 +90,7 @@ describe('copy to clipboard', () => {
         test("It should add a button for copying the thing to the clipboard", () => {
 
           expect(component.querySelector('button')).not.toBeNull();
+          expect(component.querySelector('button').textContent.trim()).toContain('Copy Some Thing');
 
         });
 
@@ -137,23 +100,20 @@ describe('copy to clipboard', () => {
 
         });
 
-        test("It should tell any sticky JS present the page has changed", () => {
 
-          // recalculate forces the sticky JS to recalculate any stored DOM position/dimensions
-          expect(window.NotifyModules.stickAtBottomWhenScrolling.recalculate).toHaveBeenCalled();
+        test("It should display the value", () => {
+
+          expect(component.querySelector('.copy-to-clipboard__value')).not.toBeNull();
+          expect(component.querySelector('.copy-to-clipboard__value').textContent).toBe(apiKey);
 
         });
 
-        test("It should set the component's minimum height based on its height when the page loads", () => {
+        test("It should have an aria-live region for screen reader announcements", () => {
 
-          // to prevent the position of the button moving when the state changes
-          expect(window.getComputedStyle(component)['min-height']).toEqual(`${componentHeightOnLoad}px`);
-
-        });
-
-        test("It should render the 'thing' without extra whitespace", () => {
-
-          expect(component.querySelector('.copy-to-clipboard__value').textContent).toBe('00000000-0000-0000-0000-000000000000');
+          const liveRegion = component.querySelector('[aria-live]');
+          expect(liveRegion).not.toBeNull();
+          expect(liveRegion.getAttribute('aria-live')).toBe('polite');
+          expect(liveRegion.getAttribute('aria-atomic')).toBe('true');
 
         });
 
@@ -163,8 +123,6 @@ describe('copy to clipboard', () => {
 
         beforeEach(() => {
 
-          // If 'thing' (what the id is) and 'name' (its specific idenifier on the page) are
-          // different, it will be one of others called the same 'thing'.
           setUpDOM({ 'thing': 'ID', 'name': 'Default' });
 
           component = document.querySelector('[data-module=copy-to-clipboard]');
@@ -174,19 +132,12 @@ describe('copy to clipboard', () => {
 
         });
 
-        // Because it is not the only 'thing' on the page, the id will not have a heading
-        // and so needs some prefix text to label it
-        test("The id should have a hidden prefix to label what it is", () => {
+        test("the button should have shorter label and hidden suffix", () => {
 
-          const value = component.querySelector('.copy-to-clipboard__value .usa-sr-only');
-          expect(value).not.toBeNull();
-          expect(value.textContent).toEqual('ID: ');
+          const button = component.querySelector('button');
+          expect(button.textContent).toContain('Copy ID');
 
-        });
-
-        test("the button should have a hidden suffix naming the id it is for", () => {
-
-          const buttonSuffix = component.querySelector('button .usa-sr-only');
+          const buttonSuffix = button.querySelector('.usa-sr-only');
           expect(buttonSuffix).not.toBeNull();
           expect(buttonSuffix.textContent).toEqual(' for Default');
 
@@ -198,9 +149,6 @@ describe('copy to clipboard', () => {
 
         beforeEach(() => {
 
-          // The heading is added if 'thing' (what the id is) has the same value as 'name'
-          // (its specific identifier on the page) because this means it can assume it is
-          // the only one of its type there
           setUpDOM({ 'thing': 'Some Thing', 'name': 'Some Thing' });
 
           component = document.querySelector('[data-module=copy-to-clipboard]');
@@ -210,12 +158,11 @@ describe('copy to clipboard', () => {
 
         });
 
-        test("Its button and id shouldn't have extra hidden text to identify them", () => {
+        test("the button should have full label without extra suffix", () => {
 
-          const value = component.querySelector('.copy-to-clipboard__value .usa-sr-only');
-          const buttonSuffix = component.querySelector('button .usa-sr-only');
-          expect(value).toBeNull();
-          expect(buttonSuffix).toBeNull();
+          const button = component.querySelector('button');
+          expect(button.textContent).toContain('Copy Some Thing to clipboard');
+          expect(button.textContent).not.toContain(' for ');
 
         })
 
@@ -223,187 +170,84 @@ describe('copy to clipboard', () => {
 
     });
 
-    describe("If you click the 'Copy Some Thing to clipboard' button", () => {
+    describe("If you click the 'Copy' button", () => {
 
-      describe("For all variations of the initial HTML", () => {
+      beforeEach(async () => {
 
-        let keyEl;
+        jest.useFakeTimers();
 
-        beforeEach(() => {
+        setUpDOM({ 'thing': 'API key', 'name': 'API key' });
 
-          setUpDOM({ 'thing': 'Some Thing', 'name': 'Some Thing' });
+        component = document.querySelector('[data-module=copy-to-clipboard]');
 
-          // start the module
-          window.NotifyModules.start();
+        // start the module
+        window.NotifyModules.start();
 
-          component = document.querySelector('[data-module=copy-to-clipboard]');
-          keyEl = component.querySelector('.copy-to-clipboard__value');
+        const button = component.querySelector('button');
+        helpers.triggerEvent(button, 'click');
 
-          helpers.triggerEvent(component.querySelector('button'), 'click');
-
-        });
-
-        test("The live-region should be shown and its text should confirm the copy action", () => {
-
-          const liveRegion = component.querySelector('.copy-to-clipboard__notice');
-
-          expect(liveRegion.classList.contains('usa-sr-only')).toBe(false);
-          expect(liveRegion.textContent.trim()).toEqual(
-            expect.stringContaining('Copied to clipboard')
-          );
-
-        });
-
-        // The button also says this but its text after being changed is not announced due to being
-        // lower priority than the live-region
-        test("The live-region should contain some hidden text giving context to the statement shown", () => {
-
-          const liveRegionHiddenText = component.querySelectorAll('.copy-to-clipboard__notice .usa-sr-only');
-
-          expect(liveRegionHiddenText.length).toEqual(2);
-          expect(liveRegionHiddenText[0].textContent).toEqual('Some Thing ');
-          expect(liveRegionHiddenText[1].textContent).toEqual(', press button to show in page');
-
-        });
-
-        test("It should swap the button for one to show the Some Thing", () => {
-
-          expect(component.querySelector('button').textContent.trim()).toEqual(
-            expect.stringContaining('Show Some Thing')
-          );
-
-        });
-
-        test("It should remove the id from the page", () => {
-
-          expect(component.querySelector('.copy-to-clipboard__value')).toBeNull();
-
-        });
-
-        test("It should copy the thing to the clipboard", () => {
-
-          // it should make a selection (a range) from the contents of the element containing the Some Thing
-          expect(rangeMock.selectNodeContents.mock.calls[0]).toEqual([keyEl]);
-
-          // that selection (a range) should be added to that for the page (a selection)
-          expect(selectionMock.addRange.mock.calls[0]).toEqual([rangeMock]);
-
-          expect(document.execCommand).toHaveBeenCalled();
-          expect(document.execCommand.mock.calls[0]).toEqual(['copy']);
-
-          // reset any methods in the global space
-          window.queryCommandSupported = undefined;
-          window.getSelection = undefined;
-          document.createRange = undefined;
-
-        });
-
-        describe("If you then click the 'Show Some Thing'", () => {
-
-          beforeEach(() => {
-
-            helpers.triggerEvent(component.querySelector('button'), 'click');
-
-          });
-
-          test("It should change the text to show the Some Thing", () => {
-
-            expect(component.querySelector('.copy-to-clipboard__value')).not.toBeNull();
-
-          });
-
-          test("It should swap the button for one to copy the thing to the clipboard", () => {
-
-            expect(component.querySelector('button').textContent.trim()).toEqual(
-              expect.stringContaining('Copy Some Thing to clipboard')
-            );
-
-          })
-
-        });
+        // Wait for async clipboard operation
+        await Promise.resolve();
 
       });
 
-      describe("If it's one of many in the page", () => {
+      afterEach(() => {
+        jest.useRealTimers();
+      });
 
-        beforeEach(() => {
+      test("The value should still be visible", () => {
 
-          // If 'thing' (what the id is) and 'name' (its specific idenifier on the page) are
-          // different, it will be one of others called the same 'thing'.
-          setUpDOM({ 'thing': 'ID', 'name': 'Default' });
-
-          // start the module
-          window.NotifyModules.start();
-
-          component = document.querySelector('[data-module=copy-to-clipboard]');
-
-          helpers.triggerEvent(component.querySelector('button'), 'click');
-
-        });
-
-        test("the button should have a hidden suffix naming the id it is for", () => {
-
-          const buttonSuffix = component.querySelector('button .usa-sr-only');
-          expect(buttonSuffix).not.toBeNull();
-          expect(buttonSuffix.textContent).toEqual(' for Default');
-
-        });
-
-        test("the copied selection (range) should start after visually hidden prefix", () => {
-
-          // that selection (a range) should have a startOffset of 1:
-          // index 0: the visually hidden prefix node, for example "Template ID: " or "API key: "
-          // index 1: the value node
-          expect(rangeMock.setStart).toHaveBeenCalled();
-          expect(rangeMock.setStart.mock.calls[0][1]).toEqual(1);
-
-          // reset any methods in the global space
-          window.queryCommandSupported = undefined;
-          window.getSelection = undefined;
-          document.createRange = undefined;
-
-        });
+        expect(component.querySelector('.copy-to-clipboard__value')).not.toBeNull();
+        expect(component.querySelector('.copy-to-clipboard__value').textContent).toBe(apiKey);
 
       });
 
-      describe("If it's the only one on the page", () => {
+      test("The button text should change to 'Copied!'", () => {
 
-        beforeEach(() => {
+        const button = component.querySelector('button');
+        expect(button.textContent).toContain('Copied!');
 
-          // The heading is added if 'thing' (what the id is) has the same value as 'name'
-          // (its specific identifier on the page) because this means it can assume it is
-          // the only one of its type there
-          setUpDOM({ 'thing': 'Some Thing', 'name': 'Some Thing' });
+      });
 
-          // start the module
-          window.NotifyModules.start();
+      test("The button should be disabled", () => {
 
-          component = document.querySelector('[data-module=copy-to-clipboard]');
+        const button = component.querySelector('button');
+        expect(button.disabled).toBe(true);
 
-          helpers.triggerEvent(component.querySelector('button'), 'click');
+      });
 
-        });
+      test("Screen reader announcement should confirm the copy", () => {
 
-        test("Its button and id shouldn't have extra hidden text to identify them", () => {
+        const liveRegion = component.querySelector('[aria-live]');
+        expect(liveRegion.textContent).toBe('API key copied to clipboard');
 
-          const prefix = component.querySelector('.copy-to-clipboard__value .usa-sr-only');
-          const buttonSuffix = component.querySelector('button .usa-sr-only');
-          expect(prefix).toBeNull();
-          expect(buttonSuffix).toBeNull();
+      });
 
-        })
+      test("It should copy the value to clipboard using Clipboard API", () => {
 
-        test("the copied selection (range) should start at the default position", () => {
+        expect(clipboardWriteTextMock).toHaveBeenCalledWith(apiKey);
 
-          // that selection (a range) shouldn't call setStart to avoid the prefix:
-          expect(rangeMock.setStart).not.toHaveBeenCalled();
+      });
 
-          // reset any methods in the global space
-          window.queryCommandSupported = undefined;
-          window.getSelection = undefined;
-          document.createRange = undefined;
+      test("After 2 seconds, button should reset to original text", () => {
 
-        });
+        const button = component.querySelector('button');
+
+        jest.advanceTimersByTime(2000);
+
+        expect(button.textContent).toContain('Copy API key');
+        expect(button.textContent).not.toContain('Copied!');
+        expect(button.disabled).toBe(false);
+
+      });
+
+      test("After 2 seconds, screen reader announcement should clear", () => {
+
+        const liveRegion = component.querySelector('[aria-live]');
+
+        jest.advanceTimersByTime(2000);
+
+        expect(liveRegion.textContent).toBe('');
 
       });
 
diff --git a/tests/javascripts/errorBanner.test.js b/tests/javascripts/errorBanner.test.js
index 55affdc7d..932826043 100644
--- a/tests/javascripts/errorBanner.test.js
+++ b/tests/javascripts/errorBanner.test.js
@@ -1,6 +1,11 @@
 beforeAll(() => {
-  // ErrorBanner module sets window.NotifyModules.ErrorBanner for backward compatibility
+  const originalNotifyModules = window.NotifyModules;
+  delete window.NotifyModules;
+
   require('../../app/assets/javascripts/errorBanner.js');
+
+  expect(window.NotifyModules).toBeDefined();
+  expect(window.NotifyModules.ErrorBanner).toBeDefined();
 });
 
 afterAll(() => {
@@ -20,6 +25,13 @@ describe("Error Banner", () => {
       window.NotifyModules.ErrorBanner.hideBanner();
       expect(document.querySelector('.banner-dangerous').classList).toContain('display-none')
     });
+
+    test("Will not error when no banner elements exist", () => {
+      document.body.innerHTML = `<div>No banners here</div>`;
+      expect(() => {
+        window.NotifyModules.ErrorBanner.hideBanner();
+      }).not.toThrow();
+    });
   });
 
   describe("The `showBanner` method", () => {
@@ -34,6 +46,13 @@ describe("Error Banner", () => {
     test("Will show the element", () => {
       expect(document.querySelector('.banner-dangerous').classList).not.toContain('display-none')
     });
+
+    test("Will not error when no banner elements exist", () => {
+      document.body.innerHTML = `<div>No banners here</div>`;
+      expect(() => {
+        window.NotifyModules.ErrorBanner.showBanner();
+      }).not.toThrow();
+    });
   });
 
   test("Module exports ErrorBanner to window.NotifyModules", () => {
diff --git a/tests/javascripts/fileUpload.test.js b/tests/javascripts/fileUpload.test.js
index 2d8bf06f9..f02c48880 100644
--- a/tests/javascripts/fileUpload.test.js
+++ b/tests/javascripts/fileUpload.test.js
@@ -184,4 +184,15 @@ describe('announceUploadStatusFromElement', () => {
     // Still unchanged
     expect(srRegion.textContent).toBe('Old message');
   });
+
+  test('does nothing if upload-status-live element does not exist', () => {
+    document.body.innerHTML = `
+      <span id="upload-error" class="usa-sr-only">File upload failed</span>
+    `;
+
+    expect(() => {
+      announceUploadStatusFromElement();
+      jest.advanceTimersByTime(300);
+    }).not.toThrow();
+  });
 });
diff --git a/tests/javascripts/jest.config.js b/tests/javascripts/jest.config.js
index a3be0bb1d..d56f4c146 100644
--- a/tests/javascripts/jest.config.js
+++ b/tests/javascripts/jest.config.js
@@ -2,7 +2,8 @@ module.exports = {
   collectCoverage: true,
   coverageDirectory: './coverage',
   coveragePathIgnorePatterns: [
-    'support/polyfills.js'
+    'support/polyfills.js',
+    'support/helpers/'
   ],
   coverageThreshold: {
     global: {
diff --git a/tests/javascripts/listEntry.test.js b/tests/javascripts/listEntry.test.js
index 176949eea..e4fac6859 100644
--- a/tests/javascripts/listEntry.test.js
+++ b/tests/javascripts/listEntry.test.js
@@ -420,4 +420,23 @@ describe("List entry", () => {
       expect(inputList.innerHTML).toContain('id="test-2"');
     });
   });
+
+  describe("when the container element has no id attribute", () => {
+    test("the module should not initialize", () => {
+      document.body.innerHTML = `
+        <div class="input-list" data-module="list-entry" data-list-item-name="domain">
+          <div class="list-entry">
+            <input type="text" name="domains-1" class="usa-input">
+          </div>
+        </div>`;
+
+      const inputList = document.querySelector('[data-module="list-entry"]');
+
+      expect(() => {
+        window.NotifyModules.start();
+      }).not.toThrow();
+
+      expect(inputList.querySelector('.input-list__button--add')).toBeNull();
+    });
+  });
 });
diff --git a/tests/javascripts/liveSearch.test.js b/tests/javascripts/liveSearch.test.js
index c0918fbd2..681bd9930 100644
--- a/tests/javascripts/liveSearch.test.js
+++ b/tests/javascripts/liveSearch.test.js
@@ -276,4 +276,133 @@ describe('Live search', () => {
 
   });
 
+  describe("When items have checked checkboxes", () => {
+
+    beforeEach(() => {
+
+      const users = [
+        {
+          "label": "Template editor",
+          "email": "template-editor@example.gov",
+          "permissions" : ["Add and edit templates"],
+          "checked": true
+        },
+        {
+          "label": "Administrator",
+          "email": "admin@example.gov",
+          "permissions" : ["Send messages", "Add and edit templates", "Manage settings, team and usage", "API integration"],
+          "checked": false
+        }
+      ];
+
+      document.body.innerHTML = `
+        <div class="live-search js-header" data-module="live-search" data-targets=".user-list-item">
+          <div class="form-group" data-module="">
+            <label class="form-label" for="search">
+                ${searchLabelText}
+            </label>
+            <input autocomplete="off" class="form-control form-control-1-1 " data-module="" id="search" name="search" rows="8" type="search" value="">
+            <div role="region" aria-live="polite" class="live-search__status usa-sr-only"></div>
+          </div>
+        </div>
+        <form method="post" autocomplete="off" novalidate>
+          <div class="user-list-item">
+            <input type="checkbox" checked>
+            <span class="live-search-relevant">${users[0].label} (${users[0].email})</span>
+          </div>
+          <div class="user-list-item">
+            <input type="checkbox">
+            <span class="live-search-relevant">${users[1].label} (${users[1].email})</span>
+          </div>
+        </form>`;
+
+      searchTextbox = document.getElementById('search');
+      liveRegion = document.querySelector('.live-search__status');
+      list = document.querySelector('form');
+
+    });
+
+    test("Items with checked checkboxes should always be visible", () => {
+
+      searchTextbox.value = 'Administrator';
+
+      window.NotifyModules.start();
+
+      const listItems = list.querySelectorAll('.user-list-item');
+      const listItemsShowing = Array.from(listItems).filter(item => !item.classList.contains('js-hidden'));
+
+      expect(listItemsShowing.length).toEqual(2);
+
+    });
+
+  });
+
+  describe("When no results message element exists", () => {
+
+    beforeEach(() => {
+
+      document.body.innerHTML = `
+        <div class="live-search js-header" data-module="live-search" data-targets=".user-list-item">
+          <div class="form-group" data-module="">
+            <label class="form-label" for="search">
+                ${searchLabelText}
+            </label>
+            <input autocomplete="off" class="form-control form-control-1-1 " data-module="" id="search" name="search" rows="8" type="search" value="">
+            <div role="region" aria-live="polite" class="live-search__status usa-sr-only"></div>
+          </div>
+          <div class="js-live-search-no-results js-hidden">No results found</div>
+        </div>
+        <form method="post" autocomplete="off" novalidate>
+          <div class="user-list-item">
+            <span class="live-search-relevant">Test User (test@example.com)</span>
+          </div>
+        </form>`;
+
+      searchTextbox = document.getElementById('search');
+      liveRegion = document.querySelector('.live-search__status');
+      list = document.querySelector('form');
+
+    });
+
+    test("No results message should show when search yields no results", () => {
+
+      searchTextbox.value = 'nomatch';
+
+      window.NotifyModules.start();
+
+      const noResultsMessage = document.querySelector('.js-live-search-no-results');
+      expect(noResultsMessage.classList.contains('js-hidden')).toBe(false);
+
+    });
+
+    test("No results message should hide when search yields results", () => {
+
+      searchTextbox.value = 'nomatch';
+      window.NotifyModules.start();
+
+      let noResultsMessage = document.querySelector('.js-live-search-no-results');
+      expect(noResultsMessage.classList.contains('js-hidden')).toBe(false);
+
+      searchTextbox.value = 'Test';
+      helpers.triggerEvent(searchTextbox, 'input');
+
+      expect(noResultsMessage.classList.contains('js-hidden')).toBe(true);
+
+    });
+
+    test("No results message should hide when search is empty", () => {
+
+      searchTextbox.value = 'nomatch';
+      window.NotifyModules.start();
+
+      searchTextbox.value = '';
+      helpers.triggerEvent(searchTextbox, 'input');
+
+      const noResultsMessage = document.querySelector('.js-live-search-no-results');
+      expect(noResultsMessage.classList.contains('js-hidden')).toBe(true);
+
+    });
+
+  });
+
 });
diff --git a/tests/javascripts/notifyModal.test.js b/tests/javascripts/notifyModal.test.js
index be703fd97..5e8156194 100644
--- a/tests/javascripts/notifyModal.test.js
+++ b/tests/javascripts/notifyModal.test.js
@@ -159,3 +159,70 @@ describe("Modal trigger buttons", () => {
       expect(modalWrapper.classList.contains("is-hidden")).toBe(true);
     });
   });
+
+describe("Modal edge cases", () => {
+  test("openModal does nothing if wrapper doesn't exist", () => {
+    expect(() => {
+      openModal("nonExistentModal");
+    }).not.toThrow();
+  });
+
+  test("openModal does nothing if modal element doesn't exist inside wrapper", () => {
+    document.body.innerHTML = `<div id="emptyWrapper"></div>`;
+    expect(() => {
+      openModal("emptyWrapper");
+    }).not.toThrow();
+  });
+
+  test("openModal works when there is no focusable element", () => {
+    document.body.innerHTML = `
+      <div id="noFocusModal">
+        <div class="usa-modal">
+          <p>No focusable elements here</p>
+        </div>
+      </div>
+    `;
+    expect(() => {
+      openModal("noFocusModal");
+    }).not.toThrow();
+    expect(document.getElementById("noFocusModal").classList.contains("is-hidden")).toBe(false);
+  });
+
+  test("closeModal does nothing if no modal is active", () => {
+    expect(() => {
+      closeModal();
+    }).not.toThrow();
+  });
+
+  test("closeModal handles case where modal element is missing", () => {
+    document.body.innerHTML = `
+      <button data-open-modal="testModal">Open</button>
+      <div id="testModal"></div>
+    `;
+    openModal("testModal");
+    expect(() => {
+      closeModal();
+    }).not.toThrow();
+  });
+
+  test("Modal keydown handler ignores non-Tab keys", () => {
+    document.body.innerHTML = `
+      <div id="keyModal">
+        <div class="usa-modal">
+          <button>Test</button>
+        </div>
+      </div>
+    `;
+    openModal("keyModal");
+    const modal = document.querySelector(".usa-modal");
+
+    const enterEvent = new KeyboardEvent("keydown", {
+      key: "Enter",
+      bubbles: true
+    });
+
+    expect(() => {
+      modal.dispatchEvent(enterEvent);
+    }).not.toThrow();
+  });
+});
diff --git a/tests/javascripts/preventDuplicateFormSubmissions.test.js b/tests/javascripts/preventDuplicateFormSubmissions.test.js
index af043b3e6..450ef483f 100644
--- a/tests/javascripts/preventDuplicateFormSubmissions.test.js
+++ b/tests/javascripts/preventDuplicateFormSubmissions.test.js
@@ -65,5 +65,140 @@ describe('Prevent duplicate form submissions', () => {
 
   });
 
+  test("It should not error when form has no submit button", () => {
+
+    document.body.innerHTML = `
+      <form action="/" method="post">
+        <input type="text" name="test">
+      </form>`;
+
+    form = document.querySelector('form');
+    formEventSpy = helpers.spyOnFormSubmitEventPrevention(jest, form);
+
+    jest.resetModules();
+    require('../../app/assets/javascripts/preventDuplicateFormSubmissions.js');
+
+    expect(() => {
+      helpers.triggerEvent(form, 'submit');
+    }).not.toThrow();
+
+  });
+
+  test("It should disable and add spinner to 'send' button", () => {
+
+    document.body.innerHTML = `
+      <form action="/" method="post">
+        <button class="usa-button" type="submit" name="send">Send</button>
+      </form>`;
+
+    form = document.querySelector('form');
+    button = document.querySelector('button');
+    formEventSpy = helpers.spyOnFormSubmitEventPrevention(jest, form);
+
+    jest.resetModules();
+    require('../../app/assets/javascripts/preventDuplicateFormSubmissions.js');
+
+    helpers.triggerEvent(button, 'click');
+
+    jest.advanceTimersByTime(100);
+
+    expect(button.disabled).toBe(true);
+    expect(button.getAttribute('aria-busy')).toBe('true');
+    expect(button.querySelector('.loading-spinner')).not.toBeNull();
+
+  });
+
+  test("It should disable and add spinner to 'schedule' button", () => {
+
+    document.body.innerHTML = `
+      <form action="/" method="post">
+        <button class="usa-button" type="submit" name="schedule">Schedule</button>
+      </form>`;
+
+    form = document.querySelector('form');
+    button = document.querySelector('button');
+    formEventSpy = helpers.spyOnFormSubmitEventPrevention(jest, form);
+
+    jest.resetModules();
+    require('../../app/assets/javascripts/preventDuplicateFormSubmissions.js');
+
+    helpers.triggerEvent(button, 'click');
+
+    jest.advanceTimersByTime(100);
+
+    expect(button.disabled).toBe(true);
+    expect(button.getAttribute('aria-busy')).toBe('true');
+    expect(button.querySelector('.loading-spinner')).not.toBeNull();
+
+  });
+
+  test("It should disable both send and cancel buttons when send is clicked", () => {
+
+    document.body.innerHTML = `
+      <form action="/" method="post">
+        <button class="usa-button" type="submit" name="send">Send</button>
+        <button class="usa-button" type="submit" name="cancel">Cancel</button>
+      </form>`;
+
+    form = document.querySelector('form');
+    const sendButton = document.querySelector('button[name="send"]');
+    const cancelButton = document.querySelector('button[name="cancel"]');
+    formEventSpy = helpers.spyOnFormSubmitEventPrevention(jest, form);
+
+    jest.resetModules();
+    require('../../app/assets/javascripts/preventDuplicateFormSubmissions.js');
+
+    helpers.triggerEvent(sendButton, 'click');
+
+    jest.advanceTimersByTime(100);
+
+    expect(sendButton.disabled).toBe(true);
+    expect(cancelButton.disabled).toBe(true);
+
+  });
+
+  test("It should not add duplicate spinner if one already exists", () => {
+
+    document.body.innerHTML = `
+      <form action="/" method="post">
+        <button class="usa-button" type="submit" name="send">Send<span class="loading-spinner"></span></button>
+      </form>`;
+
+    form = document.querySelector('form');
+    button = document.querySelector('button');
+    formEventSpy = helpers.spyOnFormSubmitEventPrevention(jest, form);
+
+    jest.resetModules();
+    require('../../app/assets/javascripts/preventDuplicateFormSubmissions.js');
+
+    helpers.triggerEvent(button, 'click');
+
+    jest.advanceTimersByTime(100);
+
+    expect(button.querySelectorAll('.loading-spinner').length).toBe(1);
+
+  });
+
+  test("It should handle button with no name attribute", () => {
+
+    document.body.innerHTML = `
+      <form action="/" method="post">
+        <button class="usa-button" type="submit">Submit</button>
+      </form>`;
+
+    form = document.querySelector('form');
+    button = document.querySelector('button');
+    formEventSpy = helpers.spyOnFormSubmitEventPrevention(jest, form);
+
+    jest.resetModules();
+    require('../../app/assets/javascripts/preventDuplicateFormSubmissions.js');
+
+    expect(() => {
+      helpers.triggerEvent(button, 'click');
+      jest.advanceTimersByTime(1600);
+    }).not.toThrow();
+
+  });
+
 
 });
diff --git a/tests/javascripts/radioSelect.test.js b/tests/javascripts/radioSelect.test.js
index 9e67288a0..387efe5ae 100644
--- a/tests/javascripts/radioSelect.test.js
+++ b/tests/javascripts/radioSelect.test.js
@@ -434,6 +434,17 @@ describe('RadioSelect', () => {
 
     });
 
+    test("clicking the 'Done' button without selecting an option should reset to default state", () => {
+
+      const doneButton = document.querySelector('.radio-select__column:nth-child(2) input[type=button]');
+
+      helpers.triggerEvent(doneButton, 'click');
+
+      const categoryButtons = document.querySelectorAll('.radio-select__column:nth-child(2) .radio-select__button--category');
+      expect(categoryButtons.length).toBeGreaterThan(0);
+
+    });
+
     describe("after selecting an option clicking the 'Choose a different time' button should", () => {
 
       beforeEach(() => {
diff --git a/tests/javascripts/stick-to-window-when-scrolling.test.js b/tests/javascripts/stick-to-window-when-scrolling.test.js
deleted file mode 100644
index 7b418df23..000000000
--- a/tests/javascripts/stick-to-window-when-scrolling.test.js
+++ /dev/null
@@ -1,1446 +0,0 @@
-const helpers = require('./support/helpers');
-const PADDING_BETWEEN_STICKYS = 40;
-const PADDING_BEFORE_STOPPING_POINT = 10;
-
-function getScreenItemBottomPosition (screenItem) {
-  return screenItem.offsetTop + screenItem.offsetHeight;
-};
-
-function getCaretPosition (caretPosition, textarea) {
-
-  return {
-    top: textarea.offsetTop + caretPosition.top,
-    bottom: textarea.offsetTop + caretPosition.top + caretPosition.height,
-    height: caretPosition.height
-  };
-
-};
-
-function getStickyGroupPosition (screenMock, opts) {
-
-  const edgePosition = screenMock.window[opts.edge];
-  const height = opts.stickyEls
-                  .map(el => el.offsetHeight)
-                  .reduce((accumulator, height) => accumulator + height);
-
-  if (opts.edge === 'top') {
-    return {
-      top: screenMock.window.top,
-      bottom: edgePosition + height,
-      height: height
-    };
-  } else {
-    return {
-      top: edgePosition - height,
-      bottom: screenMock.window.bottom,
-      height: height
-    }
-  }
-
-};
-
-class CaretCoordinates {
-  constructor (data) {
-    this.top = 5.5;
-    this.left = 2;
-    this.height = 19;
-  }
-
-  moveToLine (lineNumber) {
-    const lineHeight = 30;
-    const verticalPadding = 5.5;
-
-    this.top = ((lineNumber - 1) * lineHeight) + verticalPadding;
-  }
-}
-
-beforeAll(() => {
-  require('../../app/assets/javascripts/stick-to-window-when-scrolling.js');
-});
-
-afterAll(() => {
-  require('./support/teardown.js');
-});
-
-describe("Stick to top/bottom of window when scrolling", () => {
-
-  let screenMock;
-
-  describe("If intending to stick to the top", () => {
-
-    let inputForm;
-    let formFooter;
-    let footer;
-    let windowHeight;
-    let getFurthestTopPoint;
-
-    beforeEach(() => {
-
-      document.body.innerHTML = `
-        <div class="grid-row">
-          <main class="grid-col-9 column-main">
-            <form method="post" autocomplete="off">
-              <div class="grid-row js-stick-at-top-when-scrolling">
-                <div class="grid-col-8">
-                  <div class="form-group" data-module="">
-                    <label class="form-label" for="placeholder_value">
-                      name
-                    </label>
-                    <input class="form-control form-control-1-1 " data-module="" id="placeholder_value" name="placeholder_value" required="" rows="8" type="text" value="">
-                  </div>
-                </div>
-              </div>
-              <div class="page-footer">
-                <button type="submit" class="usa-button">Continue</button>
-              </div>
-            </form>
-          </main>
-        </div>
-        <footer class="js-footer"></footer>`;
-
-      inputForm = document.querySelector('form > .grid-row');
-      formFooter = document.querySelector('.page-footer');
-      footer = document.querySelector('.js-footer');
-
-      windowHeight = 940;
-
-      // mock the rendering of all components
-      screenMock = new helpers.ScreenMock(jest);
-      screenMock.setWindow({
-        width: 1990,
-        height: windowHeight,
-        scrollTop: 0
-      });
-      screenMock.mockPositionAndDimension('inputForm', inputForm, {
-        offsetHeight: 168,
-        offsetWidth: 727,
-        offsetTop: 238
-      });
-      screenMock.mockPositionAndDimension('formFooter', formFooter, {
-        offsetHeight: 200,
-        offsetWidth: 727,
-        offsetTop: inputForm.offsetTop + 200
-      });
-      screenMock.mockPositionAndDimension('footer', footer, {
-        offsetHeight: 535,
-        offsetWidth: 1990,
-        offsetTop: formFooter.offsetTop + formFooter.offsetHeight
-      });
-
-      getFurthestTopPoint = (stickysHeight) => {
-        return footer.offsetTop - PADDING_BEFORE_STOPPING_POINT - stickysHeight;
-      };
-
-      // the sticky JS polls for changes to position/dimension so we need to fake setTimeout and setInterval
-      jest.useFakeTimers();
-
-    });
-
-    afterEach(() => {
-
-      document.body.innerHTML = '';
-
-      window.NotifyModules.stickAtTopWhenScrolling.clearEvents();
-
-      screenMock.reset();
-
-    });
-
-    test("if top of viewport is above top of element on load, the element should not be marked as sticky", () => {
-
-      // scroll position defaults to 0, element top defaults to 138px
-
-      window.NotifyModules.stickAtTopWhenScrolling.init();
-
-      expect(inputForm.classList.contains('content-fixed-onload')).toBe(false);
-      expect(inputForm.classList.contains('content-fixed')).toBe(false);
-
-    });
-
-    test("if the window is 768px or less wide and the top of the viewport is below top of element on load, the element should not be marked as sticky", () => {
-
-      screenMock.window.resizeTo({
-        height: windowHeight,
-        width: 768
-      });
-
-      // scroll past top of form
-      screenMock.scrollTo(inputForm.offsetTop + 10);
-
-      window.NotifyModules.stickAtTopWhenScrolling.init();
-
-      expect(inputForm.classList.contains('content-fixed')).toBe(false);
-      expect(inputForm.classList.contains('content-fixed-onload')).toBe(false); // check the class for onload isn't applied
-
-    });
-
-    describe("if top of viewport is below top of element but still in the scroll area on load", () => {
-
-      beforeEach(() => {
-
-        // scroll past the top of the form
-        screenMock.scrollTo(inputForm.offsetTop + 10);
-
-        window.NotifyModules.stickAtTopWhenScrolling.init();
-
-      });
-
-      test("the element should be marked as already sticky", () => {
-
-        // `.content-fixed-onload` adds the drop-shadow without fading in to show it did not become sticky from user interaction
-        expect(inputForm.classList.contains('content-fixed-onload')).toBe(true);
-        expect(inputForm.classList.contains('content-fixed')).toBe(false);
-
-      });
-
-      test("a 'shim' element with dimensions matching the sticky element should be added to the document to take up the space it no longer occupies", () => {
-
-        const shim = inputForm.previousElementSibling;
-
-        expect(shim).not.toBeNull();
-        expect(shim.classList.contains('shim')).toBe(true);
-        expect(shim.style.height).toEqual(`${inputForm.offsetHeight}px`);
-        expect(shim.style.marginTop).toEqual(''); // 0px would return an empty string
-        expect(shim.style.marginBottom).toEqual(''); // 0px would return an empty string
-
-      });
-
-    });
-
-    test("if top of viewport is below the furthest point the top of the element can go in the scroll area on load, the element should be marked as stopped", () => {
-
-      // the element should stop a set distance from the stopping point
-      const furthestTopPoint = getFurthestTopPoint(inputForm.offsetHeight);
-
-      // scroll past the furthest point
-      screenMock.scrollTo(furthestTopPoint + 10);
-
-      window.NotifyModules.stickAtTopWhenScrolling.init();
-
-      // `.content-fixed-onload` adds the drop-shadow without fading in to show it did not become sticky from user interaction
-      expect(inputForm.classList.contains('content-fixed-onload')).toBe(true);
-      expect(inputForm.classList.contains('content-fixed')).toBe(false);
-
-      // elements are stopped by adding inline styles
-      expect(inputForm.style.position).toEqual('absolute');
-      expect(inputForm.style.top).toEqual(`${furthestTopPoint}px`);
-
-    });
-
-    describe("if viewport top starts above element top", () => {
-
-      beforeEach(() => {
-
-        // default scroll position is above top of form
-        window.NotifyModules.stickAtTopWhenScrolling.init();
-
-      });
-
-      test("if window is scrolled so top of it is below the top of the element, the element should be marked so it becomes sticky to the user", () => {
-
-        // scroll past top of form
-        screenMock.scrollTo(inputForm.offsetTop + 10);
-        jest.advanceTimersByTime(60); // fake advance of time to something similar to that for a scroll
-
-        // `content-fixed` fades the drop-shadow in to show it became sticky from user interaction
-        expect(inputForm.classList.contains('content-fixed')).toBe(true);
-        expect(inputForm.classList.contains('content-fixed-onload')).toBe(false); // check the class for onload isn't applied
-
-      });
-
-      test("if window is scrolled so top of it is below the furthest point the top of the element can go in the scroll area, the element should be stopped", () => {
-
-        const furthestTopPoint = getFurthestTopPoint(inputForm.offsetHeight);
-
-        // scroll past top of form
-        screenMock.scrollTo(furthestTopPoint + 10);
-        jest.advanceTimersByTime(60); // fake advance of time to something similar to that for a scroll
-
-        // `content-fixed` fades the drop-shadow in to show it became sticky from user interaction
-        expect(inputForm.classList.contains('content-fixed')).toBe(true);
-        expect(inputForm.classList.contains('content-fixed-onload')).toBe(false); // check the class for onload isn't applied
-
-        // elements are stopped by adding inline styles
-        expect(inputForm.style.position).toEqual('absolute');
-        expect(inputForm.style.top).toEqual(`${furthestTopPoint}px`);
-
-      });
-
-    });
-
-    describe("if viewport top starts below element top", () => {
-
-      beforeEach(() => {
-
-        // scroll past top of form
-        screenMock.scrollTo(inputForm.offsetTop + 10);
-
-        window.NotifyModules.stickAtTopWhenScrolling.init();
-
-      });
-
-      test("if window is scrolled so top of it is above the top of the element, the element should be made not sticky", () => {
-
-        // scroll to top
-        screenMock.scrollTo(0);
-        jest.advanceTimersByTime(60); // fake advance of time to something similar to that for a scroll
-
-        expect(inputForm.classList.contains('content-fixed')).toBe(false);
-        expect(inputForm.classList.contains('content-fixed-onload')).toBe(false); // check the class for onload isn't applied
-
-      });
-
-    });
-
-    describe("if scrollToRevealElement is called with an element", () => {
-
-      let link;
-      let linkBottom;
-
-      beforeEach(() => {
-
-        const inputFormBottom = getScreenItemBottomPosition(inputForm);
-
-        inputForm.insertAdjacentHTML('afterEnd', '<a href="" id="formatting-options">Formatting options</a>');
-        link = document.querySelector('#formatting-options');
-
-        screenMock.mockPositionAndDimension('link', link, {
-          offsetHeight: 25, // 143px smaller than the sticky
-          offsetWidth: 727,
-          offsetTop: inputFormBottom
-        });
-
-        linkBottom = getScreenItemBottomPosition(link);
-
-        // move the sticky over the link. It's 168px high so this position will cause it to overlap.
-        screenMock.scrollTo(link.offsetTop - 140);
-
-        window.NotifyModules.stickAtTopWhenScrolling.init();
-
-      });
-
-      afterEach(() => {
-
-        screenMock.window.spies.window.scrollTo.mockClear();
-
-      });
-
-      test("the window should scroll so the element is revealed", () => {
-
-        // update inputForm position as DOM normally would
-        inputForm.offsetTop = screenMock.window.top;
-
-        let stickyPosition = getStickyGroupPosition(screenMock, { stickyEls: [inputForm], edge: 'top' });
-
-        // sticky position should overlap link position
-        expect(stickyPosition.top).toBeLessThanOrEqual(link.offsetTop);
-        expect(stickyPosition.bottom).toBeGreaterThanOrEqual(linkBottom);
-
-        window.NotifyModules.stickAtTopWhenScrolling.scrollToRevealElement(link);
-
-        stickyPosition = getStickyGroupPosition(screenMock, { stickyEls: [inputForm], edge: 'top' });
-
-        // the bottom of the sticky element should be at the top of the link
-        expect(screenMock.window.spies.window.scrollTo.mock.calls[0]).toEqual([0, link.offsetTop - stickyPosition.height]);
-
-      });
-
-    });
-
-    describe("if element is made sticky and another element underneath it is focused", () => {
-
-      let checkbox;
-      let checkboxBottom;
-
-      beforeEach(() => {
-
-        const inputFormBottom = getScreenItemBottomPosition(inputForm);
-
-        inputForm.insertAdjacentHTML('afterEnd', '<input type="checkbox" name="confirm" value="yes" />');
-        checkbox = document.querySelector('input[type=checkbox]');
-
-        screenMock.mockPositionAndDimension('checkbox', checkbox, {
-          offsetHeight: 50, // 118px smaller than the sticky
-          offsetWidth: 727,
-          offsetTop: inputFormBottom
-        });
-
-        checkboxBottom = getScreenItemBottomPosition(checkbox);
-
-        // move the sticky over the checkbox. It's 168px high so this position will cause it to overlap.
-        screenMock.scrollTo(checkbox.offsetTop - 10);
-
-        window.NotifyModules.stickAtTopWhenScrolling.init();
-
-      });
-
-      afterEach(() => {
-
-        screenMock.window.spies.window.scrollTo.mockClear();
-
-      });
-
-      test("the window should scroll so the focused element is revealed", () => {
-
-        // update inputForm position as DOM normally would
-        inputForm.offsetTop = screenMock.window.top;
-
-        let stickyPosition = getStickyGroupPosition(screenMock, { stickyEls: [inputForm], edge: 'top' });
-
-        // sticky position should overlap checkbox position
-        expect(stickyPosition.top).toBeLessThanOrEqual(checkbox.offsetTop);
-        expect(stickyPosition.bottom).toBeGreaterThanOrEqual(checkboxBottom);
-
-        // the sticky element (page footer) is 50 high so should cover the last of the radios if the bottom edge of the viewport is at its bottom
-        checkbox.focus();
-
-        stickyPosition = getStickyGroupPosition(screenMock, { stickyEls: [inputForm], edge: 'top' });
-
-        // the bottom of the sticky element should be at the top of the checkbox
-        expect(screenMock.window.spies.window.scrollTo.mock.calls[0]).toEqual([0, checkbox.offsetTop - stickyPosition.height]);
-
-      });
-
-    });
-
-    describe("if element is made sticky and overlaps a textarea", () => {
-
-      let textarea;
-      let textareaBottom;
-      let caretCoordinates;
-      let caretCoordinatesMock;
-
-      beforeEach(() => {
-
-        const inputFormBottom = getScreenItemBottomPosition(inputForm);
-
-        inputForm.insertAdjacentHTML('afterEnd', '<textarea name="notes"></textarea>');
-        textarea = document.querySelector('textarea');
-
-        // line height: 30px, text height: 19px, lines: 10
-        screenMock.mockPositionAndDimension('textarea', textarea, {
-          offsetHeight: 300,
-          offsetWidth: 727,
-          offsetTop: inputFormBottom
-        });
-
-        textareaBottom = getScreenItemBottomPosition(textarea);
-
-        // mock calls for caret position, relative to textarea
-        caretCoordinatesMock = jest.fn(() => caretCoordinates);
-        window.getCaretCoordinates = caretCoordinatesMock;
-
-        // start caret on first line
-        caretCoordinates = new CaretCoordinates();
-
-        // move the sticky so it overlaps the top 168px of the textarea.
-        screenMock.scrollTo(textarea.offsetTop);
-
-        // update inputForm position as DOM normally would
-        inputForm.offsetTop = screenMock.window.top;
-
-        window.NotifyModules.stickAtTopWhenScrolling.init();
-
-      });
-
-      afterEach(() => {
-
-        screenMock.window.spies.window.scrollTo.mockClear();
-        caretCoordinatesMock.mockClear();
-
-      });
-
-      test("if the textarea receives focus while its caret is underneath, the window should scroll to reveal the caret", () => {
-
-        // caret is on first line
-        const stickyPosition = getStickyGroupPosition(screenMock, { stickyEls: [inputForm], edge: 'top' });
-        const caretPosition = getCaretPosition(caretCoordinates, textarea);
-
-        // sticky position should overlap caret position
-        expect(stickyPosition.top).toBeLessThanOrEqual(caretPosition.top);
-        expect(stickyPosition.bottom).toBeGreaterThanOrEqual(caretPosition.bottom);
-
-        // the sticky element (page footer) is 50 high so should cover the last of the radios if the bottom edge of the viewport is at its bottom
-        textarea.focus();
-
-        // the bottom of the sticky element should be at the top of the checkbox
-        expect(screenMock.window.spies.window.scrollTo.mock.calls[0]).toEqual([0, caretPosition.top - stickyPosition.height]);
-
-      });
-
-      test("if the caret is moved so it isn't underneath the sticky element, the window shouldn't scroll", () => {
-
-        // start caret on 7th line which isn't under the sticky element.
-        caretCoordinates.moveToLine(7);
-
-        const stickyPosition = getStickyGroupPosition(screenMock, { stickyEls: [inputForm], edge: 'top' });
-        const caretPosition = getCaretPosition(caretCoordinates, textarea);
-
-        // the sticky element should be above the caret
-        expect(stickyPosition.bottom).toBeLessThan(caretPosition.top);
-
-        textarea.focus();
-
-        // no scrolling should have happened
-        expect(screenMock.window.spies.window.scrollTo.mock.calls.length).toEqual(0);
-
-      });
-
-      test("if the caret is moved to be underneath the sticky element, the window should scroll to reveal the caret", () => {
-
-        // start caret on 7th line which isn't under the sticky element.
-        caretCoordinates.moveToLine(7);
-
-        // make sure the textarea has focus
-        textarea.focus();
-
-        // line 6 is under the sticky element
-        caretCoordinates.moveToLine(6);
-
-        const stickyPosition = getStickyGroupPosition(screenMock, { stickyEls: [inputForm], edge: 'top' });
-        const caretPosition = getCaretPosition(caretCoordinates, textarea);
-
-        // sticky should now overlap the caret
-        expect(stickyPosition.bottom).toBeGreaterThanOrEqual(caretPosition.top);
-
-        // the sticky element (page footer) is 50 high so should cover the last of the radios if the bottom edge of the viewport is at its bottom
-        helpers.triggerEvent(textarea, 'keyup', { interface: window.KeyboardEvent });
-
-        // the bottom of the sticky element should be at the top of the checkbox
-        expect(screenMock.window.spies.window.scrollTo.mock.calls[0]).toEqual([0, caretPosition.top - stickyPosition.height]);
-
-      });
-
-    });
-
-    describe("if mode is set to 'dialog' and multiple sticky elements share the same scroll area", () => {
-
-      let radios;
-
-      beforeEach(() => {
-
-        const inputFormBottom = getScreenItemBottomPosition(inputForm);
-
-        // set mode to 'dialog' so sticky elements are treated as one item
-        window.NotifyModules.stickAtTopWhenScrolling.setMode('dialog')
-
-        // add another sticky element before the form footer
-        radios = helpers.getRadioGroup({
-          cssClasses: ['js-stick-at-top-when-scrolling'],
-          name: 'choose-send-time',
-          label: 'Choose send time',
-          fields: [
-            {
-              label: 'Now',
-              value: 'now',
-              checked: true
-            },
-            {
-              label: 'Tomorrow',
-              value: 'tomorrow',
-              checked: false
-            },
-            {
-              label: 'Friday',
-              value: 'friday',
-              checked: false
-            }
-          ]
-        });
-        formFooter.parentNode.insertBefore(radios, formFooter);
-        screenMock.mockPositionAndDimension('radios', radios, {
-          offsetHeight: 175,
-          offsetWidth: 727,
-          offsetTop: inputFormBottom
-        });
-        const radiosBottom = getScreenItemBottomPosition(radios);
-
-        // adjust other screen items
-
-        // formFooter top should be at the radios bottom
-        formFooter.offsetTop = radiosBottom;
-
-        // footer top should be at formFooter's bottom
-        footer.offsetTop = getScreenItemBottomPosition(formFooter);
-
-      });
-
-      afterEach(() => {
-
-        window.NotifyModules.stickAtTopWhenScrolling.setMode('default');
-
-      });
-
-      describe("if window top is below the top of the highest element on load", () => {
-
-        beforeEach(() => {
-
-          // scroll past top of first sticky element
-          screenMock.scrollTo(inputForm.offsetTop + 10);
-
-          window.NotifyModules.stickAtTopWhenScrolling.init();
-
-        });
-
-        test("both should be marked as already sticky", () => {
-
-          // `.content-fixed-onload` adds the drop-shadow without fading in to show it did not become sticky from user interaction
-          expect(radios.classList.contains('content-fixed-onload')).toBe(true);
-          expect(radios.classList.contains('content-fixed')).toBe(false);
-          expect(inputForm.classList.contains('content-fixed-onload')).toBe(true);
-          expect(inputForm.classList.contains('content-fixed')).toBe(false);
-
-        });
-
-        test("the lowest element should have the drop-shadow", () => {
-
-          expect(radios.classList.contains('content-fixed__top')).toBe(true);
-
-        });
-
-        test("they should be stacked from the top edge of the viewport in the order they appear in the document", () => {
-
-          expect(inputForm.style.top).toEqual('0px');
-
-          // dialog mode removes enough padding to deal with that each sticky element is given to give its content enough space from the surrounding page
-          expect(radios.style.top).toEqual(`${inputForm.offsetHeight - PADDING_BETWEEN_STICKYS}px`);
-
-        });
-
-      });
-
-      describe("if window top is below the furthest point the highest element can go on load", () => {
-
-        let furthestTopPoint;
-
-        beforeEach(() => {
-
-          // ensure each sticky element is positioned correctly relative to the furthest point
-          const dialogHeight = (inputForm.offsetHeight + radios.offsetHeight) - PADDING_BETWEEN_STICKYS;
-
-          furthestTopPoint = getFurthestTopPoint(dialogHeight);
-
-          // scroll past top of first sticky element
-          screenMock.scrollTo(furthestTopPoint + 10);
-
-          window.NotifyModules.stickAtTopWhenScrolling.init();
-
-        });
-
-        test("both should be stopped so the bottom of their stack is at the furthest point", () => {
-
-          expect(inputForm.style.position).toEqual('absolute');
-          expect(radios.style.position).toEqual('absolute');
-
-          expect(inputForm.style.top).toEqual(`${furthestTopPoint}px`);
-          expect(radios.style.top).toEqual(`${footer.offsetTop - PADDING_BEFORE_STOPPING_POINT - radios.offsetHeight}px`);
-
-        });
-
-      });
-
-      describe("if the group of sticky elements is taller than the window when stuck together", () => {
-
-        // the sticky behaviour should stick as many elements as possible to the top of the viewport
-        // the rest should be put back into their place in the document
-        beforeEach(() => {
-
-          const windowHeight = 460;
-
-          function makeStickysBiggerThanWindow () {
-
-            // make the radios too big to fit in the viewport
-            const fields = ['Saturday', 'Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
-              .map(field => {
-                return {
-                  label: field,
-                  value: field.toLowerCase(),
-                  checked: false
-                }
-              });
-
-            radios.querySelector('fieldset').insertAdjacentHTML('beforeend', helpers.getRadios(fields, 'days'));
-
-            radios.offsetHeight = 475;
-
-          };
-
-          function adjustScreenPositions () {
-
-            const radiosBottom = getScreenItemBottomPosition(radios);
-
-            screenMock.window.setHeightTo(windowHeight);
-
-            // formFooter top should be at the radios bottom
-            formFooter.offsetTop = radiosBottom;
-
-            // footer top should be at formFooter's bottom
-            footer.offsetTop = getScreenItemBottomPosition(formFooter);
-
-          };
-
-          makeStickysBiggerThanWindow();
-          adjustScreenPositions();
-
-          screenMock.scrollTo(inputForm.offsetTop + 10);
-
-          window.NotifyModules.stickAtTopWhenScrolling.init()
-
-        });
-
-        test("the number of elements in the group that are stuck should be reduced until it fits into the viewport", () => {
-
-          // when the group is stuck, pageFooter is closest to the viewport edge so should stay sticky
-          expect(inputForm.classList.contains('content-fixed-onload')).toBe(true);
-          expect(inputForm.classList.contains('content-fixed')).toBe(false);
-
-          // radios are made not sticky
-          expect(radios.classList.contains('content-fixed-onload')).toBe(false);
-          expect(radios.classList.contains('content-fixed')).toBe(false);
-
-        });
-
-        test("window is scrolled so the sticky elements (stuck and not stuck) appear in sequence", () => {
-
-          // we assume it's useful to start by seeing all the elements in the position they normally sit in the page
-          expect(screenMock.window.top).toEqual(inputForm.offsetTop);
-
-        });
-
-      });
-
-    });
-
-  });
-
-  describe("If intending to stick to the bottom", () => {
-
-    let heading;
-    let content;
-    let pageFooter;
-    let windowHeight;
-    let getFurthestBottomPoint;
-
-    beforeEach(() => {
-
-      document.body.innerHTML = `
-        <main role="main" class="grid-col-9 column-main">
-          <a class="usa-back-link" href="">Back</a>
-          <h1 class="heading-large js-header">
-            Preview of ‘Content email’
-          </h1>
-          <div class="wrapper">
-            <div class="email-message-body">
-              <h2>This is the title</h2>
-              <p>This is a paragraph, defined as a block of content where the contents run horizontally across lines.</p>
-              <table role="presentation">
-                <tbody>
-                  <tr>
-                    <td>
-                      <ul>
-                        <li>these</li>
-                        <li>are</li>
-                        <li>bullet points</li>
-                      </ul>
-                    </td>
-                  </tr>
-                </tbody>
-              </table>
-              <blockquote>
-                <p>This block of text is formatted to stand out from the rest</p>
-              </blockquote>
-              <p>This is a paragraph with a horizontal line underneath.</p>
-              <hr>
-              <p>This is a paragraph with a horizontal line above.</p>
-              <p>This paragraph has a link in it: <a class="usa-link" href="https://www.usa.gov">https://www.usa.gov</a>.</p>
-            </div>
-            <div class="page-footer js-stick-at-bottom-when-scrolling">
-              <form method="post" action="">
-                  <button type="submit" class="usa-button">Send 1 email </button>
-              </form>
-            </div>
-          </div>
-        </main>`;
-
-      heading = document.querySelector('.js-header');
-      content = document.querySelector('.email-message-body');
-      pageFooter = document.querySelector('.page-footer');
-
-      windowHeight = 940;
-
-      // mock the rendering of all components
-      screenMock = new helpers.ScreenMock(jest);
-      screenMock.setWindow({
-        width: 1990,
-        height: windowHeight,
-        scrollTop: 0
-      });
-      screenMock.mockPositionAndDimension('heading', heading, {
-        offsetHeight: 75,
-        offsetWidth: 727,
-        offsetTop: 185
-      });
-      screenMock.mockPositionAndDimension('content', content, {
-        offsetHeight: 900,
-        offsetWidth: 727,
-        offsetTop: heading.offsetTop + heading.offsetHeight
-      });
-      screenMock.mockPositionAndDimension('pageFooter', pageFooter, {
-        offsetHeight: 50,
-        offsetWidth: 727,
-        offsetTop: content.offsetTop + content.offsetHeight
-      });
-
-      getFurthestBottomPoint = (stickysTotalHeight) => {
-        const headingBottom = getScreenItemBottomPosition(heading);
-
-        return headingBottom + PADDING_BEFORE_STOPPING_POINT + stickysTotalHeight;
-      };
-
-      // the sticky JS polls for changes to position/dimension so we need to fake setTimeout and setInterval
-      jest.useFakeTimers();
-
-    });
-
-    afterEach(() => {
-
-      window.NotifyModules.stickAtBottomWhenScrolling.clearEvents();
-
-    });
-
-    test("if bottom of viewport is below bottom of element on load, the element should not be marked as sticky", () => {
-
-      const pageFooterBottom = getScreenItemBottomPosition(pageFooter);
-
-      // scroll so the bottom of the window goes past the bottom of the element
-      screenMock.scrollTo((pageFooterBottom - windowHeight) + 10);
-
-      window.NotifyModules.stickAtBottomWhenScrolling.init();
-
-      // `.content-fixed-onload` adds the drop-shadow without fading in to show it did not become sticky from user interaction
-      expect(pageFooter.classList.contains('content-fixed-onload')).toBe(false);
-      expect(pageFooter.classList.contains('content-fixed')).toBe(false);
-
-    });
-
-    test("if the window is 768px or less wide and the bottom of the viewport is above bottom of element on load, the element should not be marked as sticky", () => {
-
-      const pageFooterBottom = getScreenItemBottomPosition(pageFooter);
-
-      screenMock.window.resizeTo({
-        height: windowHeight,
-        width: 768
-      });
-
-      // scroll past top of form
-      screenMock.scrollTo(pageFooterBottom - 10);
-
-      window.NotifyModules.stickAtTopWhenScrolling.init();
-
-      expect(pageFooter.classList.contains('content-fixed')).toBe(false);
-      expect(pageFooter.classList.contains('content-fixed-onload')).toBe(false); // check the class for onload isn't applied
-
-    });
-
-    describe("if bottom of viewport is above bottom of element on load", () => {
-
-      beforeEach(() => {
-
-        // scroll position defaults to 0 so bottom of window starts at 940px. Element bottom defaults to 1160px.
-        window.NotifyModules.stickAtBottomWhenScrolling.init();
-
-      });
-
-      test("the element should be marked as already sticky", () => {
-
-        expect(pageFooter.classList.contains('content-fixed-onload')).toBe(true);
-        expect(pageFooter.classList.contains('content-fixed')).toBe(false);
-
-      });
-
-      test("a 'shim' element with dimensions matching the sticky element should be added to the document to take up the space it no longer occupies", () => {
-
-        const shim = pageFooter.nextElementSibling;
-
-        expect(shim).not.toBeNull();
-        expect(shim.classList.contains('shim')).toBe(true);
-        expect(shim.style.height).toEqual(`${pageFooter.offsetHeight}px`);
-        expect(shim.style.marginTop).toEqual(''); // 0px would return an empty string
-        expect(shim.style.marginBottom).toEqual(''); // 0px would return an empty string
-
-      });
-
-    });
-
-    test("if bottom of viewport is above the furthest point the bottom of the element can go in the scroll area on load, the element should be marked as stopped", () => {
-
-      // change window size so its bottom can go past stopping position
-      const windowHeight = 200;
-      const furthestBottomPoint = getFurthestBottomPoint(pageFooter.offsetHeight);
-
-      screenMock.window.setHeightTo(windowHeight);
-
-      // scroll the window bottom past the furthest point
-      screenMock.scrollTo((furthestBottomPoint - windowHeight) - 10);
-
-      window.NotifyModules.stickAtBottomWhenScrolling.init();
-
-      // `.content-fixed-onload` adds the drop-shadow without fading in to show it did not become sticky from user interaction
-      expect(pageFooter.classList.contains('content-fixed-onload')).toBe(true);
-      expect(pageFooter.classList.contains('content-fixed')).toBe(false);
-
-      // elements are stopped by adding inline styles
-      expect(pageFooter.style.position).toEqual('absolute');
-      expect(pageFooter.style.top).toEqual(`${furthestBottomPoint - pageFooter.offsetHeight}px`);
-
-    });
-
-    describe("if viewport bottom starts below element bottom", () => {
-
-      let pageFooterBottom;
-
-      beforeEach(() => {
-
-        pageFooterBottom = getScreenItemBottomPosition(pageFooter);
-
-        // change window size so its bottom can go past stopping position
-        const windowHeight = 600;
-
-        screenMock.window.setHeightTo(windowHeight);
-
-        // scroll to just below the element
-        screenMock.scrollTo((pageFooterBottom - windowHeight) + 10);
-
-        window.NotifyModules.stickAtBottomWhenScrolling.init();
-
-      });
-
-      test("if window is scrolled so bottom of it is above the bottom of the element, the element should be marked so it becomes sticky to the user", () => {
-
-        // scroll above bottom of sticky element
-        screenMock.scrollTo((pageFooterBottom - windowHeight) - 10);
-        jest.advanceTimersByTime(60); // fake advance of time to something similar to that for a scroll
-
-        // `content-fixed` fades the drop-shadow in to show it became sticky from user interaction
-        expect(pageFooter.classList.contains('content-fixed')).toBe(true);
-        expect(pageFooter.classList.contains('content-fixed-onload')).toBe(false); // check the class for onload isn't applied
-
-      });
-
-      test("if window is scrolled so bottom of it is above the furthest point the bottom of the element can go in the scroll area, the element should be stopped", () => {
-
-        const furthestBottomPoint = getFurthestBottomPoint(pageFooter.offsetHeight);
-
-        // scroll past furthest point
-        screenMock.scrollTo((furthestBottomPoint - windowHeight) - 10);
-        jest.advanceTimersByTime(60); // fake advance of time to something similar to that for a scroll
-
-        // `content-fixed` fades the drop-shadow in to show it became sticky from user interaction
-        expect(pageFooter.classList.contains('content-fixed')).toBe(true);
-        expect(pageFooter.classList.contains('content-fixed-onload')).toBe(false); // check the class for onload isn't applied
-
-        // elements are stopped by adding inline styles
-        expect(pageFooter.style.position).toEqual('absolute');
-        expect(pageFooter.style.top).toEqual(`${furthestBottomPoint - pageFooter.offsetHeight}px`);
-
-      });
-
-      test("if window resizes so bottom is above the bottom of the element, the element should be marked so it becomes sticky to the user", () => {
-
-        // resize window so the bottom is 30px above the bottom of the element
-        screenMock.window.resizeTo({ height: 560, width: screenMock.window.width });
-        jest.advanceTimersByTime(60); // fake advance of time to something similar to that for a resize
-
-        // `content-fixed` fades the drop-shadow in to show it became sticky from user interaction
-        expect(pageFooter.classList.contains('content-fixed')).toBe(true);
-        expect(pageFooter.classList.contains('content-fixed-onload')).toBe(false); // check the class for onload isn't applied
-
-      });
-
-    });
-
-    describe("if scrollToRevealElement is called with an element", () => {
-
-      let link;
-      let linkBottom;
-
-      beforeEach(() => {
-
-        const contentBottom = getScreenItemBottomPosition(content);
-
-        content.insertAdjacentHTML('afterEnd', '<a href="" id="formatting-options">Formatting options</a>');
-        link = document.querySelector('#formatting-options');
-
-        screenMock.mockPositionAndDimension('link', link, {
-          offsetHeight: 25, // 25px smaller than the sticky
-          offsetWidth: 727,
-          offsetTop: contentBottom
-        });
-
-        linkBottom = getScreenItemBottomPosition(link);
-
-        // move the sticky over the link. It's 50px high so this position will cause it to overlap.
-        screenMock.scrollTo((linkBottom - windowHeight) + 5);
-
-        window.NotifyModules.stickAtBottomWhenScrolling.init();
-
-      });
-
-      afterEach(() => {
-
-        screenMock.window.spies.window.scrollTo.mockClear();
-
-      });
-
-      test("the window should scroll so the element is revealed", () => {
-
-        // update inputForm position as DOM normally would
-        pageFooter.offsetTop = screenMock.window.bottom - pageFooter.offsetHeight;
-
-        let stickyPosition = getStickyGroupPosition(screenMock, { stickyEls: [pageFooter], edge: 'bottom' });
-
-        // sticky position should overlap link position
-        expect(stickyPosition.top).toBeLessThanOrEqual(link.offsetTop);
-        expect(stickyPosition.bottom).toBeGreaterThanOrEqual(linkBottom);
-
-        window.NotifyModules.stickAtBottomWhenScrolling.scrollToRevealElement(link)
-
-        stickyPosition = getStickyGroupPosition(screenMock, { stickyEls: [pageFooter], edge: 'bottom' });
-
-        // the top of the sticky element should be at the bottom of the link
-        expect(screenMock.window.spies.window.scrollTo.mock.calls[0]).toEqual([0, (linkBottom + pageFooter.offsetHeight) - windowHeight]);
-
-      });
-
-    });
-
-    describe("if viewport bottom starts above element bottom", () => {
-
-      let pageFooterBottom;
-      let pageFooterShim;
-
-      beforeEach(() => {
-
-        // scroll position defaults to 0 so bottom of window starts at 940px. Element bottom defaults to 1160px so will be sticky on load.
-        pageFooterBottom = getScreenItemBottomPosition(pageFooter);
-
-        // shim will be inserted, inheriting space in the page from pageFooter so store this data
-        const pageFooterData = {
-          offsetHeight: pageFooter.offsetHeight,
-          offsetWidth: pageFooter.offsetWidth,
-          offsetTop: pageFooter.offsetTop
-        };
-
-        window.NotifyModules.stickAtBottomWhenScrolling.init();
-
-        // add mock for shim
-        pageFooterShim = document.querySelector('.shim');
-        screenMock.mockPositionAndDimension('pageFooterShim', pageFooterShim, pageFooterData);
-
-      });
-
-      test("if window is scrolled so bottom of it is below the bottom of the element, the element should be made not sticky", () => {
-
-        // scroll so bottom of window is below bottom of element
-        screenMock.scrollTo((pageFooterBottom - windowHeight) + 10);
-        jest.advanceTimersByTime(60); // fake advance of time to something similar to that for a scroll
-
-        expect(pageFooter.classList.contains('content-fixed')).toBe(false);
-        expect(pageFooter.classList.contains('content-fixed-onload')).toBe(false); // check the class for onload isn't applied
-
-      });
-
-      test("if window resizes so bottom is below the bottom of the element, the element should be made not sticky", () => {
-
-        // resize window so the bottom is 30px above the bottom of the element
-        screenMock.window.resizeTo({ height: pageFooterBottom + 10, width: screenMock.window.width });
-        jest.advanceTimersByTime(60); // fake advance of time to something similar to that for a resize
-
-        expect(pageFooter.classList.contains('content-fixed')).toBe(false);
-        expect(pageFooter.classList.contains('content-fixed-onload')).toBe(false);
-
-      });
-
-      test("if window resizes so bottom is above the furthest point the bottom of the element can go in the scroll area, the element should be stopped", () => {
-
-        const furthestBottomPoint = getFurthestBottomPoint(pageFooter.offsetHeight);
-
-        // resize window so the bottom is above the furthest point
-        screenMock.window.resizeTo({ height: furthestBottomPoint - 10, width: screenMock.window.width });
-        jest.advanceTimersByTime(60); // fake advance of time to something similar to that for a resize
-
-        expect(pageFooter.classList.contains('content-fixed')).toBe(false); // applied if made sticky after page load
-        expect(pageFooter.classList.contains('content-fixed-onload')).toBe(true); // check the class for onload isn't applied
-
-        // elements are stopped by adding inline styles
-        expect(pageFooter.style.position).toEqual('absolute');
-        expect(pageFooter.style.top).toEqual(`${furthestBottomPoint - pageFooter.offsetHeight}px`);
-
-      });
-
-    });
-
-    describe("if element is made sticky and another element underneath it is focused", () => {
-
-      let checkbox;
-      let checkboxBottom;
-
-      beforeEach(() => {
-
-        const contentBottom = getScreenItemBottomPosition(content);
-
-        content.insertAdjacentHTML('afterEnd', '<input type="checkbox" name="confirm" value="yes" />');
-        checkbox = document.querySelector('input[type=checkbox]');
-
-        screenMock.mockPositionAndDimension('checkbox', checkbox, {
-          offsetHeight: 40, // 10px smaller than the sticky
-          offsetWidth: 727,
-          offsetTop: contentBottom
-        });
-
-        checkboxBottom = getScreenItemBottomPosition(checkbox);
-
-        // move the sticky over the checkbox. It's 50px high so this position will cause it to overlap.
-        screenMock.scrollTo((checkboxBottom - windowHeight) + 5);
-
-        window.NotifyModules.stickAtBottomWhenScrolling.init();
-
-      });
-
-      afterEach(() => {
-
-        screenMock.window.spies.window.scrollTo.mockClear();
-
-      });
-
-      test("the window should scroll so the focused element is revealed", () => {
-
-        // update inputForm position as DOM normally would
-        pageFooter.offsetTop = screenMock.window.bottom - pageFooter.offsetHeight;
-
-        let stickyPosition = getStickyGroupPosition(screenMock, { stickyEls: [pageFooter], edge: 'bottom' });
-
-        // sticky position should overlap checkbox position
-        expect(stickyPosition.top).toBeLessThanOrEqual(checkbox.offsetTop);
-        expect(stickyPosition.bottom).toBeGreaterThanOrEqual(checkboxBottom);
-
-        // the sticky element (page footer) is 50 high so should cover the last of the radios if the bottom edge of the viewport is at its bottom
-        checkbox.focus();
-
-        stickyPosition = getStickyGroupPosition(screenMock, { stickyEls: [pageFooter], edge: 'bottom' });
-
-        // the top of the sticky element should be at the bottom of the checkbox
-        expect(screenMock.window.spies.window.scrollTo.mock.calls[0]).toEqual([0, (checkboxBottom + pageFooter.offsetHeight) - windowHeight]);
-
-      });
-
-    });
-
-    describe("if element is made sticky and overlaps a textarea", () => {
-
-      let textarea;
-      let textareaBottom;
-      let caretCoordinates;
-      let caretCoordinatesMock;
-
-      beforeEach(() => {
-
-        const contentBottom = getScreenItemBottomPosition(content);
-
-        content.insertAdjacentHTML('afterEnd', '<textarea name="notes"></textarea>');
-        textarea = document.querySelector('textarea');
-
-        // line height: 30px, text height: 19px, 10 lines.
-        screenMock.mockPositionAndDimension('textarea', textarea, {
-          offsetHeight: 300,
-          offsetWidth: 727,
-          offsetTop: contentBottom
-        });
-
-        textareaBottom = getScreenItemBottomPosition(textarea);
-
-        // start caret on the last line
-        caretCoordinates = new CaretCoordinates();
-        caretCoordinates.moveToLine(10);
-        caretCoordinatesMock = jest.fn(() => caretCoordinates);
-        window.getCaretCoordinates = caretCoordinatesMock;
-
-        // move the sticky so it overlaps the bottom 50px of the textarea.
-        screenMock.scrollTo(textareaBottom - windowHeight);
-
-        // update content position as DOM normally would
-        pageFooter.offsetTop = screenMock.window.bottom - pageFooter.offsetHeight;
-
-        window.NotifyModules.stickAtBottomWhenScrolling.init();
-
-      });
-
-      afterEach(() => {
-
-        screenMock.window.spies.window.scrollTo.mockClear();
-        caretCoordinatesMock.mockClear();
-
-      });
-
-      test("if the textarea receives focus while its caret is underneath, the window should scroll to reveal the caret", () => {
-
-        const stickyPosition = getStickyGroupPosition(screenMock, { stickyEls: [pageFooter], edge: 'bottom' });
-        const caretPosition = getCaretPosition(caretCoordinates, textarea);
-
-        // sticky position should overlap caret position
-        expect(stickyPosition.top).toBeLessThan(caretPosition.bottom);
-
-        textarea.focus();
-
-        // the top of the sticky element should be at the bottom of the caret
-        expect(screenMock.window.spies.window.scrollTo.mock.calls[0]).toEqual([0, caretPosition.bottom - (windowHeight - stickyPosition.height)]);
-
-      });
-
-      test("if the caret is moved so it isn't underneath the sticky element, the window shouldn't scroll", () => {
-
-        // start caret on 8th line which isn't under the sticky element.
-        caretCoordinates.moveToLine(8);
-
-        const stickyPosition = getStickyGroupPosition(screenMock, { stickyEls: [pageFooter], edge: 'bottom' });
-        const caretPosition = getCaretPosition(caretCoordinates, textarea);
-
-        // the sticky element should be below the caret
-        expect(stickyPosition.top).toBeGreaterThan(caretPosition.bottom);
-
-        textarea.focus();
-
-        // no scrolling should have happened
-        expect(screenMock.window.spies.window.scrollTo.mock.calls.length).toEqual(0);
-
-      });
-
-      test("if the caret is moved to be underneath the sticky element, the window should scroll to reveal the caret", () => {
-
-        // start caret on 8th line which isn't under the sticky element.
-        caretCoordinates.moveToLine(8);
-
-        // make sure the textarea has focus
-        textarea.focus();
-
-        // move the caret underneath the sticky element
-        caretCoordinates.moveToLine(9);
-
-        const stickyPosition = getStickyGroupPosition(screenMock, { stickyEls: [pageFooter], edge: 'bottom' });
-        const caretPosition = getCaretPosition(caretCoordinates, textarea);
-
-        // sticky position should overlap caret position
-        expect(stickyPosition.top).toBeLessThan(caretPosition.bottom);
-
-        // simulate a press of the down arrow
-        helpers.triggerEvent(textarea, 'keyup', { interface: window.KeyboardEvent });
-
-        // the top of the sticky element should be at the bottom of the caret
-        expect(screenMock.window.spies.window.scrollTo.mock.calls[0]).toEqual([0, caretPosition.bottom - (windowHeight - stickyPosition.height)]);
-
-      });
-
-    });
-
-    describe("if mode is set to 'dialog' and multiple sticky elements have the same scroll area", () => {
-
-      let radios;
-
-      beforeEach(() => {
-
-        const contentBottom = getScreenItemBottomPosition(content);
-
-        // set mode to 'dialog' so sticky elements are treated as one item
-        window.NotifyModules.stickAtBottomWhenScrolling.setMode('dialog')
-
-        // add another sticky element before the form footer
-        radios = helpers.getRadioGroup({
-          cssClasses: ['js-stick-at-bottom-when-scrolling'],
-          name: 'choose-send-time',
-          label: 'Choose send time',
-          fields: [
-            {
-              label: 'Now',
-              value: 'now',
-              checked: true
-            },
-            {
-              label: 'Tomorrow',
-              value: 'tomorrow',
-              checked: false
-            },
-            {
-              label: 'Friday',
-              value: 'friday',
-              checked: false
-            }
-          ]
-        });
-
-        pageFooter.parentNode.insertBefore(radios, pageFooter);
-        screenMock.mockPositionAndDimension('radios', radios, {
-          offsetHeight: 175,
-          offsetWidth: 727,
-          offsetTop: contentBottom
-        });
-        const radiosBottom = getScreenItemBottomPosition(radios);
-
-        // adjust other screen items
-
-        // pageFooter top should be at the radios bottom
-        pageFooter.offsetTop = radiosBottom;
-
-      });
-
-      afterEach(() => {
-
-        window.NotifyModules.stickAtBottomWhenScrolling.setMode('default');
-
-      });
-
-      describe("if window bottom is above the bottom of the lowest element on load", () => {
-
-        let pageFooterBottom;
-
-        beforeEach(() => {
-
-          pageFooterBottom = getScreenItemBottomPosition(pageFooter);
-
-          // scroll to just above the element
-          screenMock.scrollTo((pageFooterBottom - windowHeight) - 10);
-
-          window.NotifyModules.stickAtBottomWhenScrolling.init();
-
-        });
-
-        test("both should be marked as already sticky", () => {
-
-          expect(pageFooter.classList.contains('content-fixed-onload')).toBe(true);
-          expect(pageFooter.classList.contains('content-fixed')).toBe(false);
-
-        });
-
-        test("the highest element should have the drop-shadow", () => {
-
-          expect(radios.classList.contains('content-fixed__bottom')).toBe(true);
-
-        });
-
-        test("they should be stacked from the bottom edge of the viewport in the order they appear in the document", () => {
-
-          expect(radios.style.bottom).toEqual(`${pageFooter.offsetHeight - PADDING_BETWEEN_STICKYS}px`);
-
-        });
-
-      });
-
-      describe("if window bottom is above the furthest point the lowest element can go on load", () => {
-
-        let headingBottom;
-
-        beforeEach(() => {
-
-          const dialogHeight = (pageFooter.offsetHeight + radios.offsetHeight) - PADDING_BETWEEN_STICKYS;
-          const furthestBottomPoint = getFurthestBottomPoint(dialogHeight);
-
-          // change window size so its bottom can go past stopping position
-          const windowHeight = 200;
-
-          headingBottom = getScreenItemBottomPosition(heading);
-
-          screenMock.window.setHeightTo(windowHeight);
-
-          screenMock.scrollTo((furthestBottomPoint - windowHeight) - 10)
-
-          window.NotifyModules.stickAtBottomWhenScrolling.init();
-
-        });
-
-        test("both should be stopped so the top of their stack is at the furthest point", () => {
-
-          expect(radios.style.position).toEqual('absolute');
-          expect(pageFooter.style.position).toEqual('absolute');
-          expect(radios.style.top).toEqual(`${headingBottom + PADDING_BEFORE_STOPPING_POINT}px`);
-          expect(pageFooter.style.top).toEqual(`${headingBottom + PADDING_BEFORE_STOPPING_POINT + (radios.offsetHeight - PADDING_BETWEEN_STICKYS)}px`);
-
-        });
-
-      });
-
-      describe("if the group of sticky elements is taller than the window when stuck together", () => {
-
-        let windowHeight;
-        let pageFooterBottom;
-
-        // the sticky behaviour should stick as many elements as possible to the bottom of the viewport
-        // the rest should be put back into their place in the document
-        beforeEach(() => {
-
-          windowHeight = 460;
-
-          function makeStickysBiggerThanWindow () {
-
-            // make the radios too big to fit in the viewport
-            const fields = ['Saturday', 'Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
-              .map(field => {
-                return {
-                  label: field,
-                  value: field.toLowerCase(),
-                  checked: false
-                }
-              });
-
-            radios.querySelector('fieldset').insertAdjacentHTML('beforeend', helpers.getRadios(fields, 'days'));
-
-            radios.offsetHeight = 475;
-
-          };
-
-          function adjustScreenPositions () {
-
-            const radiosBottom = getScreenItemBottomPosition(radios);
-
-            screenMock.window.setHeightTo(windowHeight);
-
-            // formFooter top should be at the radios bottom
-            pageFooter.offsetTop = radiosBottom;
-
-          };
-
-          makeStickysBiggerThanWindow();
-          adjustScreenPositions();
-
-          pageFooterBottom = getScreenItemBottomPosition(pageFooter);
-
-          screenMock.scrollTo((pageFooterBottom - windowHeight) - 10);
-
-          window.NotifyModules.stickAtBottomWhenScrolling.init()
-
-        });
-
-        test("the number of elements in the group that are stuck should be reduced until it fits into the viewport", () => {
-
-          // when the group is stuck, pageFooter is closest to the viewport edge so should stay sticky
-          expect(pageFooter.classList.contains('content-fixed-onload')).toBe(true);
-          expect(pageFooter.classList.contains('content-fixed')).toBe(false);
-
-          // radios are made not sticky
-          expect(radios.classList.contains('content-fixed-onload')).toBe(false);
-          expect(radios.classList.contains('content-fixed')).toBe(false);
-
-        });
-
-        test("window is scrolled so the sticky elements (stuck and not stuck) appear in sequence", () => {
-
-          // we assume it's useful to start by seeing all the elements in the position they normally sit in the page
-          expect(screenMock.window.top).toEqual(pageFooterBottom - windowHeight);
-
-        });
-
-      });
-
-    });
-
-  });
-
-});
diff --git a/tests/javascripts/support/jest.setup.js b/tests/javascripts/support/jest.setup.js
index 59a5dee29..39c342018 100644
--- a/tests/javascripts/support/jest.setup.js
+++ b/tests/javascripts/support/jest.setup.js
@@ -1,8 +1,6 @@
 const fs = require('fs');
 const path = require('path');
 
-// Set up jQuery
-global.$ = global.jQuery = require('jquery');
 
 // tests/jest.setup.js
 global.io = jest.fn().mockReturnValue({
diff --git a/tests/javascripts/support/setup.js b/tests/javascripts/support/setup.js
index 17084446f..010be5c81 100644
--- a/tests/javascripts/support/setup.js
+++ b/tests/javascripts/support/setup.js
@@ -3,6 +3,3 @@ const path = require('path');
 
 // Fill in the gaps where JSDOM doesn't quite match real browsers
 require('./polyfills.js');
-
-// Make jQuery available everywhere
-global.$ = global.jQuery = require('jquery');
diff --git a/tests/javascripts/support/teardown.js b/tests/javascripts/support/teardown.js
index e4ee16fc4..9ba30070b 100644
--- a/tests/javascripts/support/teardown.js
+++ b/tests/javascripts/support/teardown.js
@@ -1,6 +1,3 @@
-window.jQuery = null;
-$ = null;
-
 delete window.USWDS;
 
 jest.restoreAllMocks();
diff --git a/tests/javascripts/timeoutPopup.test.js b/tests/javascripts/timeoutPopup.test.js
index 1afea4b86..26d35a1f1 100644
--- a/tests/javascripts/timeoutPopup.test.js
+++ b/tests/javascripts/timeoutPopup.test.js
@@ -135,4 +135,37 @@ describe('The session timer ', () => {
     window.NotifyModules.TimeoutPopup.checkTimer();
     expect(checkTimerMock).toHaveBeenCalled();
   });
+
+  test('checkTimer expires and redirects when time runs out', () => {
+    const restore = mockWindowLocation();
+    const sessionTimer = document.getElementById('sessionTimer');
+    sessionTimer.showModal = jest.fn();
+    sessionTimer.close = jest.fn();
+
+    const closeTimerMock = jest.spyOn(sessionTimer, 'close');
+
+    const pastTime = new Date().getTime() - 1000;
+
+    window.NotifyModules.TimeoutPopup.checkTimer(pastTime);
+
+    expect(closeTimerMock).toHaveBeenCalled();
+
+    restore();
+  });
+
+  test('checkTimer updates time display and shows modal when time is remaining', () => {
+    const sessionTimer = document.getElementById('sessionTimer');
+    const timeLeftElement = document.getElementById('timeLeft');
+    sessionTimer.showModal = jest.fn();
+    sessionTimer.close = jest.fn();
+
+    const showModalMock = jest.spyOn(sessionTimer, 'showModal');
+
+    const futureTime = new Date().getTime() + (2 * 60 * 1000);
+
+    window.NotifyModules.TimeoutPopup.checkTimer(futureTime);
+
+    expect(showModalMock).toHaveBeenCalled();
+    expect(timeLeftElement.textContent).toMatch(/\d+m \d+s/);
+  });
 });
diff --git a/tests/javascripts/updateStatus.test.js b/tests/javascripts/updateStatus.test.js
index ef01ca10e..0504db2e8 100644
--- a/tests/javascripts/updateStatus.test.js
+++ b/tests/javascripts/updateStatus.test.js
@@ -6,27 +6,19 @@ const serviceNumber = '6658542f-0cad-491f-bec8-ab8457700ead';
 const updatesURL = `/services/${serviceNumber}/templates/count-sms-length`;
 
 let responseObj = {};
-let jqueryAJAXReturnObj;
 
 beforeAll(() => {
 
   // ensure all timers go through Jest
   jest.useFakeTimers();
 
-  // mock the bits of jQuery used
-  jest.spyOn(window.$, 'ajax');
-
-  // set up the object returned from $.ajax so it responds with whatever responseObj is set to
-  jqueryAJAXReturnObj = {
-    done: callback => {
-      // For these tests the server responds immediately
-      callback(responseObj);
-      return jqueryAJAXReturnObj;
-    },
-    fail: () => {}
-  };
-
-  $.ajax.mockImplementation(() => jqueryAJAXReturnObj);
+  // mock fetch
+  global.fetch = jest.fn(() =>
+    Promise.resolve({
+      ok: true,
+      json: () => Promise.resolve(responseObj)
+    })
+  );
 
   require('../../app/assets/javascripts/updateStatus.js');
 
@@ -58,8 +50,8 @@ describe('Update content', () => {
 
     document.body.innerHTML = '';
 
-    // tidy up record of mocked AJAX calls
-    $.ajax.mockClear();
+    // tidy up record of mocked fetch calls
+    fetch.mockClear();
 
     // ensure any timers set by continually starting the module are cleared
     jest.clearAllTimers();
@@ -102,18 +94,21 @@ describe('Update content', () => {
 
     window.NotifyModules.start();
 
-    expect($.ajax.mock.calls[0][0]).toEqual(updatesURL);
-    expect($.ajax.mock.calls[0]).toEqual([
-      updatesURL,
-      {
-        "data": "csrf_token=abc123&template_content=Content%20of%20message",
-        "method": "post"
-      }
-    ]);
+    expect(fetch.mock.calls[0][0]).toEqual(updatesURL);
+    expect(fetch.mock.calls[0][1]).toMatchObject({
+      method: 'POST',
+      credentials: 'same-origin',
+      body: expect.any(FormData)
+    });
+
+    // Verify FormData contents
+    const formData = fetch.mock.calls[0][1].body;
+    expect(formData.get('csrf_token')).toBe('abc123');
+    expect(formData.get('template_content')).toBe('Content of message');
 
   });
 
-  test("It should replace the content of the div with the returned HTML", () => {
+  test("It should replace the content of the div with the returned HTML", async () => {
 
     responseObj = {'html': 'Updated content'}
 
@@ -123,14 +118,23 @@ describe('Update content', () => {
       "Initial content"
     );
 
+    // Use real timers for async operations
+    jest.useRealTimers();
+
     window.NotifyModules.start();
 
+    // Wait for the promise chain to complete
+    await new Promise(resolve => setTimeout(resolve, 0));
+
     expect(
       document.querySelectorAll('[data-module=update-status]')[0].textContent.trim()
     ).toEqual(
       "Updated content"
     );
 
+    // Restore fake timers
+    jest.useFakeTimers();
+
   });
 
   test("It should fire when the content of the textarea changes", () => {
@@ -139,13 +143,13 @@ describe('Update content', () => {
 
     // Initial update triggered
     window.NotifyModules.start();
-    expect($.ajax.mock.calls.length).toEqual(1);
+    expect(fetch.mock.calls.length).toEqual(1);
 
     // 150ms of inactivity
     jest.advanceTimersByTime(150);
     helpers.triggerEvent(textarea, 'input');
 
-    expect($.ajax.mock.calls.length).toEqual(2);
+    expect(fetch.mock.calls.length).toEqual(2);
 
   });
 
@@ -155,23 +159,44 @@ describe('Update content', () => {
 
     // Initial update triggered
     window.NotifyModules.start();
-    expect($.ajax.mock.calls.length).toEqual(1);
+    expect(fetch.mock.calls.length).toEqual(1);
 
     helpers.triggerEvent(textarea, 'input');
     jest.advanceTimersByTime(149);
-    expect($.ajax.mock.calls.length).toEqual(1);
+    expect(fetch.mock.calls.length).toEqual(1);
 
     helpers.triggerEvent(textarea, 'input');
     jest.advanceTimersByTime(149);
-    expect($.ajax.mock.calls.length).toEqual(1);
+    expect(fetch.mock.calls.length).toEqual(1);
 
     helpers.triggerEvent(textarea, 'input');
     jest.advanceTimersByTime(149);
-    expect($.ajax.mock.calls.length).toEqual(1);
+    expect(fetch.mock.calls.length).toEqual(1);
 
     // > 150ms of inactivity
     jest.advanceTimersByTime(1);
-    expect($.ajax.mock.calls.length).toEqual(2);
+    expect(fetch.mock.calls.length).toEqual(2);
+
+  });
+
+  test("It should handle fetch errors gracefully", async () => {
+
+    global.fetch.mockImplementationOnce(() =>
+      Promise.resolve({
+        ok: false,
+        status: 500,
+        json: () => Promise.resolve({})
+      })
+    );
+
+    window.NotifyModules.start();
+
+    const textbox = document.getElementById('template_content');
+    helpers.triggerEvent(textbox, 'input');
+
+    jest.runAllTimers();
+
+    expect(document.querySelector('[data-module="update-status"]')).not.toBeNull();
 
   });
 
diff --git a/urls.js b/urls.js
index 5c9772d69..ee5ec8d97 100644
--- a/urls.js
+++ b/urls.js
@@ -38,7 +38,6 @@ const routes = {
     { label: 'Service Usage', path: servicePath('/usage') },
     { label: 'Service Template Usage', path: servicePath('/template-usage') },
     { label: 'Service Jobs', path: servicePath('/jobs') },
-    { label: 'Service Notifications', path: servicePath('/notifications') },
     { label: 'Service History', path: servicePath('/history') },
     { label: 'Service Settings', path: servicePath('/service-settings') },
     { label: 'Service Settings Admin', path: servicePath('/service-settings?show_admin_view=true') },
diff --git a/webpack.config.js b/webpack.config.js
index e7c69700f..438273443 100644
--- a/webpack.config.js
+++ b/webpack.config.js
@@ -77,11 +77,6 @@ module.exports = {
   },
 
   plugins: [
-    new webpack.ProvidePlugin({
-      $: 'jquery',
-      jQuery: 'jquery',
-      'window.jQuery': 'jquery'
-    }),
     new MiniCssExtractPlugin({
       filename: '../css/styles.css'
     }),