* Accepts a callback and returns an iterable of matching plugin callbacks, * where each callback is wrapped with the current handler state (i.e

* Adds a promise to the * [extend lifetime promises]{@link https://w3c.github.io/ServiceWorker/#extendableevent-extend-lifetime-promises}

* Perform a request strategy and returns a `Promise` that will resolve with * a `Response`, invoking all relevant plugin callbacks. *

* Runs all plugin callbacks matching the given name, in order, passing the * given param object (merged ith the current plugin state) as the on

* Puts a request/response pair in the cache (and invokes any applicable * plugin callback methods) using the `cacheName` and `plugins` defined

* Fetches a given request (and invokes any applicable plugin callback * methods) using the `fetchOptions` (for non-navigation requests) and

* Checks the list of plugins for the `cacheKeyWillBeUsed` callback, and * executes any of those callbacks found in sequence. The final `Request

* Returns the cache key used for storing a given URL. If that URL is * unversioned, like `/index.html', then the cache key will be the original

* @param {string} groupTitle * @param {Array<string>} urls * * @private

* This method is complex, as there a number of things to account for: * * The `plugins` array can be set at construction, and/or it migh

* Similar to {@link workbox-strategies.Strategy~handle}, but * instead of just returning a `Promise` that resolves to a `Response` it *

* Apply the routing rules to a FetchEvent object to get a Response from an * appropriate Route's handler. * * @param {Object} opt

* Returns true if the strategy has at least one plugin with the given * callback. * * @param {string} name The name of the callba

* A utility method that makes it easier to use `event.waitUntil` with * async functions and return the result. * * @param {ExtendableEv

* This method will call cacheWillUpdate on the available plugins (or use * status === 200) to determine if the Response is safe and valid to ca

* @private * @param {Request|string} request A request to run this strategy for. * @param {workbox-strategies.StrategyHandler} handler T

* Routes match handler. * * @param {Object} options * @param {URL} options.url * @param {Request} options.request *

* Adds a message event listener for URLs to cache from the window. * This is useful to cache resources loaded on the page prior to when the

* Adds a fetch event listener to respond to events when a route matches * the event's request.

* Add a `fetch` listener to the service worker that will * respond to * [network requests]{@link https://developer.mozilla.org/en-US/docs/We

* This method will add items to the precache list, removing duplicates * and ensuring the information is valid. * * @param {Array

* Matches a request from the cache (and invokes any applicable plugin * callback methods) using the `cacheName`, `matchOptions`, and `plugins`

* Matches an item in the cache, ignoring specific URL params. This is similar * to the `ignoreSearch` option, but it allows you to ignore just sp

* A utility function that determines whether the current browser supports * constructing a new `Response` from a `response.body` stream. *

* Allows developers to copy a response and modify its `headers`, `status`, * or `statusText` values (the values settable via a * [`ResponseI

* Converts a manifest entry into a versioned URL suitable for precaching. * * @param {Object|string} entry * @return {string} A URL wit

* Returns a function that looks up `url` in the precache (taking into * account revision information), and returns the corresponding `Response`

* Stops running the strategy and immediately resolves any pending * `waitUntil()` promises.

* Returns a promise that resolves once all promises passed to * {@link workbox-strategies.StrategyHandler~waitUntil} * have settled.

* Runs all of the callback functions, one at a time sequentially, in the order * in which they were registered. * * @memberof workbox-c

* Checks a request and URL (and optionally an event) against the list of * registered routes, and if there's a match, returns the corresponding

* Generator function that yields possible variations on the original URL to * check, one at a time. * * @param {string} url * @par

* @param {string} url A cache key whose SRI you want to look up. * @return {string} The subresource integrity associated with the cache key,

* Returns a mapping of a precached URL to the corresponding cache key, taking * into account the revision information for the URL. *

* Adds items to the precache list, removing any duplicates and * stores the files in the * {@link workbox-core.cacheNames|"precache cache"}

* Adds items to the precache list, removing any duplicates and * stores the files in the * {@link workbox-core.cacheNames|"precache cach

* @param {Array<string>} deletedURLs * * @private * @memberof workbox-precaching

* @param {Array<string>} urlsToPrecache * @param {Array<string>} urlsAlreadyPrecached * * @private * @memberof workbox-precaching

* Easily register a RegExp, string, or function with a caching * strategy to a singleton Router instance. * * This method will generate

* Registers a route with the router. * * @param {workbox-routing.Route} route The route to register.

* Removes any URL search parameters that should be ignored. * * @param {URL} urlObject The original URL. * @param {Array<RegExp>} ignor

* Returns a promise that resolves and the passed number of milliseconds. * This utility is an async/await-friendly version of `setTimeout`.

* Deletes assets that are no longer present in the current precache manifest. * Call this method from the service worker activate event.

* Adds an `activate` event listener which will clean up incompatible * precaches that were created by older versions of Workbox. * * @m

* Claim any currently available clients once the service worker * becomes active. This is normally used in conjunction with `skipWaiting()`.

* * @param {string} errorCode The error code that * identifies this particular error. * @param {Object=} details Any relevant arg

* Constructor for Route class. * * @param {workbox-routing~matchCallback} match * A callback function that determines whether the

* If the regular expression contains * [capture groups]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/

* Initializes a new Router.

* Creates a promise and exposes its resolve and reject functions as methods.

* Creates a new instance associated with the passed strategy and event * that's handling the request. * * The constructor also in

* Creates a new instance of the strategy and sets all documented option * properties as public instance properties. * * Note: if

* * @param {Object} [options] * @param {string} [options.cacheName] Cache name to store and retrieve * requests. Defaults to the

* Create a new PrecacheController. * * @param {Object} [options] * @param {string} [options.cacheName] The cache to use for preca

* @param {PrecacheController} precacheController A `PrecacheController` * instance used to both match requests and respond to fetch events.

* If both `denylist` and `allowlist` are provided, the `denylist` will * take precedence and the request will not match this route. *

* Helper function that calls * {@link PrecacheController#createHandlerBoundToURL} on the default * {@link PrecacheController} instance.

* Calls `this.fetch()` and (in the background) runs `this.cachePut()` on * the response generated by `this.fetch()`. * * The call

* Returns a list of all the URLs that have been precached by the current * service worker. * * @return {Array<string>} The precac

* Precaches new and updated assets. Call this method from the service worker * install event. * * Note: this method calls `event.

* This acts as a drop-in replacement for * [`cache.match()`](https://developer.mozilla.org/en-US/docs/Web/API/Cache/match) * with the fo

* This method will add entries to the precache list and add a route to * respond to fetch events. * * This is a convenience method that

* @return {Map<string, Array<workbox-routing.Route>>} routes A `Map` of HTTP * method name ('GET', etc.) to an array of all the corresponding `