this.workbox=this.workbox||{};this.workbox.core=(function(exports){'use strict';try{self['workbox:core:4.3.1']&&_();}catch(e){}
const logger=(()=>{let inGroup=false;const methodToColorMap={debug:`#7f8c8d`,log:`#2ecc71`,warn:`#f39c12`,error:`#c0392b`,groupCollapsed:`#3498db`,groupEnd:null};const print=function(method,args){if(method==='groupCollapsed'){if(/^((?!chrome|android).)*safari/i.test(navigator.userAgent)){console[method](...args);return;}}
const styles=[`background: ${methodToColorMap[method]}`,`border-radius: 0.5em`,`color: white`,`font-weight: bold`,`padding: 2px 0.5em`];const logPrefix=inGroup?[]:['%cworkbox',styles.join(';')];console[method](...logPrefix,...args);if(method==='groupCollapsed'){inGroup=true;}
if(method==='groupEnd'){inGroup=false;}};const api={};for(const method of Object.keys(methodToColorMap)){api[method]=(...args)=>{print(method,args);};}
return api;})();const messages={'invalid-value':({paramName,validValueDescription,value})=>{if(!paramName||!validValueDescription){throw new Error(`Unexpected input to 'invalid-value' error.`);}
return`The '${paramName}' parameter was given a value with an `+`unexpected value. ${validValueDescription} Received a value of `+`${JSON.stringify(value)}.`;},'not-in-sw':({moduleName})=>{if(!moduleName){throw new Error(`Unexpected input to 'not-in-sw' error.`);}
return`The '${moduleName}' must be used in a service worker.`;},'not-an-array':({moduleName,className,funcName,paramName})=>{if(!moduleName||!className||!funcName||!paramName){throw new Error(`Unexpected input to 'not-an-array' error.`);}
return`The parameter '${paramName}' passed into `+`'${moduleName}.${className}.${funcName}()' must be an array.`;},'incorrect-type':({expectedType,paramName,moduleName,className,funcName})=>{if(!expectedType||!paramName||!moduleName||!funcName){throw new Error(`Unexpected input to 'incorrect-type' error.`);}
return`The parameter '${paramName}' passed into `+`'${moduleName}.${className ? className + '.' : ''}`+`${funcName}()' must be of type ${expectedType}.`;},'incorrect-class':({expectedClass,paramName,moduleName,className,funcName,isReturnValueProblem})=>{if(!expectedClass||!moduleName||!funcName){throw new Error(`Unexpected input to 'incorrect-class' error.`);}
if(isReturnValueProblem){return`The return value from `+`'${moduleName}.${className ? className + '.' : ''}${funcName}()' `+`must be an instance of class ${expectedClass.name}.`;}
return`The parameter '${paramName}' passed into `+`'${moduleName}.${className ? className + '.' : ''}${funcName}()' `+`must be an instance of class ${expectedClass.name}.`;},'missing-a-method':({expectedMethod,paramName,moduleName,className,funcName})=>{if(!expectedMethod||!paramName||!moduleName||!className||!funcName){throw new Error(`Unexpected input to 'missing-a-method' error.`);}
return`${moduleName}.${className}.${funcName}() expected the `+`'${paramName}' parameter to expose a '${expectedMethod}' method.`;},'add-to-cache-list-unexpected-type':({entry})=>{return`An unexpected entry was passed to `+`'workbox-precaching.PrecacheController.addToCacheList()' The entry `+`'${JSON.stringify(entry)}' isn't supported. You must supply an array of `+`strings with one or more characters, objects with a url property or `+`Request objects.`;},'add-to-cache-list-conflicting-entries':({firstEntry,secondEntry})=>{if(!firstEntry||!secondEntry){throw new Error(`Unexpected input to `+`'add-to-cache-list-duplicate-entries' error.`);}
return`Two of the entries passed to `+`'workbox-precaching.PrecacheController.addToCacheList()' had the URL `+`${firstEntry._entryId} but different revision details. Workbox is `+`is unable to cache and version the asset correctly. Please remove one `+`of the entries.`;},'plugin-error-request-will-fetch':({thrownError})=>{if(!thrownError){throw new Error(`Unexpected input to `+`'plugin-error-request-will-fetch', error.`);}
return`An error was thrown by a plugins 'requestWillFetch()' method. `+`The thrown error message was: '${thrownError.message}'.`;},'invalid-cache-name':({cacheNameId,value})=>{if(!cacheNameId){throw new Error(`Expected a 'cacheNameId' for error 'invalid-cache-name'`);}
return`You must provide a name containing at least one character for `+`setCacheDeatils({${cacheNameId}: '...'}). Received a value of `+`'${JSON.stringify(value)}'`;},'unregister-route-but-not-found-with-method':({method})=>{if(!method){throw new Error(`Unexpected input to `+`'unregister-route-but-not-found-with-method' error.`);}
return`The route you're trying to unregister was not  previously `+`registered for the method type '${method}'.`;},'unregister-route-route-not-registered':()=>{return`The route you're trying to unregister was not previously `+`registered.`;},'queue-replay-failed':({name})=>{return`Replaying the background sync queue '${name}' failed.`;},'duplicate-queue-name':({name})=>{return`The Queue name '${name}' is already being used. `+`All instances of backgroundSync.Queue must be given unique names.`;},'expired-test-without-max-age':({methodName,paramName})=>{return`The '${methodName}()' method can only be used when the `+`'${paramName}' is used in the constructor.`;},'unsupported-route-type':({moduleName,className,funcName,paramName})=>{return`The supplied '${paramName}' parameter was an unsupported type. `+`Please check the docs for ${moduleName}.${className}.${funcName} for `+`valid input types.`;},'not-array-of-class':({value,expectedClass,moduleName,className,funcName,paramName})=>{return`The supplied '${paramName}' parameter must be an array of `+`'${expectedClass}' objects. Received '${JSON.stringify(value)},'. `+`Please check the call to ${moduleName}.${className}.${funcName}() `+`to fix the issue.`;},'max-entries-or-age-required':({moduleName,className,funcName})=>{return`You must define either config.maxEntries or config.maxAgeSeconds`+`in ${moduleName}.${className}.${funcName}`;},'statuses-or-headers-required':({moduleName,className,funcName})=>{return`You must define either config.statuses or config.headers`+`in ${moduleName}.${className}.${funcName}`;},'invalid-string':({moduleName,className,funcName,paramName})=>{if(!paramName||!moduleName||!funcName){throw new Error(`Unexpected input to 'invalid-string' error.`);}
return`When using strings, the '${paramName}' parameter must start with `+`'http' (for cross-origin matches) or '/' (for same-origin matches). `+`Please see the docs for ${moduleName}.${funcName}() for `+`more info.`;},'channel-name-required':()=>{return`You must provide a channelName to construct a `+`BroadcastCacheUpdate instance.`;},'invalid-responses-are-same-args':()=>{return`The arguments passed into responsesAreSame() appear to be `+`invalid. Please ensure valid Responses are used.`;},'expire-custom-caches-only':()=>{return`You must provide a 'cacheName' property when using the `+`expiration plugin with a runtime caching strategy.`;},'unit-must-be-bytes':({normalizedRangeHeader})=>{if(!normalizedRangeHeader){throw new Error(`Unexpected input to 'unit-must-be-bytes' error.`);}
return`The 'unit' portion of the Range header must be set to 'bytes'. `+`The Range header provided was "${normalizedRangeHeader}"`;},'single-range-only':({normalizedRangeHeader})=>{if(!normalizedRangeHeader){throw new Error(`Unexpected input to 'single-range-only' error.`);}
return`Multiple ranges are not supported. Please use a  single start `+`value, and optional end value. The Range header provided was `+`"${normalizedRangeHeader}"`;},'invalid-range-values':({normalizedRangeHeader})=>{if(!normalizedRangeHeader){throw new Error(`Unexpected input to 'invalid-range-values' error.`);}
return`The Range header is missing both start and end values. At least `+`one of those values is needed. The Range header provided was `+`"${normalizedRangeHeader}"`;},'no-range-header':()=>{return`No Range header was found in the Request provided.`;},'range-not-satisfiable':({size,start,end})=>{return`The start (${start}) and end (${end}) values in the Range are `+`not satisfiable by the cached response, which is ${size} bytes.`;},'attempt-to-cache-non-get-request':({url,method})=>{return`Unable to cache '${url}' because it is a '${method}' request and `+`only 'GET' requests can be cached.`;},'cache-put-with-no-response':({url})=>{return`There was an attempt to cache '${url}' but the response was not `+`defined.`;},'no-response':({url,error})=>{let message=`The strategy could not generate a response for '${url}'.`;if(error){message+=` The underlying error is ${error}.`;}
return message;},'bad-precaching-response':({url,status})=>{return`The precaching request for '${url}' failed with an HTTP `+`status of ${status}.`;}};const generatorFunction=(code,...args)=>{const message=messages[code];if(!message){throw new Error(`Unable to find message for code '${code}'.`);}
return message(...args);};const messageGenerator=generatorFunction;class WorkboxError extends Error{constructor(errorCode,details){let message=messageGenerator(errorCode,details);super(message);this.name=errorCode;this.details=details;}}
const isSWEnv=moduleName=>{if(!('ServiceWorkerGlobalScope'in self)){throw new WorkboxError('not-in-sw',{moduleName});}};const isArray=(value,{moduleName,className,funcName,paramName})=>{if(!Array.isArray(value)){throw new WorkboxError('not-an-array',{moduleName,className,funcName,paramName});}};const hasMethod=(object,expectedMethod,{moduleName,className,funcName,paramName})=>{const type=typeof object[expectedMethod];if(type!=='function'){throw new WorkboxError('missing-a-method',{paramName,expectedMethod,moduleName,className,funcName});}};const isType=(object,expectedType,{moduleName,className,funcName,paramName})=>{if(typeof object!==expectedType){throw new WorkboxError('incorrect-type',{paramName,expectedType,moduleName,className,funcName});}};const isInstance=(object,expectedClass,{moduleName,className,funcName,paramName,isReturnValueProblem})=>{if(!(object instanceof expectedClass)){throw new WorkboxError('incorrect-class',{paramName,expectedClass,moduleName,className,funcName,isReturnValueProblem});}};const isOneOf=(value,validValues,{paramName})=>{if(!validValues.includes(value)){throw new WorkboxError('invalid-value',{paramName,value,validValueDescription:`Valid values are ${JSON.stringify(validValues)}.`});}};const isArrayOfClass=(value,expectedClass,{moduleName,className,funcName,paramName})=>{const error=new WorkboxError('not-array-of-class',{value,expectedClass,moduleName,className,funcName,paramName});if(!Array.isArray(value)){throw error;}
for(let item of value){if(!(item instanceof expectedClass)){throw error;}}};const finalAssertExports={hasMethod,isArray,isInstance,isOneOf,isSWEnv,isType,isArrayOfClass};const quotaErrorCallbacks=new Set();function registerQuotaErrorCallback(callback){{finalAssertExports.isType(callback,'function',{moduleName:'workbox-core',funcName:'register',paramName:'callback'});}
quotaErrorCallbacks.add(callback);{logger.log('Registered a callback to respond to quota errors.',callback);}}
const _cacheNameDetails={googleAnalytics:'googleAnalytics',precache:'precache-v2',prefix:'workbox',runtime:'runtime',suffix:self.registration.scope};const _createCacheName=cacheName=>{return[_cacheNameDetails.prefix,cacheName,_cacheNameDetails.suffix].filter(value=>value.length>0).join('-');};const cacheNames={updateDetails:details=>{Object.keys(_cacheNameDetails).forEach(key=>{if(typeof details[key]!=='undefined'){_cacheNameDetails[key]=details[key];}});},getGoogleAnalyticsName:userCacheName=>{return userCacheName||_createCacheName(_cacheNameDetails.googleAnalytics);},getPrecacheName:userCacheName=>{return userCacheName||_createCacheName(_cacheNameDetails.precache);},getPrefix:()=>{return _cacheNameDetails.prefix;},getRuntimeName:userCacheName=>{return userCacheName||_createCacheName(_cacheNameDetails.runtime);},getSuffix:()=>{return _cacheNameDetails.suffix;}};const getFriendlyURL=url=>{const urlObj=new URL(url,location);if(urlObj.origin===location.origin){return urlObj.pathname;}
return urlObj.href;};async function executeQuotaErrorCallbacks(){{logger.log(`About to run ${quotaErrorCallbacks.size} `+`callbacks to clean up caches.`);}
for(const callback of quotaErrorCallbacks){await callback();{logger.log(callback,'is complete.');}}
{logger.log('Finished running callbacks.');}}
const pluginEvents={CACHE_DID_UPDATE:'cacheDidUpdate',CACHE_KEY_WILL_BE_USED:'cacheKeyWillBeUsed',CACHE_WILL_UPDATE:'cacheWillUpdate',CACHED_RESPONSE_WILL_BE_USED:'cachedResponseWillBeUsed',FETCH_DID_FAIL:'fetchDidFail',FETCH_DID_SUCCEED:'fetchDidSucceed',REQUEST_WILL_FETCH:'requestWillFetch'};const pluginUtils={filter:(plugins,callbackName)=>{return plugins.filter(plugin=>callbackName in plugin);}};const putWrapper=async({cacheName,request,response,event,plugins=[],matchOptions}={})=>{{if(request.method&&request.method!=='GET'){throw new WorkboxError('attempt-to-cache-non-get-request',{url:getFriendlyURL(request.url),method:request.method});}}
const effectiveRequest=await _getEffectiveRequest({plugins,request,mode:'write'});if(!response){{logger.error(`Cannot cache non-existent response for `+`'${getFriendlyURL(effectiveRequest.url)}'.`);}
throw new WorkboxError('cache-put-with-no-response',{url:getFriendlyURL(effectiveRequest.url)});}
let responseToCache=await _isResponseSafeToCache({event,plugins,response,request:effectiveRequest});if(!responseToCache){{logger.debug(`Response '${getFriendlyURL(effectiveRequest.url)}' will `+`not be cached.`,responseToCache);}
return;}
const cache=await caches.open(cacheName);const updatePlugins=pluginUtils.filter(plugins,pluginEvents.CACHE_DID_UPDATE);let oldResponse=updatePlugins.length>0?await matchWrapper({cacheName,matchOptions,request:effectiveRequest}):null;{logger.debug(`Updating the '${cacheName}' cache with a new Response for `+`${getFriendlyURL(effectiveRequest.url)}.`);}
try{await cache.put(effectiveRequest,responseToCache);}catch(error){if(error.name==='QuotaExceededError'){await executeQuotaErrorCallbacks();}
throw error;}
for(let plugin of updatePlugins){await plugin[pluginEvents.CACHE_DID_UPDATE].call(plugin,{cacheName,event,oldResponse,newResponse:responseToCache,request:effectiveRequest});}};const matchWrapper=async({cacheName,request,event,matchOptions,plugins=[]})=>{const cache=await caches.open(cacheName);const effectiveRequest=await _getEffectiveRequest({plugins,request,mode:'read'});let cachedResponse=await cache.match(effectiveRequest,matchOptions);{if(cachedResponse){logger.debug(`Found a cached response in '${cacheName}'.`);}else{logger.debug(`No cached response found in '${cacheName}'.`);}}
for(const plugin of plugins){if(pluginEvents.CACHED_RESPONSE_WILL_BE_USED in plugin){cachedResponse=await plugin[pluginEvents.CACHED_RESPONSE_WILL_BE_USED].call(plugin,{cacheName,event,matchOptions,cachedResponse,request:effectiveRequest});{if(cachedResponse){finalAssertExports.isInstance(cachedResponse,Response,{moduleName:'Plugin',funcName:pluginEvents.CACHED_RESPONSE_WILL_BE_USED,isReturnValueProblem:true});}}}}
return cachedResponse;};const _isResponseSafeToCache=async({request,response,event,plugins})=>{let responseToCache=response;let pluginsUsed=false;for(let plugin of plugins){if(pluginEvents.CACHE_WILL_UPDATE in plugin){pluginsUsed=true;responseToCache=await plugin[pluginEvents.CACHE_WILL_UPDATE].call(plugin,{request,response:responseToCache,event});{if(responseToCache){finalAssertExports.isInstance(responseToCache,Response,{moduleName:'Plugin',funcName:pluginEvents.CACHE_WILL_UPDATE,isReturnValueProblem:true});}}
if(!responseToCache){break;}}}
if(!pluginsUsed){{if(!responseToCache.status===200){if(responseToCache.status===0){logger.warn(`The response for '${request.url}' is an opaque `+`response. The caching strategy that you're using will not `+`cache opaque responses by default.`);}else{logger.debug(`The response for '${request.url}' returned `+`a status code of '${response.status}' and won't be cached as a `+`result.`);}}}
responseToCache=responseToCache.status===200?responseToCache:null;}
return responseToCache?responseToCache:null;};const _getEffectiveRequest=async({request,mode,plugins})=>{const cacheKeyWillBeUsedPlugins=pluginUtils.filter(plugins,pluginEvents.CACHE_KEY_WILL_BE_USED);let effectiveRequest=request;for(const plugin of cacheKeyWillBeUsedPlugins){effectiveRequest=await plugin[pluginEvents.CACHE_KEY_WILL_BE_USED].call(plugin,{mode,request:effectiveRequest});if(typeof effectiveRequest==='string'){effectiveRequest=new Request(effectiveRequest);}
{finalAssertExports.isInstance(effectiveRequest,Request,{moduleName:'Plugin',funcName:pluginEvents.CACHE_KEY_WILL_BE_USED,isReturnValueProblem:true});}}
return effectiveRequest;};const cacheWrapper={put:putWrapper,match:matchWrapper};class DBWrapper{constructor(name,version,{onupgradeneeded,onversionchange=this._onversionchange}={}){this._name=name;this._version=version;this._onupgradeneeded=onupgradeneeded;this._onversionchange=onversionchange;this._db=null;}
get db(){return this._db;}
async open(){if(this._db)return;this._db=await new Promise((resolve,reject)=>{let openRequestTimedOut=false;setTimeout(()=>{openRequestTimedOut=true;reject(new Error('The open request was blocked and timed out'));},this.OPEN_TIMEOUT);const openRequest=indexedDB.open(this._name,this._version);openRequest.onerror=()=>reject(openRequest.error);openRequest.onupgradeneeded=evt=>{if(openRequestTimedOut){openRequest.transaction.abort();evt.target.result.close();}else if(this._onupgradeneeded){this._onupgradeneeded(evt);}};openRequest.onsuccess=({target})=>{const db=target.result;if(openRequestTimedOut){db.close();}else{db.onversionchange=this._onversionchange.bind(this);resolve(db);}};});return this;}
async getKey(storeName,query){return(await this.getAllKeys(storeName,query,1))[0];}
async getAll(storeName,query,count){return await this.getAllMatching(storeName,{query,count});}
async getAllKeys(storeName,query,count){return(await this.getAllMatching(storeName,{query,count,includeKeys:true})).map(({key})=>key);}
async getAllMatching(storeName,{index,query=null,direction='next',count,includeKeys}={}){return await this.transaction([storeName],'readonly',(txn,done)=>{const store=txn.objectStore(storeName);const target=index?store.index(index):store;const results=[];target.openCursor(query,direction).onsuccess=({target})=>{const cursor=target.result;if(cursor){const{primaryKey,key,value}=cursor;results.push(includeKeys?{primaryKey,key,value}:value);if(count&&results.length>=count){done(results);}else{cursor.continue();}}else{done(results);}};});}
async transaction(storeNames,type,callback){await this.open();return await new Promise((resolve,reject)=>{const txn=this._db.transaction(storeNames,type);txn.onabort=({target})=>reject(target.error);txn.oncomplete=()=>resolve();callback(txn,value=>resolve(value));});}
async _call(method,storeName,type,...args){const callback=(txn,done)=>{txn.objectStore(storeName)[method](...args).onsuccess=({target})=>{done(target.result);};};return await this.transaction([storeName],type,callback);}
_onversionchange(){this.close();}
close(){if(this._db){this._db.close();this._db=null;}}}
DBWrapper.prototype.OPEN_TIMEOUT=2000;const methodsToWrap={'readonly':['get','count','getKey','getAll','getAllKeys'],'readwrite':['add','put','clear','delete']};for(const[mode,methods]of Object.entries(methodsToWrap)){for(const method of methods){if(method in IDBObjectStore.prototype){DBWrapper.prototype[method]=async function(storeName,...args){return await this._call(method,storeName,mode,...args);};}}}
class Deferred{constructor(){this.promise=new Promise((resolve,reject)=>{this.resolve=resolve;this.reject=reject;});}}
const deleteDatabase=async name=>{await new Promise((resolve,reject)=>{const request=indexedDB.deleteDatabase(name);request.onerror=({target})=>{reject(target.error);};request.onblocked=()=>{reject(new Error('Delete blocked'));};request.onsuccess=()=>{resolve();};});};const wrappedFetch=async({request,fetchOptions,event,plugins=[]})=>{if(event&&event.preloadResponse){const possiblePreloadResponse=await event.preloadResponse;if(possiblePreloadResponse){{logger.log(`Using a preloaded navigation response for `+`'${getFriendlyURL(request.url)}'`);}
return possiblePreloadResponse;}}
if(typeof request==='string'){request=new Request(request);}
{finalAssertExports.isInstance(request,Request,{paramName:request,expectedClass:'Request',moduleName:'workbox-core',className:'fetchWrapper',funcName:'wrappedFetch'});}
const failedFetchPlugins=pluginUtils.filter(plugins,pluginEvents.FETCH_DID_FAIL);const originalRequest=failedFetchPlugins.length>0?request.clone():null;try{for(let plugin of plugins){if(pluginEvents.REQUEST_WILL_FETCH in plugin){request=await plugin[pluginEvents.REQUEST_WILL_FETCH].call(plugin,{request:request.clone(),event});{if(request){finalAssertExports.isInstance(request,Request,{moduleName:'Plugin',funcName:pluginEvents.CACHED_RESPONSE_WILL_BE_USED,isReturnValueProblem:true});}}}}}catch(err){throw new WorkboxError('plugin-error-request-will-fetch',{thrownError:err});}
let pluginFilteredRequest=request.clone();try{let fetchResponse;if(request.mode==='navigate'){fetchResponse=await fetch(request);}else{fetchResponse=await fetch(request,fetchOptions);}
{logger.debug(`Network request for `+`'${getFriendlyURL(request.url)}' returned a response with `+`status '${fetchResponse.status}'.`);}
for(const plugin of plugins){if(pluginEvents.FETCH_DID_SUCCEED in plugin){fetchResponse=await plugin[pluginEvents.FETCH_DID_SUCCEED].call(plugin,{event,request:pluginFilteredRequest,response:fetchResponse});{if(fetchResponse){finalAssertExports.isInstance(fetchResponse,Response,{moduleName:'Plugin',funcName:pluginEvents.FETCH_DID_SUCCEED,isReturnValueProblem:true});}}}}
return fetchResponse;}catch(error){{logger.error(`Network request for `+`'${getFriendlyURL(request.url)}' threw an error.`,error);}
for(const plugin of failedFetchPlugins){await plugin[pluginEvents.FETCH_DID_FAIL].call(plugin,{error,event,originalRequest:originalRequest.clone(),request:pluginFilteredRequest.clone()});}
throw error;}};const fetchWrapper={fetch:wrappedFetch};var _private=Object.freeze({assert:finalAssertExports,cacheNames:cacheNames,cacheWrapper:cacheWrapper,DBWrapper:DBWrapper,Deferred:Deferred,deleteDatabase:deleteDatabase,executeQuotaErrorCallbacks:executeQuotaErrorCallbacks,fetchWrapper:fetchWrapper,getFriendlyURL:getFriendlyURL,logger:logger,WorkboxError:WorkboxError});const clientsClaim=()=>{addEventListener('activate',()=>clients.claim());};const cacheNames$1={get googleAnalytics(){return cacheNames.getGoogleAnalyticsName();},get precache(){return cacheNames.getPrecacheName();},get prefix(){return cacheNames.getPrefix();},get runtime(){return cacheNames.getRuntimeName();},get suffix(){return cacheNames.getSuffix();}};const setCacheNameDetails=details=>{{Object.keys(details).forEach(key=>{finalAssertExports.isType(details[key],'string',{moduleName:'workbox-core',funcName:'setCacheNameDetails',paramName:`details.${key}`});});if('precache'in details&&details.precache.length===0){throw new WorkboxError('invalid-cache-name',{cacheNameId:'precache',value:details.precache});}
if('runtime'in details&&details.runtime.length===0){throw new WorkboxError('invalid-cache-name',{cacheNameId:'runtime',value:details.runtime});}
if('googleAnalytics'in details&&details.googleAnalytics.length===0){throw new WorkboxError('invalid-cache-name',{cacheNameId:'googleAnalytics',value:details.googleAnalytics});}}
cacheNames.updateDetails(details);};const skipWaiting=()=>{addEventListener('install',()=>self.skipWaiting());};try{self.workbox.v=self.workbox.v||{};}catch(errer){}
exports._private=_private;exports.clientsClaim=clientsClaim;exports.cacheNames=cacheNames$1;exports.registerQuotaErrorCallback=registerQuotaErrorCallback;exports.setCacheNameDetails=setCacheNameDetails;exports.skipWaiting=skipWaiting;return exports;}({}));