		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';
		this.workbox.expiration = (function (exports, DBWrapper_js, deleteDatabase_js, WorkboxError_js, assert_js, logger_js, cacheNames_js, getFriendlyURL_js, registerQuotaErrorCallback_js) {
		'use strict';

		try {
		self['workbox:expiration:5.0.0-alpha.0'] && _();
		} catch (e) {} // eslint-disable-line
		// @ts-ignore
		try {
		self['workbox:expiration:5.0.0-alpha.1'] && _();
		} catch (e) {}

		/*
		Copyright 2018 Google LLC
		/*
		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';
		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 {
		const normalizeURL = unNormalizedUrl => {
		const url = new URL(unNormalizedUrl, location.href);
		url.hash = '';
		return url.href;
		};
		/**
		* Returns the timestamp model.
		*
		* @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.
		class CacheTimestampsModel {
		/**
		*
		* @param {string} cacheName
		*
		* @private
		*/
		constructor(cacheName) {
		this._cacheName = cacheName;
		this._db = new DBWrapper_js.DBWrapper(DB_NAME, 1, {
		onupgradeneeded: event => this._handleUpgrade(event)
		});
		}
		/**
		* Should perform an upgrade of indexedDB.
		*
		* @param {Event} event
		*
		* @private
		*/

		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.
		_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.

		deleteDatabase_mjs.deleteDatabase(this._cacheName);
		}
		/**
		* @param {string} url
		* @param {number} timestamp
		*
		* @private
		*/
		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.

		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
		*/
		deleteDatabase_js.deleteDatabase(this._cacheName);
		}
		/**
		* @param {string} url
		* @param {number} timestamp
		*
		* @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 setTimestamp(url, timestamp) {
		url = normalizeURL(url);
		const entry = {
		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)
		};
		await this._db.put(OBJECT_STORE_NAME, entry);
		}
		/**
		* Returns the timestamp stored for a given URL.
		*
		* @param {string} url
		* @return {number}
		*
		* @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;
		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
		* @return {Array<string>}
		*
		* @private
		*/

		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.
		async expireEntries(minTimestamp, maxCount) {
		const entriesToDelete = await this._db.transaction(OBJECT_STORE_NAME, 'readwrite', (txn, done) => {
		const store = txn.objectStore(OBJECT_STORE_NAME);
		const request = store.index('timestamp').openCursor(null, 'prev');
		const entriesToDelete = [];
		let entriesNotDeletedCount = 0;

		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++;
		request.onsuccess = () => {
		const cursor = request.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

		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 = [];

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

		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
		*/

		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);
		}

		_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

		/*
		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 {
		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.
		*/
		/**
		* To construct a new CacheExpiration instance you must provide at least
		* one of the `config` properties.
		* 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).
		*
		* @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.
		* @memberof workbox.expiration
		*/
		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'
		});
		}
		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 = {}) {
		this._isRunning = false;
		this._rerunRequested = false;

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

		if (config.maxAgeSeconds) {
		assert_mjs.assert.isType(config.maxAgeSeconds, 'number', {
		moduleName: 'workbox-expiration',
		className: 'CacheExpiration',
		funcName: 'constructor',
		paramName: 'config.maxAgeSeconds'
		}); // TODO: Assert is positive
		}
		}
		if (!(config.maxEntries \|\| config.maxAgeSeconds)) {
		throw new WorkboxError_js.WorkboxError('max-entries-or-age-required', {
		moduleName: 'workbox-expiration',
		className: 'CacheExpiration',
		funcName: 'constructor'
		});
		}

		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.
		*/
		if (config.maxEntries) {
		assert_js.assert.isType(config.maxEntries, 'number', {
		moduleName: 'workbox-expiration',
		className: 'CacheExpiration',
		funcName: 'constructor',
		paramName: 'config.maxEntries'
		}); // TODO: Assert is positive
		}

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

		async expireEntries() {
		if (this._isRunning) {
		this._rerunRequested = true;
		return;
		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.
		*/

		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.`);
		async expireEntries() {
		if (this._isRunning) {
		this._rerunRequested = true;
		return;
		}
		}

		this._isRunning = false;
		this._isRunning = true;
		const minTimestamp = this._maxAgeSeconds ? Date.now() - this._maxAgeSeconds * 1000 : 0;
		const urlsExpired = await this._timestampModel.expireEntries(minTimestamp, this._maxEntries); // Delete URLs from the cache

		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
		*/
		const cache = await caches.open(this._cacheName);

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

		async updateTimestamp(url) {
		{
		assert_mjs.assert.isType(url, 'string', {
		moduleName: 'workbox-expiration',
		className: 'CacheExpiration',
		funcName: 'updateTimestamp',
		paramName: 'url'
		});
		}
		{
		if (urlsExpired.length > 0) {
		logger_js.logger.groupCollapsed(`Expired ${urlsExpired.length} ` + `${urlsExpired.length === 1 ? 'entry' : 'entries'} and removed ` + `${urlsExpired.length === 1 ? 'it' : 'them'} from the ` + `'${this._cacheName}' cache.`);
		logger_js.logger.log(`Expired the following ${urlsExpired.length === 1 ? 'URL' : 'URLs'}:`);
		urlsExpired.forEach(url => logger_js.logger.log(` ${url}`));
		logger_js.logger.groupEnd();
		} else {
		logger_js.logger.debug(`Cache expiration ran and found no entries to remove.`);
		}
		}

		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}
		*/
		this._isRunning = false;


		async isURLExpired(url) {
		{
		if (!this._maxAgeSeconds) {
		throw new WorkboxError_mjs.WorkboxError(`expired-test-without-max-age`, {
		methodName: 'isURLExpired',
		paramName: 'maxAgeSeconds'
		});
		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
		*/

		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', {
		async updateTimestamp(url) {
		{
		assert_js.assert.isType(url, 'string', {
		moduleName: 'workbox-expiration',
		className: 'Plugin',
		funcName: 'constructor'
		className: 'CacheExpiration',
		funcName: 'updateTimestamp',
		paramName: 'url'
		});
		}

		if (config.maxEntries) {
		assert_mjs.assert.isType(config.maxEntries, 'number', {
		moduleName: 'workbox-expiration',
		className: 'Plugin',
		funcName: 'constructor',
		paramName: 'config.maxEntries'
		});
		}
		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}
		*/

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

		async isURLExpired(url) {
		if (!this._maxAgeSeconds) {
		{
		throw new WorkboxError_js.WorkboxError(`expired-test-without-max-age`, {
		methodName: 'isURLExpired',
		paramName: 'maxAgeSeconds'
		});
		}

		return false;
		} else {
		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.
		*/

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

		if (config.purgeOnQuotaError) {
		registerQuotaErrorCallback_mjs.registerQuotaErrorCallback(() => this.deleteCacheAndMetadata());
		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.
		*/
		/**
		* A simple helper method to return a CacheExpiration instance for a given
		* cache name.
		* This plugin can be used in the Workbox APIs to regularly enforce a
		* limit on the age and / or the number of cached requests.
		*
		* @param {string} cacheName
		* @return {CacheExpiration}
		* Whenever a cached request is used or updated, this plugin will look
		* at the used Cache and remove any old or extra requests.
		*
		* @private
		* 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 = {}) {
		/**
		* 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
		*/
		this.cachedResponseWillBeUsed = async ({
		event,
		request,
		cacheName,
		cachedResponse
		}) => {
		if (!cachedResponse) {
		return null;
		}

		_getCacheExpiration(cacheName) {
		if (cacheName === cacheNames_mjs.cacheNames.getRuntimeName()) {
		throw new WorkboxError_mjs.WorkboxError('expire-custom-caches-only');
		}
		let isFresh = this._isResponseDateFresh(cachedResponse); // Expire entries to ensure that even if the expiration date has
		// expired, it'll only be used once.

		let cacheExpiration = this._cacheExpirations.get(cacheName);

		if (!cacheExpiration) {
		cacheExpiration = new CacheExpiration(cacheName, this._config);
		const cacheExpiration = this._getCacheExpiration(cacheName);

		this._cacheExpirations.set(cacheName, cacheExpiration);
		}
		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.

		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
		*/
		const updateTimestampDone = cacheExpiration.updateTimestamp(request.url);

		if (event) {
		try {
		event.waitUntil(updateTimestampDone);
		} catch (error) {
		{
		// The event may not be a fetch event; only log the URL if it is.
		if ('request' in event) {
		logger_js.logger.warn(`Unable to ensure service worker stays alive when ` + `updating cache entry for ` + `'${getFriendlyURL_js.getFriendlyURL(event.request.url)}'.`);
		}
		}
		}
		}

		cachedResponseWillBeUsed({
		event,
		request,
		cacheName,
		cachedResponse
		}) {
		if (!cachedResponse) {
		return null;
		}
		return isFresh ? cachedResponse : null;
		};
		/**
		* 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
		*/

		let isFresh = this._isResponseDateFresh(cachedResponse); // Expire entries to ensure that even if the expiration date has
		// expired, it'll only be used once.

		this.cacheDidUpdate = async ({
		cacheName,
		request
		}) => {
		{
		assert_js.assert.isType(cacheName, 'string', {
		moduleName: 'workbox-expiration',
		className: 'Plugin',
		funcName: 'cacheDidUpdate',
		paramName: 'cacheName'
		});
		assert_js.assert.isInstance(request, Request, {
		moduleName: 'workbox-expiration',
		className: 'Plugin',
		funcName: 'cacheDidUpdate',
		paramName: 'request'
		});
		}

		const cacheExpiration = this._getCacheExpiration(cacheName);
		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.
		await cacheExpiration.updateTimestamp(request.url);
		await cacheExpiration.expireEntries();
		};

		const updateTimestampDone = cacheExpiration.updateTimestamp(request.url);
		{
		if (!(config.maxEntries \|\| config.maxAgeSeconds)) {
		throw new WorkboxError_js.WorkboxError('max-entries-or-age-required', {
		moduleName: 'workbox-expiration',
		className: 'Plugin',
		funcName: 'constructor'
		});
		}

		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)}'.`);
		if (config.maxEntries) {
		assert_js.assert.isType(config.maxEntries, 'number', {
		moduleName: 'workbox-expiration',
		className: 'Plugin',
		funcName: 'constructor',
		paramName: 'config.maxEntries'
		});
		}

		if (config.maxAgeSeconds) {
		assert_js.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_js.registerQuotaErrorCallback(() => this.deleteCacheAndMetadata());
		}
		}
		/**
		* A simple helper method to return a CacheExpiration instance for a given
		* cache name.
		*
		* @param {string} cacheName
		* @return {CacheExpiration}
		*
		* @private
		*/

		return isFresh ? cachedResponse : null;
		}
		/**
		* @param {Response} cachedResponse
		* @return {boolean}
		*
		* @private
		*/

		_getCacheExpiration(cacheName) {
		if (cacheName === cacheNames_js.cacheNames.getRuntimeName()) {
		throw new WorkboxError_js.WorkboxError('expire-custom-caches-only');
		}

		_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.
		let cacheExpiration = this._cacheExpirations.get(cacheName);

		if (!cacheExpiration) {
		cacheExpiration = new CacheExpiration(cacheName, this._config);

		const dateHeaderTimestamp = this._getDateHeaderTimestamp(cachedResponse);
		this._cacheExpirations.set(cacheName, cacheExpiration);
		}

		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.
		return cacheExpiration;
		}
		/**
		* @param {Response} cachedResponse
		* @return {boolean}
		*
		* @private
		*/


		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
		*/
		_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.


		_getDateHeaderTimestamp(cachedResponse) {
		if (!cachedResponse.headers.has('date')) {
		return null;
		}
		const dateHeaderTimestamp = this._getDateHeaderTimestamp(cachedResponse);

		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 (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.

		if (isNaN(headerTime)) {
		return null;

		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\|null}
		*
		* @private
		*/

		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
		*/

		_getDateHeaderTimestamp(cachedResponse) {
		if (!cachedResponse.headers.has('date')) {
		return null;
		}

		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 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;
		}
		/**
		* 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.
		*/

		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.


		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();
		}


		this._cacheExpirations = new Map();
		}

		}
		/*
		Copyright 2018 Google LLC

		/*
		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.
		*/

		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;

		exports.CacheExpiration = CacheExpiration;
		exports.Plugin = Plugin;
		return exports;

		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

build/workbox-expiration.prod.js

		@@ -1,2 +0,2 @@
		this.workbox=this.workbox\|\|{},this.workbox.expiration=function(t,e,s,i,a,n){"use strict";try{self["workbox:expiration:5.0.0-alpha.0"]&&_()}catch(t){}const h="workbox-expiration",c="cache-entries",r=t=>{const e=new URL(t,location);return e.hash="",e.href};class o{constructor(t){this.t=t,this.s=new e.DBWrapper(h,1,{onupgradeneeded:t=>this.i(t)})}i(t){const e=t.target.result.createObjectStore(c,{keyPath:"id"});e.createIndex("cacheName","cacheName",{unique:!1}),e.createIndex("timestamp","timestamp",{unique:!1}),s.deleteDatabase(this.t)}async setTimestamp(t,e){t=r(t),await this.s.put(c,{url:t,timestamp:e,cacheName:this.t,id:this.h(t)})}async getTimestamp(t){return(await this.s.get(c,this.h(t))).timestamp}async expireEntries(t,e){const s=await this.s.transaction(c,"readwrite",(s,i)=>{const a=s.objectStore(c),n=[];let h=0;a.index("timestamp").openCursor(null,"prev").onsuccess=(({target:s})=>{const a=s.result;if(a){const s=a.value;s.cacheName===this.t&&(t&&s.timestamp<t\|\|e&&h>=e?n.push(a.value):h++),a.continue()}else i(n)})}),i=[];for(const t of s)await this.s.delete(c,t.id),i.push(t.url);return i}h(t){return this.t+"\|"+r(t)}}class u{constructor(t,e={}){this.o=!1,this.u=!1,this.l=e.maxEntries,this.p=e.maxAgeSeconds,this.t=t,this.m=new o(t)}async expireEntries(){if(this.o)return void(this.u=!0);this.o=!0;const t=this.p?Date.now()-1e3this.p:void 0,e=await this.m.expireEntries(t,this.l),s=await caches.open(this.t);for(const t of e)await s.delete(t);this.o=!1,this.u&&(this.u=!1,this.expireEntries())}async updateTimestamp(t){await this.m.setTimestamp(t,Date.now())}async isURLExpired(t){return await this.m.getTimestamp(t)<Date.now()-1e3this.p}async delete(){this.u=!1,await this.m.expireEntries(1/0)}}return t.CacheExpiration=u,t.Plugin=class{constructor(t={}){this.D=t,this.p=t.maxAgeSeconds,this.g=new Map,t.purgeOnQuotaError&&n.registerQuotaErrorCallback(()=>this.deleteCacheAndMetadata())}k(t){if(t===a.cacheNames.getRuntimeName())throw new i.WorkboxError("expire-custom-caches-only");let e=this.g.get(t);return e\|\|(e=new u(t,this.D),this.g.set(t,e)),e}cachedResponseWillBeUsed({event:t,request:e,cacheName:s,cachedResponse:i}){if(!i)return null;let a=this.N(i);const n=this.k(s);n.expireEntries();const h=n.updateTimestamp(e.url);if(t)try{t.waitUntil(h)}catch(t){}return a?i:null}N(t){if(!this.p)return!0;const e=this._(t);return null===e\|\|e>=Date.now()-1e3*this.p}_(t){if(!t.headers.has("date"))return null;const e=t.headers.get("date"),s=new Date(e).getTime();return isNaN(s)?null:s}async cacheDidUpdate({cacheName:t,request:e}){const s=this.k(t);await s.updateTimestamp(e.url),await s.expireEntries()}async deleteCacheAndMetadata(){for(const[t,e]of this.g)await caches.delete(t),await e.delete();this.g=new Map}},t}({},workbox.core._private,workbox.core._private,workbox.core._private,workbox.core._private,workbox.core);
		this.workbox=this.workbox\|\|{},this.workbox.expiration=function(t,s,e,i,a,n){"use strict";try{self["workbox:expiration:5.0.0-alpha.1"]&&_()}catch(t){}const h="workbox-expiration",r="cache-entries",c=t=>{const s=new URL(t,location.href);return s.hash="",s.href};class o{constructor(t){this.t=t,this.s=new s.DBWrapper(h,1,{onupgradeneeded:t=>this.i(t)})}i(t){const s=t.target.result.createObjectStore(r,{keyPath:"id"});s.createIndex("cacheName","cacheName",{unique:!1}),s.createIndex("timestamp","timestamp",{unique:!1}),e.deleteDatabase(this.t)}async setTimestamp(t,s){const e={url:t=c(t),timestamp:s,cacheName:this.t,id:this.h(t)};await this.s.put(r,e)}async getTimestamp(t){return(await this.s.get(r,this.h(t))).timestamp}async expireEntries(t,s){const e=await this.s.transaction(r,"readwrite",(e,i)=>{const a=e.objectStore(r).index("timestamp").openCursor(null,"prev"),n=[];let h=0;a.onsuccess=(()=>{const e=a.result;if(e){const i=e.value;i.cacheName===this.t&&(t&&i.timestamp<t\|\|s&&h>=s?n.push(e.value):h++),e.continue()}else i(n)})}),i=[];for(const t of e)await this.s.delete(r,t.id),i.push(t.url);return i}h(t){return this.t+"\|"+c(t)}}class u{constructor(t,s={}){this.o=!1,this.u=!1,this.l=s.maxEntries,this.m=s.maxAgeSeconds,this.t=t,this.p=new o(t)}async expireEntries(){if(this.o)return void(this.u=!0);this.o=!0;const t=this.m?Date.now()-1e3this.m:0,s=await this.p.expireEntries(t,this.l),e=await caches.open(this.t);for(const t of s)await e.delete(t);this.o=!1,this.u&&(this.u=!1,this.expireEntries())}async updateTimestamp(t){await this.p.setTimestamp(t,Date.now())}async isURLExpired(t){if(this.m){return await this.p.getTimestamp(t)<Date.now()-1e3this.m}return!1}async delete(){this.u=!1,await this.p.expireEntries(1/0)}}return t.CacheExpiration=u,t.Plugin=class{constructor(t={}){this.cachedResponseWillBeUsed=(async({event:t,request:s,cacheName:e,cachedResponse:i})=>{if(!i)return null;let a=this.k(i);const n=this.D(e);n.expireEntries();const h=n.updateTimestamp(s.url);if(t)try{t.waitUntil(h)}catch(t){}return a?i:null}),this.cacheDidUpdate=(async({cacheName:t,request:s})=>{const e=this.D(t);await e.updateTimestamp(s.url),await e.expireEntries()}),this.N=t,this.m=t.maxAgeSeconds,this.g=new Map,t.purgeOnQuotaError&&n.registerQuotaErrorCallback(()=>this.deleteCacheAndMetadata())}D(t){if(t===a.cacheNames.getRuntimeName())throw new i.WorkboxError("expire-custom-caches-only");let s=this.g.get(t);return s\|\|(s=new u(t,this.N),this.g.set(t,s)),s}k(t){if(!this.m)return!0;const s=this._(t);return null===s\|\|s>=Date.now()-1e3*this.m}_(t){if(!t.headers.has("date"))return null;const s=t.headers.get("date"),e=new Date(s).getTime();return isNaN(e)?null:e}async deleteCacheAndMetadata(){for(const[t,s]of this.g)await caches.delete(t),await s.delete();this.g=new Map}},t}({},workbox.core._private,workbox.core._private,workbox.core._private,workbox.core._private,workbox.core);
		//# sourceMappingURL=workbox-expiration.prod.js.map

package.json

		{
		"name": "workbox-expiration",
		"version": "5.0.0-alpha.0",
		"version": "5.0.0-alpha.1",
		"license": "MIT",
		@@ -26,8 +26,9 @@ "author": "Google's Web DevRel Team",
		},
		"main": "build/workbox-expiration.prod.js",
		"main": "index.js",
		"module": "index.mjs",
		"types": "index.d.ts",
		"dependencies": {
		"workbox-core": "^5.0.0-alpha.0"
		"workbox-core": "^5.0.0-alpha.1"
		},
		"gitHead": "7f231c04023669bc42d5a939d1359b0867e2efda"
		"gitHead": "20d2110ddace710a46af06addd4977cae08f5942"
		}

_version.mjs