SYMBOL INDEX (723 symbols across 226 files)

FILE: demos/src/workbox-routing/sw.js
  constant GLITCH_ICO_URL (line 25) | const GLITCH_ICO_URL = 'https://glitch.com/edit/favicon-app.ico';

FILE: demos/src/workbox-streams/sw.js
  constant CACHE_NAME (line 9) | const CACHE_NAME = 'my-cache';
  constant START_CACHE_KEY (line 10) | const START_CACHE_KEY = 'start';
  constant END_CACHE_KEY (line 11) | const END_CACHE_KEY = 'end';

FILE: demos/src/workbox-window/sw.js
  constant SW_VERSION (line 9) | const SW_VERSION = '5.0.0';

FILE: gulp-tasks/analyze-properties.js
  function analyze_properties (line 11) | async function analyze_properties() {

FILE: gulp-tasks/build-node-packages.js
  constant TJS (line 12) | const TJS = require('typescript-json-schema');
  function buildNodePackage (line 18) | async function buildNodePackage(packagePath) {
  function generateWorkboxBuildJSONSchema (line 44) | async function generateWorkboxBuildJSONSchema(packagePath) {

FILE: gulp-tasks/build-packages.js
  function cleanPackage (line 24) | async function cleanPackage(packagePath) {
  function cleanSequence (line 56) | function cleanSequence() {

FILE: gulp-tasks/build-sw-packages.js
  function globals (line 24) | function globals(moduleId) {
  function externalAndPure (line 76) | function externalAndPure(importPath) {
  function buildSWBundle (line 80) | async function buildSWBundle(packagePath, buildType) {
  function swBundleSequence (line 156) | function swBundleSequence() {

FILE: gulp-tasks/build-window-packages.js
  function buildWindowBundle (line 22) | async function buildWindowBundle(packagePath, buildType) {
  function windowBundleSequence (line 98) | function windowBundleSequence() {

FILE: gulp-tasks/build.js
  function build_update_cdn_details (line 19) | async function build_update_cdn_details() {
  function build_lerna_bootstrap (line 48) | async function build_lerna_bootstrap() {

FILE: gulp-tasks/docs.js
  constant DOCS_DIRECTORY (line 16) | const DOCS_DIRECTORY = upath.join(__dirname, '..', 'docs');
  function docs_build (line 18) | async function docs_build() {
  function docs_watch (line 66) | function docs_watch() {

FILE: gulp-tasks/lint.js
  function lint_js (line 12) | async function lint_js() {
  function lint_ts (line 26) | async function lint_ts() {

FILE: gulp-tasks/publish-cdn.js
  function cleanTagName (line 18) | function cleanTagName(name) {
  function findMissingCDNTags (line 28) | async function findMissingCDNTags(tagsData) {
  function handleCDNUpload (line 42) | async function handleCDNUpload(tagName, gitBranch) {
  function publish_cdn (line 59) | async function publish_cdn() {

FILE: gulp-tasks/publish-github.js
  function publishReleaseOnGithub (line 14) | async function publishReleaseOnGithub(tagName, releaseInfo) {
  function handleGithubRelease (line 26) | async function handleGithubRelease(tagName, gitBranch, releaseInfo) {
  function filterTagsWithReleaseBundles (line 32) | function filterTagsWithReleaseBundles(allTags, taggedReleases) {
  function publish_github (line 46) | async function publish_github() {

FILE: gulp-tasks/publish-glitch.js
  constant DEMOS_DIR (line 20) | const DEMOS_DIR = 'demos/src';
  function publish_glitch (line 22) | async function publish_glitch() {

FILE: gulp-tasks/publish-lerna.js
  function publish_lerna (line 14) | async function publish_lerna() {

FILE: gulp-tasks/publish.js
  function publish_clean (line 22) | async function publish_clean() {
  function publish_sign_in_check (line 26) | async function publish_sign_in_check() {
  function dist_tag_check (line 30) | async function dist_tag_check() {

FILE: gulp-tasks/test-integration.js
  function runFiles (line 20) | function runFiles(filePaths) {
  function runTestSuite (line 46) | async function runTestSuite(testPath, nodeEnv, seleniumBrowser, webdrive...
  function runIntegrationForBrowser (line 76) | async function runIntegrationForBrowser(browser) {
  function test_integration (line 106) | async function test_integration() {

FILE: gulp-tasks/test-node.js
  function runNodeTestSuite (line 19) | async function runNodeTestSuite(testPath, nodeEnv) {
  function runNodeTestsWithEnv (line 52) | async function runNodeTestsWithEnv(testGroup, nodeEnv) {
  function test_node_prod (line 74) | async function test_node_prod() {
  function test_node_dev (line 78) | async function test_node_dev() {
  function test_node_all (line 82) | async function test_node_all() {
  function test_node_clean (line 86) | async function test_node_clean() {
  function test_node_coverage (line 90) | async function test_node_coverage() {

FILE: gulp-tasks/test-server.js
  function handleExit (line 18) | function handleExit() {
  function startServer (line 23) | function startServer() {

FILE: gulp-tasks/test.js
  function logSkip (line 16) | async function logSkip() {
  function runTestsUnlessSkipped (line 20) | function runTestsUnlessSkipped() {

FILE: gulp-tasks/transpile-typescript.js
  function queueTranspile (line 33) | async function queueTranspile(packageName, options) {
  function needsTranspile (line 57) | function needsTranspile(packageName) {
  function transpile_typescript (line 71) | async function transpile_typescript() {
  function transpile_typescript_watch (line 86) | async function transpile_typescript_watch() {

FILE: gulp-tasks/utils/analyse-properties.js
  class AnalyseBuildForProperties (line 30) | class AnalyseBuildForProperties {
    method run (line 31) | run() {
    method getBuildFiles (line 46) | getBuildFiles() {
    method analyzeFile (line 60) | analyzeFile(filePath) {
    method tidyData (line 87) | tidyData(analysisEntries) {
    method printDetails (line 108) | printDetails({filePath, analysis}) {

FILE: gulp-tasks/utils/cdn-helper.js
  constant PROJECT_ID (line 16) | const PROJECT_ID = 'workbox-bab1f';
  class CDNHelper (line 18) | class CDNHelper {
    method constructor (line 19) | constructor() {
    method _getReleaseTagPath (line 23) | _getReleaseTagPath(tagName) {
    method getGCS (line 27) | async getGCS() {
    method tagExists (line 39) | async tagExists(tagName) {
    method upload (line 56) | async upload(tagName, directoryToUpload) {

FILE: gulp-tasks/utils/get-packages.js
  constant DEFAULT_ROOT (line 12) | const DEFAULT_ROOT = path.join(__dirname, '..', '..');

FILE: gulp-tasks/utils/package-runner.js
  function getPackages (line 21) | function getPackages(typeFilter) {

FILE: gulp-tasks/utils/publish-helpers.js
  constant SOURCE_CODE_DIR (line 19) | const SOURCE_CODE_DIR = 'source-code';
  constant GROUPED_BUILD_FILES (line 20) | const GROUPED_BUILD_FILES = 'grouped-build-files';

FILE: infra/pr-bot/aggregate-size-plugin.js
  constant MAX_SIZE_GZIP (line 17) | const MAX_SIZE_GZIP = 15 * 1024;
  class AggregateSizePlugin (line 19) | class AggregateSizePlugin extends PluginInterface {
    method constructor (line 20) | constructor() {
    method run (line 24) | async run({afterPath} = {}) {

FILE: infra/templates/reference-docs/jsdoc/lib/publishjob.js
  class PublishJob (line 15) | class PublishJob extends BaselinePublishJob {
    method constructor (line 16) | constructor(...args) {
    method generateTocYaml (line 22) | generateTocYaml(symbols, basepath) {
    method generateIndex (line 85) | generateIndex(readme) {
    method generateIndexAll (line 98) | generateIndexAll(longnames) {

FILE: infra/testing/activate-and-control.js
  function _onStateChangePromise (line 19) | function _onStateChangePromise(registration, desiredState) {

FILE: infra/testing/comlink/window-interface.js
  function initComlink (line 9) | function initComlink() {

FILE: infra/testing/server/cross-origin-server.js
  constant PORT (line 11) | const PORT = 3010;
  function initApp (line 16) | function initApp(staticDir) {
  function start (line 21) | function start(staticDir) {
  function stop (line 37) | function stop() {

FILE: infra/testing/server/index.js
  constant PORT (line 19) | const PORT = 3004;
  function initApp (line 25) | function initApp() {
  function start (line 51) | function start() {
  function stop (line 68) | function stop() {
  function getAddress (line 74) | function getAddress() {
  function startCountingRequests (line 78) | function startCountingRequests(headerValue) {
  function stopCountingRequests (line 84) | function stopCountingRequests(requestCounter) {

FILE: infra/testing/server/request-counter.js
  class RequestCounter (line 9) | class RequestCounter {
    method constructor (line 10) | constructor(headerName) {
    method count (line 16) | count(req) {
    method getHeaderCount (line 34) | getHeaderCount(headerValue) {
    method getURLCount (line 38) | getURLCount(url) {

FILE: infra/testing/server/routes/build-file.js
  function handler (line 16) | async function handler(req, res) {

FILE: infra/testing/server/routes/comlink.js
  function handler (line 11) | async function handler(req, res) {

FILE: infra/testing/server/routes/integration-html.js
  function handler (line 13) | async function handler(req, res) {

FILE: infra/testing/server/routes/sw-bundle.js
  constant SW_NAMESPACES (line 18) | const SW_NAMESPACES = getPackages({type: 'sw'}).map((pkg) => {
  function handler (line 25) | async function handler(req, res) {

FILE: infra/testing/server/routes/templates-update.js
  function handler (line 15) | async function handler(req, res) {

FILE: infra/testing/server/routes/templates.js
  function handler (line 18) | async function handler(req, res) {

FILE: infra/testing/server/routes/test-sw.js
  function handler (line 15) | async function handler(req, res) {

FILE: infra/testing/server/routes/test-window.js
  function handler (line 15) | async function handler(req, res) {

FILE: infra/testing/server/routes/unique-etag.js
  function handler (line 12) | async function handler(req, res) {

FILE: infra/testing/server/routes/unique-value.js
  function handler (line 12) | async function handler(req, res) {

FILE: infra/testing/validator/service-worker-runtime.js
  function stringifyFunctionsInArray (line 21) | function stringifyFunctionsInArray(arr) {
  function setupSpiesAndContextForInjectManifest (line 27) | function setupSpiesAndContextForInjectManifest() {
  function setupSpiesAndContextForGenerateSW (line 113) | function setupSpiesAndContextForGenerateSW() {
  function validateMethodCalls (line 152) | function validateMethodCalls({methodsToSpies, expectedMethodCalls, conte...

FILE: infra/testing/webdriver/IframeManager.js
  constant PREFIX (line 9) | const PREFIX = 'iframe-';
  class Client (line 12) | class Client {
    method constructor (line 13) | constructor(driver, id) {
    method executeAsyncScript (line 18) | async executeAsyncScript(code) {
    method wait (line 33) | async wait(code) {
    method remove (line 37) | remove() {
  class IframeManager (line 49) | class IframeManager {
    method constructor (line 55) | constructor(driver) {
    method createIframeClient (line 60) | async createIframeClient(url) {

FILE: infra/testing/webpack-build-check.js
  function joinMessages (line 9) | function joinMessages(errorsOrWarnings) {

FILE: infra/type-overrides.d.ts
  type IDBIndex (line 4) | interface IDBIndex {
  type IDBObjectStore (line 15) | interface IDBObjectStore {
  type CacheStorage (line 29) | interface CacheStorage {
  type Headers (line 39) | interface Headers {
  type URLSearchParams (line 55) | interface URLSearchParams {

FILE: infra/utils/AsyncDebounce.js
  class AsyncDebounce (line 9) | class AsyncDebounce {
    method constructor (line 10) | constructor(fn) {
    method call (line 15) | call() {

FILE: packages/workbox-background-sync/src/BackgroundSyncPlugin.ts
  class BackgroundSyncPlugin (line 19) | class BackgroundSyncPlugin implements WorkboxPlugin {
    method constructor (line 29) | constructor(name: string, options?: QueueOptions) {

FILE: packages/workbox-background-sync/src/Queue.ts
  type OnSyncCallbackOptions (line 21) | interface OnSyncCallbackOptions {
  type OnSyncCallback (line 25) | interface OnSyncCallback {
  type QueueOptions (line 29) | interface QueueOptions {
  type QueueEntry (line 35) | interface QueueEntry {
  constant TAG_PREFIX (line 44) | const TAG_PREFIX = 'workbox-background-sync';
  constant MAX_RETENTION_TIME (line 45) | const MAX_RETENTION_TIME = 60 * 24 * 7;
  class Queue (line 78) | class Queue {
    method constructor (line 112) | constructor(
    method name (line 135) | get name(): string {
    method pushRequest (line 155) | async pushRequest(entry: QueueEntry): Promise<void> {
    method unshiftRequest (line 190) | async unshiftRequest(entry: QueueEntry): Promise<void> {
    method popRequest (line 216) | async popRequest(): Promise<QueueEntry | undefined> {
    method shiftRequest (line 227) | async shiftRequest(): Promise<QueueEntry | undefined> {
    method getAll (line 237) | async getAll(): Promise<Array<QueueEntry>> {
    method size (line 262) | async size(): Promise<number> {
    method _addRequest (line 276) | async _addRequest(
    method _removeRequest (line 325) | async _removeRequest(
    method replayRequests (line 358) | async replayRequests(): Promise<void> {
    method registerSync (line 393) | async registerSync(): Promise<void> {
    method _addSyncListener (line 418) | private _addSyncListener() {
    method _queueNames (line 482) | static get _queueNames(): Set<string> {

FILE: packages/workbox-background-sync/src/index.ts
  type SyncManager (line 17) | interface SyncManager {
  type ServiceWorkerRegistration (line 23) | interface ServiceWorkerRegistration {
  type SyncEvent (line 27) | interface SyncEvent extends ExtendableEvent {
  type ServiceWorkerGlobalScopeEventMap (line 32) | interface ServiceWorkerGlobalScopeEventMap {

FILE: packages/workbox-background-sync/src/lib/QueueDb.ts
  type QueueDBSchema (line 13) | interface QueueDBSchema extends DBSchema {
  constant DB_VERSION (line 21) | const DB_VERSION = 3;
  constant DB_NAME (line 22) | const DB_NAME = 'workbox-background-sync';
  constant REQUEST_OBJECT_STORE_NAME (line 23) | const REQUEST_OBJECT_STORE_NAME = 'requests';
  constant QUEUE_NAME_INDEX (line 24) | const QUEUE_NAME_INDEX = 'queueName';
  type UnidentifiedQueueStoreEntry (line 26) | interface UnidentifiedQueueStoreEntry {
  type QueueStoreEntry (line 37) | interface QueueStoreEntry extends UnidentifiedQueueStoreEntry {
  class QueueDb (line 49) | class QueueDb {
    method addEntry (line 57) | async addEntry(entry: UnidentifiedQueueStoreEntry): Promise<void> {
    method getFirstEntryId (line 71) | async getFirstEntryId(): Promise<number | undefined> {
    method getAllEntriesByQueueName (line 85) | async getAllEntriesByQueueName(
    method getEntryCountByQueueName (line 103) | async getEntryCountByQueueName(queueName: string): Promise<number> {
    method deleteEntry (line 117) | async deleteEntry(id: number): Promise<void> {
    method getFirstEntryByQueueName (line 127) | async getFirstEntryByQueueName(
    method getLastEntryByQueueName (line 138) | async getLastEntryByQueueName(
    method getEndEntryFromIndex (line 153) | async getEndEntryFromIndex(
    method getDb (line 171) | private async getDb() {
    method _upgradeDb (line 187) | private _upgradeDb(db: IDBPDatabase<QueueDBSchema>, oldVersion: number) {

FILE: packages/workbox-background-sync/src/lib/QueueStore.ts
  class QueueStore (line 24) | class QueueStore {
    method constructor (line 34) | constructor(queueName: string) {
    method pushEntry (line 47) | async pushEntry(entry: UnidentifiedQueueStoreEntry): Promise<void> {
    method unshiftEntry (line 78) | async unshiftEntry(entry: UnidentifiedQueueStoreEntry): Promise<void> {
    method popEntry (line 113) | async popEntry(): Promise<QueueStoreEntry | undefined> {
    method shiftEntry (line 124) | async shiftEntry(): Promise<QueueStoreEntry | undefined> {
    method getAll (line 136) | async getAll(): Promise<QueueStoreEntry[]> {
    method size (line 146) | async size(): Promise<number> {
    method deleteEntry (line 160) | async deleteEntry(id: number): Promise<void> {
    method _removeEntry (line 171) | async _removeEntry(

FILE: packages/workbox-background-sync/src/lib/StorableRequest.ts
  type SerializableProperties (line 13) | type SerializableProperties =
  type RequestData (line 36) | interface RequestData extends MapLikeObject {
  class StorableRequest (line 49) | class StorableRequest {
    method fromRequest (line 59) | static async fromRequest(request: Request): Promise<StorableRequest> {
    method constructor (line 97) | constructor(requestData: RequestData) {
    method toObject (line 127) | toObject(): RequestData {
    method toRequest (line 142) | toRequest(): Request {
    method clone (line 151) | clone(): StorableRequest {

FILE: packages/workbox-broadcast-update/src/BroadcastCacheUpdate.ts
  type BroadcastCacheUpdateOptions (line 32) | interface BroadcastCacheUpdateOptions {
  function defaultPayloadGenerator (line 47) | function defaultPayloadGenerator(
  class BroadcastCacheUpdate (line 65) | class BroadcastCacheUpdate {
    method constructor (line 87) | constructor({
    method notifyIfUpdated (line 128) | async notifyIfUpdated(options: CacheDidUpdateCallbackParam): Promise<v...

FILE: packages/workbox-broadcast-update/src/BroadcastUpdatePlugin.ts
  class BroadcastUpdatePlugin (line 25) | class BroadcastUpdatePlugin implements WorkboxPlugin {
    method constructor (line 41) | constructor(options?: BroadcastCacheUpdateOptions) {

FILE: packages/workbox-broadcast-update/src/utils/constants.ts
  constant CACHE_UPDATED_MESSAGE_TYPE (line 11) | const CACHE_UPDATED_MESSAGE_TYPE = 'CACHE_UPDATED';
  constant CACHE_UPDATED_MESSAGE_META (line 12) | const CACHE_UPDATED_MESSAGE_META = 'workbox-broadcast-update';
  constant NOTIFY_ALL_CLIENTS (line 13) | const NOTIFY_ALL_CLIENTS = true;
  constant DEFAULT_HEADERS_TO_CHECK (line 14) | const DEFAULT_HEADERS_TO_CHECK: string[] = [

FILE: packages/workbox-build/src/generate-sw.ts
  function generateSW (line 62) | async function generateSW(

FILE: packages/workbox-build/src/get-manifest.ts
  function getManifest (line 31) | async function getManifest(

FILE: packages/workbox-build/src/inject-manifest.ts
  function injectManifest (line 53) | async function injectManifest(

FILE: packages/workbox-build/src/lib/additional-manifest-entries-transform.ts
  type AdditionalManifestEntriesTransform (line 12) | type AdditionalManifestEntriesTransform = {
  function additionalManifestEntriesTransform (line 19) | function additionalManifestEntriesTransform(

FILE: packages/workbox-build/src/lib/bundle.ts
  type NameAndContents (line 22) | interface NameAndContents {
  function bundle (line 27) | async function bundle({

FILE: packages/workbox-build/src/lib/cdn-utils.ts
  function getVersionedURL (line 15) | function getVersionedURL(): string {
  function getCDNPrefix (line 19) | function getCDNPrefix() {
  function getModuleURL (line 23) | function getModuleURL(moduleName: string, buildType: BuildType): string {

FILE: packages/workbox-build/src/lib/copy-workbox-libraries.ts
  constant WORKBOX_PREFIX (line 16) | const WORKBOX_PREFIX = 'workbox-';
  constant BUILD_DIR (line 19) | const BUILD_DIR = 'build';
  function copyWorkboxLibraries (line 40) | async function copyWorkboxLibraries(

FILE: packages/workbox-build/src/lib/escape-regexp.ts
  function escapeRegExp (line 10) | function escapeRegExp(str: string): string {

FILE: packages/workbox-build/src/lib/get-composite-details.ts
  function getCompositeDetails (line 13) | function getCompositeDetails(

FILE: packages/workbox-build/src/lib/get-file-details.ts
  type FileDetails (line 18) | interface FileDetails {
  function getFileDetails (line 24) | function getFileDetails({

FILE: packages/workbox-build/src/lib/get-file-hash.ts
  function getFileHash (line 14) | function getFileHash(file: string): string {

FILE: packages/workbox-build/src/lib/get-file-manifest-entries.ts
  function getFileManifestEntries (line 18) | async function getFileManifestEntries({

FILE: packages/workbox-build/src/lib/get-file-size.ts
  function getFileSize (line 13) | function getFileSize(file: string): number | null {

FILE: packages/workbox-build/src/lib/get-source-map-url.ts
  function getSourceMapURL (line 29) | function getSourceMapURL(srcContents: string): string | null {

FILE: packages/workbox-build/src/lib/get-string-details.ts
  function getStringDetails (line 12) | function getStringDetails(url: string, str: string): FileDetails {

FILE: packages/workbox-build/src/lib/get-string-hash.ts
  function getStringHash (line 11) | function getStringHash(input: crypto.BinaryLike): string {

FILE: packages/workbox-build/src/lib/maximum-size-transform.ts
  function maximumSizeTransform (line 13) | function maximumSizeTransform(

FILE: packages/workbox-build/src/lib/modify-url-prefix-transform.ts
  function modifyURLPrefixTransform (line 13) | function modifyURLPrefixTransform(modifyURLPrefix: {

FILE: packages/workbox-build/src/lib/module-registry.ts
  class ModuleRegistry (line 18) | class ModuleRegistry {
    method constructor (line 23) | constructor() {
    method getImportStatements (line 32) | getImportStatements(): Array<string> {
    method getLocalName (line 57) | getLocalName(pkg: string, moduleName: string): string {
    method use (line 67) | use(pkg: string, moduleName: string): string {

FILE: packages/workbox-build/src/lib/no-revision-for-urls-matching-transform.ts
  function noRevisionForURLsMatchingTransform (line 12) | function noRevisionForURLsMatchingTransform(

FILE: packages/workbox-build/src/lib/populate-sw-template.ts
  function populateSWTemplate (line 18) | function populateSWTemplate({

FILE: packages/workbox-build/src/lib/rebase-path.ts
  function rebasePath (line 11) | function rebasePath({

FILE: packages/workbox-build/src/lib/replace-and-update-source-map.ts
  function replaceAndUpdateSourceMap (line 30) | async function replaceAndUpdateSourceMap({

FILE: packages/workbox-build/src/lib/runtime-caching-converter.ts
  function getOptionsString (line 27) | function getOptionsString(
  function runtimeCachingConverter (line 166) | function runtimeCachingConverter(

FILE: packages/workbox-build/src/lib/stringify-without-comments.ts
  function stringifyWithoutComments (line 12) | function stringifyWithoutComments(obj: {[key: string]: any}): string {

FILE: packages/workbox-build/src/lib/transform-manifest.ts
  type ManifestTransformResultWithWarnings (line 73) | interface ManifestTransformResultWithWarnings {
  function transformManifest (line 79) | async function transformManifest({

FILE: packages/workbox-build/src/lib/translate-url-to-sourcemap-paths.ts
  function translateURLToSourcemapPaths (line 14) | function translateURLToSourcemapPaths(

FILE: packages/workbox-build/src/lib/validate-options.ts
  type MethodNames (line 23) | type MethodNames =
  constant DEFAULT_EXCLUDE_VALUE (line 34) | const DEFAULT_EXCLUDE_VALUE = [/\.map$/, /^manifest.*\.js$/];
  class WorkboxConfigError (line 36) | class WorkboxConfigError extends Error {
    method constructor (line 37) | constructor(message?: string) {
  function validate (line 45) | function validate<T>(
  function ensureValidManifestTransforms (line 76) | function ensureValidManifestTransforms(
  function ensureValidNavigationPreloadConfig (line 95) | function ensureValidNavigationPreloadConfig(
  function ensureValidCacheExpiration (line 107) | function ensureValidCacheExpiration(
  function ensureValidRuntimeCachingOrGlobDirectory (line 120) | function ensureValidRuntimeCachingOrGlobDirectory(
  function ensureValidStringHandler (line 138) | function ensureValidStringHandler(
  function validateGenerateSWOptions (line 165) | function validateGenerateSWOptions(input: unknown): GenerateSWOptions {
  function validateGetManifestOptions (line 178) | function validateGetManifestOptions(input: unknown): GetManifestOptions {
  function validateInjectManifestOptions (line 184) | function validateInjectManifestOptions(
  function validateWebpackGenerateSWOptions (line 197) | function validateWebpackGenerateSWOptions(
  function validateWebpackInjectManifestOptions (line 219) | function validateWebpackInjectManifestOptions(

FILE: packages/workbox-build/src/lib/write-sw-using-default-template.ts
  function writeSWUsingDefaultTemplate (line 17) | async function writeSWUsingDefaultTemplate({

FILE: packages/workbox-build/src/types.ts
  type ManifestEntry (line 12) | interface ManifestEntry {
  type StrategyName (line 18) | type StrategyName =
  type RuntimeCaching (line 25) | interface RuntimeCaching {
  type ManifestTransformResult (line 130) | interface ManifestTransformResult {
  type ManifestTransform (line 135) | type ManifestTransform = (
  type BasePartial (line 140) | interface BasePartial {
  type GeneratePartial (line 192) | interface GeneratePartial {
  type RequiredGlobDirectoryPartial (line 369) | interface RequiredGlobDirectoryPartial {
  type OptionalGlobDirectoryPartial (line 377) | interface OptionalGlobDirectoryPartial {
  type GlobPartial (line 385) | interface GlobPartial {
  type InjectPartial (line 421) | interface InjectPartial {
  type WebpackPartial (line 435) | interface WebpackPartial {
  type RequiredSWDestPartial (line 476) | interface RequiredSWDestPartial {
  type WebpackGenerateSWPartial (line 485) | interface WebpackGenerateSWPartial {
  type WebpackInjectManifestPartial (line 498) | interface WebpackInjectManifestPartial {
  type GenerateSWOptions (line 524) | type GenerateSWOptions = BasePartial &
  type GetManifestOptions (line 530) | type GetManifestOptions = BasePartial &
  type InjectManifestOptions (line 534) | type InjectManifestOptions = BasePartial &
  type WebpackGenerateSWOptions (line 540) | type WebpackGenerateSWOptions = BasePartial &
  type WebpackInjectManifestOptions (line 545) | type WebpackInjectManifestOptions = BasePartial &
  type GetManifestResult (line 550) | interface GetManifestResult {
  type BuildResult (line 557) | type BuildResult = Omit<GetManifestResult, 'manifestEntries'> & {
  type FileDetails (line 564) | interface FileDetails {
  type BuildType (line 573) | type BuildType = 'dev' | 'prod';
  type WorkboxPackageJSON (line 578) | interface WorkboxPackageJSON extends PackageJson {

FILE: packages/workbox-cacheable-response/src/CacheableResponse.ts
  type CacheableResponseOptions (line 15) | interface CacheableResponseOptions {
  class CacheableResponse (line 28) | class CacheableResponse {
    method constructor (line 46) | constructor(config: CacheableResponseOptions = {}) {
    method isResponseCacheable (line 88) | isResponseCacheable(response: Response): boolean {

FILE: packages/workbox-cacheable-response/src/CacheableResponsePlugin.ts
  class CacheableResponsePlugin (line 23) | class CacheableResponsePlugin implements WorkboxPlugin {
    method constructor (line 40) | constructor(config: CacheableResponseOptions) {

FILE: packages/workbox-cli/src/app.ts
  type BuildCommand (line 24) | interface BuildCommand {
  function runBuildCommand (line 35) | async function runBuildCommand({command, config, watch}: BuildCommand) {

FILE: packages/workbox-cli/src/bin.ts
  type SupportedFlags (line 19) | interface SupportedFlags extends meow.AnyFlags {

FILE: packages/workbox-cli/src/lib/cleanup-stack-trace.ts
  function cleanupStackTrace (line 13) | function cleanupStackTrace(error: Error, moduleName: string): string {

FILE: packages/workbox-cli/src/lib/questions/ask-config-location.ts
  function askQuestion (line 29) | function askQuestion(): Promise<Answers> {
  function askConfigLocation (line 33) | async function askConfigLocation(): Promise<string> {

FILE: packages/workbox-cli/src/lib/questions/ask-extensions-to-cache.ts
  function getAllFileExtensions (line 27) | async function getAllFileExtensions(globDirectory: string) {
  function askQuestion (line 55) | async function askQuestion(globDirectory: string): Promise<Answers> {
  function askExtensionsToCache (line 79) | async function askExtensionsToCache(

FILE: packages/workbox-cli/src/lib/questions/ask-questions.ts
  type ConfigWithConfigLocation (line 16) | interface ConfigWithConfigLocation {
  function askQuestions (line 23) | async function askQuestions(

FILE: packages/workbox-cli/src/lib/questions/ask-root-of-web-app.ts
  constant ROOT_PROMPT (line 18) | const ROOT_PROMPT = 'Please enter the path to the root of your web app:';
  function getSubdirectories (line 28) | async function getSubdirectories(): Promise<Array<string>> {
  function askQuestion (line 37) | async function askQuestion(): Promise<{
  function askRootOfWebApp (line 75) | async function askRootOfWebApp(): Promise<string> {

FILE: packages/workbox-cli/src/lib/questions/ask-start_url-query-params.ts
  constant START_URL_QUERY_PARAMS_PROMPT (line 16) | const START_URL_QUERY_PARAMS_PROMPT =
  function askQuestion (line 27) | async function askQuestion(): Promise<{
  function askQueryParametersInStartUrl (line 50) | async function askQueryParametersInStartUrl(

FILE: packages/workbox-cli/src/lib/questions/ask-sw-dest.ts
  function askQuestion (line 23) | function askQuestion(defaultDir: string): Promise<Answers> {
  function askSWDest (line 34) | async function askSWDest(defaultDir = '.'): Promise<string> {

FILE: packages/workbox-cli/src/lib/questions/ask-sw-src.ts
  function askQuestion (line 19) | function askQuestion(): Promise<Answers> {
  function askSWSrc (line 31) | async function askSWSrc(): Promise<string | null> {

FILE: packages/workbox-cli/src/lib/read-config.ts
  function readConfig (line 13) | function readConfig(

FILE: packages/workbox-cli/src/lib/run-wizard.ts
  function runWizard (line 16) | async function runWizard(options = {}): Promise<void> {

FILE: packages/workbox-core/src/_private/Deferred.ts
  class Deferred (line 19) | class Deferred<T> {
    method constructor (line 27) | constructor() {

FILE: packages/workbox-core/src/_private/WorkboxError.ts
  class WorkboxError (line 22) | class WorkboxError extends Error {
    method constructor (line 33) | constructor(errorCode: string, details?: MapLikeObject) {

FILE: packages/workbox-core/src/_private/cacheMatchIgnoreParams.ts
  function stripParams (line 10) | function stripParams(fullURL: string, ignoreParams: string[]) {
  function cacheMatchIgnoreParams (line 30) | async function cacheMatchIgnoreParams(

FILE: packages/workbox-core/src/_private/cacheNames.ts
  type CacheNameDetails (line 13) | interface CacheNameDetails {
  type PartialCacheNameDetails (line 21) | interface PartialCacheNameDetails {
  type CacheNameDetailsProp (line 25) | type CacheNameDetailsProp =

FILE: packages/workbox-core/src/_private/canConstructReadableStream.ts
  function canConstructReadableStream (line 23) | function canConstructReadableStream(): boolean {

FILE: packages/workbox-core/src/_private/canConstructResponseFromBodyStream.ts
  function canConstructResponseFromBodyStream (line 22) | function canConstructResponseFromBodyStream(): boolean {

FILE: packages/workbox-core/src/_private/dontWaitFor.ts
  function dontWaitFor (line 15) | function dontWaitFor(promise: Promise<any>): void {

FILE: packages/workbox-core/src/_private/executeQuotaErrorCallbacks.ts
  function executeQuotaErrorCallbacks (line 20) | async function executeQuotaErrorCallbacks(): Promise<void> {

FILE: packages/workbox-core/src/_private/logger.ts
  type WorkerGlobalScope (line 12) | interface WorkerGlobalScope {
  type Window (line 16) | interface Window {
  type LoggerMethods (line 21) | type LoggerMethods =

FILE: packages/workbox-core/src/_private/resultingClientExists.ts
  constant MAX_RETRY_TIME (line 14) | const MAX_RETRY_TIME = 2000;
  function resultingClientExists (line 26) | async function resultingClientExists(

FILE: packages/workbox-core/src/_private/timeout.ts
  function timeout (line 19) | function timeout(ms: number): Promise<unknown> {

FILE: packages/workbox-core/src/_private/waitUntil.ts
  function waitUntil (line 19) | function waitUntil(

FILE: packages/workbox-core/src/cacheNames.ts
  method googleAnalytics (line 28) | get googleAnalytics(): string {
  method precache (line 31) | get precache(): string {
  method prefix (line 34) | get prefix(): string {
  method runtime (line 37) | get runtime(): string {
  method suffix (line 40) | get suffix(): string {

FILE: packages/workbox-core/src/clientsClaim.ts
  function clientsClaim (line 20) | function clientsClaim(): void {

FILE: packages/workbox-core/src/copyResponse.ts
  function copyResponse (line 33) | async function copyResponse(

FILE: packages/workbox-core/src/models/messages/messages.ts
  type LoggableObject (line 11) | interface LoggableObject {
  type MessageMap (line 14) | interface MessageMap {

FILE: packages/workbox-core/src/models/pluginEvents.ts
  type pluginEvents (line 11) | const enum pluginEvents {

FILE: packages/workbox-core/src/registerQuotaErrorCallback.ts
  function registerQuotaErrorCallback (line 23) | function registerQuotaErrorCallback(callback: Function): void {

FILE: packages/workbox-core/src/setCacheNameDetails.ts
  function setCacheNameDetails (line 31) | function setCacheNameDetails(details: PartialCacheNameDetails): void {

FILE: packages/workbox-core/src/skipWaiting.ts
  function skipWaiting (line 23) | function skipWaiting(): void {

FILE: packages/workbox-core/src/types.ts
  type MapLikeObject (line 11) | interface MapLikeObject {
  type PluginState (line 19) | type PluginState = MapLikeObject;
  type RouteMatchCallbackOptions (line 24) | interface RouteMatchCallbackOptions {
  type RouteMatchCallback (line 42) | interface RouteMatchCallback {
  type RouteHandlerCallbackOptions (line 49) | interface RouteHandlerCallbackOptions {
  type ManualHandlerCallbackOptions (line 59) | interface ManualHandlerCallbackOptions {
  type HandlerCallbackOptions (line 64) | type HandlerCallbackOptions =
  type RouteHandlerCallback (line 76) | interface RouteHandlerCallback {
  type ManualHandlerCallback (line 88) | interface ManualHandlerCallback {
  type RouteHandlerObject (line 99) | interface RouteHandlerObject {
  type RouteHandler (line 107) | type RouteHandler = RouteHandlerCallback | RouteHandlerObject;
  type HandlerWillStartCallbackParam (line 109) | interface HandlerWillStartCallbackParam {
  type HandlerWillStartCallback (line 115) | interface HandlerWillStartCallback {
  type CacheDidUpdateCallbackParam (line 119) | interface CacheDidUpdateCallbackParam {
  type CacheDidUpdateCallback (line 128) | interface CacheDidUpdateCallback {
  type CacheKeyWillBeUsedCallbackParam (line 132) | interface CacheKeyWillBeUsedCallbackParam {
  type CacheKeyWillBeUsedCallback (line 140) | interface CacheKeyWillBeUsedCallback {
  type CacheWillUpdateCallbackParam (line 144) | interface CacheWillUpdateCallbackParam {
  type CacheWillUpdateCallback (line 151) | interface CacheWillUpdateCallback {
  type CachedResponseWillBeUsedCallbackParam (line 157) | interface CachedResponseWillBeUsedCallbackParam {
  type CachedResponseWillBeUsedCallback (line 166) | interface CachedResponseWillBeUsedCallback {
  type FetchDidFailCallbackParam (line 172) | interface FetchDidFailCallbackParam {
  type FetchDidFailCallback (line 180) | interface FetchDidFailCallback {
  type FetchDidSucceedCallbackParam (line 184) | interface FetchDidSucceedCallbackParam {
  type FetchDidSucceedCallback (line 191) | interface FetchDidSucceedCallback {
  type RequestWillFetchCallbackParam (line 195) | interface RequestWillFetchCallbackParam {
  type RequestWillFetchCallback (line 201) | interface RequestWillFetchCallback {
  type HandlerWillRespondCallbackParam (line 205) | interface HandlerWillRespondCallbackParam {
  type HandlerWillRespondCallback (line 212) | interface HandlerWillRespondCallback {
  type HandlerDidErrorCallbackParam (line 216) | interface HandlerDidErrorCallbackParam {
  type HandlerDidErrorCallback (line 223) | interface HandlerDidErrorCallback {
  type HandlerDidRespondCallbackParam (line 227) | interface HandlerDidRespondCallbackParam {
  type HandlerDidRespondCallback (line 234) | interface HandlerDidRespondCallback {
  type HandlerDidCompleteCallbackParam (line 238) | interface HandlerDidCompleteCallbackParam {
  type HandlerDidCompleteCallback (line 246) | interface HandlerDidCompleteCallback {
  type WorkboxPlugin (line 254) | interface WorkboxPlugin {
  type WorkboxPluginCallbackParam (line 269) | interface WorkboxPluginCallbackParam {

FILE: packages/workbox-expiration/src/CacheExpiration.ts
  type CacheExpirationConfig (line 18) | interface CacheExpirationConfig {
  class CacheExpiration (line 31) | class CacheExpiration {
    method constructor (line 53) | constructor(cacheName: string, config: CacheExpirationConfig = {}) {
    method expireEntries (line 99) | async expireEntries(): Promise<void> {
    method updateTimestamp (line 153) | async updateTimestamp(url: string): Promise<void> {
    method isURLExpired (line 177) | async isURLExpired(url: string): Promise<boolean> {
    method delete (line 197) | async delete(): Promise<void> {

FILE: packages/workbox-expiration/src/ExpirationPlugin.ts
  type ExpirationPluginOptions (line 22) | interface ExpirationPluginOptions {
  class ExpirationPlugin (line 52) | class ExpirationPlugin implements WorkboxPlugin {
    method constructor (line 68) | constructor(config: ExpirationPluginOptions = {}) {
    method _getCacheExpiration (line 115) | private _getCacheExpiration(cacheName: string): CacheExpiration {
    method _isResponseDateFresh (line 191) | private _isResponseDateFresh(cachedResponse: Response): boolean {
    method _getDateHeaderTimestamp (line 221) | private _getDateHeaderTimestamp(cachedResponse: Response): number | nu...
    method deleteCacheAndMetadata (line 289) | async deleteCacheAndMetadata(): Promise<void> {

FILE: packages/workbox-expiration/src/models/CacheTimestampsModel.ts
  constant DB_NAME (line 12) | const DB_NAME = 'workbox-expiration';
  constant CACHE_OBJECT_STORE (line 13) | const CACHE_OBJECT_STORE = 'cache-entries';
  type CacheTimestampsModelEntry (line 22) | interface CacheTimestampsModelEntry {
  type CacheDbSchema (line 29) | interface CacheDbSchema extends DBSchema {
  class CacheTimestampsModel (line 42) | class CacheTimestampsModel {
    method constructor (line 52) | constructor(cacheName: string) {
    method _upgradeDb (line 63) | private _upgradeDb(db: IDBPDatabase<CacheDbSchema>) {
    method _upgradeDbAndDeleteOldDbs (line 84) | private _upgradeDbAndDeleteOldDbs(db: IDBPDatabase<CacheDbSchema>) {
    method setTimestamp (line 97) | async setTimestamp(url: string, timestamp: number): Promise<void> {
    method getTimestamp (line 125) | async getTimestamp(url: string): Promise<number | undefined> {
    method expireEntries (line 142) | async expireEntries(
    method _getId (line 202) | private _getId(url: string): string {
    method getDb (line 214) | private async getDb() {

FILE: packages/workbox-google-analytics/src/initialize.ts
  type GoogleAnalyticsInitializeOptions (line 31) | interface GoogleAnalyticsInitializeOptions {

FILE: packages/workbox-google-analytics/src/utils/constants.ts
  constant QUEUE_NAME (line 11) | const QUEUE_NAME = 'workbox-google-analytics';
  constant MAX_RETENTION_TIME (line 12) | const MAX_RETENTION_TIME = 60 * 48;
  constant GOOGLE_ANALYTICS_HOST (line 13) | const GOOGLE_ANALYTICS_HOST = 'www.google-analytics.com';
  constant GTM_HOST (line 14) | const GTM_HOST = 'www.googletagmanager.com';
  constant ANALYTICS_JS_PATH (line 15) | const ANALYTICS_JS_PATH = '/analytics.js';
  constant GTAG_JS_PATH (line 16) | const GTAG_JS_PATH = '/gtag/js';
  constant GTM_JS_PATH (line 17) | const GTM_JS_PATH = '/gtm.js';
  constant COLLECT_DEFAULT_PATH (line 18) | const COLLECT_DEFAULT_PATH = '/collect';
  constant COLLECT_PATHS_REGEX (line 24) | const COLLECT_PATHS_REGEX = /^\/(\w+\/)?collect/;

FILE: packages/workbox-navigation-preload/src/disable.ts
  function disable (line 21) | function disable(): void {

FILE: packages/workbox-navigation-preload/src/enable.ts
  function enable (line 26) | function enable(headerValue?: string): void {

FILE: packages/workbox-navigation-preload/src/index.ts
  type NavigationPreloadState (line 15) | interface NavigationPreloadState {
  type NavigationPreloadManager (line 20) | interface NavigationPreloadManager {
  type ServiceWorkerRegistration (line 28) | interface ServiceWorkerRegistration {

FILE: packages/workbox-navigation-preload/src/isSupported.ts
  function isSupported (line 20) | function isSupported(): boolean {

FILE: packages/workbox-precaching/src/PrecacheController.ts
  type ServiceWorkerGlobalScope (line 30) | interface ServiceWorkerGlobalScope {
  type PrecacheControllerOptions (line 35) | interface PrecacheControllerOptions {
  class PrecacheController (line 46) | class PrecacheController {
    method constructor (line 71) | constructor({
    method strategy (line 94) | get strategy(): Strategy {
    method precache (line 108) | precache(entries: Array<PrecacheEntry | string>): void {
    method addToCacheList (line 125) | addToCacheList(entries: Array<PrecacheEntry | string>): void {
    method install (line 199) | install(event: ExtendableEvent): Promise<InstallResult> {
    method activate (line 247) | activate(event: ExtendableEvent): Promise<CleanupResult> {
    method getURLsToCacheKeys (line 277) | getURLsToCacheKeys(): Map<string, string> {
    method getCachedURLs (line 287) | getCachedURLs(): Array<string> {
    method getCacheKeyForURL (line 300) | getCacheKeyForURL(url: string): string | undefined {
    method getIntegrityForCacheKey (line 310) | getIntegrityForCacheKey(cacheKey: string): string | undefined {
    method matchPrecache (line 332) | async matchPrecache(
    method createHandlerBoundToURL (line 352) | createHandlerBoundToURL(url: string): RouteHandlerCallback {

FILE: packages/workbox-precaching/src/PrecacheFallbackPlugin.ts
  class PrecacheFallbackPlugin (line 30) | class PrecacheFallbackPlugin implements WorkboxPlugin {
    method constructor (line 44) | constructor({

FILE: packages/workbox-precaching/src/PrecacheRoute.ts
  class PrecacheRoute (line 32) | class PrecacheRoute extends Route {
    method constructor (line 49) | constructor(

FILE: packages/workbox-precaching/src/PrecacheStrategy.ts
  type PrecacheStrategyOptions (line 20) | interface PrecacheStrategyOptions extends StrategyOptions {
  class PrecacheStrategy (line 36) | class PrecacheStrategy extends Strategy {
    method cacheWillUpdate (line 40) | async cacheWillUpdate({response}) {
    method cacheWillUpdate (line 50) | async cacheWillUpdate({response}) {
    method constructor (line 72) | constructor(options: PrecacheStrategyOptions = {}) {
    method _handle (line 93) | async _handle(request: Request, handler: StrategyHandler): Promise<Res...
    method _handleFetch (line 110) | async _handleFetch(
    method _handleInstall (line 207) | async _handleInstall(
    method _useDefaultCacheabilityPluginIfNeeded (line 257) | _useDefaultCacheabilityPluginIfNeeded(): void {

FILE: packages/workbox-precaching/src/_types.ts
  type InstallResult (line 11) | interface InstallResult {
  type CleanupResult (line 16) | interface CleanupResult {
  type PrecacheEntry (line 20) | interface PrecacheEntry {
  type PrecacheRouteOptions (line 26) | interface PrecacheRouteOptions {
  type urlManipulation (line 33) | type urlManipulation = ({url}: {url: URL}) => URL[];

FILE: packages/workbox-precaching/src/addPlugins.ts
  function addPlugins (line 20) | function addPlugins(plugins: WorkboxPlugin[]): void {

FILE: packages/workbox-precaching/src/addRoute.ts
  function addRoute (line 31) | function addRoute(options?: PrecacheRouteOptions): void {

FILE: packages/workbox-precaching/src/cleanupOutdatedCaches.ts
  function cleanupOutdatedCaches (line 20) | function cleanupOutdatedCaches(): void {

FILE: packages/workbox-precaching/src/createHandlerBoundToURL.ts
  function createHandlerBoundToURL (line 30) | function createHandlerBoundToURL(url: string): RouteHandlerCallback {

FILE: packages/workbox-precaching/src/getCacheKeyForURL.ts
  function getCacheKeyForURL (line 31) | function getCacheKeyForURL(url: string): string | undefined {

FILE: packages/workbox-precaching/src/matchPrecache.ts
  function matchPrecache (line 28) | function matchPrecache(

FILE: packages/workbox-precaching/src/precache.ts
  function precache (line 32) | function precache(entries: Array<PrecacheEntry | string>): void {

FILE: packages/workbox-precaching/src/precacheAndRoute.ts
  function precacheAndRoute (line 28) | function precacheAndRoute(

FILE: packages/workbox-precaching/src/utils/PrecacheCacheKeyPlugin.ts
  class PrecacheCacheKeyPlugin (line 21) | class PrecacheCacheKeyPlugin implements WorkboxPlugin {
    method constructor (line 24) | constructor({precacheController}: {precacheController: PrecacheControl...

FILE: packages/workbox-precaching/src/utils/PrecacheInstallReportPlugin.ts
  class PrecacheInstallReportPlugin (line 19) | class PrecacheInstallReportPlugin implements WorkboxPlugin {

FILE: packages/workbox-precaching/src/utils/createCacheKey.ts
  type CacheKey (line 13) | interface CacheKey {
  constant REVISION_SEARCH_PARAM (line 19) | const REVISION_SEARCH_PARAM = '__WB_REVISION__';
  function createCacheKey (line 30) | function createCacheKey(entry: PrecacheEntry | string): CacheKey {

FILE: packages/workbox-precaching/src/utils/deleteOutdatedCaches.ts
  constant SUBSTRING_TO_FIND (line 14) | const SUBSTRING_TO_FIND = '-precache-';

FILE: packages/workbox-precaching/src/utils/printCleanupDetails.ts
  function printCleanupDetails (line 34) | function printCleanupDetails(deletedURLs: string[]): void {

FILE: packages/workbox-precaching/src/utils/printInstallDetails.ts
  function _nestedGroup (line 18) | function _nestedGroup(groupTitle: string, urls: string[]): void {
  function printInstallDetails (line 39) | function printInstallDetails(

FILE: packages/workbox-precaching/src/utils/removeIgnoredSearchParams.ts
  function removeIgnoredSearchParams (line 23) | function removeIgnoredSearchParams(

FILE: packages/workbox-range-requests/src/RangeRequestsPlugin.ts
  class RangeRequestsPlugin (line 22) | class RangeRequestsPlugin implements WorkboxPlugin {

FILE: packages/workbox-range-requests/src/createPartialResponse.ts
  function createPartialResponse (line 34) | async function createPartialResponse(

FILE: packages/workbox-range-requests/src/utils/calculateEffectiveBoundaries.ts
  function calculateEffectiveBoundaries (line 23) | function calculateEffectiveBoundaries(

FILE: packages/workbox-range-requests/src/utils/parseRangeHeader.ts
  function parseRangeHeader (line 21) | function parseRangeHeader(rangeHeader: string): {start?: number; end?: n...

FILE: packages/workbox-recipes/src/googleFontsCache.ts
  type GoogleFontCacheOptions (line 16) | interface GoogleFontCacheOptions {
  function googleFontsCache (line 32) | function googleFontsCache(options: GoogleFontCacheOptions = {}): void {

FILE: packages/workbox-recipes/src/imageCache.ts
  type ImageCacheOptions (line 21) | interface ImageCacheOptions {
  function imageCache (line 43) | function imageCache(options: ImageCacheOptions = {}): void {

FILE: packages/workbox-recipes/src/offlineFallback.ts
  type OfflineFallbackOptions (line 14) | interface OfflineFallbackOptions {
  function offlineFallback (line 33) | function offlineFallback(options: OfflineFallbackOptions = {}): void {

FILE: packages/workbox-recipes/src/pageCache.ts
  type PageCacheOptions (line 20) | interface PageCacheOptions {
  function pageCache (line 40) | function pageCache(options: PageCacheOptions = {}): void {

FILE: packages/workbox-recipes/src/staticResourceCache.ts
  type StaticResourceOptions (line 20) | interface StaticResourceOptions {
  function staticResourceCache (line 38) | function staticResourceCache(options: StaticResourceOptions = {}): void {

FILE: packages/workbox-recipes/src/warmStrategyCache.ts
  type WarmStrategyCacheOptions (line 5) | interface WarmStrategyCacheOptions {
  function warmStrategyCache (line 20) | function warmStrategyCache(options: WarmStrategyCacheOptions): void {

FILE: packages/workbox-routing/src/NavigationRoute.ts
  type NavigationRouteMatchOptions (line 17) | interface NavigationRouteMatchOptions {
  class NavigationRoute (line 37) | class NavigationRoute extends Route {
    method constructor (line 65) | constructor(
    method _match (line 103) | private _match({url, request}: RouteMatchCallbackOptions): boolean {

FILE: packages/workbox-routing/src/RegExpRoute.ts
  class RegExpRoute (line 33) | class RegExpRoute extends Route {
    method constructor (line 47) | constructor(regExp: RegExp, handler: RouteHandler, method?: HTTPMethod) {

FILE: packages/workbox-routing/src/Route.ts
  class Route (line 28) | class Route {
    method constructor (line 45) | constructor(
    method setCatchHandler (line 75) | setCatchHandler(handler: RouteHandler): void {

FILE: packages/workbox-routing/src/Router.ts
  type RequestArgs (line 25) | type RequestArgs = string | [string, RequestInit?];
  type CacheURLsMessageData (line 27) | interface CacheURLsMessageData {
  class Router (line 51) | class Router {
    method constructor (line 59) | constructor() {
    method routes (line 69) | get routes(): Map<HTTPMethod, Route[]> {
    method addFetchListener (line 77) | addFetchListener(): void {
    method addCacheListener (line 110) | addCacheListener(): void {
    method handleRequest (line 160) | handleRequest({
    method findMatchingRoute (line 328) | findMatchingRoute({
    method setDefaultHandler (line 398) | setDefaultHandler(
    method setCatchHandler (line 412) | setCatchHandler(handler: RouteHandler): void {
    method registerRoute (line 421) | registerRoute(route: Route): void {
    method unregisterRoute (line 473) | unregisterRoute(route: Route): void {

FILE: packages/workbox-routing/src/registerRoute.ts
  function registerRoute (line 38) | function registerRoute(

FILE: packages/workbox-routing/src/setCatchHandler.ts
  function setCatchHandler (line 24) | function setCatchHandler(handler: RouteHandler): void {

FILE: packages/workbox-routing/src/setDefaultHandler.ts
  function setDefaultHandler (line 27) | function setDefaultHandler(handler: RouteHandler): void {

FILE: packages/workbox-routing/src/utils/constants.ts
  type HTTPMethod (line 11) | type HTTPMethod = 'DELETE' | 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT';

FILE: packages/workbox-strategies/src/CacheFirst.ts
  class CacheFirst (line 32) | class CacheFirst extends Strategy {
    method _handle (line 40) | async _handle(request: Request, handler: StrategyHandler): Promise<Res...

FILE: packages/workbox-strategies/src/CacheOnly.ts
  class CacheOnly (line 30) | class CacheOnly extends Strategy {
    method _handle (line 38) | async _handle(request: Request, handler: StrategyHandler): Promise<Res...

FILE: packages/workbox-strategies/src/NetworkFirst.ts
  type NetworkFirstOptions (line 19) | interface NetworkFirstOptions extends StrategyOptions {
  class NetworkFirst (line 39) | class NetworkFirst extends Strategy {
    method constructor (line 61) | constructor(options: NetworkFirstOptions = {}) {
    method _handle (line 90) | async _handle(request: Request, handler: StrategyHandler): Promise<Res...
    method _getTimeoutPromise (line 161) | private _getTimeoutPromise({
    method _getNetworkPromise (line 205) | async _getNetworkPromise({

FILE: packages/workbox-strategies/src/NetworkOnly.ts
  type NetworkOnlyOptions (line 19) | interface NetworkOnlyOptions
  class NetworkOnly (line 37) | class NetworkOnly extends Strategy {
    method constructor (line 51) | constructor(options: NetworkOnlyOptions = {}) {
    method _handle (line 64) | async _handle(request: Request, handler: StrategyHandler): Promise<Res...

FILE: packages/workbox-strategies/src/StaleWhileRevalidate.ts
  class StaleWhileRevalidate (line 40) | class StaleWhileRevalidate extends Strategy {
    method constructor (line 54) | constructor(options: StrategyOptions = {}) {
    method _handle (line 71) | async _handle(request: Request, handler: StrategyHandler): Promise<Res...

FILE: packages/workbox-strategies/src/Strategy.ts
  type StrategyOptions (line 23) | interface StrategyOptions {
  method constructor (line 68) | constructor(options: StrategyOptions = {}) {
  method handle (line 122) | handle(options: FetchEvent | HandlerCallbackOptions): Promise<Response> {
  method handleAll (line 149) | handleAll(
  method _getResponse (line 181) | async _getResponse(
  method _awaitComplete (line 227) | async _awaitComplete(

FILE: packages/workbox-strategies/src/StrategyHandler.ts
  function toRequest (line 27) | function toRequest(input: RequestInfo) {
  class StrategyHandler (line 40) | class StrategyHandler {
    method constructor (line 70) | constructor(strategy: Strategy, options: HandlerCallbackOptions) {
    method fetch (line 148) | async fetch(input: RequestInfo): Promise<Response> {
    method fetchAndCachePut (line 253) | async fetchAndCachePut(input: RequestInfo): Promise<Response> {
    method cacheMatch (line 274) | async cacheMatch(key: RequestInfo): Promise<Response | undefined> {
    method cachePut (line 320) | async cachePut(key: RequestInfo, response: Response): Promise<boolean> {
    method getCacheKey (line 437) | async getCacheKey(
    method hasCallback (line 469) | hasCallback<C extends keyof WorkboxPlugin>(name: C): boolean {
    method runCallbacks (line 494) | async runCallbacks<C extends keyof NonNullable<WorkboxPlugin>>(
    method iterateCallbacks (line 514) | *iterateCallbacks<C extends keyof WorkboxPlugin>(
    method waitUntil (line 547) | waitUntil<T>(promise: Promise<T>): Promise<T> {
    method doneWaiting (line 562) | async doneWaiting(): Promise<void> {
    method destroy (line 577) | destroy(): void {
    method _ensureResponseSafeToCache (line 591) | async _ensureResponseSafeToCache(

FILE: packages/workbox-strategies/src/index.ts
  type FetchEvent (line 20) | interface FetchEvent {

FILE: packages/workbox-streams/src/_types.ts
  type StreamSource (line 11) | type StreamSource = Response | ReadableStream | BodyInit;

FILE: packages/workbox-streams/src/concatenate.ts
  function _getReaderFromSource (line 26) | function _getReaderFromSource(
  function concatenate (line 55) | function concatenate(sourcePromises: Promise<StreamSource>[]): {

FILE: packages/workbox-streams/src/concatenateToResponse.ts
  function concatenateToResponse (line 31) | function concatenateToResponse(

FILE: packages/workbox-streams/src/isSupported.ts
  function isSupported (line 23) | function isSupported(): boolean {

FILE: packages/workbox-streams/src/strategy.ts
  type StreamsHandlerCallback (line 20) | interface StreamsHandlerCallback {
  function strategy (line 42) | function strategy(

FILE: packages/workbox-streams/src/utils/createHeaders.ts
  function createHeaders (line 25) | function createHeaders(headersInit = {}): Headers {

FILE: packages/workbox-sw/controllers/WorkboxSW.mjs
  constant CDN_PATH (line 11) | const CDN_PATH = `WORKBOX_CDN_ROOT_URL`;
  constant MODULE_KEY_TO_NAME_MAPPING (line 13) | const MODULE_KEY_TO_NAME_MAPPING = {
  class WorkboxSW (line 100) | class WorkboxSW {
    method constructor (line 106) | constructor() {
    method setConfig (line 150) | setConfig(options = {}) {
    method loadModule (line 170) | loadModule(moduleName) {
    method _getImportPath (line 194) | _getImportPath(moduleName) {

FILE: packages/workbox-webpack-plugin/src/generate-sw.ts
  type GenerateSWConfig (line 27) | interface GenerateSWConfig extends WebpackGenerateSWOptions {
  class GenerateSW (line 71) | class GenerateSW {
    method constructor (line 78) | constructor(config: GenerateSWConfig = {}) {
    method propagateWebpackConfig (line 88) | propagateWebpackConfig(compiler: webpack.Compiler): void {
    method apply (line 105) | apply(compiler: webpack.Compiler): void {
    method addAssets (line 147) | async addAssets(compilation: webpack.Compilation): Promise<void> {

FILE: packages/workbox-webpack-plugin/src/inject-manifest.ts
  class InjectManifest (line 56) | class InjectManifest {
    method constructor (line 63) | constructor(config: WebpackInjectManifestOptions) {
    method propagateWebpackConfig (line 73) | propagateWebpackConfig(compiler: webpack.Compiler): void {
    method apply (line 91) | apply(compiler: webpack.Compiler): void {
    method performChildCompilation (line 142) | async performChildCompilation(
    method addSrcToAssets (line 200) | addSrcToAssets(
    method handleMake (line 217) | async handleMake(
    method addAssets (line 260) | async addAssets(compilation: webpack.Compilation): Promise<void> {

FILE: packages/workbox-webpack-plugin/src/lib/get-asset-hash.ts
  function getAssetHash (line 18) | function getAssetHash(asset: Asset): string | null {

FILE: packages/workbox-webpack-plugin/src/lib/get-manifest-entries-from-compilation.ts
  function checkConditions (line 38) | function checkConditions(
  function getNamesOfAssetsInChunkOrGroup (line 73) | function getNamesOfAssetsInChunkOrGroup(
  function getNamesOfAssetsInChunk (line 105) | function getNamesOfAssetsInChunk(chunk: Chunk): Array<string> {
  function filterAssets (line 129) | function filterAssets(
  function getManifestEntriesFromCompilation (line 215) | async function getManifestEntriesFromCompilation(

FILE: packages/workbox-webpack-plugin/src/lib/get-script-files-for-chunks.ts
  function getScriptFilesForChunks (line 14) | function getScriptFilesForChunks(

FILE: packages/workbox-webpack-plugin/src/lib/get-sourcemap-asset-name.ts
  function getSourcemapAssetName (line 31) | function getSourcemapAssetName(

FILE: packages/workbox-webpack-plugin/src/lib/relative-to-output-path.ts
  function relativeToOutputPath (line 21) | function relativeToOutputPath(

FILE: packages/workbox-webpack-plugin/src/lib/resolve-webpack-url.ts
  function resolveWebpackURL (line 22) | function resolveWebpackURL(

FILE: packages/workbox-window/src/Workbox.ts
  constant WAITING_TIMEOUT_DURATION (line 24) | const WAITING_TIMEOUT_DURATION = 200;
  constant REGISTRATION_TIMEOUT_DURATION (line 28) | const REGISTRATION_TIMEOUT_DURATION = 60000;
  constant SKIP_WAITING_MESSAGE (line 32) | const SKIP_WAITING_MESSAGE = {type: 'SKIP_WAITING'};
  class Workbox (line 46) | class Workbox extends WorkboxEventTarget {
    method constructor (line 78) | constructor(scriptURL: string | TrustedScriptURL, registerOptions: {} ...
    method register (line 100) | async register({immediate = false} = {}): Promise<
    method update (line 231) | async update(): Promise<void> {
    method active (line 255) | get active(): Promise<ServiceWorker> {
    method controlling (line 271) | get controlling(): Promise<ServiceWorker> {
    method getSW (line 290) | getSW(): Promise<ServiceWorker> {
    method messageSW (line 313) | async messageSW(data: object): Promise<any> {
    method messageSkipWaiting (line 325) | messageSkipWaiting(): void {
    method _getControllingSWIfCompatible (line 338) | private _getControllingSWIfCompatible() {
    method _registerScript (line 356) | private async _registerScript() {

FILE: packages/workbox-window/src/messageSW.ts
  function messageSW (line 27) | function messageSW(sw: ServiceWorker, data: {}): Promise<any> {

FILE: packages/workbox-window/src/utils/WorkboxEvent.ts
  class WorkboxEvent (line 18) | class WorkboxEvent<K extends keyof WorkboxEventMap> {
    method constructor (line 24) | constructor(
  type WorkboxMessageEvent (line 32) | interface WorkboxMessageEvent extends WorkboxEvent<'message'> {
  type WorkboxLifecycleEvent (line 38) | interface WorkboxLifecycleEvent
  type WorkboxLifecycleWaitingEvent (line 43) | interface WorkboxLifecycleWaitingEvent extends WorkboxLifecycleEvent {
  type WorkboxLifecycleEventMap (line 47) | interface WorkboxLifecycleEventMap {
  type WorkboxEventMap (line 57) | interface WorkboxEventMap extends WorkboxLifecycleEventMap {

FILE: packages/workbox-window/src/utils/WorkboxEventTarget.ts
  type ListenerCallback (line 11) | type ListenerCallback = (event: WorkboxEvent<any>) => any;
  class WorkboxEventTarget (line 19) | class WorkboxEventTarget {
    method addEventListener (line 30) | addEventListener<K extends keyof WorkboxEventMap>(
    method removeEventListener (line 43) | removeEventListener<K extends keyof WorkboxEventMap>(
    method dispatchEvent (line 54) | dispatchEvent(event: WorkboxEvent<any>): void {
    method _getEventListenersByType (line 71) | private _getEventListenersByType(type: keyof WorkboxEventMap) {

FILE: packages/workbox-window/src/utils/urlsMatch.ts
  function urlsMatch (line 20) | function urlsMatch(url1: string, url2: string): boolean {

FILE: test/workbox-background-sync/sw/lib/test-QueueDb.mjs
  method blocked (line 126) | blocked() {
  method upgrade (line 136) | upgrade(db) {
  method blocked (line 180) | blocked() {
  method blocked (line 198) | blocked() {
  method upgrade (line 208) | upgrade(db) {
  method blocked (line 247) | blocked() {
  method blocked (line 265) | blocked() {

FILE: test/workbox-background-sync/sw/test-BackgroundSyncPlugin.mjs
  function getUniqueQueueName (line 13) | function getUniqueQueueName() {

FILE: test/workbox-background-sync/sw/test-Queue.mjs
  constant MINUTES (line 16) | const MINUTES = 60 * 1000;

FILE: test/workbox-build/node/lib/additional-manifest-entries-transform.js
  function getManifest (line 17) | function getManifest() {

FILE: test/workbox-build/node/lib/modify-url-prefix-transform.js
  function getManifest (line 17) | function getManifest() {

FILE: test/workbox-build/node/lib/runtime-caching-converter.js
  function validate (line 30) | function validate(runtimeCachingOptions, convertedOptions) {

FILE: test/workbox-build/node/lib/validate-options.js
  class AJVFailsValidation (line 13) | class AJVFailsValidation {
    method compile (line 14) | compile() {
    method addKeyword (line 19) | addKeyword() {
  class AJVPassesValidation (line 24) | class AJVPassesValidation {
    method compile (line 25) | compile() {
    method addKeyword (line 28) | addKeyword() {

FILE: test/workbox-cli/node/lib/questions/ask-config-location.js
  constant MODULE_PATH (line 16) | const MODULE_PATH =
  constant QUESTION_NAME (line 20) | const QUESTION_NAME = 'configLocation';

FILE: test/workbox-cli/node/lib/questions/ask-extensions-to-cache.js
  constant MODULE_PATH (line 16) | const MODULE_PATH =
  constant QUESTION_NAME (line 20) | const QUESTION_NAME = 'globPatterns';
  constant GLOB_DIRECTORY (line 21) | const GLOB_DIRECTORY = '/path/to/fake';
  constant SINGLE_EXTENSION (line 22) | const SINGLE_EXTENSION = 'js';
  constant MULTIPLE_EXTENSIONS (line 23) | const MULTIPLE_EXTENSIONS = ['html', 'js'];

FILE: test/workbox-cli/node/lib/questions/ask-questions.js
  constant MODULE_PATH (line 13) | const MODULE_PATH =

FILE: test/workbox-cli/node/lib/questions/ask-root-of-web-app.js
  constant MODULE_PATH (line 16) | const MODULE_PATH =
  constant DIRECTORY (line 22) | const DIRECTORY = '/path/to/directory';
  constant CHILD_DIRECTORY (line 23) | const CHILD_DIRECTORY = '/path/to/directory/child';
  constant CHILD_DIRECTORY_WHITE_SPACE (line 24) | const CHILD_DIRECTORY_WHITE_SPACE = '/path/to/directory/   child';
  constant CHILD_DIRECTORY_BLANK (line 25) | const CHILD_DIRECTORY_BLANK = '  ';

FILE: test/workbox-cli/node/lib/questions/ask-start_url-query-params.js
  constant MODULE_PATH (line 19) | const MODULE_PATH =
  constant DEFAULT_IGNORED_URL_PARAMETERS (line 28) | const DEFAULT_IGNORED_URL_PARAMETERS = constants.ignoreURLParametersMatc...

FILE: test/workbox-cli/node/lib/questions/ask-sw-dest.js
  constant MODULE_PATH (line 16) | const MODULE_PATH =
  constant QUESTION_NAME (line 20) | const QUESTION_NAME = 'swDest';

FILE: test/workbox-cli/node/lib/questions/ask-sw-src.js
  constant MODULE_PATH (line 12) | const MODULE_PATH =
  constant QUESTION_NAME (line 16) | const QUESTION_NAME = 'swSrc';

FILE: test/workbox-cli/node/lib/run-wizard.js
  constant MODULE_PATH (line 14) | const MODULE_PATH = '../../../../packages/workbox-cli/build/lib/run-wiza...

FILE: test/workbox-core/sw/_private/test-assert.mjs
  class TestClass (line 51) | class TestClass {}
  class TestClass (line 67) | class TestClass {}
  class NotTestClass (line 68) | class NotTestClass {}
  class TestClass (line 86) | class TestClass {}
  class Example (line 128) | class Example {}
  class Example (line 142) | class Example {}

FILE: test/workbox-google-analytics/sw/test-initialize.mjs
  constant PAYLOAD (line 25) | const PAYLOAD = 'v=1&t=pageview&tid=UA-12345-1&cid=1&dp=%2F';

FILE: test/workbox-precaching/sw/resetDefaultPrecacheController.mjs
  function resetDefaultPrecacheController (line 11) | function resetDefaultPrecacheController() {

FILE: test/workbox-precaching/sw/test-PrecacheController.mjs
  function createFetchEvent (line 16) | function createFetchEvent(url) {
  class TestPlugin (line 600) | class TestPlugin {
    method cacheWillUpdate (line 601) | cacheWillUpdate({response}) {

FILE: test/workbox-precaching/sw/test-PrecacheRoute.mjs
  function createMatchParams (line 12) | function createMatchParams(path) {

FILE: test/workbox-precaching/sw/test-PrecacheStrategy.mjs
  function createFetchEvent (line 16) | function createFetchEvent(url, requestInit) {

FILE: test/workbox-precaching/sw/test-addRoute.mjs
  function getAddedFetchListeners (line 15) | function getAddedFetchListeners() {

FILE: test/workbox-range-requests/sw/test-createPartialResponse.mjs
  function constructBlob (line 14) | function constructBlob(length) {

FILE: test/workbox-range-requests/sw/utils/test-calculateEffectiveBoundaries.mjs
  function constructBlob (line 12) | function constructBlob(length) {

FILE: test/workbox-strategies/sw/test-Strategy.mjs
  class FetchStrategy (line 13) | class FetchStrategy extends Strategy {
    method _handle (line 14) | _handle(request, handler) {
  class LongWaitUntilStrategy (line 19) | class LongWaitUntilStrategy extends Strategy {
    method _handle (line 20) | _handle(request, handler) {
  class EmptyStrategy (line 26) | class EmptyStrategy extends Strategy {
    method _handle (line 27) | _handle(request, handler) {
  class ErrorStrategy (line 32) | class ErrorStrategy extends Strategy {
    method _handle (line 33) | _handle(request, handler) {
  class HandlerThrowsStrategy (line 39) | class HandlerThrowsStrategy extends Strategy {
    method constructor (line 40) | constructor(options) {
    method _handle (line 44) | async _handle(request, handler) {
  class HandlerReturnsUndefinedStrategy (line 49) | class HandlerReturnsUndefinedStrategy extends Strategy {
    method _handle (line 50) | async _handle(request, handler) {
  class HandlerReturnsResponseErrorStrategy (line 55) | class HandlerReturnsResponseErrorStrategy extends Strategy {
    method _handle (line 56) | async _handle(request, handler) {
  class ExtendingStrategy (line 61) | class ExtendingStrategy extends FetchStrategy {
    method constructor (line 62) | constructor(options) {
    method _handle (line 66) | async _handle(request, handler) {
  function generateOptions (line 75) | function generateOptions() {
  method handlerWillStart (line 106) | handlerWillStart() {}
  method handlerWillStart (line 126) | handlerWillStart() {}

FILE: test/workbox-strategies/sw/test-StrategyHandler.mjs
  class TestStrategy (line 21) | class TestStrategy extends Strategy {
    method _handle (line 22) | _handle() {
  method handlerWillStart (line 1245) | handlerWillStart({event, request}) {
  method handlerWillStart (line 1253) | handlerWillStart({event, request}) {
  method cacheKeyWillBeUsed (line 1274) | cacheKeyWillBeUsed({mode, request}) {
  method cacheKeyWillBeUsed (line 1279) | cacheKeyWillBeUsed({mode, request}) {
  method cacheKeyWillBeUsed (line 1286) | cacheKeyWillBeUsed({mode, request}) {
  method cacheKeyWillBeUsed (line 1305) | cacheKeyWillBeUsed({mode, request}) {

FILE: test/workbox-streams/sw/test-isSupported.mjs
  method start (line 14) | start() {}

FILE: test/workbox-webpack-plugin/node/v4/lib/create-webpack-asset-plugin.js
  class CreateWebpackAssetPlugin (line 13) | class CreateWebpackAssetPlugin {
    method constructor (line 14) | constructor(name) {
    method apply (line 21) | apply(compiler) {

FILE: test/workbox-webpack-plugin/node/v5/lib/create-webpack-asset-plugin.js
  class CreateWebpackAssetPlugin (line 11) | class CreateWebpackAssetPlugin {
    method constructor (line 12) | constructor(name) {
    method apply (line 19) | apply(compiler) {