switch to vuepress

1 files changed, 305 insertions, 0 deletions

diff --git a/node_modules/workbox-precaching/_default.mjs b/node_modules/workbox-precaching/_default.mjs
new file mode 100644
index 00000000..b791572d
--- /dev/null
+++ b/node_modules/workbox-precaching/_default.mjs
@@ -0,0 +1,305 @@
+/*
+  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;