workbox-v4.3.1/workbox-expiration.dev.js - incubator-liminal-site - Git at Google

 this.workbox = this.workbox || {};
 this.workbox.expiration = (function (exports, DBWrapper_mjs, deleteDatabase_mjs, WorkboxError_mjs, assert_mjs, logger_mjs, cacheNames_mjs, getFriendlyURL_mjs, registerQuotaErrorCallback_mjs) {
   'use strict';

   try {
     self['workbox:expiration:4.3.1'] && _();
   } catch (e) {} // eslint-disable-line

   /*
     Copyright 2018 Google LLC

     Use of this source code is governed by an MIT-style
     license that can be found in the LICENSE file or at
     https://opensource.org/licenses/MIT.
   */
   const DB_NAME = 'workbox-expiration';
   const OBJECT_STORE_NAME = 'cache-entries';

   const normalizeURL = unNormalizedUrl => {
     const url = new URL(unNormalizedUrl, location);
     url.hash = '';
     return url.href;
   };
   /**
    * Returns the timestamp model.
    *
    * @private
    */


   class CacheTimestampsModel {
     /**
      *
      * @param {string} cacheName
      *
      * @private
      */
     constructor(cacheName) {
       this._cacheName = cacheName;
       this._db = new DBWrapper_mjs.DBWrapper(DB_NAME, 1, {
         onupgradeneeded: event => this._handleUpgrade(event)
       });
     }
     /**
      * Should perform an upgrade of indexedDB.
      *
      * @param {Event} event
      *
      * @private
      */


     _handleUpgrade(event) {
       const db = event.target.result; // TODO(philipwalton): EdgeHTML doesn't support arrays as a keyPath, so we
       // have to use the `id` keyPath here and create our own values (a
       // concatenation of `url + cacheName`) instead of simply using
       // `keyPath: ['url', 'cacheName']`, which is supported in other browsers.

       const objStore = db.createObjectStore(OBJECT_STORE_NAME, {
         keyPath: 'id'
       }); // TODO(philipwalton): once we don't have to support EdgeHTML, we can
       // create a single index with the keyPath `['cacheName', 'timestamp']`
       // instead of doing both these indexes.

       objStore.createIndex('cacheName', 'cacheName', {
         unique: false
       });
       objStore.createIndex('timestamp', 'timestamp', {
         unique: false
       }); // Previous versions of `workbox-expiration` used `this._cacheName`
       // as the IDBDatabase name.

       deleteDatabase_mjs.deleteDatabase(this._cacheName);
     }
     /**
      * @param {string} url
      * @param {number} timestamp
      *
      * @private
      */


     async setTimestamp(url, timestamp) {
       url = normalizeURL(url);
       await this._db.put(OBJECT_STORE_NAME, {
         url,
         timestamp,
         cacheName: this._cacheName,
         // Creating an ID from the URL and cache name won't be necessary once
         // Edge switches to Chromium and all browsers we support work with
         // array keyPaths.
         id: this._getId(url)
       });
     }
     /**
      * Returns the timestamp stored for a given URL.
      *
      * @param {string} url
      * @return {number}
      *
      * @private
      */


     async getTimestamp(url) {
       const entry = await this._db.get(OBJECT_STORE_NAME, this._getId(url));
       return entry.timestamp;
     }
     /**
      * Iterates through all the entries in the object store (from newest to
      * oldest) and removes entries once either `maxCount` is reached or the
      * entry's timestamp is less than `minTimestamp`.
      *
      * @param {number} minTimestamp
      * @param {number} maxCount
      *
      * @private
      */


     async expireEntries(minTimestamp, maxCount) {
       const entriesToDelete = await this._db.transaction(OBJECT_STORE_NAME, 'readwrite', (txn, done) => {
         const store = txn.objectStore(OBJECT_STORE_NAME);
         const entriesToDelete = [];
         let entriesNotDeletedCount = 0;

         store.index('timestamp').openCursor(null, 'prev').onsuccess = ({
           target
         }) => {
           const cursor = target.result;

           if (cursor) {
             const result = cursor.value; // TODO(philipwalton): once we can use a multi-key index, we
             // won't have to check `cacheName` here.

             if (result.cacheName === this._cacheName) {
               // Delete an entry if it's older than the max age or
               // if we already have the max number allowed.
               if (minTimestamp && result.timestamp < minTimestamp || maxCount && entriesNotDeletedCount >= maxCount) {
                 // TODO(philipwalton): we should be able to delete the
                 // entry right here, but doing so causes an iteration
                 // bug in Safari stable (fixed in TP). Instead we can
                 // store the keys of the entries to delete, and then
                 // delete the separate transactions.
                 // https://github.com/GoogleChrome/workbox/issues/1978
                 // cursor.delete();
                 // We only need to return the URL, not the whole entry.
                 entriesToDelete.push(cursor.value);
               } else {
                 entriesNotDeletedCount++;
               }
             }

             cursor.continue();
           } else {
             done(entriesToDelete);
           }
         };
       }); // TODO(philipwalton): once the Safari bug in the following issue is fixed,
       // we should be able to remove this loop and do the entry deletion in the
       // cursor loop above:
       // https://github.com/GoogleChrome/workbox/issues/1978

       const urlsDeleted = [];

       for (const entry of entriesToDelete) {
         await this._db.delete(OBJECT_STORE_NAME, entry.id);
         urlsDeleted.push(entry.url);
       }

       return urlsDeleted;
     }
     /**
      * Takes a URL and returns an ID that will be unique in the object store.
      *
      * @param {string} url
      * @return {string}
      *
      * @private
      */


     _getId(url) {
       // Creating an ID from the URL and cache name won't be necessary once
       // Edge switches to Chromium and all browsers we support work with
       // array keyPaths.
       return this._cacheName + '|' + normalizeURL(url);
     }

   }

   /*
     Copyright 2018 Google LLC

     Use of this source code is governed by an MIT-style
     license that can be found in the LICENSE file or at
     https://opensource.org/licenses/MIT.
   */
   /**
    * 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-expiration',
           className: 'CacheExpiration',
           funcName: 'constructor',
           paramName: 'cacheName'
         });

         if (!(config.maxEntries || config.maxAgeSeconds)) {
           throw new WorkboxError_mjs.WorkboxError('max-entries-or-age-required', {
             moduleName: 'workbox-expiration',
             className: 'CacheExpiration',
             funcName: 'constructor'
           });
         }

         if (config.maxEntries) {
           assert_mjs.assert.isType(config.maxEntries, 'number', {
             moduleName: 'workbox-expiration',
             className: 'CacheExpiration',
             funcName: 'constructor',
             paramName: 'config.maxEntries'
           }); // TODO: Assert is positive
         }

         if (config.maxAgeSeconds) {
           assert_mjs.assert.isType(config.maxAgeSeconds, 'number', {
             moduleName: 'workbox-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 minTimestamp = this._maxAgeSeconds ? Date.now() - this._maxAgeSeconds * 1000 : undefined;
       const urlsExpired = await this._timestampModel.expireEntries(minTimestamp, this._maxEntries); // Delete URLs from the cache

       const cache = await caches.open(this._cacheName);

       for (const url of urlsExpired) {
         await cache.delete(url);
       }

       {
         if (urlsExpired.length > 0) {
           logger_mjs.logger.groupCollapsed(`Expired ${urlsExpired.length} ` + `${urlsExpired.length === 1 ? 'entry' : 'entries'} and removed ` + `${urlsExpired.length === 1 ? 'it' : 'them'} from the ` + `'${this._cacheName}' cache.`);
           logger_mjs.logger.log(`Expired the following ${urlsExpired.length === 1 ? 'URL' : 'URLs'}:`);
           urlsExpired.forEach(url => 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();
       }
     }
     /**
      * 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) {
       {
         assert_mjs.assert.isType(url, 'string', {
           moduleName: 'workbox-expiration',
           className: 'CacheExpiration',
           funcName: 'updateTimestamp',
           paramName: 'url'
         });
       }

       await this._timestampModel.setTimestamp(url, 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_mjs.WorkboxError(`expired-test-without-max-age`, {
             methodName: 'isURLExpired',
             paramName: 'maxAgeSeconds'
           });
         }
       }

       const timestamp = await this._timestampModel.getTimestamp(url);
       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.expireEntries(Infinity); // Expires all.
     }

   }

   /*
     Copyright 2018 Google LLC

     Use of this source code is governed by an MIT-style
     license that can be found in the LICENSE file or at
     https://opensource.org/licenses/MIT.
   */
   /**
    * 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 entry least-recently requested will be removed from the cache first.
    *
    * @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-expiration',
             className: 'Plugin',
             funcName: 'constructor'
           });
         }

         if (config.maxEntries) {
           assert_mjs.assert.isType(config.maxEntries, 'number', {
             moduleName: 'workbox-expiration',
             className: 'Plugin',
             funcName: 'constructor',
             paramName: 'config.maxEntries'
           });
         }

         if (config.maxAgeSeconds) {
           assert_mjs.assert.isType(config.maxAgeSeconds, 'number', {
             moduleName: 'workbox-expiration',
             className: 'Plugin',
             funcName: 'constructor',
             paramName: 'config.maxAgeSeconds'
           });
         }
       }

       this._config = config;
       this._maxAgeSeconds = config.maxAgeSeconds;
       this._cacheExpirations = new Map();

       if (config.purgeOnQuotaError) {
         registerQuotaErrorCallback_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.strategies` 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({
       event,
       request,
       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(); // Update the metadata for the request URL to the current timestamp,
       // but don't `await` it as we don't want to block the response.

       const updateTimestampDone = cacheExpiration.updateTimestamp(request.url);

       if (event) {
         try {
           event.waitUntil(updateTimestampDone);
         } catch (error) {
           {
             logger_mjs.logger.warn(`Unable to ensure service worker stays alive when ` + `updating cache entry for '${getFriendlyURL_mjs.getFriendlyURL(event.request.url)}'.`);
           }
         }
       }

       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.strategies` 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
     }) {
       {
         assert_mjs.assert.isType(cacheName, 'string', {
           moduleName: 'workbox-expiration',
           className: 'Plugin',
           funcName: 'cacheDidUpdate',
           paramName: 'cacheName'
         });
         assert_mjs.assert.isInstance(request, Request, {
           moduleName: 'workbox-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 your 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();
     }

   }

   /*
     Copyright 2018 Google LLC

     Use of this source code is governed by an MIT-style
     license that can be found in the LICENSE file or at
     https://opensource.org/licenses/MIT.
   */

   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._private, workbox.core._private, workbox.core));
 //# sourceMappingURL=workbox-expiration.dev.js.map
	this.workbox = this.workbox \|\| {};
	this.workbox.expiration = (function (exports, DBWrapper_mjs, deleteDatabase_mjs, WorkboxError_mjs, assert_mjs, logger_mjs, cacheNames_mjs, getFriendlyURL_mjs, registerQuotaErrorCallback_mjs) {
	'use strict';

	try {
	self['workbox:expiration:4.3.1'] && _();
	} catch (e) {} // eslint-disable-line

	/*
	Copyright 2018 Google LLC

	Use of this source code is governed by an MIT-style
	license that can be found in the LICENSE file or at
	https://opensource.org/licenses/MIT.
	*/
	const DB_NAME = 'workbox-expiration';
	const OBJECT_STORE_NAME = 'cache-entries';

	const normalizeURL = unNormalizedUrl => {
	const url = new URL(unNormalizedUrl, location);
	url.hash = '';
	return url.href;
	};
	/**
	* Returns the timestamp model.
	*
	* @private
	*/


	class CacheTimestampsModel {
	/**
	*
	* @param {string} cacheName
	*
	* @private
	*/
	constructor(cacheName) {
	this._cacheName = cacheName;
	this._db = new DBWrapper_mjs.DBWrapper(DB_NAME, 1, {
	onupgradeneeded: event => this._handleUpgrade(event)
	});
	}
	/**
	* Should perform an upgrade of indexedDB.
	*
	* @param {Event} event
	*
	* @private
	*/


	_handleUpgrade(event) {
	const db = event.target.result; // TODO(philipwalton): EdgeHTML doesn't support arrays as a keyPath, so we
	// have to use the `id` keyPath here and create our own values (a
	// concatenation of `url + cacheName`) instead of simply using
	// `keyPath: ['url', 'cacheName']`, which is supported in other browsers.

	const objStore = db.createObjectStore(OBJECT_STORE_NAME, {
	keyPath: 'id'
	}); // TODO(philipwalton): once we don't have to support EdgeHTML, we can
	// create a single index with the keyPath `['cacheName', 'timestamp']`
	// instead of doing both these indexes.

	objStore.createIndex('cacheName', 'cacheName', {
	unique: false
	});
	objStore.createIndex('timestamp', 'timestamp', {
	unique: false
	}); // Previous versions of `workbox-expiration` used `this._cacheName`
	// as the IDBDatabase name.

	deleteDatabase_mjs.deleteDatabase(this._cacheName);
	}
	/**
	* @param {string} url
	* @param {number} timestamp
	*
	* @private
	*/


	async setTimestamp(url, timestamp) {
	url = normalizeURL(url);
	await this._db.put(OBJECT_STORE_NAME, {
	url,
	timestamp,
	cacheName: this._cacheName,
	// Creating an ID from the URL and cache name won't be necessary once
	// Edge switches to Chromium and all browsers we support work with
	// array keyPaths.
	id: this._getId(url)
	});
	}
	/**
	* Returns the timestamp stored for a given URL.
	*
	* @param {string} url
	* @return {number}
	*
	* @private
	*/


	async getTimestamp(url) {
	const entry = await this._db.get(OBJECT_STORE_NAME, this._getId(url));
	return entry.timestamp;
	}
	/**
	* Iterates through all the entries in the object store (from newest to
	* oldest) and removes entries once either `maxCount` is reached or the
	* entry's timestamp is less than `minTimestamp`.
	*
	* @param {number} minTimestamp
	* @param {number} maxCount
	*
	* @private
	*/


	async expireEntries(minTimestamp, maxCount) {
	const entriesToDelete = await this._db.transaction(OBJECT_STORE_NAME, 'readwrite', (txn, done) => {
	const store = txn.objectStore(OBJECT_STORE_NAME);
	const entriesToDelete = [];
	let entriesNotDeletedCount = 0;

	store.index('timestamp').openCursor(null, 'prev').onsuccess = ({
	target
	}) => {
	const cursor = target.result;

	if (cursor) {
	const result = cursor.value; // TODO(philipwalton): once we can use a multi-key index, we
	// won't have to check `cacheName` here.

	if (result.cacheName === this._cacheName) {
	// Delete an entry if it's older than the max age or
	// if we already have the max number allowed.
	if (minTimestamp && result.timestamp < minTimestamp \|\| maxCount && entriesNotDeletedCount >= maxCount) {
	// TODO(philipwalton): we should be able to delete the
	// entry right here, but doing so causes an iteration
	// bug in Safari stable (fixed in TP). Instead we can
	// store the keys of the entries to delete, and then
	// delete the separate transactions.
	// https://github.com/GoogleChrome/workbox/issues/1978
	// cursor.delete();
	// We only need to return the URL, not the whole entry.
	entriesToDelete.push(cursor.value);
	} else {
	entriesNotDeletedCount++;
	}
	}

	cursor.continue();
	} else {
	done(entriesToDelete);
	}
	};
	}); // TODO(philipwalton): once the Safari bug in the following issue is fixed,
	// we should be able to remove this loop and do the entry deletion in the
	// cursor loop above:
	// https://github.com/GoogleChrome/workbox/issues/1978

	const urlsDeleted = [];

	for (const entry of entriesToDelete) {
	await this._db.delete(OBJECT_STORE_NAME, entry.id);
	urlsDeleted.push(entry.url);
	}

	return urlsDeleted;
	}
	/**
	* Takes a URL and returns an ID that will be unique in the object store.
	*
	* @param {string} url
	* @return {string}
	*
	* @private
	*/


	_getId(url) {
	// Creating an ID from the URL and cache name won't be necessary once
	// Edge switches to Chromium and all browsers we support work with
	// array keyPaths.
	return this._cacheName + '\|' + normalizeURL(url);
	}

	}

	/*
	Copyright 2018 Google LLC

	Use of this source code is governed by an MIT-style
	license that can be found in the LICENSE file or at
	https://opensource.org/licenses/MIT.
	*/
	/**
	* 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-expiration',
	className: 'CacheExpiration',
	funcName: 'constructor',
	paramName: 'cacheName'
	});

	if (!(config.maxEntries \|\| config.maxAgeSeconds)) {
	throw new WorkboxError_mjs.WorkboxError('max-entries-or-age-required', {
	moduleName: 'workbox-expiration',
	className: 'CacheExpiration',
	funcName: 'constructor'
	});
	}

	if (config.maxEntries) {
	assert_mjs.assert.isType(config.maxEntries, 'number', {
	moduleName: 'workbox-expiration',
	className: 'CacheExpiration',
	funcName: 'constructor',
	paramName: 'config.maxEntries'
	}); // TODO: Assert is positive
	}

	if (config.maxAgeSeconds) {
	assert_mjs.assert.isType(config.maxAgeSeconds, 'number', {
	moduleName: 'workbox-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 minTimestamp = this._maxAgeSeconds ? Date.now() - this._maxAgeSeconds * 1000 : undefined;
	const urlsExpired = await this._timestampModel.expireEntries(minTimestamp, this._maxEntries); // Delete URLs from the cache

	const cache = await caches.open(this._cacheName);

	for (const url of urlsExpired) {
	await cache.delete(url);
	}

	{
	if (urlsExpired.length > 0) {
	logger_mjs.logger.groupCollapsed(`Expired ${urlsExpired.length} ` + `${urlsExpired.length === 1 ? 'entry' : 'entries'} and removed ` + `${urlsExpired.length === 1 ? 'it' : 'them'} from the ` + `'${this._cacheName}' cache.`);
	logger_mjs.logger.log(`Expired the following ${urlsExpired.length === 1 ? 'URL' : 'URLs'}:`);
	urlsExpired.forEach(url => 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();
	}
	}
	/**
	* 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) {
	{
	assert_mjs.assert.isType(url, 'string', {
	moduleName: 'workbox-expiration',
	className: 'CacheExpiration',
	funcName: 'updateTimestamp',
	paramName: 'url'
	});
	}

	await this._timestampModel.setTimestamp(url, 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_mjs.WorkboxError(`expired-test-without-max-age`, {
	methodName: 'isURLExpired',
	paramName: 'maxAgeSeconds'
	});
	}
	}

	const timestamp = await this._timestampModel.getTimestamp(url);
	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.expireEntries(Infinity); // Expires all.
	}

	}

	/*
	Copyright 2018 Google LLC

	Use of this source code is governed by an MIT-style
	license that can be found in the LICENSE file or at
	https://opensource.org/licenses/MIT.
	*/
	/**
	* 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 entry least-recently requested will be removed from the cache first.
	*
	* @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-expiration',
	className: 'Plugin',
	funcName: 'constructor'
	});
	}

	if (config.maxEntries) {
	assert_mjs.assert.isType(config.maxEntries, 'number', {
	moduleName: 'workbox-expiration',
	className: 'Plugin',
	funcName: 'constructor',
	paramName: 'config.maxEntries'
	});
	}

	if (config.maxAgeSeconds) {
	assert_mjs.assert.isType(config.maxAgeSeconds, 'number', {
	moduleName: 'workbox-expiration',
	className: 'Plugin',
	funcName: 'constructor',
	paramName: 'config.maxAgeSeconds'
	});
	}
	}

	this._config = config;
	this._maxAgeSeconds = config.maxAgeSeconds;
	this._cacheExpirations = new Map();

	if (config.purgeOnQuotaError) {
	registerQuotaErrorCallback_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.strategies` 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({
	event,
	request,
	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(); // Update the metadata for the request URL to the current timestamp,
	// but don't `await` it as we don't want to block the response.

	const updateTimestampDone = cacheExpiration.updateTimestamp(request.url);

	if (event) {
	try {
	event.waitUntil(updateTimestampDone);
	} catch (error) {
	{
	logger_mjs.logger.warn(`Unable to ensure service worker stays alive when ` + `updating cache entry for '${getFriendlyURL_mjs.getFriendlyURL(event.request.url)}'.`);
	}
	}
	}

	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.strategies` 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
	}) {
	{
	assert_mjs.assert.isType(cacheName, 'string', {
	moduleName: 'workbox-expiration',
	className: 'Plugin',
	funcName: 'cacheDidUpdate',
	paramName: 'cacheName'
	});
	assert_mjs.assert.isInstance(request, Request, {
	moduleName: 'workbox-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 your 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();
	}

	}

	/*
	Copyright 2018 Google LLC

	Use of this source code is governed by an MIT-style
	license that can be found in the LICENSE file or at
	https://opensource.org/licenses/MIT.
	*/

	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._private, workbox.core._private, workbox.core));
	//# sourceMappingURL=workbox-expiration.dev.js.map