switch to vuepress

22 files changed, 1895 insertions, 0 deletions

diff --git a/node_modules/workbox-core/README.md b/node_modules/workbox-core/README.md
new file mode 100644
index 00000000..0cd4cfea
--- /dev/null
+++ b/node_modules/workbox-core/README.md
@@ -0,0 +1 @@
+This module's documentation can be found at https://developers.google.com/web/tools/workbox/modules/workbox-core
diff --git a/node_modules/workbox-core/_default.mjs b/node_modules/workbox-core/_default.mjs
new file mode 100644
index 00000000..5e0b50bb
--- /dev/null
+++ b/node_modules/workbox-core/_default.mjs
@@ -0,0 +1,194 @@
+/*
+  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 LOG_LEVELS from './models/LogLevels.mjs';
+import {WorkboxError} from './_private/WorkboxError.mjs';
+import {cacheNames} from './_private/cacheNames.mjs';
+import {logger} from './_private/logger.mjs';
+import {assert} from './_private/assert.mjs';
+import {checkSWFileCacheHeaders} from './_private/checkSWFileCacheHeaders.mjs';
+import {setLoggerLevel, getLoggerLevel} from './_private/logger.mjs';
+import './_version.mjs';
+
+/**
+ * This class is never exposed publicly. Inidividual methods are exposed
+ * using jsdoc alias commands.
+ *
+ * @memberof workbox.core
+ * @private
+ */
+class WorkboxCore {
+  /**
+   * You should not instantiate this object directly.
+   *
+   * @private
+   */
+  constructor() {
+    // Give our version strings something to hang off of.
+    try {
+      self.workbox.v = self.workbox.v || {};
+    } catch (err) {
+      // NOOP
+    }
+
+    // A WorkboxCore instance must be exported before we can use the logger.
+    // This is so it can get the current log level.
+    if (process.env.NODE_ENV !== 'production') {
+      const padding = '   ';
+      logger.groupCollapsed('Welcome to Workbox!');
+      logger.unprefixed.log(`You are currently using a development build. ` +
+        `By default this will switch to prod builds when not on localhost. ` +
+        `You can force this with workbox.setConfig({debug: true|false}).`);
+      logger.unprefixed.log(
+        `📖 Read the guides and documentation\n` +
+        `${padding}https://developers.google.com/web/tools/workbox/`
+      );
+      logger.unprefixed.log(
+        `❓ Use the [workbox] tag on Stack Overflow to ask questions\n` +
+        `${padding}https://stackoverflow.com/questions/ask?tags=workbox`
+      );
+      logger.unprefixed.log(
+        `🐛 Found a bug? Report it on GitHub\n` +
+        `${padding}https://github.com/GoogleChrome/workbox/issues/new`
+      );
+      logger.groupEnd();
+
+      if (typeof checkSWFileCacheHeaders === 'function') {
+        checkSWFileCacheHeaders();
+      }
+    }
+  }
+
+  /**
+   * Get the current cache names used by Workbox.
+   *
+   * `cacheNames.precache` is used for precached assets,
+   * `cacheNames.googleAnalytics` is used by `workbox-google-analytics` to
+   * store `analytics.js`,
+   * and `cacheNames.runtime` is used for everything else.
+   *
+   * @return {Object} An object with `precache` and `runtime` cache names.
+   *
+   * @alias workbox.core.cacheNames
+   */
+  get cacheNames() {
+    return {
+      googleAnalytics: cacheNames.getGoogleAnalyticsName(),
+      precache: cacheNames.getPrecacheName(),
+      runtime: cacheNames.getRuntimeName(),
+    };
+  }
+
+  /**
+   * You can alter the default cache names used by the Workbox modules by
+   * changing the cache name details.
+   *
+   * Cache names are generated as `<prefix>-<Cache Name>-<suffix>`.
+   *
+   * @param {Object} details
+   * @param {Object} details.prefix The string to add to the beginning of
+   * the precache and runtime cache names.
+   * @param {Object} details.suffix The string to add to the end of
+   * the precache and runtime cache names.
+   * @param {Object} details.precache The cache name to use for precache
+   * caching.
+   * @param {Object} details.runtime The cache name to use for runtime caching.
+   * @param {Object} details.googleAnalytics The cache name to use for
+   * `workbox-google-analytics` caching.
+   *
+   * @alias workbox.core.setCacheNameDetails
+   */
+  setCacheNameDetails(details) {
+    if (process.env.NODE_ENV !== 'production') {
+      Object.keys(details).forEach((key) => {
+        assert.isType(details[key], 'string', {
+          moduleName: 'workbox-core',
+          className: 'WorkboxCore',
+          funcName: 'setCacheNameDetails',
+          paramName: `details.${key}`,
+        });
+      });
+
+      if ('precache' in details && details.precache.length === 0) {
+        throw new WorkboxError('invalid-cache-name', {
+          cacheNameId: 'precache',
+          value: details.precache,
+        });
+      }
+
+      if ('runtime' in details && details.runtime.length === 0) {
+        throw new WorkboxError('invalid-cache-name', {
+          cacheNameId: 'runtime',
+          value: details.runtime,
+        });
+      }
+
+      if ('googleAnalytics' in details &&
+        details.googleAnalytics.length === 0) {
+        throw new WorkboxError('invalid-cache-name', {
+          cacheNameId: 'googleAnalytics',
+          value: details.googleAnalytics,
+        });
+      }
+    }
+
+    cacheNames.updateDetails(details);
+  }
+
+  /**
+   * Get the current log level.
+   *
+   * @return {number}.
+   *
+   * @alias workbox.core.logLevel
+   */
+  get logLevel() {
+    return getLoggerLevel();
+  }
+
+  /**
+   * Set the current log level passing in one of the values from
+   * [LOG_LEVELS]{@link module:workbox-core.LOG_LEVELS}.
+   *
+   * @param {number} newLevel The new log level to use.
+   *
+   * @alias workbox.core.setLogLevel
+   */
+  setLogLevel(newLevel) {
+    if (process.env.NODE_ENV !== 'production') {
+      assert.isType(newLevel, 'number', {
+        moduleName: 'workbox-core',
+        className: 'WorkboxCore',
+        funcName: 'logLevel [setter]',
+        paramName: `logLevel`,
+      });
+    }
+
+    if (newLevel > LOG_LEVELS.silent ||
+      newLevel < LOG_LEVELS.debug) {
+      throw new WorkboxError('invalid-value', {
+        paramName: 'logLevel',
+        validValueDescription: `Please use a value from LOG_LEVELS, i.e ` +
+          `'logLevel = workbox.core.LOG_LEVELS.debug'.`,
+        value: newLevel,
+      });
+    }
+
+    setLoggerLevel(newLevel);
+  }
+}
+
+export default new WorkboxCore();
diff --git a/node_modules/workbox-core/_private.mjs b/node_modules/workbox-core/_private.mjs
new file mode 100644
index 00000000..5c26ff1a
--- /dev/null
+++ b/node_modules/workbox-core/_private.mjs
@@ -0,0 +1,38 @@
+/*
+  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.
+*/
+
+// We either expose defaults or we expose every named export.
+import {DBWrapper} from './_private/DBWrapper.mjs';
+import {WorkboxError} from './_private/WorkboxError.mjs';
+import {assert} from './_private/assert.mjs';
+import {cacheNames} from './_private/cacheNames.mjs';
+import {cacheWrapper} from './_private/cacheWrapper.mjs';
+import {fetchWrapper} from './_private/fetchWrapper.mjs';
+import {getFriendlyURL} from './_private/getFriendlyURL.mjs';
+import {logger} from './_private/logger.mjs';
+
+import './_version.mjs';
+
+export {
+  DBWrapper,
+  WorkboxError,
+  assert,
+  cacheNames,
+  cacheWrapper,
+  fetchWrapper,
+  getFriendlyURL,
+  logger,
+};
diff --git a/node_modules/workbox-core/_private/DBWrapper.mjs b/node_modules/workbox-core/_private/DBWrapper.mjs
new file mode 100644
index 00000000..61def037
--- /dev/null
+++ b/node_modules/workbox-core/_private/DBWrapper.mjs
@@ -0,0 +1,325 @@
+/*
+  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';
+
+/**
+ * A class that wraps common IndexedDB functionality in a promise-based API.
+ * It exposes all the underlying power and functionality of IndexedDB, but
+ * wraps the most commonly used features in a way that's much simpler to use.
+ *
+ * @private
+ */
+class DBWrapper {
+  /**
+   * @param {string} name
+   * @param {number} version
+   * @param {Object=} [callback]
+   * @param {function(this:DBWrapper, Event)} [callbacks.onupgradeneeded]
+   * @param {function(this:DBWrapper, Event)} [callbacks.onversionchange]
+   *     Defaults to DBWrapper.prototype._onversionchange when not specified.
+   */
+  constructor(name, version, {
+    onupgradeneeded,
+    onversionchange = this._onversionchange,
+  } = {}) {
+    this._name = name;
+    this._version = version;
+    this._onupgradeneeded = onupgradeneeded;
+    this._onversionchange = onversionchange;
+
+    // If this is null, it means the database isn't open.
+    this._db = null;
+  }
+
+  /**
+   * Opens a connected to an IDBDatabase, invokes any onupgradedneeded
+   * callback, and added an onversionchange callback to the database.
+   *
+   * @return {IDBDatabase}
+   *
+   * @private
+   */
+  async open() {
+    if (this._db) return;
+
+    this._db = await new Promise((resolve, reject) => {
+      // This flag is flipped to true if the timeout callback runs prior
+      // to the request failing or succeeding. Note: we use a timeout instead
+      // of an onblocked handler since there are cases where onblocked will
+      // never never run. A timeout better handles all possible scenarios:
+      // https://github.com/w3c/IndexedDB/issues/223
+      let openRequestTimedOut = false;
+      setTimeout(() => {
+        openRequestTimedOut = true;
+        reject(new Error('The open request was blocked and timed out'));
+      }, this.OPEN_TIMEOUT);
+
+      const openRequest = indexedDB.open(this._name, this._version);
+      openRequest.onerror = (evt) => reject(openRequest.error);
+      openRequest.onupgradeneeded = (evt) => {
+        if (openRequestTimedOut) {
+          openRequest.transaction.abort();
+          evt.target.result.close();
+        } else if (this._onupgradeneeded) {
+          this._onupgradeneeded(evt);
+        }
+      };
+      openRequest.onsuccess = (evt) => {
+        const db = evt.target.result;
+        if (openRequestTimedOut) {
+          db.close();
+        } else {
+          db.onversionchange = this._onversionchange;
+          resolve(db);
+        }
+      };
+    });
+
+    return this;
+  }
+
+  /**
+   * Delegates to the native `get()` method for the object store.
+   *
+   * @param {string} storeName The name of the object store to put the value.
+   * @param {...*} args The values passed to the delegated method.
+   * @return {*} The key of the entry.
+   *
+   * @private
+   */
+  async get(storeName, ...args) {
+    return await this._call('get', storeName, 'readonly', ...args);
+  }
+
+  /**
+   * Delegates to the native `add()` method for the object store.
+   *
+   * @param {string} storeName The name of the object store to put the value.
+   * @param {...*} args The values passed to the delegated method.
+   * @return {*} The key of the entry.
+   *
+   * @private
+   */
+  async add(storeName, ...args) {
+    return await this._call('add', storeName, 'readwrite', ...args);
+  }
+
+  /**
+   * Delegates to the native `put()` method for the object store.
+   *
+   * @param {string} storeName The name of the object store to put the value.
+   * @param {...*} args The values passed to the delegated method.
+   * @return {*} The key of the entry.
+   *
+   * @private
+   */
+  async put(storeName, ...args) {
+    return await this._call('put', storeName, 'readwrite', ...args);
+  }
+
+  /**
+   * Delegates to the native `delete()` method for the object store.
+   *
+   * @param {string} storeName
+   * @param {...*} args The values passed to the delegated method.
+   *
+   * @private
+   */
+  async delete(storeName, ...args) {
+    await this._call('delete', storeName, 'readwrite', ...args);
+  }
+
+  /**
+   * Deletes the underlying database, ensuring that any open connections are
+   * closed first.
+   *
+   * @private
+   */
+  async deleteDatabase() {
+    this.close();
+    this._db = null;
+    await new Promise((resolve, reject) => {
+      const request = indexedDB.deleteDatabase(this._name);
+      request.onerror = (evt) => reject(evt.target.error);
+      request.onblocked = () => reject(new Error('Deletion was blocked.'));
+      request.onsuccess = () => resolve();
+    });
+  }
+
+  /**
+   * Delegates to the native `getAll()` or polyfills it via the `find()`
+   * method in older browsers.
+   *
+   * @param {string} storeName
+   * @param {*} query
+   * @param {number} count
+   * @return {Array}
+   *
+   * @private
+   */
+  async getAll(storeName, query, count) {
+    if ('getAll' in IDBObjectStore.prototype) {
+      return await this._call('getAll', storeName, 'readonly', query, count);
+    } else {
+      return await this.getAllMatching(storeName, {query, count});
+    }
+  }
+
+  /**
+   * Supports flexible lookup in an object store by specifying an index,
+   * query, direction, and count. This method returns an array of objects
+   * with the signature .
+   *
+   * @param {string} storeName
+   * @param {Object} [opts]
+   * @param {IDBCursorDirection} [opts.direction]
+   * @param {*} [opts.query]
+   * @param {string} [opts.index] The index to use (if specified).
+   * @param {number} [opts.count] The max number of results to return.
+   * @param {boolean} [opts.includeKeys] When true, the structure of the
+   *     returned objects is changed from an array of values to an array of
+   *     objects in the form {key, primaryKey, value}.
+   * @return {Array}
+   *
+   * @private
+   */
+  async getAllMatching(storeName, opts = {}) {
+    return await this.transaction([storeName], 'readonly', (stores, done) => {
+      const store = stores[storeName];
+      const target = opts.index ? store.index(opts.index) : store;
+      const results = [];
+
+      // Passing `undefined` arguments to Edge's `openCursor(...)` causes
+      // 'DOMException: DataError'
+      // Details in issue: https://github.com/GoogleChrome/workbox/issues/1509
+      const query = opts.query || null;
+      const direction = opts.direction || 'next';
+      target.openCursor(query, direction).onsuccess = (evt) => {
+        const cursor = evt.target.result;
+        if (cursor) {
+          const {primaryKey, key, value} = cursor;
+          results.push(opts.includeKeys ? {primaryKey, key, value} : value);
+          if (opts.count && results.length >= opts.count) {
+            done(results);
+          } else {
+            cursor.continue();
+          }
+        } else {
+          done(results);
+        }
+      };
+    });
+  }
+
+  /**
+   * Accepts a list of stores, a transaction type, and a callback and
+   * performs a transaction. A promise is returned that resolves to whatever
+   * value the callback chooses. The callback holds all the transaction logic
+   * and is invoked with three arguments:
+   *   1. An object mapping object store names to IDBObjectStore values.
+   *   2. A `done` function, that's used to resolve the promise when
+   *      when the transaction is done.
+   *   3. An `abort` function that can be called to abort the transaction
+   *      at any time.
+   *
+   * @param {Array<string>} storeNames An array of object store names
+   *     involved in the transaction.
+   * @param {string} type Can be `readonly` or `readwrite`.
+   * @param {function(Object, function(), function(*)):?IDBRequest} callback
+   * @return {*} The result of the transaction ran by the callback.
+   *
+   * @private
+   */
+  async transaction(storeNames, type, callback) {
+    await this.open();
+    const result = await new Promise((resolve, reject) => {
+      const txn = this._db.transaction(storeNames, type);
+      const done = (value) => resolve(value);
+      const abort = () => {
+        reject(new Error('The transaction was manually aborted'));
+        txn.abort();
+      };
+      txn.onerror = (evt) => reject(evt.target.error);
+      txn.onabort = (evt) => reject(evt.target.error);
+      txn.oncomplete = () => resolve();
+
+      const stores = {};
+      for (const storeName of storeNames) {
+        stores[storeName] = txn.objectStore(storeName);
+      }
+      callback(stores, done, abort);
+    });
+    return result;
+  }
+
+  /**
+   * Delegates async to a native IDBObjectStore method.
+   *
+   * @param {string} method The method name.
+   * @param {string} storeName The object store name.
+   * @param {string} type Can be `readonly` or `readwrite`.
+   * @param {...*} args The list of args to pass to the native method.
+   * @return {*} The result of the transaction.
+   *
+   * @private
+   */
+  async _call(method, storeName, type, ...args) {
+    await this.open();
+    const callback = (stores, done) => {
+      stores[storeName][method](...args).onsuccess = (evt) => {
+        done(evt.target.result);
+      };
+    };
+
+    return await this.transaction([storeName], type, callback);
+  }
+
+  /**
+   * The default onversionchange handler, which closes the database so other
+   * connections can open without being blocked.
+   *
+   * @param {Event} evt
+   *
+   * @private
+   */
+  _onversionchange(evt) {
+    this.close();
+  }
+
+  /**
+   * Closes the connection opened by `DBWrapper.open()`. Generally this method
+   * doesn't need to be called since:
+   *   1. It's usually better to keep a connection open since opening
+   *      a new connection is somewhat slow.
+   *   2. Connections are automatically closed when the reference is
+   *      garbage collected.
+   * The primary use case for needing to close a connection is when another
+   * reference (typically in another tab) needs to upgrade it and would be
+   * blocked by the current, open connection.
+   *
+   * @private
+   */
+  close() {
+    if (this._db) this._db.close();
+  }
+}
+
+// Exposed to let users modify the default timeout on a per-instance
+// or global basis.
+DBWrapper.prototype.OPEN_TIMEOUT = 2000;
+
+export {DBWrapper};
diff --git a/node_modules/workbox-core/_private/WorkboxError.mjs b/node_modules/workbox-core/_private/WorkboxError.mjs
new file mode 100644
index 00000000..6a2d0c5a
--- /dev/null
+++ b/node_modules/workbox-core/_private/WorkboxError.mjs
@@ -0,0 +1,48 @@
+/*
+  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 messageGenerator from '../models/messages/messageGenerator.mjs';
+import '../_version.mjs';
+
+/**
+ * Workbox errors should be thrown with this class.
+ * This allows use to ensure the type easily in tests,
+ * helps developers identify errors from workbox
+ * easily and allows use to optimise error
+ * messages correctly.
+ *
+ * @private
+ */
+class WorkboxError extends Error {
+  /**
+   *
+   * @param {string} errorCode The error code that
+   * identifies this particular error.
+   * @param {Object=} details Any relevant arguments
+   * that will help developers identify issues should
+   * be added as a key on the context object.
+   */
+  constructor(errorCode, details) {
+    let message = messageGenerator(errorCode, details);
+
+    super(message);
+
+    this.name = errorCode;
+    this.details = details;
+  }
+}
+
+export {WorkboxError};
diff --git a/node_modules/workbox-core/_private/assert.mjs b/node_modules/workbox-core/_private/assert.mjs
new file mode 100644
index 00000000..f9832834
--- /dev/null
+++ b/node_modules/workbox-core/_private/assert.mjs
@@ -0,0 +1,109 @@
+/*
+  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 {WorkboxError} from '../_private/WorkboxError.mjs';
+import '../_version.mjs';
+
+/*
+ * This method returns true if the current context is a service worker.
+ */
+const isSwEnv = (moduleName) => {
+  if (!('ServiceWorkerGlobalScope' in self)) {
+    throw new WorkboxError('not-in-sw', {moduleName});
+  }
+};
+
+/*
+ * This method throws if the supplied value is not an array.
+ * The destructed values are required to produce a meaningful error for users.
+ * The destructed and restructured object is so it's clear what is
+ * needed.
+ */
+const isArray = (value, {moduleName, className, funcName, paramName}) => {
+  if (!Array.isArray(value)) {
+    throw new WorkboxError('not-an-array', {
+      moduleName,
+      className,
+      funcName,
+      paramName,
+    });
+  }
+};
+
+const hasMethod = (object, expectedMethod,
+                   {moduleName, className, funcName, paramName}) => {
+  const type = typeof object[expectedMethod];
+  if (type !== 'function') {
+    throw new WorkboxError('missing-a-method', {paramName, expectedMethod,
+      moduleName, className, funcName});
+  }
+};
+
+const isType = (object, expectedType,
+                {moduleName, className, funcName, paramName}) => {
+  if (typeof object !== expectedType) {
+    throw new WorkboxError('incorrect-type', {paramName, expectedType,
+      moduleName, className, funcName});
+  }
+};
+
+const isInstance = (object, expectedClass,
+                    {moduleName, className, funcName,
+                      paramName, isReturnValueProblem}) => {
+  if (!(object instanceof expectedClass)) {
+    throw new WorkboxError('incorrect-class', {paramName, expectedClass,
+      moduleName, className, funcName, isReturnValueProblem});
+  }
+};
+
+const isOneOf = (value, validValues, {paramName}) => {
+  if (!validValues.includes(value)) {
+    throw new WorkboxError('invalid-value', {
+      paramName,
+      value,
+      validValueDescription: `Valid values are ${JSON.stringify(validValues)}.`,
+    });
+  }
+};
+
+const isArrayOfClass = (value, expectedClass,
+  {moduleName, className, funcName, paramName}) => {
+  const error = new WorkboxError('not-array-of-class', {
+    value, expectedClass,
+    moduleName, className, funcName, paramName,
+  });
+  if (!Array.isArray(value)) {
+    throw error;
+  }
+
+  for (let item of value) {
+    if (!(item instanceof expectedClass)) {
+      throw error;
+    }
+  }
+};
+
+const finalAssertExports = process.env.NODE_ENV === 'production' ? null : {
+  hasMethod,
+  isArray,
+  isInstance,
+  isOneOf,
+  isSwEnv,
+  isType,
+  isArrayOfClass,
+};
+
+export {finalAssertExports as assert};
diff --git a/node_modules/workbox-core/_private/cacheNames.mjs b/node_modules/workbox-core/_private/cacheNames.mjs
new file mode 100644
index 00000000..11698cdf
--- /dev/null
+++ b/node_modules/workbox-core/_private/cacheNames.mjs
@@ -0,0 +1,52 @@
+/*
+  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';
+
+const _cacheNameDetails = {
+  prefix: 'workbox',
+  suffix: self.registration.scope,
+  googleAnalytics: 'googleAnalytics',
+  precache: 'precache',
+  runtime: 'runtime',
+};
+
+const _createCacheName = (cacheName) => {
+  return [_cacheNameDetails.prefix, cacheName, _cacheNameDetails.suffix]
+    .filter((value) => value.length > 0)
+    .join('-');
+};
+
+const cacheNames = {
+  updateDetails: (details) => {
+    Object.keys(_cacheNameDetails).forEach((key) => {
+      if (typeof details[key] !== 'undefined') {
+        _cacheNameDetails[key] = details[key];
+      }
+    });
+  },
+  getGoogleAnalyticsName: (userCacheName) => {
+    return userCacheName || _createCacheName(_cacheNameDetails.googleAnalytics);
+  },
+  getPrecacheName: (userCacheName) => {
+    return userCacheName || _createCacheName(_cacheNameDetails.precache);
+  },
+  getRuntimeName: (userCacheName) => {
+    return userCacheName || _createCacheName(_cacheNameDetails.runtime);
+  },
+};
+
+export {cacheNames};
diff --git a/node_modules/workbox-core/_private/cacheWrapper.mjs b/node_modules/workbox-core/_private/cacheWrapper.mjs
new file mode 100644
index 00000000..7c71884c
--- /dev/null
+++ b/node_modules/workbox-core/_private/cacheWrapper.mjs
@@ -0,0 +1,236 @@
+/*
+  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 pluginEvents from '../models/pluginEvents.mjs';
+import pluginUtils from '../utils/pluginUtils.mjs';
+import {WorkboxError} from './WorkboxError.mjs';
+import {assert} from './assert.mjs';
+import {executeQuotaErrorCallbacks} from './quota.mjs';
+import {getFriendlyURL} from './getFriendlyURL.mjs';
+import {logger} from './logger.mjs';
+
+import '../_version.mjs';
+
+/**
+ * Wrapper around cache.put().
+ *
+ * Will call `cacheDidUpdate` on plugins if the cache was updated.
+ *
+ * @param {Object} options
+ * @param {string} options.cacheName
+ * @param {Request} options.request
+ * @param {Response} options.response
+ * @param {Event} [options.event]
+ * @param {Array<Object>} [options.plugins=[]]
+ *
+ * @private
+ * @memberof module:workbox-core
+ */
+const putWrapper = async ({
+    cacheName,
+    request,
+    response,
+    event,
+    plugins = [],
+  } = {}) => {
+  if (!response) {
+    if (process.env.NODE_ENV !== 'production') {
+      logger.error(`Cannot cache non-existent response for ` +
+        `'${getFriendlyURL(request.url)}'.`);
+    }
+
+    throw new WorkboxError('cache-put-with-no-response', {
+      url: getFriendlyURL(request.url),
+    });
+  }
+
+  let responseToCache =
+      await _isResponseSafeToCache({request, response, event, plugins});
+
+  if (!responseToCache) {
+    if (process.env.NODE_ENV !== 'production') {
+      logger.debug(`Response '${getFriendlyURL(request.url)}' will not be ` +
+        `cached.`, responseToCache);
+    }
+    return;
+  }
+
+  if (process.env.NODE_ENV !== 'production') {
+    if (responseToCache.method && responseToCache.method !== 'GET') {
+      throw new WorkboxError('attempt-to-cache-non-get-request', {
+        url: getFriendlyURL(request.url),
+        method: responseToCache.method,
+      });
+    }
+  }
+
+  const cache = await caches.open(cacheName);
+
+  const updatePlugins = pluginUtils.filter(
+    plugins, pluginEvents.CACHE_DID_UPDATE);
+
+  let oldResponse = updatePlugins.length > 0 ?
+    await matchWrapper({cacheName, request}) : null;
+
+  if (process.env.NODE_ENV !== 'production') {
+    logger.debug(`Updating the '${cacheName}' cache with a new Response for ` +
+      `${getFriendlyURL(request.url)}.`);
+  }
+
+  try {
+    await cache.put(request, responseToCache);
+  } catch (error) {
+    // See https://developer.mozilla.org/en-US/docs/Web/API/DOMException#exception-QuotaExceededError
+    if (error.name === 'QuotaExceededError') {
+      await executeQuotaErrorCallbacks();
+    }
+    throw error;
+  }
+
+  for (let plugin of updatePlugins) {
+    await plugin[pluginEvents.CACHE_DID_UPDATE].call(plugin, {
+      cacheName,
+      request,
+      event,
+      oldResponse,
+      newResponse: responseToCache,
+    });
+  }
+};
+
+/**
+ * This is a wrapper around cache.match().
+ *
+ * @param {Object} options
+ * @param {string} options.cacheName Name of the cache to match against.
+ * @param {Request} options.request The Request that will be used to look up
+ *.    cache entries.
+ * @param {Event} [options.event] The event that propted the action.
+ * @param {Object} [options.matchOptions] Options passed to cache.match().
+ * @param {Array<Object>} [options.plugins=[]] Array of plugins.
+ * @return {Response} A cached response if available.
+ *
+ * @private
+ * @memberof module:workbox-core
+ */
+const matchWrapper = async ({
+    cacheName,
+    request,
+    event,
+    matchOptions,
+    plugins = []}) => {
+  const cache = await caches.open(cacheName);
+  let cachedResponse = await cache.match(request, matchOptions);
+  if (process.env.NODE_ENV !== 'production') {
+    if (cachedResponse) {
+      logger.debug(`Found a cached response in '${cacheName}'.`);
+    } else {
+      logger.debug(`No cached response found in '${cacheName}'.`);
+    }
+  }
+  for (let plugin of plugins) {
+    if (pluginEvents.CACHED_RESPONSE_WILL_BE_USED in plugin) {
+      cachedResponse = await plugin[pluginEvents.CACHED_RESPONSE_WILL_BE_USED]
+        .call(plugin, {
+          cacheName,
+          request,
+          event,
+          matchOptions,
+          cachedResponse,
+        });
+      if (process.env.NODE_ENV !== 'production') {
+        if (cachedResponse) {
+          assert.isInstance(cachedResponse, Response, {
+            moduleName: 'Plugin',
+            funcName: pluginEvents.CACHED_RESPONSE_WILL_BE_USED,
+            isReturnValueProblem: true,
+          });
+        }
+      }
+    }
+  }
+  return cachedResponse;
+};
+
+/**
+ * This method will call cacheWillUpdate on the available plugins (or use
+ * response.ok) to determine if the Response is safe and valid to cache.
+ *
+ * @param {Object} options
+ * @param {Request} options.request
+ * @param {Response} options.response
+ * @param {Event} [options.event]
+ * @param {Array<Object>} [options.plugins=[]]
+ * @return {Promise<Response>}
+ *
+ * @private
+ * @memberof module:workbox-core
+ */
+const _isResponseSafeToCache = async ({request, response, event, plugins}) => {
+  let responseToCache = response;
+  let pluginsUsed = false;
+  for (let plugin of plugins) {
+    if (pluginEvents.CACHE_WILL_UPDATE in plugin) {
+      pluginsUsed = true;
+      responseToCache = await plugin[pluginEvents.CACHE_WILL_UPDATE]
+        .call(plugin, {
+          request,
+          response: responseToCache,
+          event,
+        });
+
+      if (process.env.NODE_ENV !== 'production') {
+        if (responseToCache) {
+          assert.isInstance(responseToCache, Response, {
+            moduleName: 'Plugin',
+            funcName: pluginEvents.CACHE_WILL_UPDATE,
+            isReturnValueProblem: true,
+          });
+        }
+      }
+
+      if (!responseToCache) {
+        break;
+      }
+    }
+  }
+
+  if (!pluginsUsed) {
+    if (process.env.NODE_ENV !== 'production') {
+      if (!responseToCache.ok) {
+        if (responseToCache.status === 0) {
+          logger.warn(`The response for '${request.url}' is an opaque ` +
+            `response. The caching strategy that you're using will not ` +
+            `cache opaque responses by default.`);
+        } else {
+          logger.debug(`The response for '${request.url}' returned ` +
+          `a status code of '${response.status}' and won't be cached as a ` +
+          `result.`);
+        }
+      }
+    }
+    responseToCache = responseToCache.ok ? responseToCache : null;
+  }
+
+  return responseToCache ? responseToCache : null;
+};
+
+const cacheWrapper = {
+  put: putWrapper,
+  match: matchWrapper,
+};
+
+export {cacheWrapper};
diff --git a/node_modules/workbox-core/_private/checkSWFileCacheHeaders.mjs b/node_modules/workbox-core/_private/checkSWFileCacheHeaders.mjs
new file mode 100644
index 00000000..7382ceed
--- /dev/null
+++ b/node_modules/workbox-core/_private/checkSWFileCacheHeaders.mjs
@@ -0,0 +1,88 @@
+/*
+  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 './logger.mjs';
+import '../_version.mjs';
+
+/**
+ * Logs a warning to the user recommending changing
+ * to max-age=0 or no-cache.
+ *
+ * @param {string} cacheControlHeader
+ *
+ * @private
+ */
+function showWarning(cacheControlHeader) {
+  const docsUrl = 'https://developers.google.com/web/tools/workbox/guides/service-worker-checklist#cache-control_of_your_service_worker_file';
+  logger.warn(`You are setting a 'cache-control' header of ` +
+    `'${cacheControlHeader}' on your service worker file. This should be ` +
+    `set to 'max-age=0' or 'no-cache' to ensure the latest service worker ` +
+    `is served to your users. Learn more here: ${docsUrl}`
+  );
+}
+
+/**
+ * Checks for cache-control header on SW file and
+ * warns the developer if it exists with a value
+ * other than max-age=0 or no-cache.
+ *
+ * @return {Promise}
+ * @private
+ */
+function checkSWFileCacheHeaders() {
+  // This is wrapped as an iife to allow async/await while making
+  //  rollup exclude it in builds.
+  return (async () => {
+    try {
+      const swFile = self.location.href;
+      const response = await fetch(swFile);
+      if (!response.ok) {
+        // Response failed so nothing we can check;
+        return;
+      }
+
+      if (!response.headers.has('cache-control')) {
+        // No cache control header.
+        return;
+      }
+
+      const cacheControlHeader = response.headers.get('cache-control');
+      const maxAgeResult = /max-age\s*=\s*(\d*)/g.exec(cacheControlHeader);
+      if (maxAgeResult) {
+        if (parseInt(maxAgeResult[1], 10) === 0) {
+          return;
+        }
+      }
+
+      if (cacheControlHeader.indexOf('no-cache') !== -1) {
+        return;
+      }
+
+      if (cacheControlHeader.indexOf('no-store') !== -1) {
+        return;
+      }
+
+      showWarning(cacheControlHeader);
+    } catch (err) {
+      // NOOP
+    }
+  })();
+}
+
+const finalCheckSWFileCacheHeaders =
+  process.env.NODE_ENV === 'production' ? null : checkSWFileCacheHeaders;
+
+export {finalCheckSWFileCacheHeaders as checkSWFileCacheHeaders};
diff --git a/node_modules/workbox-core/_private/fetchWrapper.mjs b/node_modules/workbox-core/_private/fetchWrapper.mjs
new file mode 100644
index 00000000..fc9e7eeb
--- /dev/null
+++ b/node_modules/workbox-core/_private/fetchWrapper.mjs
@@ -0,0 +1,143 @@
+/*
+  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 {WorkboxError} from './WorkboxError.mjs';
+import {logger} from './logger.mjs';
+import {assert} from './assert.mjs';
+import {getFriendlyURL} from '../_private/getFriendlyURL.mjs';
+import pluginEvents from '../models/pluginEvents.mjs';
+import pluginUtils from '../utils/pluginUtils.mjs';
+import '../_version.mjs';
+
+/**
+ * Wrapper around the fetch API.
+ *
+ * Will call requestWillFetch on available plugins.
+ *
+ * @param {Object} options
+ * @param {Request|string} options.request
+ * @param {Object} [options.fetchOptions]
+ * @param {Event} [options.event]
+ * @param {Array<Object>} [options.plugins=[]]
+ * @return {Promise<Response>}
+ *
+ * @private
+ * @memberof module:workbox-core
+ */
+const wrappedFetch = async ({
+    request,
+    fetchOptions,
+    event,
+    plugins = []}) => {
+  // We *should* be able to call `await event.preloadResponse` even if it's
+  // undefined, but for some reason, doing so leads to errors in our Node unit
+  // tests. To work around that, explicitly check preloadResponse's value first.
+  if (event && event.preloadResponse) {
+    const possiblePreloadResponse = await event.preloadResponse;
+    if (possiblePreloadResponse) {
+      if (process.env.NODE_ENV !== 'production') {
+        logger.log(`Using a preloaded navigation response for ` +
+          `'${getFriendlyURL(request.url)}'`);
+      }
+      return possiblePreloadResponse;
+    }
+  }
+
+  if (typeof request === 'string') {
+    request = new Request(request);
+  }
+
+  if (process.env.NODE_ENV !== 'production') {
+    assert.isInstance(request, Request, {
+      paramName: request,
+      expectedClass: 'Request',
+      moduleName: 'workbox-core',
+      className: 'fetchWrapper',
+      funcName: 'wrappedFetch',
+    });
+  }
+
+  const failedFetchPlugins = pluginUtils.filter(
+    plugins, pluginEvents.FETCH_DID_FAIL);
+
+  // If there is a fetchDidFail plugin, we need to save a clone of the
+  // original request before it's either modified by a requestWillFetch
+  // plugin or before the original request's body is consumed via fetch().
+  const originalRequest = failedFetchPlugins.length > 0 ?
+    request.clone() : null;
+
+  try {
+    for (let plugin of plugins) {
+      if (pluginEvents.REQUEST_WILL_FETCH in plugin) {
+        request = await plugin[pluginEvents.REQUEST_WILL_FETCH].call(plugin, {
+          request: request.clone(),
+          event,
+        });
+
+        if (process.env.NODE_ENV !== 'production') {
+          if (request) {
+            assert.isInstance(request, Request, {
+              moduleName: 'Plugin',
+              funcName: pluginEvents.CACHED_RESPONSE_WILL_BE_USED,
+              isReturnValueProblem: true,
+            });
+          }
+        }
+      }
+    }
+  } catch (err) {
+    throw new WorkboxError('plugin-error-request-will-fetch', {
+      thrownError: err,
+    });
+  }
+
+  // The request can be altered by plugins with `requestWillFetch` making
+  // the original request (Most likely from a `fetch` event) to be different
+  // to the Request we make. Pass both to `fetchDidFail` to aid debugging.
+  const pluginFilteredRequest = request.clone();
+
+  try {
+    const fetchResponse = await fetch(request, fetchOptions);
+    if (process.env.NODE_ENV !== 'production') {
+      logger.debug(`Network request for `+
+      `'${getFriendlyURL(request.url)}' returned a response with ` +
+      `status '${fetchResponse.status}'.`);
+    }
+    return fetchResponse;
+  } catch (error) {
+    if (process.env.NODE_ENV !== 'production') {
+      logger.error(`Network request for `+
+      `'${getFriendlyURL(request.url)}' threw an error.`, error);
+    }
+
+    for (let plugin of failedFetchPlugins) {
+      await plugin[pluginEvents.FETCH_DID_FAIL].call(plugin, {
+        error,
+        event,
+        originalRequest: originalRequest.clone(),
+        request: pluginFilteredRequest.clone(),
+      });
+    }
+
+    throw error;
+  }
+};
+
+const fetchWrapper = {
+  fetch: wrappedFetch,
+};
+
+export {fetchWrapper};
diff --git a/node_modules/workbox-core/_private/getFriendlyURL.mjs b/node_modules/workbox-core/_private/getFriendlyURL.mjs
new file mode 100644
index 00000000..e7159feb
--- /dev/null
+++ b/node_modules/workbox-core/_private/getFriendlyURL.mjs
@@ -0,0 +1,27 @@
+/*
+  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';
+
+const getFriendlyURL = (url) => {
+  const urlObj = new URL(url, location);
+  if (urlObj.origin === location.origin) {
+    return urlObj.pathname;
+  }
+  return urlObj.href;
+};
+
+export {getFriendlyURL};
diff --git a/node_modules/workbox-core/_private/logger.mjs b/node_modules/workbox-core/_private/logger.mjs
new file mode 100644
index 00000000..cfa11f8f
--- /dev/null
+++ b/node_modules/workbox-core/_private/logger.mjs
@@ -0,0 +1,95 @@
+/*
+  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 LOG_LEVELS from '../models/LogLevels.mjs';
+import '../_version.mjs';
+
+// Safari doesn't print all console.groupCollapsed() arguments.
+// Related bug: https://bugs.webkit.org/show_bug.cgi?id=182754
+const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+
+const GREY = `#7f8c8d`;
+const GREEN = `#2ecc71`;
+const YELLOW = `#f39c12`;
+const RED = `#c0392b`;
+const BLUE = `#3498db`;
+
+const getDefaultLogLevel = () => (process.env.NODE_ENV === 'production') ?
+  LOG_LEVELS.warn : LOG_LEVELS.log;
+
+let logLevel = getDefaultLogLevel();
+const shouldPrint = (minLevel) => (logLevel <= minLevel);
+const setLoggerLevel = (newLogLevel) => logLevel = newLogLevel;
+const getLoggerLevel = () => logLevel;
+
+// We always want groups to be logged unless logLevel is silent.
+const groupLevel = LOG_LEVELS.error;
+
+const _print = function(keyName, logArgs, levelColor) {
+  const logLevel = keyName.indexOf('group') === 0 ?
+    groupLevel : LOG_LEVELS[keyName];
+  if (!shouldPrint(logLevel)) {
+    return;
+  }
+
+  if (!levelColor || (keyName === 'groupCollapsed' && isSafari)) {
+    console[keyName](...logArgs);
+    return;
+  }
+
+  const logPrefix = [
+    '%cworkbox',
+    `background: ${levelColor}; color: white; padding: 2px 0.5em; ` +
+      `border-radius: 0.5em;`,
+  ];
+  console[keyName](...logPrefix, ...logArgs);
+};
+
+const groupEnd = () => {
+  if (shouldPrint(groupLevel)) {
+    console.groupEnd();
+  }
+};
+
+const defaultExport = {
+  groupEnd,
+  unprefixed: {
+    groupEnd,
+  },
+};
+
+const setupLogs = (keyName, color) => {
+  defaultExport[keyName] =
+    (...args) => _print(keyName, args, color);
+  defaultExport.unprefixed[keyName] =
+    (...args) => _print(keyName, args);
+};
+
+const levelToColor = {
+  debug: GREY,
+  log: GREEN,
+  warn: YELLOW,
+  error: RED,
+  groupCollapsed: BLUE,
+};
+Object.keys(levelToColor).forEach(
+  (keyName) => setupLogs(keyName, levelToColor[keyName])
+);
+
+export {getDefaultLogLevel};
+export {setLoggerLevel};
+export {getLoggerLevel};
+export {defaultExport as logger};
diff --git a/node_modules/workbox-core/_private/quota.mjs b/node_modules/workbox-core/_private/quota.mjs
new file mode 100644
index 00000000..98e5d962
--- /dev/null
+++ b/node_modules/workbox-core/_private/quota.mjs
@@ -0,0 +1,73 @@
+/*
+ Copyright 2018 Google Inc. All Rights Reserved.
+ 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.
+*/
+
+import {logger} from './logger.mjs';
+import {assert} from './assert.mjs';
+
+import '../_version.mjs';
+
+const callbacks = new Set();
+
+/**
+ * Adds a function to the set of callbacks that will be executed when there's
+ * a quota error.
+ *
+ * @param {Function} callback
+ * @memberof workbox.core
+ */
+function registerQuotaErrorCallback(callback) {
+  if (process.env.NODE_ENV !== 'production') {
+    assert.isType(callback, 'function', {
+      moduleName: 'workbox-core',
+      funcName: 'register',
+      paramName: 'callback',
+    });
+  }
+
+  callbacks.add(callback);
+
+  if (process.env.NODE_ENV !== 'production') {
+    logger.log('Registered a callback to respond to quota errors.', callback);
+  }
+}
+
+/**
+ * Runs all of the callback functions, one at a time sequentially, in the order
+ * in which they were registered.
+ *
+ * @memberof workbox.core
+ * @private
+ */
+async function executeQuotaErrorCallbacks() {
+  if (process.env.NODE_ENV !== 'production') {
+    logger.log(`About to run ${callbacks.size} callbacks to clean up caches.`);
+  }
+
+  for (const callback of callbacks) {
+    await callback();
+    if (process.env.NODE_ENV !== 'production') {
+      logger.log(callback, 'is complete.');
+    }
+  }
+
+  if (process.env.NODE_ENV !== 'production') {
+    logger.log('Finished running callbacks.');
+  }
+}
+
+export {
+  executeQuotaErrorCallbacks,
+  registerQuotaErrorCallback,
+};
diff --git a/node_modules/workbox-core/_version.mjs b/node_modules/workbox-core/_version.mjs
new file mode 100644
index 00000000..0e7d727b
--- /dev/null
+++ b/node_modules/workbox-core/_version.mjs
@@ -0,0 +1 @@
+try{self.workbox.v['workbox:core:3.6.3']=1;}catch(e){} // eslint-disable-line
\ No newline at end of file
diff --git a/node_modules/workbox-core/browser.mjs b/node_modules/workbox-core/browser.mjs
new file mode 100644
index 00000000..78af1592
--- /dev/null
+++ b/node_modules/workbox-core/browser.mjs
@@ -0,0 +1,30 @@
+/*
+  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 {registerQuotaErrorCallback} from './_private/quota.mjs';
+import * as _private from './_private.mjs';
+import defaultExport from './_default.mjs';
+import LOG_LEVELS from './models/LogLevels.mjs';
+
+import './_version.mjs';
+
+const finalExports = Object.assign(defaultExport, {
+  _private,
+  LOG_LEVELS,
+  registerQuotaErrorCallback,
+});
+
+export default finalExports;
diff --git a/node_modules/workbox-core/index.mjs b/node_modules/workbox-core/index.mjs
new file mode 100644
index 00000000..a46a1cb7
--- /dev/null
+++ b/node_modules/workbox-core/index.mjs
@@ -0,0 +1,45 @@
+/*
+  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 {registerQuotaErrorCallback} from './_private/quota.mjs';
+import * as _private from './_private.mjs';
+import defaultExport from './_default.mjs';
+import LOG_LEVELS from './models/LogLevels.mjs';
+
+import './_version.mjs';
+
+/**
+ * All of the Workbox service worker libraries use workbox-core for shared
+ * code as well as setting default values that need to be shared (like cache
+ * names).
+ *
+ * @namespace workbox.core
+ */
+
+/**
+ * Utilities that are shared with other Workbox modules.
+ *
+ * @alias workbox.core._private
+ * @private
+ */
+
+export {
+  _private,
+  LOG_LEVELS,
+  registerQuotaErrorCallback,
+};
+
+export default defaultExport;
diff --git a/node_modules/workbox-core/models/LogLevels.mjs b/node_modules/workbox-core/models/LogLevels.mjs
new file mode 100644
index 00000000..e1d2cc06
--- /dev/null
+++ b/node_modules/workbox-core/models/LogLevels.mjs
@@ -0,0 +1,39 @@
+/*
+  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';
+
+/**
+ * The available log levels in Workbox: debug, log, warn, error and silent.
+ *
+ * @property {int} debug Prints all logs from Workbox. Useful for debugging.
+ * @property {int} log Prints console log, warn, error and groups. Default for
+ * debug builds.
+ * @property {int} warn Prints console warn, error and groups. Default for
+ * non-debug builds.
+ * @property {int} error Print console error and groups.
+ * @property {int} silent Force no logging from Workbox.
+ *
+ * @alias workbox.core.LOG_LEVELS
+ */
+
+export default {
+  debug: 0,
+  log: 1,
+  warn: 2,
+  error: 3,
+  silent: 4,
+};
diff --git a/node_modules/workbox-core/models/messages/messageGenerator.mjs b/node_modules/workbox-core/models/messages/messageGenerator.mjs
new file mode 100644
index 00000000..c2a5412c
--- /dev/null
+++ b/node_modules/workbox-core/models/messages/messageGenerator.mjs
@@ -0,0 +1,40 @@
+/*
+  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 messages from './messages.mjs';
+import '../../_version.mjs';
+
+const fallback = (code, ...args) => {
+  let msg = code;
+  if (args.length > 0) {
+    msg += ` :: ${JSON.stringify(args)}`;
+  }
+  return msg;
+};
+
+const generatorFunction = (code, ...args) => {
+  const message = messages[code];
+  if (!message) {
+    throw new Error(`Unable to find message for code '${code}'.`);
+  }
+
+  return message(...args);
+};
+
+const exportedValue = (process.env.NODE_ENV === 'production') ?
+  fallback : generatorFunction;
+
+export default exportedValue;
diff --git a/node_modules/workbox-core/models/messages/messages.mjs b/node_modules/workbox-core/models/messages/messages.mjs
new file mode 100644
index 00000000..d9d0c379
--- /dev/null
+++ b/node_modules/workbox-core/models/messages/messages.mjs
@@ -0,0 +1,235 @@
+/*
+  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';
+
+export default {
+  'invalid-value': ({paramName, validValueDescription, value}) => {
+    if (!paramName || !validValueDescription) {
+      throw new Error(`Unexpected input to 'invalid-value' error.`);
+    }
+    return `The '${paramName}' parameter was given a value with an ` +
+      `unexpected value. ${validValueDescription} Received a value of ` +
+      `${JSON.stringify(value)}.`;
+  },
+
+  'not-in-sw': ({moduleName}) => {
+    if (!moduleName) {
+      throw new Error(`Unexpected input to 'not-in-sw' error.`);
+    }
+    return `The '${moduleName}' must be used in a service worker.`;
+  },
+
+  'not-an-array': ({moduleName, className, funcName, paramName}) => {
+    if (!moduleName || !className || !funcName || !paramName) {
+      throw new Error(`Unexpected input to 'not-an-array' error.`);
+    }
+    return `The parameter '${paramName}' passed into ` +
+      `'${moduleName}.${className}.${funcName}()' must be an array.`;
+  },
+
+  'incorrect-type': ({expectedType, paramName, moduleName, className,
+                   funcName}) => {
+    if (!expectedType || !paramName || !moduleName || !funcName) {
+      throw new Error(`Unexpected input to 'incorrect-type' error.`);
+    }
+    return `The parameter '${paramName}' passed into ` +
+      `'${moduleName}.${className ? (className + '.') : ''}` +
+      `${funcName}()' must be of type ${expectedType}.`;
+  },
+
+  'incorrect-class': ({expectedClass, paramName, moduleName, className,
+                       funcName, isReturnValueProblem}) => {
+    if (!expectedClass || !moduleName || !funcName) {
+      throw new Error(`Unexpected input to 'incorrect-class' error.`);
+    }
+
+    if (isReturnValueProblem) {
+      return `The return value from ` +
+        `'${moduleName}.${className ? (className + '.') : ''}${funcName}()' ` +
+        `must be an instance of class ${expectedClass.name}.`;
+    }
+
+    return `The parameter '${paramName}' passed into ` +
+      `'${moduleName}.${className ? (className + '.') : ''}${funcName}()' ` +
+      `must be an instance of class ${expectedClass.name}.`;
+  },
+
+  'missing-a-method': ({expectedMethod, paramName, moduleName, className,
+                    funcName}) => {
+    if (!expectedMethod || !paramName || !moduleName || !className
+        || !funcName) {
+      throw new Error(`Unexpected input to 'missing-a-method' error.`);
+    }
+    return `${moduleName}.${className}.${funcName}() expected the ` +
+      `'${paramName}' parameter to expose a '${expectedMethod}' method.`;
+  },
+
+  'add-to-cache-list-unexpected-type': ({entry}) => {
+    return `An unexpected entry was passed to ` +
+    `'workbox-precaching.PrecacheController.addToCacheList()' The entry ` +
+    `'${JSON.stringify(entry)}' isn't supported. You must supply an array of ` +
+    `strings with one or more characters, objects with a url property or ` +
+    `Request objects.`;
+  },
+
+  'add-to-cache-list-conflicting-entries': ({firstEntry, secondEntry}) => {
+    if (!firstEntry || !secondEntry) {
+      throw new Error(`Unexpected input to ` +
+        `'add-to-cache-list-duplicate-entries' error.`);
+    }
+
+    return `Two of the entries passed to ` +
+      `'workbox-precaching.PrecacheController.addToCacheList()' had matching ` +
+      `URLs but different revision details. This means workbox-precaching ` +
+      `is unable to determine cache the asset correctly. Please remove one ` +
+      `of the entries.`;
+  },
+
+  'plugin-error-request-will-fetch': ({thrownError}) => {
+    if (!thrownError) {
+      throw new Error(`Unexpected input to ` +
+        `'plugin-error-request-will-fetch', error.`);
+    }
+
+    return `An error was thrown by a plugins 'requestWillFetch()' method. ` +
+      `The thrown error message was: '${thrownError.message}'.`;
+  },
+
+  'invalid-cache-name': ({cacheNameId, value}) => {
+    if (!cacheNameId) {
+      throw new Error(
+        `Expected a 'cacheNameId' for error 'invalid-cache-name'`);
+    }
+
+    return `You must provide a name containing at least one character for ` +
+      `setCacheDeatils({${cacheNameId}: '...'}). Received a value of ` +
+      `'${JSON.stringify(value)}'`;
+  },
+
+  'unregister-route-but-not-found-with-method': ({method}) => {
+    if (!method) {
+      throw new Error(`Unexpected input to ` +
+        `'unregister-route-but-not-found-with-method' error.`);
+    }
+
+    return `The route you're trying to unregister was not  previously ` +
+      `registered for the method type '${method}'.`;
+  },
+
+  'unregister-route-route-not-registered': () => {
+    return `The route you're trying to unregister was not previously ` +
+      `registered.`;
+  },
+
+  'queue-replay-failed': ({name, count}) => {
+    return `${count} requests failed, while trying to replay Queue: ${name}.`;
+  },
+
+  'duplicate-queue-name': ({name}) => {
+    return `The Queue name '${name}' is already being used. ` +
+        `All instances of backgroundSync.Queue must be given unique names.`;
+  },
+
+  'expired-test-without-max-age': ({methodName, paramName}) => {
+    return `The '${methodName}()' method can only be used when the ` +
+      `'${paramName}' is used in the constructor.`;
+  },
+
+  'unsupported-route-type': ({moduleName, className, funcName, paramName}) => {
+    return `The supplied '${paramName}' parameter was an unsupported type. ` +
+      `Please check the docs for ${moduleName}.${className}.${funcName} for ` +
+      `valid input types.`;
+  },
+
+  'not-array-of-class': ({value, expectedClass,
+    moduleName, className, funcName, paramName}) => {
+    return `The supplied '${paramName}' parameter must be an array of ` +
+      `'${expectedClass}' objects. Received '${JSON.stringify(value)},'. ` +
+      `Please check the call to ${moduleName}.${className}.${funcName}() ` +
+      `to fix the issue.`;
+  },
+
+  'max-entries-or-age-required': ({moduleName, className, funcName}) => {
+    return `You must define either config.maxEntries or config.maxAgeSeconds` +
+      `in ${moduleName}.${className}.${funcName}`;
+  },
+
+  'statuses-or-headers-required': ({moduleName, className, funcName}) => {
+    return `You must define either config.statuses or config.headers` +
+      `in ${moduleName}.${className}.${funcName}`;
+  },
+
+  'invalid-string': ({moduleName, className, funcName, paramName}) => {
+    if (!paramName || !moduleName || !className || !funcName) {
+      throw new Error(`Unexpected input to 'invalid-string' error.`);
+    }
+    return `When using strings, the '${paramName}' parameter must start with ` +
+      `'http' (for cross-origin matches) or '/' (for same-origin matches). ` +
+      `Please see the docs for ${moduleName}.${className}.${funcName}() for ` +
+      `more info.`;
+  },
+  'channel-name-required': () => {
+    return `You must provide a channelName to construct a ` +
+    `BroadcastCacheUpdate instance.`;
+  },
+  'invalid-responses-are-same-args': () => {
+    return `The arguments passed into responsesAreSame() appear to be ` +
+      `invalid. Please ensure valid Responses are used.`;
+  },
+  'expire-custom-caches-only': () => {
+    return `You must provide a 'cacheName' property when using the ` +
+      `expiration plugin with a runtime caching strategy.`;
+  },
+  'unit-must-be-bytes': ({normalizedRangeHeader}) => {
+    if (!normalizedRangeHeader) {
+      throw new Error(`Unexpected input to 'unit-must-be-bytes' error.`);
+    }
+    return `The 'unit' portion of the Range header must be set to 'bytes'. ` +
+      `The Range header provided was "${normalizedRangeHeader}"`;
+  },
+  'single-range-only': ({normalizedRangeHeader}) => {
+    if (!normalizedRangeHeader) {
+      throw new Error(`Unexpected input to 'single-range-only' error.`);
+    }
+    return `Multiple ranges are not supported. Please use a  single start ` +
+      `value, and optional end value. The Range header provided was ` +
+      `"${normalizedRangeHeader}"`;
+  },
+  'invalid-range-values': ({normalizedRangeHeader}) => {
+    if (!normalizedRangeHeader) {
+      throw new Error(`Unexpected input to 'invalid-range-values' error.`);
+    }
+    return `The Range header is missing both start and end values. At least ` +
+      `one of those values is needed. The Range header provided was ` +
+      `"${normalizedRangeHeader}"`;
+  },
+  'no-range-header': () => {
+    return `No Range header was found in the Request provided.`;
+  },
+  'range-not-satisfiable': ({size, start, end}) => {
+    return `The start (${start}) and end (${end}) values in the Range are ` +
+      `not satisfiable by the cached response, which is ${size} bytes.`;
+  },
+  'attempt-to-cache-non-get-request': ({url, method}) => {
+    return `Unable to cache '${url}' because it is a '${method}' request and ` +
+      `only 'GET' requests can be cached.`;
+  },
+  'cache-put-with-no-response': ({url}) => {
+    return `There was an attempt to cache '${url}' but the response was not ` +
+      `defined.`;
+  },
+};
diff --git a/node_modules/workbox-core/models/pluginEvents.mjs b/node_modules/workbox-core/models/pluginEvents.mjs
new file mode 100644
index 00000000..3d8ac35e
--- /dev/null
+++ b/node_modules/workbox-core/models/pluginEvents.mjs
@@ -0,0 +1,25 @@
+/*
+  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';
+
+export default {
+  CACHE_DID_UPDATE: 'cacheDidUpdate',
+  CACHE_WILL_UPDATE: 'cacheWillUpdate',
+  CACHED_RESPONSE_WILL_BE_USED: 'cachedResponseWillBeUsed',
+  FETCH_DID_FAIL: 'fetchDidFail',
+  REQUEST_WILL_FETCH: 'requestWillFetch',
+};
diff --git a/node_modules/workbox-core/package.json b/node_modules/workbox-core/package.json
new file mode 100644
index 00000000..54c6c2ae
--- /dev/null
+++ b/node_modules/workbox-core/package.json
@@ -0,0 +1,28 @@
+{
+  "name": "workbox-core",
+  "version": "3.6.3",
+  "license": "Apache-2.0",
+  "author": "Google's Web DevRel Team",
+  "description": "This module is used by a number of the other Workbox modules to share common code.",
+  "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-core",
+    "version": "npm run build",
+    "prepare": "npm run build"
+  },
+  "workbox": {
+    "browserNamespace": "workbox.core",
+    "packageType": "browser",
+    "includeBabelHelpers": true
+  },
+  "main": "build/workbox-core.prod.js",
+  "module": "index.mjs"
+}
diff --git a/node_modules/workbox-core/utils/pluginUtils.mjs b/node_modules/workbox-core/utils/pluginUtils.mjs
new file mode 100644
index 00000000..466f5dde
--- /dev/null
+++ b/node_modules/workbox-core/utils/pluginUtils.mjs
@@ -0,0 +1,23 @@
+/*
+  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';
+
+export default {
+  filter: (plugins, callbackname) => {
+    return plugins.filter((plugin) => callbackname in plugin);
+  },
+};