{“version”:3,“file”:“workbox-core.prod.js”,“sources”:,“sourcesContent”:[“"use strict";n// @ts-ignorentry {n self && _();n}ncatch (e) { }n”,“/*n Copyright 2019 Google LLCn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport '../_version.js';nconst logger = (process.env.NODE_ENV === 'production' ? null : (() => {n // Don't overwrite this value if it's already set.n // See github.com/GoogleChrome/workbox/pull/2284#issuecomment-560470923n if (!('__WB_DISABLE_DEV_LOGS' in self)) {n self.__WB_DISABLE_DEV_LOGS = false;n }n let inGroup = false;n const methodToColorMap = {n debug: `#7f8c8d`,n log: `#2ecc71`,n warn: `#f39c12`,n error: `#c0392b`,n groupCollapsed: `#3498db`,n groupEnd: null,n };n const print = function (method, args) {n if (self.__WB_DISABLE_DEV_LOGS) {n return;n }n if (method === 'groupCollapsed') {n // Safari doesn't print all console.groupCollapsed() arguments:n // bugs.webkit.org/show_bug.cgi?id=182754n if (/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) {n console(…args);n return;n }n }n const styles = [n `background: ${methodToColorMap}`,n `border-radius: 0.5em`,n `color: white`,n `font-weight: bold`,n `padding: 2px 0.5em`,n ];n // When in a group, the workbox prefix is not displayed.n const logPrefix = inGroup ? [] : ['%cworkbox', styles.join(';')];n console(…logPrefix, …args);n if (method === 'groupCollapsed') {n inGroup = true;n }n if (method === 'groupEnd') {n inGroup = false;n }n };n const api = {};n const loggerMethods = Object.keys(methodToColorMap);n for (const key of loggerMethods) {n const method = key;n api = (…args) => {n print(method, args);n };n }n return api;n})());nexport { logger };n”,“/*n Copyright 2018 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport { messages } from './messages.js';nimport '../../_version.js';nconst fallback = (code, …args) => {n let msg = code;n if (args.length > 0) {n msg += `

${JSON.stringify(args)}`;n }n return msg;n};nconst generatorFunction = (code, details = {}) => {n const message = messages;n if (!message) {n throw new Error(`Unable to find message for code '${code}'.`);n }n return message(details);n};nexport const messageGenerator = (process.env.NODE_ENV === 'production') ?n fallback : generatorFunction;n“,”/*n Copyright 2018 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport { messageGenerator } from '../models/messages/messageGenerator.js';nimport '../_version.js';n/**n * Workbox errors should be thrown with this class.n * This allows use to ensure the type easily in tests,n * helps developers identify errors from workboxn * easily and allows use to optimise errorn * messages correctly.n *n * @privaten */nclass WorkboxError extends Error {n /**n *n * @param {string} errorCode The error code thatn * identifies this particular error.n * @param {Object=} details Any relevant argumentsn * that will help developers identify issues shouldn * be added as a key on the context object.n */n constructor(errorCode, details) {n const message = messageGenerator(errorCode, details);n super(message);n this.name = errorCode;n this.details = details;n }n}nexport { WorkboxError };n“,”/*n Copyright 2018 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport { WorkboxError } from '../_private/WorkboxError.js';nimport '../_version.js';n/*n * This method throws if the supplied value is not an array.n * The destructed values are required to produce a meaningful error for users.n * The destructed and restructured object is so it's clear what isn * needed.n */nconst isArray = (value, details) => {n if (!Array.isArray(value)) {n throw new WorkboxError('not-an-array', details);n }n};nconst hasMethod = (object, expectedMethod, details) => {n const type = typeof object;n if (type !== 'function') {n details = expectedMethod;n throw new WorkboxError('missing-a-method', details);n }n};nconst isType = (object, expectedType, details) => {n if (typeof object !== expectedType) {n details = expectedType;n throw new WorkboxError('incorrect-type', details);n }n};nconst isInstance = (object, expectedClass, details) => {n if (!(object instanceof expectedClass)) {n details = expectedClass;n throw new WorkboxError('incorrect-class', details);n }n};nconst isOneOf = (value, validValues, details) => {n if (!validValues.includes(value)) {n details =n `Valid values are ${JSON.stringify(validValues)}.`;n throw new WorkboxError('invalid-value', details);n }n};nconst isArrayOfClass = (value, expectedClass, details) => {n const error = new WorkboxError('not-array-of-class', details);n if (!Array.isArray(value)) {n throw error;n }n for (const item of value) {n if (!(item instanceof expectedClass)) {n throw error;n }n }n};nconst finalAssertExports = process.env.NODE_ENV === 'production' ? null : {n hasMethod,n isArray,n isInstance,n isOneOf,n isType,n isArrayOfClass,n};nexport { finalAssertExports as assert };n“,”/*n Copyright 2018 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport '../_version.js';n// Callbacks to be executed whenever there's a quota error.nconst quotaErrorCallbacks = new Set();nexport { quotaErrorCallbacks };n“,”/*n Copyright 2018 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport '../_version.js';nconst _cacheNameDetails = {n googleAnalytics: 'googleAnalytics',n precache: 'precache-v2',n prefix: 'workbox',n runtime: 'runtime',n suffix: typeof registration !== 'undefined' ? registration.scope : '',n};nconst _createCacheName = (cacheName) => {n return [_cacheNameDetails.prefix, cacheName, _cacheNameDetails.suffix]n .filter((value) => value && value.length > 0)n .join('-');n};nconst eachCacheNameDetail = (fn) => {n for (const key of Object.keys(_cacheNameDetails)) {n fn(key);n }n};nexport const cacheNames = {n updateDetails: (details) => {n eachCacheNameDetail((key) => {n if (typeof details === 'string') {n _cacheNameDetails = details;n }n });n },n getGoogleAnalyticsName: (userCacheName) => {n return userCacheName || _createCacheName(_cacheNameDetails.googleAnalytics);n },n getPrecacheName: (userCacheName) => {n return userCacheName || _createCacheName(_cacheNameDetails.precache);n },n getPrefix: () => {n return _cacheNameDetails.prefix;n },n getRuntimeName: (userCacheName) => {n return userCacheName || _createCacheName(_cacheNameDetails.runtime);n },n getSuffix: () => {n return _cacheNameDetails.suffix;n },n};n“,”/*n Copyright 2018 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport { logger } from '../_private/logger.js';nimport { quotaErrorCallbacks } from '../models/quotaErrorCallbacks.js';nimport '../_version.js';n/**n * Runs all of the callback functions, one at a time sequentially, in the ordern * in which they were registered.n *n * @memberof module:workbox-coren * @privaten */nasync function executeQuotaErrorCallbacks() {n if (process.env.NODE_ENV !== 'production') {n logger.log(`About to run ${quotaErrorCallbacks.size} ` +n `callbacks to clean up caches.`);n }n for (const callback of quotaErrorCallbacks) {n await callback();n if (process.env.NODE_ENV !== 'production') {n logger.log(callback, 'is complete.');n }n }n if (process.env.NODE_ENV !== 'production') {n logger.log('Finished running callbacks.');n }n}nexport { executeQuotaErrorCallbacks };n“,”/*n Copyright 2018 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport '../_version.js';nconst getFriendlyURL = (url) => {n const urlObj = new URL(String(url), location.href);n // See github.com/GoogleChrome/workbox/issues/2323n // We want to include everything, except for the origin if it's same-origin.n return urlObj.href.replace(new RegExp(`^${location.origin}`), '');n};nexport { getFriendlyURL };n“,”/*n Copyright 2018 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport '../_version.js';nexport const pluginUtils = {n filter: (plugins, callbackName) => {n return plugins.filter((plugin) => callbackName in plugin);n },n};n“,”/*n Copyright 2018 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport { assert } from './assert.js';nimport { executeQuotaErrorCallbacks } from './executeQuotaErrorCallbacks.js';nimport { getFriendlyURL } from './getFriendlyURL.js';nimport { logger } from './logger.js';nimport { pluginUtils } from '../utils/pluginUtils.js';nimport { WorkboxError } from './WorkboxError.js';nimport '../_version.js';n/**n * Checks the list of plugins for the cacheKeyWillBeUsed callback, andn * executes any of those callbacks found in sequence. The final `Request` objectn * returned by the last plugin is treated as the cache key for cache readsn * and/or writes.n *n * @param {Object} optionsn * @param {Request} options.requestn * @param {string} options.moden * @param {Array<Object>} [options.plugins=n * @return {Promise<Request>}n *n * @privaten * @memberof module:workbox-coren */nconst _getEffectiveRequest = async ({ request, mode, plugins = [], }) => {n const cacheKeyWillBeUsedPlugins = pluginUtils.filter(plugins, "cacheKeyWillBeUsed" /* CACHE_KEY_WILL_BE_USED */);n let effectiveRequest = request;n for (const plugin of cacheKeyWillBeUsedPlugins) {n effectiveRequest = await plugin["cacheKeyWillBeUsed" /* CACHE_KEY_WILL_BE_USED */].call(plugin, { mode, request: effectiveRequest });n if (typeof effectiveRequest === 'string') {n effectiveRequest = new Request(effectiveRequest);n }n if (process.env.NODE_ENV !== 'production') {n assert.isInstance(effectiveRequest, Request, {n moduleName: 'Plugin',n funcName: "cacheKeyWillBeUsed" /* CACHE_KEY_WILL_BE_USED */,n isReturnValueProblem: true,n });n }n }n return effectiveRequest;n};n/**n * This method will call cacheWillUpdate on the available plugins (or usen * status === 200) to determine if the Response is safe and valid to cache.n *n * @param {Object} optionsn * @param {Request} options.requestn * @param {Response} options.responsen * @param {Event} [options.event]n * @param {Array<Object>} [options.plugins=n * @return {Promise<Response>}n *n * @privaten * @memberof module:workbox-coren */nconst _isResponseSafeToCache = async ({ request, response, event, plugins = [], }) => {n let responseToCache = response;n let pluginsUsed = false;n for (const plugin of plugins) {n if ("cacheWillUpdate" /* CACHE_WILL_UPDATE */ in plugin) {n pluginsUsed = true;n const pluginMethod = plugin["cacheWillUpdate" /* CACHE_WILL_UPDATE */];n responseToCache = await pluginMethod.call(plugin, {n request,n response: responseToCache,n event,n });n if (process.env.NODE_ENV !== 'production') {n if (responseToCache) {n assert.isInstance(responseToCache, Response, {n moduleName: 'Plugin',n funcName: "cacheWillUpdate" /* CACHE_WILL_UPDATE */,n isReturnValueProblem: true,n });n }n }n if (!responseToCache) {n break;n }n }n }n if (!pluginsUsed) {n if (process.env.NODE_ENV !== 'production') {n if (responseToCache) {n if (responseToCache.status !== 200) {n if (responseToCache.status === 0) {n logger.warn(`The response for '${request.url}' is an opaque ` +n `response. The caching strategy that you're using will not ` +n `cache opaque responses by default.`);n }n else {n logger.debug(`The response for '${request.url}' returned ` +n `a status code of '${response.status}' and won't be cached as a ` +n `result.`);n }n }n }n }n responseToCache = responseToCache && responseToCache.status === 200 ?n responseToCache : undefined;n }n return responseToCache ? responseToCache : null;n};n/**n * This is a wrapper around cache.match().n *n * @param {Object} optionsn * @param {string} options.cacheName Name of the cache to match against.n * @param {Request} options.request The Request that will be used to look upn * cache entries.n * @param {Event} [options.event] The event that prompted the action.n * @param {Object} [options.matchOptions] Options passed to cache.match().n * @param {Array<Object>} [options.plugins= Array of plugins.n * @return {Response} A cached response if available.n *n * @privaten * @memberof module:workbox-coren */nconst matchWrapper = async ({ cacheName, request, event, matchOptions, plugins = [], }) => {n const cache = await self.caches.open(cacheName);n const effectiveRequest = await _getEffectiveRequest({n plugins, request, mode: 'read'n });n let cachedResponse = await cache.match(effectiveRequest, matchOptions);n if (process.env.NODE_ENV !== 'production') {n if (cachedResponse) {n logger.debug(`Found a cached response in '${cacheName}'.`);n }n else {n logger.debug(`No cached response found in '${cacheName}'.`);n }n }n for (const plugin of plugins) {n if ("cachedResponseWillBeUsed" /* CACHED_RESPONSE_WILL_BE_USED */ in plugin) {n const pluginMethod = plugin["cachedResponseWillBeUsed" /* CACHED_RESPONSE_WILL_BE_USED */];n cachedResponse = await pluginMethod.call(plugin, {n cacheName,n event,n matchOptions,n cachedResponse,n request: effectiveRequest,n });n if (process.env.NODE_ENV !== 'production') {n if (cachedResponse) {n assert.isInstance(cachedResponse, Response, {n moduleName: 'Plugin',n funcName: "cachedResponseWillBeUsed" /* CACHED_RESPONSE_WILL_BE_USED */,n isReturnValueProblem: true,n });n }n }n }n }n return cachedResponse;n};n/**n * Wrapper around cache.put().n *n * Will call `cacheDidUpdate` on plugins if the cache was updated, usingn * `matchOptions` when determining what the old entry is.n *n * @param {Object} optionsn * @param {string} options.cacheNamen * @param {Request} options.requestn * @param {Response} options.responsen * @param {Event} [options.event]n * @param {Array<Object>} [options.plugins=n * @param {Object} [options.matchOptions]n *n * @privaten * @memberof module:workbox-coren */nconst putWrapper = async ({ cacheName, request, response, event, plugins = [], matchOptions, }) => {n if (process.env.NODE_ENV !== 'production') {n if (request.method && request.method !== 'GET') {n throw new WorkboxError('attempt-to-cache-non-get-request', {n url: getFriendlyURL(request.url),n method: request.method,n });n }n }n const effectiveRequest = await _getEffectiveRequest({n plugins, request, mode: 'write'n });n if (!response) {n if (process.env.NODE_ENV !== 'production') {n logger.error(`Cannot cache non-existent response for ` +n `'${getFriendlyURL(effectiveRequest.url)}'.`);n }n throw new WorkboxError('cache-put-with-no-response', {n url: getFriendlyURL(effectiveRequest.url),n });n }n const responseToCache = await _isResponseSafeToCache({n event,n plugins,n response,n request: effectiveRequest,n });n if (!responseToCache) {n if (process.env.NODE_ENV !== 'production') {n logger.debug(`Response '${getFriendlyURL(effectiveRequest.url)}' will ` +n `not be cached.`, responseToCache);n }n return;n }n const cache = await self.caches.open(cacheName);n const updatePlugins = pluginUtils.filter(plugins, "cacheDidUpdate" /* CACHE_DID_UPDATE */);n const oldResponse = updatePlugins.length > 0 ?n await matchWrapper({ cacheName, matchOptions, request: effectiveRequest }) :n null;n if (process.env.NODE_ENV !== 'production') {n logger.debug(`Updating the '${cacheName}' cache with a new Response for ` +n `${getFriendlyURL(effectiveRequest.url)}.`);n }n try {n await cache.put(effectiveRequest, responseToCache);n }n catch (error) {n // See developer.mozilla.org/en-US/docs/Web/API/DOMException#exception-QuotaExceededErrorn if (error.name === 'QuotaExceededError') {n await executeQuotaErrorCallbacks();n }n throw error;n }n for (const plugin of updatePlugins) {n await plugin["cacheDidUpdate" /* CACHE_DID_UPDATE */].call(plugin, {n cacheName,n event,n oldResponse,n newResponse: responseToCache,n request: effectiveRequest,n });n }n};nexport const cacheWrapper = {n put: putWrapper,n match: matchWrapper,n};n“,”/*n Copyright 2019 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport '../_version.js';nlet supportStatus;n/**n * A utility function that determines whether the current browser supportsn * constructing a [`ReadableStream`](developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)n * object.n *n * @return {boolean} `true`, if the current browser can successfullyn * construct a `ReadableStream`, `false` otherwise.n *n * @privaten */nfunction canConstructReadableStream() {n if (supportStatus === undefined) {n // See github.com/GoogleChrome/workbox/issues/1473n try {n new ReadableStream({ start() { } });n supportStatus = true;n }n catch (error) {n supportStatus = false;n }n }n return supportStatus;n}nexport { canConstructReadableStream };n“,”/*n Copyright 2019 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport '../_version.js';nlet supportStatus;n/**n * A utility function that determines whether the current browser supportsn * constructing a new `Response` from a `response.body` stream.n *n * @return {boolean} `true`, if the current browser can successfullyn * construct a `Response` from a `response.body` stream, `false` otherwise.n *n * @privaten */nfunction canConstructResponseFromBodyStream() {n if (supportStatus === undefined) {n const testResponse = new Response('');n if ('body' in testResponse) {n try {n new Response(testResponse.body);n supportStatus = true;n }n catch (error) {n supportStatus = false;n }n }n supportStatus = false;n }n return supportStatus;n}nexport { canConstructResponseFromBodyStream };n“,”/*n Copyright 2018 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport '../_version.js';n/**n * A class that wraps common IndexedDB functionality in a promise-based API.n * It exposes all the underlying power and functionality of IndexedDB, butn * wraps the most commonly used features in a way that's much simpler to use.n *n * @privaten */nexport class DBWrapper {n /**n * @param {string} namen * @param {number} versionn * @param {Object=} [callback]n * @param {!Function} [callbacks.onupgradeneeded]n * @param {!Function} [callbacks.onversionchange] Defaults ton * DBWrapper.prototype._onversionchange when not specified.n * @privaten */n constructor(name, version, { onupgradeneeded, onversionchange, } = {}) {n this._db = null;n this._name = name;n this._version = version;n this._onupgradeneeded = onupgradeneeded;n this._onversionchange = onversionchange || (() => this.close());n }n /**n * Returns the IDBDatabase instance (not normally needed).n * @return {IDBDatabase|undefined}n *n * @privaten */n get db() {n return this._db;n }n /**n * Opens a connected to an IDBDatabase, invokes any onupgradedneededn * callback, and added an onversionchange callback to the database.n *n * @return {IDBDatabase}n * @privaten */n async open() {n if (this._db)n return;n this._db = await new Promise((resolve, reject) => {n // This flag is flipped to true if the timeout callback runs priorn // to the request failing or succeeding. Note: we use a timeout insteadn // of an onblocked handler since there are cases where onblocked willn // never never run. A timeout better handles all possible scenarios:n // github.com/w3c/IndexedDB/issues/223n let openRequestTimedOut = false;n setTimeout(() => {n openRequestTimedOut = true;n reject(new Error('The open request was blocked and timed out'));n }, this.OPEN_TIMEOUT);n const openRequest = indexedDB.open(this._name, this._version);n openRequest.onerror = () => reject(openRequest.error);n openRequest.onupgradeneeded = (evt) => {n if (openRequestTimedOut) {n openRequest.transaction.abort();n openRequest.result.close();n }n else if (typeof this._onupgradeneeded === 'function') {n this._onupgradeneeded(evt);n }n };n openRequest.onsuccess = () => {n const db = openRequest.result;n if (openRequestTimedOut) {n db.close();n }n else {n db.onversionchange = this._onversionchange.bind(this);n resolve(db);n }n };n });n return this;n }n /**n * Polyfills the native `getKey()` method. Note, this is overridden atn * runtime if the browser supports the native method.n *n * @param {string} storeNamen * @param {*} queryn * @return {Array}n * @privaten */n async getKey(storeName, query) {n return (await this.getAllKeys(storeName, query, 1));n }n /**n * Polyfills the native `getAll()` method. Note, this is overridden atn * runtime if the browser supports the native method.n *n * @param {string} storeNamen * @param {*} queryn * @param {number} countn * @return {Array}n * @privaten */n async getAll(storeName, query, count) {n return await this.getAllMatching(storeName, { query, count });n }n /**n * Polyfills the native `getAllKeys()` method. Note, this is overridden atn * runtime if the browser supports the native method.n *n * @param {string} storeNamen * @param {*} queryn * @param {number} countn * @return {Array}n * @privaten */n async getAllKeys(storeName, query, count) {n const entries = await this.getAllMatching(storeName, { query, count, includeKeys: true });n return entries.map((entry) => entry.key);n }n /**n * Supports flexible lookup in an object store by specifying an index,n * query, direction, and count. This method returns an array of objectsn * with the signature .n *n * @param {string} storeNamen * @param {Object} [opts]n * @param {string} [opts.index] The index to use (if specified).n * @param {*} [opts.query]n * @param {IDBCursorDirection} [opts.direction]n * @param {number} [opts.count] The max number of results to return.n * @param {boolean} [opts.includeKeys] When true, the structure of then * returned objects is changed from an array of values to an array ofn * objects in the form {key, primaryKey, value}.n * @return {Array}n * @privaten */n async getAllMatching(storeName, { index, query = null, // IE/Edge errors if query === `undefined`.n direction = 'next', count, includeKeys = false, } = {}) {n return await this.transaction(, 'readonly', (txn, done) => {n const store = txn.objectStore(storeName);n const target = index ? store.index(index) : store;n const results = [];n const request = target.openCursor(query, direction);n request.onsuccess = () => {n const cursor = request.result;n if (cursor) {n results.push(includeKeys ? cursor : cursor.value);n if (count && results.length >= count) {n done(results);n }n else {n cursor.continue();n }n }n else {n done(results);n }n };n });n }n /**n * Accepts a list of stores, a transaction type, and a callback andn * performs a transaction. A promise is returned that resolves to whatevern * value the callback chooses. The callback holds all the transaction logicn * and is invoked with two arguments:n * 1. The IDBTransaction objectn * 2. A `done` function, that's used to resolve the promise whenn * when the transaction is done, if passed a value, the promise isn * resolved to that value.n *n * @param {Array<string>} storeNames An array of object store namesn * involved in the transaction.n * @param {string} type Can be `readonly` or `readwrite`.n * @param {!Function} callbackn * @return {*} The result of the transaction ran by the callback.n * @privaten */n async transaction(storeNames, type, callback) {n await this.open();n return await new Promise((resolve, reject) => {n const txn = this._db.transaction(storeNames, type);n txn.onabort = () => reject(txn.error);n txn.oncomplete = () => resolve();n callback(txn, (value) => resolve(value));n });n }n /**n * Delegates async to a native IDBObjectStore method.n *n * @param {string} method The method name.n * @param {string} storeName The object store name.n * @param {string} type Can be `readonly` or `readwrite`.n * @param {…*} args The list of args to pass to the native method.n * @return {*} The result of the transaction.n * @privaten */n async _call(method, storeName, type, …args) {n const callback = (txn, done) => {n const objStore = txn.objectStore(storeName);n // TODO(philipwalton): Fix this underlying TS2684 error.n // @ts-ignoren const request = objStore.apply(objStore, args);n request.onsuccess = () => done(request.result);n };n return await this.transaction(, type, callback);n }n /**n * Closes the connection opened by `DBWrapper.open()`. Generally this methodn * doesn't need to be called since:n * 1. It's usually better to keep a connection open since openingn * a new connection is somewhat slow.n * 2. Connections are automatically closed when the reference isn * garbage collected.n * The primary use case for needing to close a connection is when anothern * reference (typically in another tab) needs to upgrade it and would ben * blocked by the current, open connection.n *n * @privaten */n close() {n if (this._db) {n this._db.close();n this._db = null;n }n }n}n// Exposed on the prototype to let users modify the default timeout on an// per-instance or global basis.nDBWrapper.prototype.OPEN_TIMEOUT = 2000;n// Wrap native IDBObjectStore methods according to their mode.nconst methodsToWrap = {n readonly: ['get', 'count', 'getKey', 'getAll', 'getAllKeys'],n readwrite: ['add', 'put', 'clear', 'delete'],n};nfor (const [mode, methods] of Object.entries(methodsToWrap)) {n for (const method of methods) {n if (method in IDBObjectStore.prototype) {n // Don't use arrow functions here since we're outside of the class.n DBWrapper.prototype =n async function (storeName, …args) {n return await this._call(method, storeName, mode, …args);n };n }n }n}n“,”/*n Copyright 2018 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport '../_version.js';n/**n * Deletes the database.n * Note: this is exported separately from the DBWrapper module because mostn * usages of IndexedDB in workbox dont need deleting, and this way it can ben * reused in tests to delete databases without creating DBWrapper instances.n *n * @param {string} name The database name.n * @privaten */nexport const deleteDatabase = async (name) => {n await new Promise((resolve, reject) => {n const request = indexedDB.deleteDatabase(name);n request.onerror = () => {n reject(request.error);n };n request.onblocked = () => {n reject(new Error('Delete blocked'));n };n request.onsuccess = () => {n resolve();n };n });n};n“,”/*n Copyright 2018 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport { WorkboxError } from './WorkboxError.js';nimport { logger } from './logger.js';nimport { assert } from './assert.js';nimport { getFriendlyURL } from '../_private/getFriendlyURL.js';nimport { pluginUtils } from '../utils/pluginUtils.js';nimport '../_version.js';n/**n * Wrapper around the fetch API.n *n * Will call requestWillFetch on available plugins.n *n * @param {Object} optionsn * @param {Request|string} options.requestn * @param {Object} [options.fetchOptions]n * @param {ExtendableEvent} [options.event]n * @param {Array<Object>} [options.plugins=n * @return {Promise<Response>}n *n * @privaten * @memberof module:workbox-coren */nconst wrappedFetch = async ({ request, fetchOptions, event, plugins = [], }) => {n if (typeof request === 'string') {n request = new Request(request);n }n // We should be able to call `await event.preloadResponse` even if it'sn // undefined, but for some reason, doing so leads to errors in our Node unitn // tests. To work around that, explicitly check preloadResponse's value first.n if (event instanceof FetchEvent && event.preloadResponse) {n const possiblePreloadResponse = await event.preloadResponse;n if (possiblePreloadResponse) {n if (process.env.NODE_ENV !== 'production') {n logger.log(`Using a preloaded navigation response for ` +n `'${getFriendlyURL(request.url)}'`);n }n return possiblePreloadResponse;n }n }n if (process.env.NODE_ENV !== 'production') {n assert.isInstance(request, Request, {n paramName: 'request',n expectedClass: Request,n moduleName: 'workbox-core',n className: 'fetchWrapper',n funcName: 'wrappedFetch',n });n }n const failedFetchPlugins = pluginUtils.filter(plugins, "fetchDidFail" /* FETCH_DID_FAIL */);n // If there is a fetchDidFail plugin, we need to save a clone of then // original request before it's either modified by a requestWillFetchn // plugin or before the original request's body is consumed via fetch().n const originalRequest = failedFetchPlugins.length > 0 ?n request.clone() : null;n try {n for (const plugin of plugins) {n if ("requestWillFetch" /* REQUEST_WILL_FETCH */ in plugin) {n const pluginMethod = plugin["requestWillFetch" /* REQUEST_WILL_FETCH */];n const requestClone = request.clone();n request = await pluginMethod.call(plugin, {n request: requestClone,n event,n });n if (process.env.NODE_ENV !== 'production') {n if (request) {n assert.isInstance(request, Request, {n moduleName: 'Plugin',n funcName: "cachedResponseWillBeUsed" /* CACHED_RESPONSE_WILL_BE_USED */,n isReturnValueProblem: true,n });n }n }n }n }n }n catch (err) {n throw new WorkboxError('plugin-error-request-will-fetch', {n thrownError: err,n });n }n // The request can be altered by plugins with `requestWillFetch` makingn // the original request (Most likely from a `fetch` event) to be differentn // to the Request we make. Pass both to `fetchDidFail` to aid debugging.n const pluginFilteredRequest = request.clone();n try {n let fetchResponse;n // See github.com/GoogleChrome/workbox/issues/1796n if (request.mode === 'navigate') {n fetchResponse = await fetch(request);n }n else {n fetchResponse = await fetch(request, fetchOptions);n }n if (process.env.NODE_ENV !== 'production') {n logger.debug(`Network request for ` +n `'${getFriendlyURL(request.url)}' returned a response with ` +n `status '${fetchResponse.status}'.`);n }n for (const plugin of plugins) {n if ("fetchDidSucceed" /* FETCH_DID_SUCCEED */ in plugin) {n fetchResponse = await plugin["fetchDidSucceed" /* FETCH_DID_SUCCEED */]n .call(plugin, {n event,n request: pluginFilteredRequest,n response: fetchResponse,n });n if (process.env.NODE_ENV !== 'production') {n if (fetchResponse) {n assert.isInstance(fetchResponse, Response, {n moduleName: 'Plugin',n funcName: "fetchDidSucceed" /* FETCH_DID_SUCCEED */,n isReturnValueProblem: true,n });n }n }n }n }n return fetchResponse;n }n catch (error) {n if (process.env.NODE_ENV !== 'production') {n logger.error(`Network request for ` +n `'${getFriendlyURL(request.url)}' threw an error.`, error);n }n for (const plugin of failedFetchPlugins) {n await plugin["fetchDidFail" /* FETCH_DID_FAIL */].call(plugin, {n error,n event,n originalRequest: originalRequest.clone(),n request: pluginFilteredRequest.clone(),n });n }n throw error;n }n};nconst fetchWrapper = {n fetch: wrappedFetch,n};nexport { fetchWrapper };n“,”/*n Copyright 2019 Google LLCn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport '../_version.js';n/**n * Returns a promise that resolves and the passed number of milliseconds.n * This utility is an async/await-friendly version of `setTimeout`.n *n * @param {number} msn * @return {Promise}n * @privaten */nexport function timeout(ms) {n return new Promise((resolve) => setTimeout(resolve, ms));n}n“,”/*n Copyright 2019 Google LLCn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport '../_version.js';n/**n * A helper function that prevents a promise from being flagged as unused.n *n * @privaten **/nexport function dontWaitFor(promise) {n // Effective no-op.n promise.then(() => { });n}n“,”/*n Copyright 2018 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport '../_version.js';n/**n * The Deferred class composes Promises in a way that allows for them to ben * resolved or rejected from outside the constructor. In most cases promisesn * should be used directly, but Deferreds can be necessary when the logic ton * resolve a promise must be separate.n *n * @privaten */nclass Deferred {n /**n * Creates a promise and exposes its resolve and reject functions as methods.n */n constructor() {n this.promise = new Promise((resolve, reject) => {n this.resolve = resolve;n this.reject = reject;n });n }n}nexport { Deferred };n“,”/*n Copyright 2019 Google LLCn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport { timeout } from './timeout.js';nimport '../_version.js';nconst MAX_RETRY_TIME = 2000;n/**n * Returns a promise that resolves to a window client matching the passedn * `resultingClientId`. For browsers that don't support `resultingClientId`n * or if waiting for the resulting client to apper takes too long, resolve ton * `undefined`.n *n * @param {string} [resultingClientId]n * @return {Promise<Client|undefined>}n * @privaten */nexport async function resultingClientExists(resultingClientId) {n if (!resultingClientId) {n return;n }n let existingWindows = await self.clients.matchAll({ type: 'window' });n const existingWindowIds = new Set(existingWindows.map((w) => w.id));n let resultingWindow;n const startTime = performance.now();n // Only wait up to `MAX_RETRY_TIME` to find a matching client.n while (performance.now() - startTime < MAX_RETRY_TIME) {n existingWindows = await self.clients.matchAll({ type: 'window' });n resultingWindow = existingWindows.find((w) => {n if (resultingClientId) {n // If we have a `resultingClientId`, we can match on that.n return w.id === resultingClientId;n }n else {n // Otherwise match on finding a window not in `existingWindowIds`.n return !existingWindowIds.has(w.id);n }n });n if (resultingWindow) {n break;n }n // Sleep for 100ms and retry.n await timeout(100);n }n return resultingWindow;n}n“,”/*n Copyright 2019 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport { cacheNames as _cacheNames } from './_private/cacheNames.js';nimport './_version.js';n/**n * Get the current cache names and prefix/suffix used by Workbox.n *n * `cacheNames.precache` is used for precached assets,n * `cacheNames.googleAnalytics` is used by `workbox-google-analytics` ton * store `analytics.js`, and `cacheNames.runtime` is used for everything else.n *n * `cacheNames.prefix` can be used to retrieve just the current prefix value.n * `cacheNames.suffix` can be used to retrieve just the current suffix value.n *n * @return {Object} An object with `precache`, `runtime`, `prefix`, andn * `googleAnalytics` properties.n *n * @memberof module:workbox-coren */nconst cacheNames = {n get googleAnalytics() {n return _cacheNames.getGoogleAnalyticsName();n },n get precache() {n return _cacheNames.getPrecacheName();n },n get prefix() {n return _cacheNames.getPrefix();n },n get runtime() {n return _cacheNames.getRuntimeName();n },n get suffix() {n return _cacheNames.getSuffix();n },n};nexport { cacheNames };n“,”/*n Copyright 2019 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport './_version.js';n/**n * Claim any currently available clients once the service workern * becomes active. This is normally used in conjunction with `skipWaiting()`.n *n * @memberof module:workbox-coren */nfunction clientsClaim() {n self.addEventListener('activate', () => self.clients.claim());n}nexport { clientsClaim };n“,”/*n Copyright 2019 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport { canConstructResponseFromBodyStream } from './_private/canConstructResponseFromBodyStream.js';nimport './_version.js';n/**n * Allows developers to copy a response and modify its `headers`, `status`,n * or `statusText` values (the values settable via an * [`ResponseInit`]{@link developer.mozilla.org/en-US/docs/Web/API/Response/Response#Syntax}n * object in the constructor).n * To modify these values, pass a function as the second argument. Thatn * function will be invoked with a single object with the response propertiesn * `{headers, status, statusText}`. The return value of this function willn * be used as the `ResponseInit` for the new `Response`. To change the valuesn * either modify the passed parameter(s) and return it, or return a totallyn * new object.n *n * @param {Response} responsen * @param {Function} modifiern * @memberof module:workbox-coren */nasync function copyResponse(response, modifier) {n const clonedResponse = response.clone();n // Create a fresh `ResponseInit` object by cloning the headers.n const responseInit = {n headers: new Headers(clonedResponse.headers),n status: clonedResponse.status,n statusText: clonedResponse.statusText,n };n // Apply any user modifications.n const modifiedResponseInit = modifier ? modifier(responseInit) : responseInit;n // Create the new response from the body stream and `ResponseInit`n // modifications. Note: not all browsers support the Response.body stream,n // so fall back to reading the entire body into memory as a blob.n const body = canConstructResponseFromBodyStream() ?n clonedResponse.body : await clonedResponse.blob();n return new Response(body, modifiedResponseInit);n}nexport { copyResponse };n“,”/*n Copyright 2019 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport { logger } from './_private/logger.js';nimport { assert } from './_private/assert.js';nimport { quotaErrorCallbacks } from './models/quotaErrorCallbacks.js';nimport './_version.js';n/**n * Adds a function to the set of quotaErrorCallbacks that will be executed ifn * there's a quota error.n *n * @param {Function} callbackn * @memberof module:workbox-coren */nfunction registerQuotaErrorCallback(callback) {n if (process.env.NODE_ENV !== 'production') {n assert.isType(callback, 'function', {n moduleName: 'workbox-core',n funcName: 'register',n paramName: 'callback',n });n }n quotaErrorCallbacks.add(callback);n if (process.env.NODE_ENV !== 'production') {n logger.log('Registered a callback to respond to quota errors.', callback);n }n}nexport { registerQuotaErrorCallback };n“,”/*n Copyright 2019 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport { assert } from './_private/assert.js';nimport { cacheNames } from './_private/cacheNames.js';nimport { WorkboxError } from './_private/WorkboxError.js';nimport './_version.js';n/**n * Modifies the default cache names used by the Workbox packages.n * Cache names are generated as `<prefix>-<Cache Name>-<suffix>`.n *n * @param {Object} detailsn * @param {Object} [details.prefix] The string to add to the beginning ofn * the precache and runtime cache names.n * @param {Object} [details.suffix] The string to add to the end ofn * the precache and runtime cache names.n * @param {Object} [details.precache] The cache name to use for precachen * caching.n * @param {Object} [details.runtime] The cache name to use for runtime caching.n * @param {Object} [details.googleAnalytics] The cache name to use forn * `workbox-google-analytics` caching.n *n * @memberof module:workbox-coren */nfunction setCacheNameDetails(details) {n if (process.env.NODE_ENV !== 'production') {n Object.keys(details).forEach((key) => {n assert.isType(details, 'string', {n moduleName: 'workbox-core',n funcName: 'setCacheNameDetails',n paramName: `details.${key}`,n });n });n if ('precache' in details && details.length === 0) {n throw new WorkboxError('invalid-cache-name', {n cacheNameId: 'precache',n value: details,n });n }n if ('runtime' in details && details.length === 0) {n throw new WorkboxError('invalid-cache-name', {n cacheNameId: 'runtime',n value: details,n });n }n if ('googleAnalytics' in details && details.length === 0) {n throw new WorkboxError('invalid-cache-name', {n cacheNameId: 'googleAnalytics',n value: details,n });n }n }n cacheNames.updateDetails(details);n}nexport { setCacheNameDetails };n“,”/*n Copyright 2019 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport './_version.js';n/**n * Force a service worker to activate immediately, instead ofn * [waiting](developers.google.com/web/fundamentals/primers/service-workers/lifecycle#waiting)n * for existing clients to close.n *n * @memberof module:workbox-coren */nfunction skipWaiting() {n // We need to explicitly call `self.skipWaiting()` here because we'ren // shadowing `skipWaiting` with this local function.n self.addEventListener('install', () => self.skipWaiting());n}nexport { skipWaiting };n“],”names“:,”mappings“:”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“}