remove node_modulesvuepress

16 files changed, 0 insertions, 1537 deletions

diff --git a/node_modules/workbox-precaching/LICENSE b/node_modules/workbox-precaching/LICENSE
deleted file mode 100644
index 136b9039..00000000
--- a/node_modules/workbox-precaching/LICENSE
+++ /dev/null
@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "{}"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2017 Google, Inc.
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/node_modules/workbox-precaching/README.md b/node_modules/workbox-precaching/README.md
deleted file mode 100644
index c1f629bc..00000000
--- a/node_modules/workbox-precaching/README.md
+++ /dev/null
@@ -1 +0,0 @@
-This module's documentation can be found at https://developers.google.com/web/tools/workbox/modules/workbox-precaching
diff --git a/node_modules/workbox-precaching/_default.mjs b/node_modules/workbox-precaching/_default.mjs
deleted file mode 100644
index b791572d..00000000
--- a/node_modules/workbox-precaching/_default.mjs
+++ /dev/null
@@ -1,305 +0,0 @@
-/*
-  Copyright 2017 Google Inc.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      https://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-*/
-
-import {assert} from 'workbox-core/_private/assert.mjs';
-import {cacheNames} from 'workbox-core/_private/cacheNames.mjs';
-import {logger} from 'workbox-core/_private/logger.mjs';
-import {getFriendlyURL} from 'workbox-core/_private/getFriendlyURL.mjs';
-import PrecacheController from './controllers/PrecacheController.mjs';
-import './_version.mjs';
-
-if (process.env.NODE_ENV !== 'production') {
-  assert.isSwEnv('workbox-precaching');
-}
-
-let installActivateListenersAdded = false;
-let fetchListenersAdded = false;
-let suppressWarnings = false;
-let plugins = [];
-
-const cacheName = cacheNames.getPrecacheName();
-const precacheController = new PrecacheController(cacheName);
-
-const _removeIgnoreUrlParams = (origUrlObject, ignoreUrlParametersMatching) => {
-  // Exclude initial '?'
-  const searchString = origUrlObject.search.slice(1);
-
-  // Split into an array of 'key=value' strings
-  const keyValueStrings = searchString.split('&');
-  const keyValuePairs = keyValueStrings.map((keyValueString) => {
-    // Split each 'key=value' string into a [key, value] array
-    return keyValueString.split('=');
-  });
-  const filteredKeyValuesPairs = keyValuePairs.filter((keyValuePair) => {
-    return ignoreUrlParametersMatching
-      .every((ignoredRegex) => {
-        // Return true iff the key doesn't match any of the regexes.
-        return !ignoredRegex.test(keyValuePair[0]);
-      });
-  });
-  const filteredStrings = filteredKeyValuesPairs.map((keyValuePair) => {
-    // Join each [key, value] array into a 'key=value' string
-    return keyValuePair.join('=');
-  });
-
-  // Join the array of 'key=value' strings into a string with '&' in
-  // between each
-  const urlClone = new URL(origUrlObject);
-  urlClone.search = filteredStrings.join('&');
-  return urlClone;
-};
-
-/**
- * This function will take the request URL and manipulate it based on the
- * configuration options.
- *
- * @param {string} url
- * @param {Object} options
- * @return {string|null} Returns the URL in the cache that matches the request
- * if available, other null.
- *
- * @private
- */
-const _getPrecachedUrl = (url, {
-  ignoreUrlParametersMatching = [/^utm_/],
-  directoryIndex = 'index.html',
-  cleanUrls = true,
-  urlManipulation = null,
-} = {}) => {
-  const urlObject = new URL(url, location);
-
-  // Change '/some-url#123' => '/some-url'
-  urlObject.hash = '';
-
-  const urlWithoutIgnoredParams = _removeIgnoreUrlParams(
-    urlObject, ignoreUrlParametersMatching
-  );
-
-  let urlsToAttempt = [
-    // Test the URL that was fetched
-    urlObject,
-    // Test the URL without search params
-    urlWithoutIgnoredParams,
-  ];
-
-  // Test the URL with a directory index
-  if (directoryIndex && urlWithoutIgnoredParams.pathname.endsWith('/')) {
-    const directoryUrl = new URL(urlWithoutIgnoredParams);
-    directoryUrl.pathname += directoryIndex;
-    urlsToAttempt.push(directoryUrl);
-  }
-
-  // Test the URL with a '.html' extension
-  if (cleanUrls) {
-    const cleanUrl = new URL(urlWithoutIgnoredParams);
-    cleanUrl.pathname += '.html';
-    urlsToAttempt.push(cleanUrl);
-  }
-
-  if (urlManipulation) {
-    const additionalUrls = urlManipulation({url: urlObject});
-    urlsToAttempt = urlsToAttempt.concat(additionalUrls);
-  }
-
-  const cachedUrls = precacheController.getCachedUrls();
-  for (const possibleUrl of urlsToAttempt) {
-    if (cachedUrls.indexOf(possibleUrl.href) !== -1) {
-      // It's a perfect match
-      if (process.env.NODE_ENV !== 'production') {
-        logger.debug(`Precaching found a match for ` +
-          getFriendlyURL(possibleUrl.toString()));
-      }
-      return possibleUrl.href;
-    }
-  }
-
-  return null;
-};
-
-const moduleExports = {};
-
-/**
- * Add items to the precache list, removing any duplicates and
- * store the files in the
- * ["precache cache"]{@link module:workbox-core.cacheNames} when the service
- * worker installs.
- *
- * This method can be called multiple times.
- *
- * Please note: This method **will not** serve any of the cached files for you,
- * it only precaches files. To respond to a network request you call
- * [addRoute()]{@link module:workbox-precaching.addRoute}.
- *
- * If you have a single array of files to precache, you can just call
- * [precacheAndRoute()]{@link module:workbox-precaching.precacheAndRoute}.
- *
- * @param {Array<Object|string>} entries Array of entries to precache.
- *
- * @alias workbox.precaching.precache
- */
-moduleExports.precache = (entries) => {
-  precacheController.addToCacheList(entries);
-
-  if (installActivateListenersAdded || entries.length <= 0) {
-    return;
-  }
-
-  installActivateListenersAdded = true;
-  self.addEventListener('install', (event) => {
-    event.waitUntil(precacheController.install({
-      event,
-      plugins,
-      suppressWarnings,
-    }));
-  });
-  self.addEventListener('activate', (event) => {
-    event.waitUntil(precacheController.activate({
-      event,
-      plugins,
-    }));
-  });
-};
-
-/**
- * Add a `fetch` listener to the service worker that will
- * respond to
- * [network requests]{@link https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers#Custom_responses_to_requests}
- * with precached assets.
- *
- * Requests for assets that aren't precached, the `FetchEvent` will not be
- * responded to, allowing the event to fall through to other `fetch` event
- * listeners.
- *
- * @param {Object} options
- * @param {string} [options.directoryIndex=index.html] The `directoryIndex` will
- * check cache entries for a URLs ending with '/' to see if there is a hit when
- * appending the `directoryIndex` value.
- * @param {Array<RegExp>} [options.ignoreUrlParametersMatching=[/^utm_/]] An
- * array of regex's to remove search params when looking for a cache match.
- * @param {boolean} [options.cleanUrls=true] The `cleanUrls` option will
- * check the cache for the URL with a `.html` added to the end of the end.
- * @param {workbox.precaching~urlManipulation} [options.urlManipulation]
- * This is a function that should take a URL and return an array of
- * alternative URL's that should be checked for precache matches.
- *
- * @alias workbox.precaching.addRoute
- */
-moduleExports.addRoute = (options) => {
-  if (fetchListenersAdded) {
-    // TODO: Throw error here.
-    return;
-  }
-
-  fetchListenersAdded = true;
-  self.addEventListener('fetch', (event) => {
-    const precachedUrl = _getPrecachedUrl(event.request.url, options);
-    if (!precachedUrl) {
-      if (process.env.NODE_ENV !== 'production') {
-        logger.debug(`Precaching found no match for ` +
-          getFriendlyURL(event.request.url));
-      }
-      return;
-    }
-
-    let responsePromise = caches.open(cacheName)
-      .then((cache) => {
-        return cache.match(precachedUrl);
-      }).then((cachedResponse) => {
-        if (cachedResponse) {
-          return cachedResponse;
-        }
-
-        // Fall back to the network if we don't have a cached response (perhaps
-        // due to manual cache cleanup).
-        if (process.env.NODE_ENV !== 'production') {
-          logger.debug(`The precached response for ` +
-            `${getFriendlyURL(precachedUrl)} in ${cacheName} was not found. ` +
-            `Falling back to the network instead.`);
-        }
-
-        return fetch(precachedUrl);
-      });
-
-    if (process.env.NODE_ENV !== 'production') {
-      responsePromise = responsePromise.then((response) => {
-        // Workbox is going to handle the route.
-        // print the routing details to the console.
-        logger.groupCollapsed(`Precaching is responding to: ` +
-          getFriendlyURL(event.request.url));
-        logger.log(`Serving the precached url: ${precachedUrl}`);
-
-        // The Request and Response objects contains a great deal of
-        // information, hide it under a group in case developers want to see it.
-        logger.groupCollapsed(`View request details here.`);
-        logger.unprefixed.log(event.request);
-        logger.groupEnd();
-
-        logger.groupCollapsed(`View response details here.`);
-        logger.unprefixed.log(response);
-        logger.groupEnd();
-
-        logger.groupEnd();
-        return response;
-      });
-    }
-    event.respondWith(responsePromise);
-  });
-};
-
-/**
- * This method will add entries to the precache list and add a route to
- * respond to fetch events.
- *
- * This is a convenience method that will call
- * [precache()]{@link module:workbox-precaching.precache} and
- * [addRoute()]{@link module:workbox-precaching.addRoute} in a single call.
- *
- * @param {Array<Object|string>} entries Array of entries to precache.
- * @param {Object} options See
- * [addRoute() options]{@link module:workbox-precaching.addRoute}.
- *
- * @alias workbox.precaching.precacheAndRoute
- */
-moduleExports.precacheAndRoute = (entries, options) => {
-  moduleExports.precache(entries);
-  moduleExports.addRoute(options);
-};
-
-/**
- * Warnings will be logged if any of the precached assets are entered without
- * a `revision` property. This is extremely dangerous if the URL's aren't
- * revisioned. However, the warnings can be supressed with this method.
- *
- * @param {boolean} suppress
- *
- * @alias workbox.precaching.suppressWarnings
- */
-moduleExports.suppressWarnings = (suppress) => {
-  suppressWarnings = suppress;
-};
-
-/**
- * Add plugins to precaching.
- *
- * @param {Array<Object>} newPlugins
- *
- * @alias workbox.precaching.addPlugins
- */
-moduleExports.addPlugins = (newPlugins) => {
-  plugins = plugins.concat(newPlugins);
-};
-
-export default moduleExports;
diff --git a/node_modules/workbox-precaching/_public.mjs b/node_modules/workbox-precaching/_public.mjs
deleted file mode 100644
index f6733bf9..00000000
--- a/node_modules/workbox-precaching/_public.mjs
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
-  Copyright 2017 Google Inc.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      https://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-*/
-
-import PrecacheController from './controllers/PrecacheController.mjs';
-import './_version.mjs';
-
-export {
-  PrecacheController,
-};
diff --git a/node_modules/workbox-precaching/_types.mjs b/node_modules/workbox-precaching/_types.mjs
deleted file mode 100644
index 224a195a..00000000
--- a/node_modules/workbox-precaching/_types.mjs
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
-  Copyright 2017 Google Inc.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      https://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-*/
-
-import './_version.mjs';
-
-/**
- * @typedef {Object} InstallResult
- * @property {
- * Array<workbox.precaching.PrecacheEntry|string>
- * } updatedEntries List of entries
- * supplied for precaching that were precached.
- * @property {Array<workbox.precaching.PrecacheEntry|string>}
- * notUpdatedEntries List of entries
- * supplied for precaching that were already precached.
- *
- * @memberof workbox.precaching
- */
-
-/**
- * @typedef {Object} CleanupResult
- * @property {Array<string>} deletedCacheRequests List of URLs that were
- * deleted from the precache cache.
- * @property {Array<string>} deletedRevisionDetails
- * List of URLs that were deleted from the precache cache.
- *
- * @memberof workbox.precaching
- */
-
-/**
- * @typedef {Object} PrecacheEntry
- * @property {string} url URL to precache.
- * @property {string} revision Revision information for the URL.
- *
- * @memberof workbox.precaching
- */
-
-/**
- * The "urlManipulation" callback can be used to determine if there are any
- * additional permutations of a URL that should be used to check against
- * the available precached files.
- *
- * For example, Workbox supports checking for '/index.html' when the URL
- * '/' is provided. This callback allows additional, custom checks.
- *
- * @callback ~urlManipulation
- * @param {Object} context
- * @param {URL} context.url The request's URL.
- * @return {Array<URL>} To add additional urls to test, return an Array of
- * URL's. Please note that these **should not be Strings**, but URL objects.
- *
- * @memberof workbox.precaching
- */
diff --git a/node_modules/workbox-precaching/_version.mjs b/node_modules/workbox-precaching/_version.mjs
deleted file mode 100644
index 0c59270d..00000000
--- a/node_modules/workbox-precaching/_version.mjs
+++ /dev/null
@@ -1 +0,0 @@
-try{self.workbox.v['workbox:precaching:3.6.3']=1;}catch(e){} // eslint-disable-line
\ No newline at end of file
diff --git a/node_modules/workbox-precaching/browser.mjs b/node_modules/workbox-precaching/browser.mjs
deleted file mode 100644
index 20950ace..00000000
--- a/node_modules/workbox-precaching/browser.mjs
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
-  Copyright 2017 Google Inc.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      https://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-*/
-
-import * as publicAPI from './_public.mjs';
-import defaultExport from './_default.mjs';
-import './_version.mjs';
-
-const finalExport = Object.assign(defaultExport, publicAPI);
-
-export default finalExport;
diff --git a/node_modules/workbox-precaching/controllers/PrecacheController.mjs b/node_modules/workbox-precaching/controllers/PrecacheController.mjs
deleted file mode 100644
index d4b704b3..00000000
--- a/node_modules/workbox-precaching/controllers/PrecacheController.mjs
+++ /dev/null
@@ -1,393 +0,0 @@
-/*
-  Copyright 2017 Google Inc.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      https://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-*/
-
-import {cacheNames} from 'workbox-core/_private/cacheNames.mjs';
-import {WorkboxError} from 'workbox-core/_private/WorkboxError.mjs';
-import {fetchWrapper} from 'workbox-core/_private/fetchWrapper.mjs';
-import {cacheWrapper} from 'workbox-core/_private/cacheWrapper.mjs';
-import {assert} from 'workbox-core/_private/assert.mjs';
-import PrecacheEntry from '../models/PrecacheEntry.mjs';
-import PrecachedDetailsModel from '../models/PrecachedDetailsModel.mjs';
-import showWarningsIfNeeded from '../utils/showWarningsIfNeeded.mjs';
-import printInstallDetails from '../utils/printInstallDetails.mjs';
-import printCleanupDetails from '../utils/printCleanupDetails.mjs';
-import cleanRedirect from '../utils/cleanRedirect.mjs';
-import '../_version.mjs';
-
-/**
- * Performs efficient precaching of assets.
- *
- * @memberof workbox.precaching
- */
-class PrecacheController {
-  /**
-   * Create a new PrecacheController.
-   *
-   * @param {string} cacheName
-   */
-  constructor(cacheName) {
-    this._cacheName = cacheNames.getPrecacheName(cacheName);
-    this._entriesToCacheMap = new Map();
-    this._precacheDetailsModel = new PrecachedDetailsModel(this._cacheName);
-  }
-
-  /**
-   * This method will add items to the precache list, removing duplicates
-   * and ensuring the information is valid.
-   *
-   * @param {
-   * Array<module:workbox-precaching.PrecacheController.PrecacheEntry|string>
-   * } entries Array of entries to
-   * precache.
-   */
-  addToCacheList(entries) {
-    if (process.env.NODE_ENV !== 'production') {
-      assert.isArray(entries, {
-        moduleName: 'workbox-precaching',
-        className: 'PrecacheController',
-        funcName: 'addToCacheList',
-        paramName: 'entries',
-      });
-    }
-
-    entries.map((userEntry) => {
-      this._addEntryToCacheList(
-        this._parseEntry(userEntry)
-      );
-    });
-  }
-
-  /**
-   * This method returns a precache entry.
-   *
-   * @private
-   * @param {string|Object} input
-   * @return {PrecacheEntry}
-   */
-  _parseEntry(input) {
-    switch (typeof input) {
-      case 'string': {
-        if (process.env.NODE_ENV !== 'production') {
-          if (input.length === 0) {
-            throw new WorkboxError(
-              'add-to-cache-list-unexpected-type', {
-                entry: input,
-              }
-            );
-          }
-        }
-
-        return new PrecacheEntry(input, input, input);
-      }
-      case 'object': {
-        if (process.env.NODE_ENV !== 'production') {
-          if (!input || !input.url) {
-            throw new WorkboxError(
-              'add-to-cache-list-unexpected-type', {
-                entry: input,
-              }
-            );
-          }
-        }
-
-        return new PrecacheEntry(
-          input, input.url, input.revision || input.url, !!input.revision);
-      }
-      default:
-        throw new WorkboxError('add-to-cache-list-unexpected-type', {
-          entry: input,
-        });
-    }
-  }
-
-  /**
-   * Adds an entry to the precache list, accounting for possible duplicates.
-   *
-   * @private
-   * @param {PrecacheEntry} entryToAdd
-   */
-  _addEntryToCacheList(entryToAdd) {
-    // Check if the entry is already part of the map
-    const existingEntry = this._entriesToCacheMap.get(entryToAdd._entryId);
-    if (!existingEntry) {
-      this._entriesToCacheMap.set(entryToAdd._entryId, entryToAdd);
-      return;
-    }
-
-    // Duplicates are fine, but make sure the revision information
-    // is the same.
-    if (existingEntry._revision !== entryToAdd._revision) {
-      throw new WorkboxError('add-to-cache-list-conflicting-entries', {
-        firstEntry: existingEntry._originalInput,
-        secondEntry: entryToAdd._originalInput,
-      });
-    }
-  }
-
-  /**
-   * Call this method from a service work install event to start
-   * precaching assets.
-   *
-   * @param {Object} options
-   * @param {boolean} [options.suppressWarnings] Suppress warning messages.
-   * @param {Event} [options.event] The install event (if needed).
-   * @param {Array<Object>} [options.plugins] Plugins to be used for fetching
-   *     and caching during install.
-   * @return {Promise<workbox.precaching.InstallResult>}
-   */
-  async install({suppressWarnings = false, event, plugins} = {}) {
-    if (process.env.NODE_ENV !== 'production') {
-      if (suppressWarnings !== true) {
-        showWarningsIfNeeded(this._entriesToCacheMap);
-      }
-
-      if (plugins) {
-        assert.isArray(plugins, {
-          moduleName: 'workbox-precaching',
-          className: 'PrecacheController',
-          funcName: 'install',
-          paramName: 'plugins',
-        });
-      }
-    }
-
-    // Empty the temporary cache.
-    // NOTE: We remove all entries instead of deleting the cache as the cache
-    // may be marked for deletion but still exist until a later stage
-    // resulting in unexpected behavior of being deletect when all references
-    // are dropped.
-    // https://github.com/GoogleChrome/workbox/issues/1368
-    const tempCache = await caches.open(this._getTempCacheName());
-    const requests = await tempCache.keys();
-    await Promise.all(requests.map((request) => {
-      return tempCache.delete(request);
-    }));
-
-    const entriesToPrecache = [];
-    const entriesAlreadyPrecached = [];
-
-    for (const precacheEntry of this._entriesToCacheMap.values()) {
-      if (await this._precacheDetailsModel._isEntryCached(
-        this._cacheName, precacheEntry)) {
-        entriesAlreadyPrecached.push(precacheEntry);
-      } else {
-        entriesToPrecache.push(precacheEntry);
-      }
-    }
-
-    // Wait for all requests to be cached.
-    await Promise.all(entriesToPrecache.map((precacheEntry) => {
-      return this._cacheEntryInTemp({event, plugins, precacheEntry});
-    }));
-
-    if (process.env.NODE_ENV !== 'production') {
-      printInstallDetails(entriesToPrecache, entriesAlreadyPrecached);
-    }
-
-    return {
-      updatedEntries: entriesToPrecache,
-      notUpdatedEntries: entriesAlreadyPrecached,
-    };
-  }
-
-  /**
-   * Takes the current set of temporary files and moves them to the final
-   * cache, deleting the temporary cache once copying is complete.
-   *
-   * @param {Object} options
-   * @param {Array<Object>} options.plugins Plugins to be used for fetching
-   * and caching during install.
-   * @return {
-   * Promise<workbox.precaching.CleanupResult>}
-   * Resolves with an object containing details of the deleted cache requests
-   * and precache revision details.
-   */
-  async activate(options = {}) {
-    const tempCache = await caches.open(this._getTempCacheName());
-
-    const requests = await tempCache.keys();
-    // Process each request/response one at a time, deleting the temporary entry
-    // when done, to help avoid triggering quota errors.
-    for (const request of requests) {
-      const response = await tempCache.match(request);
-      await cacheWrapper.put({
-        cacheName: this._cacheName,
-        request,
-        response,
-        plugins: options.plugins,
-      });
-      await tempCache.delete(request);
-    }
-
-    return this._cleanup();
-  }
-
-  /**
-   * Returns the name of the temporary cache.
-   *
-   * @return {string}
-   *
-   * @private
-   */
-  _getTempCacheName() {
-    return `${this._cacheName}-temp`;
-  }
-
-  /**
-   * Requests the entry and saves it to the cache if the response
-   * is valid.
-   *
-   * @private
-   * @param {Object} options
-   * @param {BaseCacheEntry} options.precacheEntry The entry to fetch and cache.
-   * @param {Event} [options.event] The install event (if passed).
-   * @param {Array<Object>} [options.plugins] An array of plugins to apply to
-   *     fetch and caching.
-   * @return {Promise<boolean>} Returns a promise that resolves once the entry
-   *     has been fetched and cached or skipped if no update is needed. The
-   *     promise resolves with true if the entry was cached / updated and
-   *     false if the entry is already cached and up-to-date.
-   */
-  async _cacheEntryInTemp({precacheEntry, event, plugins}) {
-    let response = await fetchWrapper.fetch({
-      request: precacheEntry._networkRequest,
-      event,
-      fetchOptions: null,
-      plugins,
-    });
-
-    if (response.redirected) {
-      response = await cleanRedirect(response);
-    }
-
-    await cacheWrapper.put({
-      cacheName: this._getTempCacheName(),
-      request: precacheEntry._cacheRequest,
-      response,
-      event,
-      plugins,
-    });
-
-    await this._precacheDetailsModel._addEntry(precacheEntry);
-
-    return true;
-  }
-
-  /**
-   * Compare the URLs and determines which assets are no longer required
-   * in the cache.
-   *
-   * This should be called in the service worker activate event.
-   *
-   * @return {
-   * Promise<workbox.precaching.CleanupResult>}
-   * Resolves with an object containing details of the deleted cache requests
-   * and precache revision details.
-   *
-   * @private
-   */
-  async _cleanup() {
-    const expectedCacheUrls = [];
-    this._entriesToCacheMap.forEach((entry) => {
-      const fullUrl = new URL(entry._cacheRequest.url, location).toString();
-      expectedCacheUrls.push(fullUrl);
-    });
-
-    const [deletedCacheRequests, deletedRevisionDetails] = await Promise.all([
-      this._cleanupCache(expectedCacheUrls),
-      this._cleanupDetailsModel(expectedCacheUrls),
-    ]);
-
-    if (process.env.NODE_ENV !== 'production') {
-      printCleanupDetails(deletedCacheRequests, deletedRevisionDetails);
-    }
-
-    return {
-      deletedCacheRequests,
-      deletedRevisionDetails,
-    };
-  }
-
-  /**
-   * Goes through all the cache entries and removes any that are
-   * outdated.
-   *
-   * @private
-   * @param {Array<string>} expectedCacheUrls Array of URLs that are
-   * expected to be cached.
-   * @return {Promise<Array<string>>} Resolves to an array of URLs
-   * of cached requests that were deleted.
-   */
-  async _cleanupCache(expectedCacheUrls) {
-    if (!await caches.has(this._cacheName)) {
-      // Cache doesn't exist, so nothing to delete
-      return [];
-    }
-
-    const cache = await caches.open(this._cacheName);
-    const cachedRequests = await cache.keys();
-    const cachedRequestsToDelete = cachedRequests.filter((cachedRequest) => {
-      return !expectedCacheUrls.includes(
-        new URL(cachedRequest.url, location).toString()
-      );
-    });
-
-    await Promise.all(
-      cachedRequestsToDelete.map((cacheUrl) => cache.delete(cacheUrl))
-    );
-
-    return cachedRequestsToDelete.map((request) => request.url);
-  }
-
-  /**
-   * Goes through all entries in indexedDB and removes any that are outdated.
-   *
-   * @private
-   * @param {Array<string>} expectedCacheUrls Array of URLs that are
-   * expected to be cached.
-   * @return {Promise<Array<string>>} Resolves to an array of URLs removed
-   * from indexedDB.
-   */
-  async _cleanupDetailsModel(expectedCacheUrls) {
-    const revisionedEntries = await this._precacheDetailsModel._getAllEntries();
-    const detailsToDelete = revisionedEntries
-      .filter((entry) => {
-        const fullUrl = new URL(entry.value.url, location).toString();
-        return !expectedCacheUrls.includes(fullUrl);
-      });
-
-    await Promise.all(
-      detailsToDelete.map(
-        (entry) => this._precacheDetailsModel._deleteEntry(entry.primaryKey)
-      )
-    );
-    return detailsToDelete.map((entry) => {
-      return entry.value.url;
-    });
-  }
-
-  /**
-   * Returns an array of fully qualified URL's that will be precached.
-   *
-   * @return {Array<string>} An array of URLs.
-   */
-  getCachedUrls() {
-    return Array.from(this._entriesToCacheMap.keys())
-    .map((url) => new URL(url, location).href);
-  }
-}
-
-export default PrecacheController;
diff --git a/node_modules/workbox-precaching/index.mjs b/node_modules/workbox-precaching/index.mjs
deleted file mode 100644
index 1b8c3bd2..00000000
--- a/node_modules/workbox-precaching/index.mjs
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
-  Copyright 2017 Google Inc.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      https://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-*/
-
-import defaultPrecachingExport from './_default.mjs';
-import './_version.mjs';
-
-/**
- * Most consumers of this module will want to use the
- * [precacheAndRoute()]{@link workbox.precaching.precacheAndRoute}
- * method to add assets to the Cache and respond to network requests with these
- * cached assets.
- *
- * If you require finer grained control, you can use the
- * [PrecacheController]{@link workbox.precaching.PrecacheController}
- * to determine when performed.
- *
- * @namespace workbox.precaching
- */
-
-export * from './_public.mjs';
-
-export default defaultPrecachingExport;
diff --git a/node_modules/workbox-precaching/models/PrecacheEntry.mjs b/node_modules/workbox-precaching/models/PrecacheEntry.mjs
deleted file mode 100644
index 8138edfa..00000000
--- a/node_modules/workbox-precaching/models/PrecacheEntry.mjs
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
-  Copyright 2017 Google Inc.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      https://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-*/
-
-import '../_version.mjs';
-
-/**
- * Used as a consistent way of referencing a URL to precache.
- *
- * @private
- * @memberof module:workbox-precaching
- */
-export default class PrecacheEntry {
-/**
- * This class ensures all cache list entries are consistent and
- * adds cache busting if required.
- *
- * @param {*} originalInput
- * @param {string} url
- * @param {string} revision
- * @param {boolean} shouldCacheBust
- */
-  constructor(originalInput, url, revision, shouldCacheBust) {
-    this._originalInput = originalInput;
-    this._entryId = url;
-    this._revision = revision;
-    const requestAsCacheKey = new Request(url, {credentials: 'same-origin'});
-    this._cacheRequest = requestAsCacheKey;
-    this._networkRequest = shouldCacheBust ?
-      this._cacheBustRequest(requestAsCacheKey) : requestAsCacheKey;
-  }
-
-  /**
-   * This method will either use Request.cache option OR append a cache
-   * busting parameter to the URL.
-   *
-   * @param {Request} request The request to cache bust
-   * @return {Request} A cachebusted Request
-   *
-   * @private
-   */
-  _cacheBustRequest(request) {
-    let url = request.url;
-    const requestOptions = {
-      credentials: 'same-origin',
-    };
-    if ('cache' in Request.prototype) {
-      // Make use of the Request cache mode where we can.
-      // Reload skips the HTTP cache for outgoing requests and updates
-      // the cache with the returned response.
-      requestOptions.cache = 'reload';
-    } else {
-      const parsedURL = new URL(url, location);
-
-      // This is done so the minifier can mangle 'global.encodeURIComponent'
-      const _encodeURIComponent = encodeURIComponent;
-
-      parsedURL.search += (parsedURL.search ? '&' : '') +
-        _encodeURIComponent(`_workbox-cache-bust`) + '=' +
-        _encodeURIComponent(this._revision);
-      url = parsedURL.toString();
-    }
-
-    return new Request(url, requestOptions);
-  }
-}
diff --git a/node_modules/workbox-precaching/models/PrecachedDetailsModel.mjs b/node_modules/workbox-precaching/models/PrecachedDetailsModel.mjs
deleted file mode 100644
index 55f1420d..00000000
--- a/node_modules/workbox-precaching/models/PrecachedDetailsModel.mjs
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
-  Copyright 2017 Google Inc.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      https://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-*/
-
-import {DBWrapper} from 'workbox-core/_private/DBWrapper.mjs';
-import '../_version.mjs';
-
-// Allows minifier to mangle this name
-const REVISON_IDB_FIELD = 'revision';
-const URL_IDB_FIELD = 'url';
-const DB_STORE_NAME = 'precached-details-models';
-/**
- * This model will track the relevant information of entries that
- * are cached and their matching revision details.
- *
- * @private
- */
-class PrecachedDetailsModel {
-  /**
-   * Construct a new model for a specific cache.
-   *
-   * @param {string} dbName
-   * @private
-   */
-  constructor(dbName) {
-    // This ensures the db name contains only letters, numbers, '-', '_' and '$'
-    const filteredDBName = dbName.replace(/[^\w-]/g, '_');
-    this._db = new DBWrapper(filteredDBName, 2, {
-      onupgradeneeded: this._handleUpgrade,
-    });
-  }
-
-  /**
-   * Should perform an upgrade of indexedDB.
-   *
-   * @param {Event} evt
-   *
-   * @private
-   */
-  _handleUpgrade(evt) {
-    const db = evt.target.result;
-    if (evt.oldVersion < 2) {
-      // IndexedDB version 1 used both 'workbox-precaching' and
-      // 'precached-details-model' before upgrading to version 2.
-      // Delete them and create a new store with latest schema.
-      if (db.objectStoreNames.contains('workbox-precaching')) {
-        db.deleteObjectStore('workbox-precaching');
-      }
-      if (db.objectStoreNames.contains(DB_STORE_NAME)) {
-        db.deleteObjectStore(DB_STORE_NAME);
-      }
-    }
-    db.createObjectStore(DB_STORE_NAME);
-  }
-
-  /**
-   * Check if an entry is already cached. Returns false if
-   * the entry isn't cached or the revision has changed.
-   *
-   * @param {string} cacheName
-   * @param {PrecacheEntry} precacheEntry
-   * @return {boolean}
-   *
-   * @private
-   */
-  async _isEntryCached(cacheName, precacheEntry) {
-    const revisionDetails = await this._getRevision(precacheEntry._entryId);
-    if (revisionDetails !== precacheEntry._revision) {
-      return false;
-    }
-
-    const openCache = await caches.open(cacheName);
-    const cachedResponse = await openCache.match(precacheEntry._cacheRequest);
-    return !!cachedResponse;
-  }
-
-  /**
-   * @return {Promise<Array>}
-   *
-   * @private
-   */
-  async _getAllEntries() {
-    return await this._db.getAllMatching(DB_STORE_NAME, {
-      includeKeys: true,
-    });
-  }
-
-  /**
-   * Get the current revision details.
-   *
-   * @param {Object} entryId
-   * @return {Promise<string|null>}
-   *
-   * @private
-   */
-  async _getRevision(entryId) {
-    const data = await this._db.get(DB_STORE_NAME, entryId);
-    return data ? data[REVISON_IDB_FIELD] : null;
-  }
-
-  /**
-   * Add an entry to the details model.
-   *
-   * @param {PrecacheEntry} precacheEntry
-   *
-   * @private
-   */
-  async _addEntry(precacheEntry) {
-    await this._db.put(
-      DB_STORE_NAME,
-      {
-        [REVISON_IDB_FIELD]: precacheEntry._revision,
-        [URL_IDB_FIELD]: precacheEntry._cacheRequest.url,
-      },
-      precacheEntry._entryId
-    );
-  }
-
-  /**
-   * Delete entry from details model.
-   *
-   * @param {string} entryId
-   *
-   * @private
-   */
-  async _deleteEntry(entryId) {
-    await this._db.delete(DB_STORE_NAME, entryId);
-  }
-}
-
-export default PrecachedDetailsModel;
diff --git a/node_modules/workbox-precaching/package.json b/node_modules/workbox-precaching/package.json
deleted file mode 100644
index 4c0c3494..00000000
--- a/node_modules/workbox-precaching/package.json
+++ /dev/null
@@ -1,30 +0,0 @@
-{
-  "name": "workbox-precaching",
-  "version": "3.6.3",
-  "license": "Apache-2.0",
-  "author": "Google's Web DevRel Team",
-  "description": "This module efficiently precaches assets.",
-  "repository": "googlechrome/workbox",
-  "bugs": "https://github.com/googlechrome/workbox/issues",
-  "homepage": "https://github.com/GoogleChrome/workbox",
-  "keywords": [
-    "workbox",
-    "workboxjs",
-    "service worker",
-    "sw"
-  ],
-  "scripts": {
-    "build": "gulp build-packages --package workbox-precaching",
-    "version": "npm run build",
-    "prepare": "npm run build"
-  },
-  "workbox": {
-    "browserNamespace": "workbox.precaching",
-    "packageType": "browser"
-  },
-  "main": "build/workbox-precaching.prod.js",
-  "module": "index.mjs",
-  "dependencies": {
-    "workbox-core": "^3.6.3"
-  }
-}
diff --git a/node_modules/workbox-precaching/utils/cleanRedirect.mjs b/node_modules/workbox-precaching/utils/cleanRedirect.mjs
deleted file mode 100644
index aa3013ed..00000000
--- a/node_modules/workbox-precaching/utils/cleanRedirect.mjs
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
-  Copyright 2017 Google Inc.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      https://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-*/
-
-import '../_version.mjs';
-
-/**
- * @param {Response} response
- * @return {Response}
- *
- * @private
- * @memberof module:workbox-precaching
- */
-const cleanRedirect = async (response) => {
-  const clonedResponse = response.clone();
-
-  // Not all browsers support the Response.body stream, so fall back
-  // to reading the entire body into memory as a blob.
-  const bodyPromise = 'body' in clonedResponse ?
-    Promise.resolve(clonedResponse.body) :
-    clonedResponse.blob();
-
-  const body = await bodyPromise;
-
-  // new Response() is happy when passed either a stream or a Blob.
-  return new Response(body, {
-    headers: clonedResponse.headers,
-    status: clonedResponse.status,
-    statusText: clonedResponse.statusText,
-  });
-};
-
-export default cleanRedirect;
diff --git a/node_modules/workbox-precaching/utils/printCleanupDetails.mjs b/node_modules/workbox-precaching/utils/printCleanupDetails.mjs
deleted file mode 100644
index 9138f820..00000000
--- a/node_modules/workbox-precaching/utils/printCleanupDetails.mjs
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
-  Copyright 2017 Google Inc.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      https://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-*/
-
-import {logger} from 'workbox-core/_private/logger.mjs';
-import '../_version.mjs';
-
-const logGroup = (groupTitle, urls) => {
-  logger.groupCollapsed(groupTitle);
-
-  urls.forEach((url) => {
-    logger.log(url);
-  });
-
-  logger.groupEnd();
-};
-
-/**
- * @param {Array<string>} deletedCacheRequests
- * @param {Array<string>} deletedRevisionDetails
- *
- * @private
- * @memberof module:workbox-precachig
- */
-export default (deletedCacheRequests, deletedRevisionDetails) => {
-  if (deletedCacheRequests.length === 0 &&
-    deletedRevisionDetails.length === 0) {
-    return;
-  }
-
-  const cacheDeleteCount = deletedCacheRequests.length;
-  const revisionDeleteCount = deletedRevisionDetails.length;
-
-  const cacheDeleteText =
-    `${cacheDeleteCount} cached ` +
-    `request${cacheDeleteCount === 1 ? ' was' : 's were'} deleted`;
-  const revisionDeleteText =
-    `${revisionDeleteCount} ` +
-    `${revisionDeleteCount === 1 ? 'entry' : 'entries'} ` +
-    `${revisionDeleteCount === 1 ? 'was' : 'were'} deleted from IndexedDB.`;
-
-  logger.groupCollapsed(
-    `During precaching cleanup, ${cacheDeleteText} and ${revisionDeleteText}`);
-
-  logGroup('Deleted Cache Requests', deletedCacheRequests);
-  logGroup('Revision Details Deleted from DB', deletedRevisionDetails);
-
-  logger.groupEnd();
-};
diff --git a/node_modules/workbox-precaching/utils/printInstallDetails.mjs b/node_modules/workbox-precaching/utils/printInstallDetails.mjs
deleted file mode 100644
index 13bf5339..00000000
--- a/node_modules/workbox-precaching/utils/printInstallDetails.mjs
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
-  Copyright 2017 Google Inc.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      https://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-*/
-
-import {logger} from 'workbox-core/_private/logger.mjs';
-import '../_version.mjs';
-
-/**
- * @param {string} groupTitle
- * @param {Array<PrecacheEntry>} entries
- *
- * @private
- */
-const _nestedGroup = (groupTitle, entries) => {
-  if (entries.length === 0) {
-    return;
-  }
-
-  logger.groupCollapsed(groupTitle);
-
-  entries.forEach((entry) => {
-    logger.log(entry._originalInput);
-  });
-
-  logger.groupEnd();
-};
-
-/**
- * @param {Array<Object>} entriesToPrecache
- * @param {Array<Object>} alreadyPrecachedEntries
- *
- * @private
- * @memberof module:workbox-precachig
- */
-export default (entriesToPrecache, alreadyPrecachedEntries) => {
-  // Goal is to print the message:
-  //    Precaching X files.
-  // Or:
-  //    Precaching X files. Y files were cached and up-to-date.
-
-  const precachedCount = entriesToPrecache.length;
-  const alreadyPrecachedCount = alreadyPrecachedEntries.length;
-  let printText =
-    `Precaching ${precachedCount} file${precachedCount === 1 ? '' : 's'}.`;
-  if (alreadyPrecachedCount > 0) {
-    printText += ` ${alreadyPrecachedCount} ` +
-      `file${alreadyPrecachedCount === 1 ? ' is' : 's are'} already cached.`;
-  }
-
-  logger.groupCollapsed(printText);
-
-  _nestedGroup(
-    `View precached URLs.`,
-    entriesToPrecache);
-  _nestedGroup(
-    `View URLs that were already precached.`,
-    alreadyPrecachedEntries);
-  logger.groupEnd();
-};
diff --git a/node_modules/workbox-precaching/utils/showWarningsIfNeeded.mjs b/node_modules/workbox-precaching/utils/showWarningsIfNeeded.mjs
deleted file mode 100644
index 37bbcb36..00000000
--- a/node_modules/workbox-precaching/utils/showWarningsIfNeeded.mjs
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
-  Copyright 2017 Google Inc.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      https://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-*/
-
-import {logger} from 'workbox-core/_private/logger.mjs';
-import '../_version.mjs';
-
-/**
- * This method will print out a warning if a precache entry doesn't have
- * a `revision` value.
- *
- * This is common if the asset if revisioned in the url like `index.1234.css`.
- *
- * @param {Map} entriesMap
- *
- * @private
- * @memberof module:workbox-preaching
- */
-export default (entriesMap) => {
-  const urlOnlyEntries = [];
-  entriesMap.forEach(
-    (entry) => {
-      if (typeof entry === 'string' || !entry._originalInput.revision) {
-        urlOnlyEntries.push(entry._originalInput);
-      }
-    }
-  );
-
-  if (urlOnlyEntries.length === 0) {
-    // No warnings needed.
-    return;
-  }
-
-  logger.groupCollapsed('Are your precached assets revisioned?');
-
-  const urlsList = urlOnlyEntries.map((urlOnlyEntry) => {
-    return `    - ${JSON.stringify(urlOnlyEntry)}`;
-  }).join(`\n`);
-
-  logger.warn(
-    `The following precache entries might not be revisioned:` +
-    `\n\n` +
-    urlsList +
-    `\n\n`
-  );
-
-  logger.unprefixed.warn(`You can learn more about why this might be a ` +
-    `problem here: https://developers.google.com/web/tools/workbox/modules/workbox-precaching`);
-
-  logger.groupEnd();
-};