WIP - add extractor, generate snippet_data

node_modules/workbox-cache-expiration/CacheExpiration.mjs

@@ -0,0 +1,281 @@
+/*
+  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 CacheTimestampsModel from './models/CacheTimestampsModel.mjs';
+import {WorkboxError} from 'workbox-core/_private/WorkboxError.mjs';
+import {assert} from 'workbox-core/_private/assert.mjs';
+import {logger} from 'workbox-core/_private/logger.mjs';
+
+import './_version.mjs';
+
+/**
+ * The `CacheExpiration` class allows you define an expiration and / or
+ * limit on the number of responses stored in a
+ * [`Cache`](https://developer.mozilla.org/en-US/docs/Web/API/Cache).
+ *
+ * @memberof workbox.expiration
+ */
+class CacheExpiration {
+  /**
+   * To construct a new CacheExpiration instance you must provide at least
+   * one of the `config` properties.
+   *
+   * @param {string} cacheName Name of the cache to apply restrictions to.
+   * @param {Object} config
+   * @param {number} [config.maxEntries] The maximum number of entries to cache.
+   * Entries used the least will be removed as the maximum is reached.
+   * @param {number} [config.maxAgeSeconds] The maximum age of an entry before
+   * it's treated as stale and removed.
+   */
+  constructor(cacheName, config = {}) {
+    if (process.env.NODE_ENV !== 'production') {
+      assert.isType(cacheName, 'string', {
+        moduleName: 'workbox-cache-expiration',
+        className: 'CacheExpiration',
+        funcName: 'constructor',
+        paramName: 'cacheName',
+      });
+
+      if (!(config.maxEntries || config.maxAgeSeconds)) {
+        throw new WorkboxError('max-entries-or-age-required', {
+          moduleName: 'workbox-cache-expiration',
+          className: 'CacheExpiration',
+          funcName: 'constructor',
+        });
+      }
+
+      if (config.maxEntries) {
+        assert.isType(config.maxEntries, 'number', {
+          moduleName: 'workbox-cache-expiration',
+          className: 'CacheExpiration',
+          funcName: 'constructor',
+          paramName: 'config.maxEntries',
+        });
+
+        // TODO: Assert is positive
+      }
+
+      if (config.maxAgeSeconds) {
+        assert.isType(config.maxAgeSeconds, 'number', {
+          moduleName: 'workbox-cache-expiration',
+          className: 'CacheExpiration',
+          funcName: 'constructor',
+          paramName: 'config.maxAgeSeconds',
+        });
+
+        // TODO: Assert is positive
+      }
+    }
+
+    this._isRunning = false;
+    this._rerunRequested = false;
+    this._maxEntries = config.maxEntries;
+    this._maxAgeSeconds = config.maxAgeSeconds;
+    this._cacheName = cacheName;
+    this._timestampModel = new CacheTimestampsModel(cacheName);
+  }
+
+  /**
+   * Expires entries for the given cache and given criteria.
+   */
+  async expireEntries() {
+    if (this._isRunning) {
+      this._rerunRequested = true;
+      return;
+    }
+    this._isRunning = true;
+
+    const now = Date.now();
+
+    // First, expire old entries, if maxAgeSeconds is set.
+    const oldEntries = await this._findOldEntries(now);
+
+    // Once that's done, check for the maximum size.
+    const extraEntries = await this._findExtraEntries();
+
+    // Use a Set to remove any duplicates following the concatenation, then
+    // convert back into an array.
+    const allUrls = [...new Set(oldEntries.concat(extraEntries))];
+
+    await Promise.all([
+      this._deleteFromCache(allUrls),
+      this._deleteFromIDB(allUrls),
+    ]);
+
+    if (process.env.NODE_ENV !== 'production') {
+      // TODO: break apart entries deleted due to expiration vs size restraints
+      if (allUrls.length > 0) {
+        logger.groupCollapsed(
+          `Expired ${allUrls.length} ` +
+          `${allUrls.length === 1 ? 'entry' : 'entries'} and removed ` +
+          `${allUrls.length === 1 ? 'it' : 'them'} from the ` +
+          `'${this._cacheName}' cache.`);
+        logger.log(
+          `Expired the following ${allUrls.length === 1 ? 'URL' : 'URLs'}:`);
+        allUrls.forEach((url) => logger.log(`    ${url}`));
+        logger.groupEnd();
+      } else {
+        logger.debug(`Cache expiration ran and found no entries to remove.`);
+      }
+    }
+
+    this._isRunning = false;
+    if (this._rerunRequested) {
+      this._rerunRequested = false;
+      this.expireEntries();
+    }
+  }
+
+  /**
+   * Expires entries based on the maximum age.
+   *
+   * @param {number} expireFromTimestamp A timestamp.
+   * @return {Promise<Array<string>>} A list of the URLs that were expired.
+   *
+   * @private
+   */
+  async _findOldEntries(expireFromTimestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+      assert.isType(expireFromTimestamp, 'number', {
+        moduleName: 'workbox-cache-expiration',
+        className: 'CacheExpiration',
+        funcName: '_findOldEntries',
+        paramName: 'expireFromTimestamp',
+      });
+    }
+
+    if (!this._maxAgeSeconds) {
+      return [];
+    }
+
+    const expireOlderThan = expireFromTimestamp - (this._maxAgeSeconds * 1000);
+    const timestamps = await this._timestampModel.getAllTimestamps();
+    const expiredUrls = [];
+    timestamps.forEach((timestampDetails) => {
+      if (timestampDetails.timestamp < expireOlderThan) {
+        expiredUrls.push(timestampDetails.url);
+      }
+    });
+
+    return expiredUrls;
+  }
+
+  /**
+   * @return {Promise<Array>}
+   *
+   * @private
+   */
+  async _findExtraEntries() {
+    const extraUrls = [];
+
+    if (!this._maxEntries) {
+      return [];
+    }
+
+    const timestamps = await this._timestampModel.getAllTimestamps();
+    while (timestamps.length > this._maxEntries) {
+      const lastUsed = timestamps.shift();
+      extraUrls.push(lastUsed.url);
+    }
+
+    return extraUrls;
+  }
+
+  /**
+   * @param {Array<string>} urls Array of URLs to delete from cache.
+   *
+   * @private
+   */
+  async _deleteFromCache(urls) {
+    const cache = await caches.open(this._cacheName);
+    for (const url of urls) {
+      await cache.delete(url);
+    }
+  }
+
+  /**
+   * @param {Array<string>} urls Array of URLs to delete from IDB
+   *
+   * @private
+   */
+  async _deleteFromIDB(urls) {
+    for (const url of urls) {
+      await this._timestampModel.deleteUrl(url);
+    }
+  }
+
+  /**
+   * Update the timestamp for the given URL. This ensures the when
+   * removing entries based on maximum entries, most recently used
+   * is accurate or when expiring, the timestamp is up-to-date.
+   *
+   * @param {string} url
+   */
+  async updateTimestamp(url) {
+    if (process.env.NODE_ENV !== 'production') {
+      assert.isType(url, 'string', {
+        moduleName: 'workbox-cache-expiration',
+        className: 'CacheExpiration',
+        funcName: 'updateTimestamp',
+        paramName: 'url',
+      });
+    }
+
+    const urlObject = new URL(url, location);
+    urlObject.hash = '';
+
+    await this._timestampModel.setTimestamp(urlObject.href, Date.now());
+  }
+
+  /**
+   * Can be used to check if a URL has expired or not before it's used.
+   *
+   * This requires a look up from IndexedDB, so can be slow.
+   *
+   * Note: This method will not remove the cached entry, call
+   * `expireEntries()` to remove indexedDB and Cache entries.
+   *
+   * @param {string} url
+   * @return {boolean}
+   */
+  async isURLExpired(url) {
+    if (!this._maxAgeSeconds) {
+      throw new WorkboxError(`expired-test-without-max-age`, {
+        methodName: 'isURLExpired',
+        paramName: 'maxAgeSeconds',
+      });
+    }
+    const urlObject = new URL(url, location);
+    urlObject.hash = '';
+
+    const timestamp = await this._timestampModel.getTimestamp(urlObject.href);
+    const expireOlderThan = Date.now() - (this._maxAgeSeconds * 1000);
+    return (timestamp < expireOlderThan);
+  }
+
+  /**
+   * Removes the IndexedDB object store used to keep track of cache expiration
+   * metadata.
+   */
+  async delete() {
+    // Make sure we don't attempt another rerun if we're called in the middle of
+    // a cache expiration.
+    this._rerunRequested = false;
+    await this._timestampModel.delete();
+  }
+}
+
+export {CacheExpiration};

node_modules/workbox-cache-expiration/LICENSE

@@ -0,0 +1,201 @@
+                                 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.

node_modules/workbox-cache-expiration/Plugin.mjs

@@ -0,0 +1,257 @@
+/*
+ Copyright 2016 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 {CacheExpiration} from './CacheExpiration.mjs';
+import {WorkboxError} from 'workbox-core/_private/WorkboxError.mjs';
+import {assert} from 'workbox-core/_private/assert.mjs';
+import {cacheNames} from 'workbox-core/_private/cacheNames.mjs';
+import {registerQuotaErrorCallback} from 'workbox-core/index.mjs';
+
+import './_version.mjs';
+
+/**
+ * This plugin can be used in the Workbox APIs to regularly enforce a
+ * limit on the age and / or the number of cached requests.
+ *
+ * Whenever a cached request is used or updated, this plugin will look
+ * at the used Cache and remove any old or extra requests.
+ *
+ * When using `maxAgeSeconds`, requests may be used *once* after expiring
+ * because the expiration clean up will not have occurred until *after* the
+ * cached request has been used. If the request has a "Date" header, then
+ * a light weight expiration check is performed and the request will not be
+ * used immediately.
+ *
+ * When using `maxEntries`, the last request to be used will be the request
+ * that is removed from the Cache.
+ *
+ * @memberof workbox.expiration
+ */
+class Plugin {
+  /**
+   * @param {Object} config
+   * @param {number} [config.maxEntries] The maximum number of entries to cache.
+   * Entries used the least will be removed as the maximum is reached.
+   * @param {number} [config.maxAgeSeconds] The maximum age of an entry before
+   * it's treated as stale and removed.
+   * @param {boolean} [config.purgeOnQuotaError] Whether to opt this cache in to
+   * automatic deletion if the available storage quota has been exceeded.
+   */
+  constructor(config = {}) {
+    if (process.env.NODE_ENV !== 'production') {
+      if (!(config.maxEntries || config.maxAgeSeconds)) {
+        throw new WorkboxError('max-entries-or-age-required', {
+          moduleName: 'workbox-cache-expiration',
+          className: 'Plugin',
+          funcName: 'constructor',
+        });
+      }
+
+      if (config.maxEntries) {
+        assert.isType(config.maxEntries, 'number', {
+          moduleName: 'workbox-cache-expiration',
+          className: 'Plugin',
+          funcName: 'constructor',
+          paramName: 'config.maxEntries',
+        });
+      }
+
+      if (config.maxAgeSeconds) {
+        assert.isType(config.maxAgeSeconds, 'number', {
+          moduleName: 'workbox-cache-expiration',
+          className: 'Plugin',
+          funcName: 'constructor',
+          paramName: 'config.maxAgeSeconds',
+        });
+      }
+    }
+
+    this._config = config;
+    this._maxAgeSeconds = config.maxAgeSeconds;
+    this._cacheExpirations = new Map();
+
+    if (config.purgeOnQuotaError) {
+      registerQuotaErrorCallback(() => this.deleteCacheAndMetadata());
+    }
+  }
+
+  /**
+   * A simple helper method to return a CacheExpiration instance for a given
+   * cache name.
+   *
+   * @param {string} cacheName
+   * @return {CacheExpiration}
+   *
+   * @private
+   */
+  _getCacheExpiration(cacheName) {
+    if (cacheName === cacheNames.getRuntimeName()) {
+      throw new WorkboxError('expire-custom-caches-only');
+    }
+
+    let cacheExpiration = this._cacheExpirations.get(cacheName);
+    if (!cacheExpiration) {
+      cacheExpiration = new CacheExpiration(cacheName, this._config);
+      this._cacheExpirations.set(cacheName, cacheExpiration);
+    }
+    return cacheExpiration;
+  }
+
+  /**
+   * A "lifecycle" callback that will be triggered automatically by the
+   * `workbox.runtimeCaching` handlers when a `Response` is about to be returned
+   * from a [Cache](https://developer.mozilla.org/en-US/docs/Web/API/Cache) to
+   * the handler. It allows the `Response` to be inspected for freshness and
+   * prevents it from being used if the `Response`'s `Date` header value is
+   * older than the configured `maxAgeSeconds`.
+   *
+   * @param {Object} options
+   * @param {string} options.cacheName Name of the cache the response is in.
+   * @param {Response} options.cachedResponse The `Response` object that's been
+   *     read from a cache and whose freshness should be checked.
+   * @return {Response} Either the `cachedResponse`, if it's
+   *     fresh, or `null` if the `Response` is older than `maxAgeSeconds`.
+   *
+   * @private
+   */
+  cachedResponseWillBeUsed({cacheName, cachedResponse}) {
+    if (!cachedResponse) {
+      return null;
+    }
+
+    let isFresh = this._isResponseDateFresh(cachedResponse);
+
+    // Expire entries to ensure that even if the expiration date has
+    // expired, it'll only be used once.
+    const cacheExpiration = this._getCacheExpiration(cacheName);
+    cacheExpiration.expireEntries();
+
+    return isFresh ? cachedResponse : null;
+  }
+
+  /**
+   * @param {Response} cachedResponse
+   * @return {boolean}
+   *
+   * @private
+   */
+  _isResponseDateFresh(cachedResponse) {
+    if (!this._maxAgeSeconds) {
+      // We aren't expiring by age, so return true, it's fresh
+      return true;
+    }
+
+    // Check if the 'date' header will suffice a quick expiration check.
+    // See https://github.com/GoogleChromeLabs/sw-toolbox/issues/164 for
+    // discussion.
+    const dateHeaderTimestamp = this._getDateHeaderTimestamp(cachedResponse);
+    if (dateHeaderTimestamp === null) {
+      // Unable to parse date, so assume it's fresh.
+      return true;
+    }
+
+    // If we have a valid headerTime, then our response is fresh iff the
+    // headerTime plus maxAgeSeconds is greater than the current time.
+    const now = Date.now();
+    return dateHeaderTimestamp >= now - (this._maxAgeSeconds * 1000);
+  }
+
+  /**
+   * This method will extract the data header and parse it into a useful
+   * value.
+   *
+   * @param {Response} cachedResponse
+   * @return {number}
+   *
+   * @private
+   */
+  _getDateHeaderTimestamp(cachedResponse) {
+    if (!cachedResponse.headers.has('date')) {
+      return null;
+    }
+
+    const dateHeader = cachedResponse.headers.get('date');
+    const parsedDate = new Date(dateHeader);
+    const headerTime = parsedDate.getTime();
+
+    // If the Date header was invalid for some reason, parsedDate.getTime()
+    // will return NaN.
+    if (isNaN(headerTime)) {
+      return null;
+    }
+
+    return headerTime;
+  }
+
+  /**
+   * A "lifecycle" callback that will be triggered automatically by the
+   * `workbox.runtimeCaching` handlers when an entry is added to a cache.
+   *
+   * @param {Object} options
+   * @param {string} options.cacheName Name of the cache that was updated.
+   * @param {string} options.request The Request for the cached entry.
+   *
+   * @private
+   */
+  async cacheDidUpdate({cacheName, request}) {
+    if (process.env.NODE_ENV !== 'production') {
+      assert.isType(cacheName, 'string', {
+        moduleName: 'workbox-cache-expiration',
+        className: 'Plugin',
+        funcName: 'cacheDidUpdate',
+        paramName: 'cacheName',
+      });
+      assert.isInstance(request, Request, {
+        moduleName: 'workbox-cache-expiration',
+        className: 'Plugin',
+        funcName: 'cacheDidUpdate',
+        paramName: 'request',
+      });
+    }
+
+    const cacheExpiration = this._getCacheExpiration(cacheName);
+    await cacheExpiration.updateTimestamp(request.url);
+    await cacheExpiration.expireEntries();
+  }
+
+
+  /**
+   * This is a helper method that performs two operations:
+   *
+   * - Deletes *all* the underlying Cache instances associated with this plugin
+   * instance, by calling caches.delete() on you behalf.
+   * - Deletes the metadata from IndexedDB used to keep track of expiration
+   * details for each Cache instance.
+   *
+   * When using cache expiration, calling this method is preferable to calling
+   * `caches.delete()` directly, since this will ensure that the IndexedDB
+   * metadata is also cleanly removed and open IndexedDB instances are deleted.
+   *
+   * Note that if you're *not* using cache expiration for a given cache, calling
+   * `caches.delete()` and passing in the cache's name should be sufficient.
+   * There is no Workbox-specific method needed for cleanup in that case.
+   */
+  async deleteCacheAndMetadata() {
+    // Do this one at a time instead of all at once via `Promise.all()` to
+    // reduce the chance of inconsistency if a promise rejects.
+    for (const [cacheName, cacheExpiration] of this._cacheExpirations) {
+      await caches.delete(cacheName);
+      await cacheExpiration.delete();
+    }
+
+    // Reset this._cacheExpirations to its initial state.
+    this._cacheExpirations = new Map();
+  }
+}
+
+export {Plugin};

node_modules/workbox-cache-expiration/README.md

@@ -0,0 +1 @@
+This module's documentation can be found at https://developers.google.com/web/tools/workbox/modules/workbox-cache-expiration

node_modules/workbox-cache-expiration/_public.mjs

@@ -0,0 +1,24 @@
+/*
+  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 {CacheExpiration} from './CacheExpiration.mjs';
+import {Plugin} from './Plugin.mjs';
+import './_version.mjs';
+
+export {
+  CacheExpiration,
+  Plugin,
+};

node_modules/workbox-cache-expiration/_version.mjs

@@ -0,0 +1 @@
+try{self.workbox.v['workbox:cache-expiration:3.6.3']=1;}catch(e){} // eslint-disable-line

node_modules/workbox-cache-expiration/browser.mjs

@@ -0,0 +1,19 @@
+/*
+  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 * from './_public.mjs';

node_modules/workbox-cache-expiration/build/workbox-cache-expiration.dev.js

@@ -0,0 +1,740 @@
+this.workbox = this.workbox || {};
+this.workbox.expiration = (function (exports,DBWrapper_mjs,WorkboxError_mjs,assert_mjs,logger_mjs,cacheNames_mjs,index_mjs) {
+  'use strict';
+
+  try {
+    self.workbox.v['workbox:cache-expiration:3.6.3'] = 1;
+  } catch (e) {} // eslint-disable-line
+
+  /*
+    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.
+  */
+
+  const URL_KEY = 'url';
+  const TIMESTAMP_KEY = 'timestamp';
+
+  /**
+   * Returns the timestamp model.
+   *
+   * @private
+   */
+  class CacheTimestampsModel {
+    /**
+     *
+     * @param {string} cacheName
+     *
+     * @private
+     */
+    constructor(cacheName) {
+      // TODO Check cacheName
+
+      this._cacheName = cacheName;
+      this._storeName = cacheName;
+
+      this._db = new DBWrapper_mjs.DBWrapper(this._cacheName, 2, {
+        onupgradeneeded: evt => this._handleUpgrade(evt)
+      });
+    }
+
+    /**
+     * Should perform an upgrade of indexedDB.
+     *
+     * @param {Event} evt
+     *
+     * @private
+     */
+    _handleUpgrade(evt) {
+      const db = evt.target.result;
+      if (evt.oldVersion < 2) {
+        // Remove old databases.
+        if (db.objectStoreNames.contains('workbox-cache-expiration')) {
+          db.deleteObjectStore('workbox-cache-expiration');
+        }
+      }
+
+      db.createObjectStore(this._storeName, { keyPath: URL_KEY }).createIndex(TIMESTAMP_KEY, TIMESTAMP_KEY, { unique: false });
+    }
+
+    /**
+     * @param {string} url
+     * @param {number} timestamp
+     *
+     * @private
+     */
+    setTimestamp(url, timestamp) {
+      var _this = this;
+
+      return babelHelpers.asyncToGenerator(function* () {
+        yield _this._db.put(_this._storeName, {
+          [URL_KEY]: new URL(url, location).href,
+          [TIMESTAMP_KEY]: timestamp
+        });
+      })();
+    }
+
+    /**
+     * Get all of the timestamps in the indexedDB.
+     *
+     * @return {Array<Objects>}
+     *
+     * @private
+     */
+    getAllTimestamps() {
+      var _this2 = this;
+
+      return babelHelpers.asyncToGenerator(function* () {
+        return yield _this2._db.getAllMatching(_this2._storeName, {
+          index: TIMESTAMP_KEY
+        });
+      })();
+    }
+
+    /**
+     * Returns the timestamp stored for a given URL.
+     *
+     * @param {string} url
+     * @return {number}
+     *
+     * @private
+     */
+    getTimestamp(url) {
+      var _this3 = this;
+
+      return babelHelpers.asyncToGenerator(function* () {
+        const timestampObject = yield _this3._db.get(_this3._storeName, url);
+        return timestampObject.timestamp;
+      })();
+    }
+
+    /**
+     * @param {string} url
+     *
+     * @private
+     */
+    deleteUrl(url) {
+      var _this4 = this;
+
+      return babelHelpers.asyncToGenerator(function* () {
+        yield _this4._db.delete(_this4._storeName, new URL(url, location).href);
+      })();
+    }
+
+    /**
+     * Removes the underlying IndexedDB object store entirely.
+     */
+    delete() {
+      var _this5 = this;
+
+      return babelHelpers.asyncToGenerator(function* () {
+        yield _this5._db.deleteDatabase();
+        _this5._db = null;
+      })();
+    }
+  }
+
+  /*
+    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.
+  */
+
+  /**
+   * The `CacheExpiration` class allows you define an expiration and / or
+   * limit on the number of responses stored in a
+   * [`Cache`](https://developer.mozilla.org/en-US/docs/Web/API/Cache).
+   *
+   * @memberof workbox.expiration
+   */
+  class CacheExpiration {
+    /**
+     * To construct a new CacheExpiration instance you must provide at least
+     * one of the `config` properties.
+     *
+     * @param {string} cacheName Name of the cache to apply restrictions to.
+     * @param {Object} config
+     * @param {number} [config.maxEntries] The maximum number of entries to cache.
+     * Entries used the least will be removed as the maximum is reached.
+     * @param {number} [config.maxAgeSeconds] The maximum age of an entry before
+     * it's treated as stale and removed.
+     */
+    constructor(cacheName, config = {}) {
+      {
+        assert_mjs.assert.isType(cacheName, 'string', {
+          moduleName: 'workbox-cache-expiration',
+          className: 'CacheExpiration',
+          funcName: 'constructor',
+          paramName: 'cacheName'
+        });
+
+        if (!(config.maxEntries || config.maxAgeSeconds)) {
+          throw new WorkboxError_mjs.WorkboxError('max-entries-or-age-required', {
+            moduleName: 'workbox-cache-expiration',
+            className: 'CacheExpiration',
+            funcName: 'constructor'
+          });
+        }
+
+        if (config.maxEntries) {
+          assert_mjs.assert.isType(config.maxEntries, 'number', {
+            moduleName: 'workbox-cache-expiration',
+            className: 'CacheExpiration',
+            funcName: 'constructor',
+            paramName: 'config.maxEntries'
+          });
+
+          // TODO: Assert is positive
+        }
+
+        if (config.maxAgeSeconds) {
+          assert_mjs.assert.isType(config.maxAgeSeconds, 'number', {
+            moduleName: 'workbox-cache-expiration',
+            className: 'CacheExpiration',
+            funcName: 'constructor',
+            paramName: 'config.maxAgeSeconds'
+          });
+
+          // TODO: Assert is positive
+        }
+      }
+
+      this._isRunning = false;
+      this._rerunRequested = false;
+      this._maxEntries = config.maxEntries;
+      this._maxAgeSeconds = config.maxAgeSeconds;
+      this._cacheName = cacheName;
+      this._timestampModel = new CacheTimestampsModel(cacheName);
+    }
+
+    /**
+     * Expires entries for the given cache and given criteria.
+     */
+    expireEntries() {
+      var _this = this;
+
+      return babelHelpers.asyncToGenerator(function* () {
+        if (_this._isRunning) {
+          _this._rerunRequested = true;
+          return;
+        }
+        _this._isRunning = true;
+
+        const now = Date.now();
+
+        // First, expire old entries, if maxAgeSeconds is set.
+        const oldEntries = yield _this._findOldEntries(now);
+
+        // Once that's done, check for the maximum size.
+        const extraEntries = yield _this._findExtraEntries();
+
+        // Use a Set to remove any duplicates following the concatenation, then
+        // convert back into an array.
+        const allUrls = [...new Set(oldEntries.concat(extraEntries))];
+
+        yield Promise.all([_this._deleteFromCache(allUrls), _this._deleteFromIDB(allUrls)]);
+
+        {
+          // TODO: break apart entries deleted due to expiration vs size restraints
+          if (allUrls.length > 0) {
+            logger_mjs.logger.groupCollapsed(`Expired ${allUrls.length} ` + `${allUrls.length === 1 ? 'entry' : 'entries'} and removed ` + `${allUrls.length === 1 ? 'it' : 'them'} from the ` + `'${_this._cacheName}' cache.`);
+            logger_mjs.logger.log(`Expired the following ${allUrls.length === 1 ? 'URL' : 'URLs'}:`);
+            allUrls.forEach(function (url) {
+              return logger_mjs.logger.log(`    ${url}`);
+            });
+            logger_mjs.logger.groupEnd();
+          } else {
+            logger_mjs.logger.debug(`Cache expiration ran and found no entries to remove.`);
+          }
+        }
+
+        _this._isRunning = false;
+        if (_this._rerunRequested) {
+          _this._rerunRequested = false;
+          _this.expireEntries();
+        }
+      })();
+    }
+
+    /**
+     * Expires entries based on the maximum age.
+     *
+     * @param {number} expireFromTimestamp A timestamp.
+     * @return {Promise<Array<string>>} A list of the URLs that were expired.
+     *
+     * @private
+     */
+    _findOldEntries(expireFromTimestamp) {
+      var _this2 = this;
+
+      return babelHelpers.asyncToGenerator(function* () {
+        {
+          assert_mjs.assert.isType(expireFromTimestamp, 'number', {
+            moduleName: 'workbox-cache-expiration',
+            className: 'CacheExpiration',
+            funcName: '_findOldEntries',
+            paramName: 'expireFromTimestamp'
+          });
+        }
+
+        if (!_this2._maxAgeSeconds) {
+          return [];
+        }
+
+        const expireOlderThan = expireFromTimestamp - _this2._maxAgeSeconds * 1000;
+        const timestamps = yield _this2._timestampModel.getAllTimestamps();
+        const expiredUrls = [];
+        timestamps.forEach(function (timestampDetails) {
+          if (timestampDetails.timestamp < expireOlderThan) {
+            expiredUrls.push(timestampDetails.url);
+          }
+        });
+
+        return expiredUrls;
+      })();
+    }
+
+    /**
+     * @return {Promise<Array>}
+     *
+     * @private
+     */
+    _findExtraEntries() {
+      var _this3 = this;
+
+      return babelHelpers.asyncToGenerator(function* () {
+        const extraUrls = [];
+
+        if (!_this3._maxEntries) {
+          return [];
+        }
+
+        const timestamps = yield _this3._timestampModel.getAllTimestamps();
+        while (timestamps.length > _this3._maxEntries) {
+          const lastUsed = timestamps.shift();
+          extraUrls.push(lastUsed.url);
+        }
+
+        return extraUrls;
+      })();
+    }
+
+    /**
+     * @param {Array<string>} urls Array of URLs to delete from cache.
+     *
+     * @private
+     */
+    _deleteFromCache(urls) {
+      var _this4 = this;
+
+      return babelHelpers.asyncToGenerator(function* () {
+        const cache = yield caches.open(_this4._cacheName);
+        for (const url of urls) {
+          yield cache.delete(url);
+        }
+      })();
+    }
+
+    /**
+     * @param {Array<string>} urls Array of URLs to delete from IDB
+     *
+     * @private
+     */
+    _deleteFromIDB(urls) {
+      var _this5 = this;
+
+      return babelHelpers.asyncToGenerator(function* () {
+        for (const url of urls) {
+          yield _this5._timestampModel.deleteUrl(url);
+        }
+      })();
+    }
+
+    /**
+     * Update the timestamp for the given URL. This ensures the when
+     * removing entries based on maximum entries, most recently used
+     * is accurate or when expiring, the timestamp is up-to-date.
+     *
+     * @param {string} url
+     */
+    updateTimestamp(url) {
+      var _this6 = this;
+
+      return babelHelpers.asyncToGenerator(function* () {
+        {
+          assert_mjs.assert.isType(url, 'string', {
+            moduleName: 'workbox-cache-expiration',
+            className: 'CacheExpiration',
+            funcName: 'updateTimestamp',
+            paramName: 'url'
+          });
+        }
+
+        const urlObject = new URL(url, location);
+        urlObject.hash = '';
+
+        yield _this6._timestampModel.setTimestamp(urlObject.href, Date.now());
+      })();
+    }
+
+    /**
+     * Can be used to check if a URL has expired or not before it's used.
+     *
+     * This requires a look up from IndexedDB, so can be slow.
+     *
+     * Note: This method will not remove the cached entry, call
+     * `expireEntries()` to remove indexedDB and Cache entries.
+     *
+     * @param {string} url
+     * @return {boolean}
+     */
+    isURLExpired(url) {
+      var _this7 = this;
+
+      return babelHelpers.asyncToGenerator(function* () {
+        if (!_this7._maxAgeSeconds) {
+          throw new WorkboxError_mjs.WorkboxError(`expired-test-without-max-age`, {
+            methodName: 'isURLExpired',
+            paramName: 'maxAgeSeconds'
+          });
+        }
+        const urlObject = new URL(url, location);
+        urlObject.hash = '';
+
+        const timestamp = yield _this7._timestampModel.getTimestamp(urlObject.href);
+        const expireOlderThan = Date.now() - _this7._maxAgeSeconds * 1000;
+        return timestamp < expireOlderThan;
+      })();
+    }
+
+    /**
+     * Removes the IndexedDB object store used to keep track of cache expiration
+     * metadata.
+     */
+    delete() {
+      var _this8 = this;
+
+      return babelHelpers.asyncToGenerator(function* () {
+        // Make sure we don't attempt another rerun if we're called in the middle of
+        // a cache expiration.
+        _this8._rerunRequested = false;
+        yield _this8._timestampModel.delete();
+      })();
+    }
+  }
+
+  /*
+   Copyright 2016 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.
+  */
+
+  /**
+   * This plugin can be used in the Workbox APIs to regularly enforce a
+   * limit on the age and / or the number of cached requests.
+   *
+   * Whenever a cached request is used or updated, this plugin will look
+   * at the used Cache and remove any old or extra requests.
+   *
+   * When using `maxAgeSeconds`, requests may be used *once* after expiring
+   * because the expiration clean up will not have occurred until *after* the
+   * cached request has been used. If the request has a "Date" header, then
+   * a light weight expiration check is performed and the request will not be
+   * used immediately.
+   *
+   * When using `maxEntries`, the last request to be used will be the request
+   * that is removed from the Cache.
+   *
+   * @memberof workbox.expiration
+   */
+  class Plugin {
+    /**
+     * @param {Object} config
+     * @param {number} [config.maxEntries] The maximum number of entries to cache.
+     * Entries used the least will be removed as the maximum is reached.
+     * @param {number} [config.maxAgeSeconds] The maximum age of an entry before
+     * it's treated as stale and removed.
+     * @param {boolean} [config.purgeOnQuotaError] Whether to opt this cache in to
+     * automatic deletion if the available storage quota has been exceeded.
+     */
+    constructor(config = {}) {
+      {
+        if (!(config.maxEntries || config.maxAgeSeconds)) {
+          throw new WorkboxError_mjs.WorkboxError('max-entries-or-age-required', {
+            moduleName: 'workbox-cache-expiration',
+            className: 'Plugin',
+            funcName: 'constructor'
+          });
+        }
+
+        if (config.maxEntries) {
+          assert_mjs.assert.isType(config.maxEntries, 'number', {
+            moduleName: 'workbox-cache-expiration',
+            className: 'Plugin',
+            funcName: 'constructor',
+            paramName: 'config.maxEntries'
+          });
+        }
+
+        if (config.maxAgeSeconds) {
+          assert_mjs.assert.isType(config.maxAgeSeconds, 'number', {
+            moduleName: 'workbox-cache-expiration',
+            className: 'Plugin',
+            funcName: 'constructor',
+            paramName: 'config.maxAgeSeconds'
+          });
+        }
+      }
+
+      this._config = config;
+      this._maxAgeSeconds = config.maxAgeSeconds;
+      this._cacheExpirations = new Map();
+
+      if (config.purgeOnQuotaError) {
+        index_mjs.registerQuotaErrorCallback(() => this.deleteCacheAndMetadata());
+      }
+    }
+
+    /**
+     * A simple helper method to return a CacheExpiration instance for a given
+     * cache name.
+     *
+     * @param {string} cacheName
+     * @return {CacheExpiration}
+     *
+     * @private
+     */
+    _getCacheExpiration(cacheName) {
+      if (cacheName === cacheNames_mjs.cacheNames.getRuntimeName()) {
+        throw new WorkboxError_mjs.WorkboxError('expire-custom-caches-only');
+      }
+
+      let cacheExpiration = this._cacheExpirations.get(cacheName);
+      if (!cacheExpiration) {
+        cacheExpiration = new CacheExpiration(cacheName, this._config);
+        this._cacheExpirations.set(cacheName, cacheExpiration);
+      }
+      return cacheExpiration;
+    }
+
+    /**
+     * A "lifecycle" callback that will be triggered automatically by the
+     * `workbox.runtimeCaching` handlers when a `Response` is about to be returned
+     * from a [Cache](https://developer.mozilla.org/en-US/docs/Web/API/Cache) to
+     * the handler. It allows the `Response` to be inspected for freshness and
+     * prevents it from being used if the `Response`'s `Date` header value is
+     * older than the configured `maxAgeSeconds`.
+     *
+     * @param {Object} options
+     * @param {string} options.cacheName Name of the cache the response is in.
+     * @param {Response} options.cachedResponse The `Response` object that's been
+     *     read from a cache and whose freshness should be checked.
+     * @return {Response} Either the `cachedResponse`, if it's
+     *     fresh, or `null` if the `Response` is older than `maxAgeSeconds`.
+     *
+     * @private
+     */
+    cachedResponseWillBeUsed({ cacheName, cachedResponse }) {
+      if (!cachedResponse) {
+        return null;
+      }
+
+      let isFresh = this._isResponseDateFresh(cachedResponse);
+
+      // Expire entries to ensure that even if the expiration date has
+      // expired, it'll only be used once.
+      const cacheExpiration = this._getCacheExpiration(cacheName);
+      cacheExpiration.expireEntries();
+
+      return isFresh ? cachedResponse : null;
+    }
+
+    /**
+     * @param {Response} cachedResponse
+     * @return {boolean}
+     *
+     * @private
+     */
+    _isResponseDateFresh(cachedResponse) {
+      if (!this._maxAgeSeconds) {
+        // We aren't expiring by age, so return true, it's fresh
+        return true;
+      }
+
+      // Check if the 'date' header will suffice a quick expiration check.
+      // See https://github.com/GoogleChromeLabs/sw-toolbox/issues/164 for
+      // discussion.
+      const dateHeaderTimestamp = this._getDateHeaderTimestamp(cachedResponse);
+      if (dateHeaderTimestamp === null) {
+        // Unable to parse date, so assume it's fresh.
+        return true;
+      }
+
+      // If we have a valid headerTime, then our response is fresh iff the
+      // headerTime plus maxAgeSeconds is greater than the current time.
+      const now = Date.now();
+      return dateHeaderTimestamp >= now - this._maxAgeSeconds * 1000;
+    }
+
+    /**
+     * This method will extract the data header and parse it into a useful
+     * value.
+     *
+     * @param {Response} cachedResponse
+     * @return {number}
+     *
+     * @private
+     */
+    _getDateHeaderTimestamp(cachedResponse) {
+      if (!cachedResponse.headers.has('date')) {
+        return null;
+      }
+
+      const dateHeader = cachedResponse.headers.get('date');
+      const parsedDate = new Date(dateHeader);
+      const headerTime = parsedDate.getTime();
+
+      // If the Date header was invalid for some reason, parsedDate.getTime()
+      // will return NaN.
+      if (isNaN(headerTime)) {
+        return null;
+      }
+
+      return headerTime;
+    }
+
+    /**
+     * A "lifecycle" callback that will be triggered automatically by the
+     * `workbox.runtimeCaching` handlers when an entry is added to a cache.
+     *
+     * @param {Object} options
+     * @param {string} options.cacheName Name of the cache that was updated.
+     * @param {string} options.request The Request for the cached entry.
+     *
+     * @private
+     */
+    cacheDidUpdate({ cacheName, request }) {
+      var _this = this;
+
+      return babelHelpers.asyncToGenerator(function* () {
+        {
+          assert_mjs.assert.isType(cacheName, 'string', {
+            moduleName: 'workbox-cache-expiration',
+            className: 'Plugin',
+            funcName: 'cacheDidUpdate',
+            paramName: 'cacheName'
+          });
+          assert_mjs.assert.isInstance(request, Request, {
+            moduleName: 'workbox-cache-expiration',
+            className: 'Plugin',
+            funcName: 'cacheDidUpdate',
+            paramName: 'request'
+          });
+        }
+
+        const cacheExpiration = _this._getCacheExpiration(cacheName);
+        yield cacheExpiration.updateTimestamp(request.url);
+        yield cacheExpiration.expireEntries();
+      })();
+    }
+
+    /**
+     * This is a helper method that performs two operations:
+     *
+     * - Deletes *all* the underlying Cache instances associated with this plugin
+     * instance, by calling caches.delete() on you behalf.
+     * - Deletes the metadata from IndexedDB used to keep track of expiration
+     * details for each Cache instance.
+     *
+     * When using cache expiration, calling this method is preferable to calling
+     * `caches.delete()` directly, since this will ensure that the IndexedDB
+     * metadata is also cleanly removed and open IndexedDB instances are deleted.
+     *
+     * Note that if you're *not* using cache expiration for a given cache, calling
+     * `caches.delete()` and passing in the cache's name should be sufficient.
+     * There is no Workbox-specific method needed for cleanup in that case.
+     */
+    deleteCacheAndMetadata() {
+      var _this2 = this;
+
+      return babelHelpers.asyncToGenerator(function* () {
+        // Do this one at a time instead of all at once via `Promise.all()` to
+        // reduce the chance of inconsistency if a promise rejects.
+        for (const [cacheName, cacheExpiration] of _this2._cacheExpirations) {
+          yield caches.delete(cacheName);
+          yield cacheExpiration.delete();
+        }
+
+        // Reset this._cacheExpirations to its initial state.
+        _this2._cacheExpirations = new Map();
+      })();
+    }
+  }
+
+  /*
+    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.
+  */
+
+  /*
+    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.
+  */
+
+  exports.CacheExpiration = CacheExpiration;
+  exports.Plugin = Plugin;
+
+  return exports;
+
+}({},workbox.core._private,workbox.core._private,workbox.core._private,workbox.core._private,workbox.core._private,workbox.core));
+
+//# sourceMappingURL=workbox-cache-expiration.dev.js.map

node_modules/workbox-cache-expiration/build/workbox-cache-expiration.prod.js

@@ -0,0 +1,3 @@
+this.workbox=this.workbox||{},this.workbox.expiration=function(e,t,r,n,i){"use strict";try{self.workbox.v["workbox:cache-expiration:3.6.3"]=1}catch(e){}const s="url",a="timestamp";class l{constructor(e){this.e=e,this.t=e,this.r=new t.DBWrapper(this.e,2,{onupgradeneeded:e=>this.n(e)})}n(e){const t=e.target.result;e.oldVersion<2&&t.objectStoreNames.contains("workbox-cache-expiration")&&t.deleteObjectStore("workbox-cache-expiration"),t.createObjectStore(this.t,{keyPath:s}).createIndex(a,a,{unique:!1})}setTimestamp(e,t){var r=this;return babelHelpers.asyncToGenerator(function*(){yield r.r.put(r.t,{[s]:new URL(e,location).href,[a]:t})})()}getAllTimestamps(){var e=this;return babelHelpers.asyncToGenerator(function*(){return yield e.r.getAllMatching(e.t,{index:a})})()}getTimestamp(e){var t=this;return babelHelpers.asyncToGenerator(function*(){return(yield t.r.get(t.t,e)).timestamp})()}deleteUrl(e){var t=this;return babelHelpers.asyncToGenerator(function*(){yield t.r.delete(t.t,new URL(e,location).href)})()}delete(){var e=this;return babelHelpers.asyncToGenerator(function*(){yield e.r.deleteDatabase(),e.r=null})()}}class o{constructor(e,t={}){this.i=!1,this.s=!1,this.a=t.maxEntries,this.l=t.maxAgeSeconds,this.e=e,this.o=new l(e)}expireEntries(){var e=this;return babelHelpers.asyncToGenerator(function*(){if(e.i)return void(e.s=!0);e.i=!0;const t=Date.now(),r=yield e.c(t),n=yield e.u(),i=[...new Set(r.concat(n))];yield Promise.all([e.h(i),e.d(i)]),e.i=!1,e.s&&(e.s=!1,e.expireEntries())})()}c(e){var t=this;return babelHelpers.asyncToGenerator(function*(){if(!t.l)return[];const r=e-1e3*t.l,n=[];return(yield t.o.getAllTimestamps()).forEach(function(e){e.timestamp<r&&n.push(e.url)}),n})()}u(){var e=this;return babelHelpers.asyncToGenerator(function*(){const t=[];if(!e.a)return[];const r=yield e.o.getAllTimestamps();for(;r.length>e.a;){const e=r.shift();t.push(e.url)}return t})()}h(e){var t=this;return babelHelpers.asyncToGenerator(function*(){const r=yield caches.open(t.e);for(const t of e)yield r.delete(t)})()}d(e){var t=this;return babelHelpers.asyncToGenerator(function*(){for(const r of e)yield t.o.deleteUrl(r)})()}updateTimestamp(e){var t=this;return babelHelpers.asyncToGenerator(function*(){const r=new URL(e,location);r.hash="",yield t.o.setTimestamp(r.href,Date.now())})()}isURLExpired(e){var t=this;return babelHelpers.asyncToGenerator(function*(){if(!t.l)throw new r.WorkboxError("expired-test-without-max-age",{methodName:"isURLExpired",paramName:"maxAgeSeconds"});const n=new URL(e,location);return n.hash="",(yield t.o.getTimestamp(n.href))<Date.now()-1e3*t.l})()}delete(){var e=this;return babelHelpers.asyncToGenerator(function*(){e.s=!1,yield e.o.delete()})()}}return e.CacheExpiration=o,e.Plugin=class{constructor(e={}){this.p=e,this.l=e.maxAgeSeconds,this.b=new Map,e.purgeOnQuotaError&&i.registerQuotaErrorCallback(()=>this.deleteCacheAndMetadata())}f(e){if(e===n.cacheNames.getRuntimeName())throw new r.WorkboxError("expire-custom-caches-only");let t=this.b.get(e);return t||(t=new o(e,this.p),this.b.set(e,t)),t}cachedResponseWillBeUsed({cacheName:e,cachedResponse:t}){if(!t)return null;let r=this.m(t);return this.f(e).expireEntries(),r?t:null}m(e){if(!this.l)return!0;const t=this.y(e);return null===t||t>=Date.now()-1e3*this.l}y(e){if(!e.headers.has("date"))return null;const t=e.headers.get("date"),r=new Date(t).getTime();return isNaN(r)?null:r}cacheDidUpdate({cacheName:e,request:t}){var r=this;return babelHelpers.asyncToGenerator(function*(){const n=r.f(e);yield n.updateTimestamp(t.url),yield n.expireEntries()})()}deleteCacheAndMetadata(){var e=this;return babelHelpers.asyncToGenerator(function*(){for(const[t,r]of e.b)yield caches.delete(t),yield r.delete();e.b=new Map})()}},e}({},workbox.core._private,workbox.core._private,workbox.core._private,workbox.core);
+
+//# sourceMappingURL=workbox-cache-expiration.prod.js.map

node_modules/workbox-cache-expiration/build/workbox-cache-expiration.prod.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"mappings":"","sources":["packages/workbox-cache-expiration/browser.mjs"],"sourcesContent":["this.workbox=this.workbox||{},this.workbox.expiration=function(e,t,r,n,i){\"use strict\";try{self.workbox.v[\"workbox:cache-expiration:3.6.3\"]=1}catch(e){}const s=\"url\",a=\"timestamp\";class l{constructor(e){this.e=e,this.t=e,this.r=new t.DBWrapper(this.e,2,{onupgradeneeded:e=>this.n(e)})}n(e){const t=e.target.result;e.oldVersion<2&&t.objectStoreNames.contains(\"workbox-cache-expiration\")&&t.deleteObjectStore(\"workbox-cache-expiration\"),t.createObjectStore(this.t,{keyPath:s}).createIndex(a,a,{unique:!1})}setTimestamp(e,t){var r=this;return babelHelpers.asyncToGenerator(function*(){yield r.r.put(r.t,{[s]:new URL(e,location).href,[a]:t})})()}getAllTimestamps(){var e=this;return babelHelpers.asyncToGenerator(function*(){return yield e.r.getAllMatching(e.t,{index:a})})()}getTimestamp(e){var t=this;return babelHelpers.asyncToGenerator(function*(){return(yield t.r.get(t.t,e)).timestamp})()}deleteUrl(e){var t=this;return babelHelpers.asyncToGenerator(function*(){yield t.r.delete(t.t,new URL(e,location).href)})()}delete(){var e=this;return babelHelpers.asyncToGenerator(function*(){yield e.r.deleteDatabase(),e.r=null})()}}class o{constructor(e,t={}){this.i=!1,this.s=!1,this.a=t.maxEntries,this.l=t.maxAgeSeconds,this.e=e,this.o=new l(e)}expireEntries(){var e=this;return babelHelpers.asyncToGenerator(function*(){if(e.i)return void(e.s=!0);e.i=!0;const t=Date.now(),r=yield e.c(t),n=yield e.u(),i=[...new Set(r.concat(n))];yield Promise.all([e.h(i),e.d(i)]),e.i=!1,e.s&&(e.s=!1,e.expireEntries())})()}c(e){var t=this;return babelHelpers.asyncToGenerator(function*(){if(!t.l)return[];const r=e-1e3*t.l,n=[];return(yield t.o.getAllTimestamps()).forEach(function(e){e.timestamp<r&&n.push(e.url)}),n})()}u(){var e=this;return babelHelpers.asyncToGenerator(function*(){const t=[];if(!e.a)return[];const r=yield e.o.getAllTimestamps();for(;r.length>e.a;){const e=r.shift();t.push(e.url)}return t})()}h(e){var t=this;return babelHelpers.asyncToGenerator(function*(){const r=yield caches.open(t.e);for(const t of e)yield r.delete(t)})()}d(e){var t=this;return babelHelpers.asyncToGenerator(function*(){for(const r of e)yield t.o.deleteUrl(r)})()}updateTimestamp(e){var t=this;return babelHelpers.asyncToGenerator(function*(){const r=new URL(e,location);r.hash=\"\",yield t.o.setTimestamp(r.href,Date.now())})()}isURLExpired(e){var t=this;return babelHelpers.asyncToGenerator(function*(){if(!t.l)throw new r.WorkboxError(\"expired-test-without-max-age\",{methodName:\"isURLExpired\",paramName:\"maxAgeSeconds\"});const n=new URL(e,location);return n.hash=\"\",(yield t.o.getTimestamp(n.href))<Date.now()-1e3*t.l})()}delete(){var e=this;return babelHelpers.asyncToGenerator(function*(){e.s=!1,yield e.o.delete()})()}}return e.CacheExpiration=o,e.Plugin=class{constructor(e={}){this.p=e,this.l=e.maxAgeSeconds,this.b=new Map,e.purgeOnQuotaError&&i.registerQuotaErrorCallback(()=>this.deleteCacheAndMetadata())}f(e){if(e===n.cacheNames.getRuntimeName())throw new r.WorkboxError(\"expire-custom-caches-only\");let t=this.b.get(e);return t||(t=new o(e,this.p),this.b.set(e,t)),t}cachedResponseWillBeUsed({cacheName:e,cachedResponse:t}){if(!t)return null;let r=this.m(t);return this.f(e).expireEntries(),r?t:null}m(e){if(!this.l)return!0;const t=this.y(e);return null===t||t>=Date.now()-1e3*this.l}y(e){if(!e.headers.has(\"date\"))return null;const t=e.headers.get(\"date\"),r=new Date(t).getTime();return isNaN(r)?null:r}cacheDidUpdate({cacheName:e,request:t}){var r=this;return babelHelpers.asyncToGenerator(function*(){const n=r.f(e);yield n.updateTimestamp(t.url),yield n.expireEntries()})()}deleteCacheAndMetadata(){var e=this;return babelHelpers.asyncToGenerator(function*(){for(const[t,r]of e.b)yield caches.delete(t),yield r.delete();e.b=new Map})()}},e}({},workbox.core._private,workbox.core._private,workbox.core._private,workbox.core);\n"],"file":"workbox-cache-expiration.prod.js"}

node_modules/workbox-cache-expiration/index.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.
+*/
+
+/**
+ * @namespace workbox.expiration
+ */
+
+import './_version.mjs';
+
+export * from './_public.mjs';

node_modules/workbox-cache-expiration/models/CacheTimestampsModel.mjs

@@ -0,0 +1,124 @@
+/*
+  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';
+
+const URL_KEY = 'url';
+const TIMESTAMP_KEY = 'timestamp';
+
+/**
+ * Returns the timestamp model.
+ *
+ * @private
+ */
+class CacheTimestampsModel {
+  /**
+   *
+   * @param {string} cacheName
+   *
+   * @private
+   */
+  constructor(cacheName) {
+    // TODO Check cacheName
+
+    this._cacheName = cacheName;
+    this._storeName = cacheName;
+
+    this._db = new DBWrapper(this._cacheName, 2, {
+      onupgradeneeded: (evt) => this._handleUpgrade(evt),
+    });
+  }
+
+  /**
+   * Should perform an upgrade of indexedDB.
+   *
+   * @param {Event} evt
+   *
+   * @private
+   */
+  _handleUpgrade(evt) {
+    const db = evt.target.result;
+    if (evt.oldVersion < 2) {
+      // Remove old databases.
+      if (db.objectStoreNames.contains('workbox-cache-expiration')) {
+        db.deleteObjectStore('workbox-cache-expiration');
+      }
+    }
+
+    db
+    .createObjectStore(this._storeName, {keyPath: URL_KEY})
+    .createIndex(TIMESTAMP_KEY, TIMESTAMP_KEY, {unique: false});
+  }
+
+  /**
+   * @param {string} url
+   * @param {number} timestamp
+   *
+   * @private
+   */
+  async setTimestamp(url, timestamp) {
+    await this._db.put(this._storeName, {
+      [URL_KEY]: new URL(url, location).href,
+      [TIMESTAMP_KEY]: timestamp,
+    });
+  }
+
+  /**
+   * Get all of the timestamps in the indexedDB.
+   *
+   * @return {Array<Objects>}
+   *
+   * @private
+   */
+  async getAllTimestamps() {
+    return await this._db.getAllMatching(this._storeName, {
+      index: TIMESTAMP_KEY,
+    });
+  }
+
+  /**
+   * Returns the timestamp stored for a given URL.
+   *
+   * @param {string} url
+   * @return {number}
+   *
+   * @private
+   */
+  async getTimestamp(url) {
+    const timestampObject = await this._db.get(this._storeName, url);
+    return timestampObject.timestamp;
+  }
+
+  /**
+   * @param {string} url
+   *
+   * @private
+   */
+  async deleteUrl(url) {
+    await this._db.delete(this._storeName, new URL(url, location).href);
+  }
+
+  /**
+   * Removes the underlying IndexedDB object store entirely.
+   */
+  async delete() {
+    await this._db.deleteDatabase();
+    this._db = null;
+  }
+}
+
+export default CacheTimestampsModel;

node_modules/workbox-cache-expiration/package.json

@@ -0,0 +1,62 @@
+{
+  "_from": "workbox-cache-expiration@^3.6.3",
+  "_id": "workbox-cache-expiration@3.6.3",
+  "_inBundle": false,
+  "_integrity": "sha512-+ECNph/6doYx89oopO/UolYdDmQtGUgo8KCgluwBF/RieyA1ZOFKfrSiNjztxOrGJoyBB7raTIOlEEwZ1LaHoA==",
+  "_location": "/workbox-cache-expiration",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "workbox-cache-expiration@^3.6.3",
+    "name": "workbox-cache-expiration",
+    "escapedName": "workbox-cache-expiration",
+    "rawSpec": "^3.6.3",
+    "saveSpec": null,
+    "fetchSpec": "^3.6.3"
+  },
+  "_requiredBy": [
+    "/workbox-build"
+  ],
+  "_resolved": "https://registry.npmjs.org/workbox-cache-expiration/-/workbox-cache-expiration-3.6.3.tgz",
+  "_shasum": "4819697254a72098a13f94b594325a28a1e90372",
+  "_spec": "workbox-cache-expiration@^3.6.3",
+  "_where": "/Users/stefanfejes/Projects/30-seconds-of-python-code/node_modules/workbox-build",
+  "author": {
+    "name": "Google's Web DevRel Team"
+  },
+  "bugs": {
+    "url": "https://github.com/googlechrome/workbox/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "workbox-core": "^3.6.3"
+  },
+  "deprecated": false,
+  "description": "A service worker helper library that expires cached responses based on age or maximum number of entries.",
+  "homepage": "https://github.com/GoogleChrome/workbox",
+  "keywords": [
+    "workbox",
+    "workboxjs",
+    "service worker",
+    "sw"
+  ],
+  "license": "Apache-2.0",
+  "main": "build/workbox-cache-expiration.prod.js",
+  "module": "index.mjs",
+  "name": "workbox-cache-expiration",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/googlechrome/workbox.git"
+  },
+  "scripts": {
+    "build": "gulp build-packages --package workbox-cache-expiration",
+    "prepare": "npm run build",
+    "version": "npm run build"
+  },
+  "version": "3.6.3",
+  "workbox": {
+    "browserNamespace": "workbox.expiration",
+    "packageType": "browser"
+  }
+}