* Increment cycle counter and return current value * @param {string} key - Cycle identifier * @param {number} listLength - Length of the cycling

* Get current cycle index for a given key * @param {string} key - Cycle identifier (serialized list) * @returns {number} Current index (0 if not

* Handle code change from editor * @param {string} text - Current editor text

* Evaluate code immediately * @param {string} text - Code to evaluate

* Get last trigger time for cooldown tracking * @param {string} key - Cooldown identifier * @returns {number|undefined} Last trigger time (undef

* Register event listener * @param {string} event - Event name ('validated' or 'error') * @param {Function} callback - Callback function

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

* Schedule a program transition at the next quantized boundary * @param {Array} newProgram - New program clauses

* Removes the IndexedDB object store used to keep track of cache expiration * metadata.

* Set last trigger time for cooldown tracking * @param {string} key - Cooldown identifier * @param {number} time - Current time in seconds

* Emit event * @param {string} event - Event name * @param {*} data - Event data

* Record a trigger event (alias for setLastTrigger) * @param {string} key - Cooldown identifier * @param {number} time - Current time in seconds

* Save progress to localStorage

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

* Check if a transition is pending * @returns {boolean}

* Hide overlay

* Reset all state (for explicit user action only)

* Stops running the strategy and immediately resolves any pending * `waitUntil()` 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

* Check if enough time has passed since last trigger * @param {string} key - Cooldown identifier * @param {number} now - Current time in seconds

* Expires entries for the given cache and given criteria.

* 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

* Get current step index * @returns {number}

* Returns an open connection to the database. * * @private

* Register event listener * @param {string} event - Event name * @param {Function} callback - Callback function

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

* Update the validation state * @param {string} state - State: 'valid', 'invalid', or 'evaluating' * @param {string} errorMessage - Optional err

* Show overlay

* A simple helper method to return a CacheExpiration instance for a given * cache name. * * @param {string} cacheName * @r

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

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

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

* Cancel any pending transition

* Complete the tutorial

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

* A helper function that prevents a promise from being flagged as unused. * * @private

* Emit event to all registered listeners * @param {string} event - Event name * @param {*} data - Event data

* Get the last successfully validated code * @returns {string}

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

* Handle next button click

* 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