1134 lines
32 KiB
JavaScript
1134 lines
32 KiB
JavaScript
define('./workbox-ea903bce.js', ['exports'], function (t) {
|
|
'use strict'
|
|
try {
|
|
self['workbox:core:6.1.5'] && _()
|
|
} catch (t) {}
|
|
const e = (t, ...e) => {
|
|
let s = t
|
|
return e.length > 0 && (s += ` :: ${JSON.stringify(e)}`), s
|
|
}
|
|
class s extends Error {
|
|
constructor(t, s) {
|
|
super(e(t, s)), (this.name = t), (this.details = s)
|
|
}
|
|
}
|
|
try {
|
|
self['workbox:routing:6.1.5'] && _()
|
|
} catch (t) {}
|
|
const n = (t) => (t && 'object' == typeof t ? t : { handle: t })
|
|
class i {
|
|
constructor(t, e, s = 'GET') {
|
|
;(this.handler = n(e)), (this.match = t), (this.method = s)
|
|
}
|
|
setCatchHandler(t) {
|
|
this.catchHandler = n(t)
|
|
}
|
|
}
|
|
class r extends i {
|
|
constructor(t, e, s) {
|
|
super(
|
|
({ url: e }) => {
|
|
const s = t.exec(e.href)
|
|
if (s && (e.origin === location.origin || 0 === s.index))
|
|
return s.slice(1)
|
|
},
|
|
e,
|
|
s
|
|
)
|
|
}
|
|
}
|
|
class a {
|
|
constructor() {
|
|
;(this.t = new Map()), (this.i = new Map())
|
|
}
|
|
get routes() {
|
|
return this.t
|
|
}
|
|
addFetchListener() {
|
|
self.addEventListener('fetch', (t) => {
|
|
const { request: e } = t,
|
|
s = this.handleRequest({ request: e, event: t })
|
|
s && t.respondWith(s)
|
|
})
|
|
}
|
|
addCacheListener() {
|
|
self.addEventListener('message', (t) => {
|
|
if (t.data && 'CACHE_URLS' === t.data.type) {
|
|
const { payload: e } = t.data,
|
|
s = Promise.all(
|
|
e.urlsToCache.map((e) => {
|
|
'string' == typeof e && (e = [e])
|
|
const s = new Request(...e)
|
|
return this.handleRequest({ request: s, event: t })
|
|
})
|
|
)
|
|
t.waitUntil(s),
|
|
t.ports && t.ports[0] && s.then(() => t.ports[0].postMessage(!0))
|
|
}
|
|
})
|
|
}
|
|
handleRequest({ request: t, event: e }) {
|
|
const s = new URL(t.url, location.href)
|
|
if (!s.protocol.startsWith('http')) return
|
|
const n = s.origin === location.origin,
|
|
{ params: i, route: r } = this.findMatchingRoute({
|
|
event: e,
|
|
request: t,
|
|
sameOrigin: n,
|
|
url: s,
|
|
})
|
|
let a = r && r.handler
|
|
const c = t.method
|
|
if ((!a && this.i.has(c) && (a = this.i.get(c)), !a)) return
|
|
let o
|
|
try {
|
|
o = a.handle({ url: s, request: t, event: e, params: i })
|
|
} catch (t) {
|
|
o = Promise.reject(t)
|
|
}
|
|
const h = r && r.catchHandler
|
|
return (
|
|
o instanceof Promise &&
|
|
(this.o || h) &&
|
|
(o = o.catch(async (n) => {
|
|
if (h)
|
|
try {
|
|
return await h.handle({
|
|
url: s,
|
|
request: t,
|
|
event: e,
|
|
params: i,
|
|
})
|
|
} catch (t) {
|
|
n = t
|
|
}
|
|
if (this.o) return this.o.handle({ url: s, request: t, event: e })
|
|
throw n
|
|
})),
|
|
o
|
|
)
|
|
}
|
|
findMatchingRoute({ url: t, sameOrigin: e, request: s, event: n }) {
|
|
const i = this.t.get(s.method) || []
|
|
for (const r of i) {
|
|
let i
|
|
const a = r.match({ url: t, sameOrigin: e, request: s, event: n })
|
|
if (a)
|
|
return (
|
|
(i = a),
|
|
((Array.isArray(a) && 0 === a.length) ||
|
|
(a.constructor === Object && 0 === Object.keys(a).length) ||
|
|
'boolean' == typeof a) &&
|
|
(i = void 0),
|
|
{ route: r, params: i }
|
|
)
|
|
}
|
|
return {}
|
|
}
|
|
setDefaultHandler(t, e = 'GET') {
|
|
this.i.set(e, n(t))
|
|
}
|
|
setCatchHandler(t) {
|
|
this.o = n(t)
|
|
}
|
|
registerRoute(t) {
|
|
this.t.has(t.method) || this.t.set(t.method, []),
|
|
this.t.get(t.method).push(t)
|
|
}
|
|
unregisterRoute(t) {
|
|
if (!this.t.has(t.method))
|
|
throw new s('unregister-route-but-not-found-with-method', {
|
|
method: t.method,
|
|
})
|
|
const e = this.t.get(t.method).indexOf(t)
|
|
if (!(e > -1)) throw new s('unregister-route-route-not-registered')
|
|
this.t.get(t.method).splice(e, 1)
|
|
}
|
|
}
|
|
let c
|
|
const o = () => (
|
|
c || ((c = new a()), c.addFetchListener(), c.addCacheListener()), c
|
|
)
|
|
function h(t, e, n) {
|
|
let a
|
|
if ('string' == typeof t) {
|
|
const s = new URL(t, location.href)
|
|
a = new i(({ url: t }) => t.href === s.href, e, n)
|
|
} else if (t instanceof RegExp) a = new r(t, e, n)
|
|
else if ('function' == typeof t) a = new i(t, e, n)
|
|
else {
|
|
if (!(t instanceof i))
|
|
throw new s('unsupported-route-type', {
|
|
moduleName: 'workbox-routing',
|
|
funcName: 'registerRoute',
|
|
paramName: 'capture',
|
|
})
|
|
a = t
|
|
}
|
|
return o().registerRoute(a), a
|
|
}
|
|
try {
|
|
self['workbox:strategies:6.1.5'] && _()
|
|
} catch (t) {}
|
|
const u = {
|
|
cacheWillUpdate: async ({ response: t }) =>
|
|
200 === t.status || 0 === t.status ? t : null,
|
|
},
|
|
l = {
|
|
googleAnalytics: 'googleAnalytics',
|
|
precache: 'precache-v2',
|
|
prefix: 'workbox',
|
|
runtime: 'runtime',
|
|
suffix: 'undefined' != typeof registration ? registration.scope : '',
|
|
},
|
|
f = (t) =>
|
|
[l.prefix, t, l.suffix].filter((t) => t && t.length > 0).join('-'),
|
|
w = (t) => t || f(l.precache),
|
|
d = (t) => t || f(l.runtime)
|
|
function p() {
|
|
return (p =
|
|
Object.assign ||
|
|
function (t) {
|
|
for (var e = 1; e < arguments.length; e++) {
|
|
var s = arguments[e]
|
|
for (var n in s)
|
|
Object.prototype.hasOwnProperty.call(s, n) && (t[n] = s[n])
|
|
}
|
|
return t
|
|
}).apply(this, arguments)
|
|
}
|
|
function y(t, e) {
|
|
const s = new URL(t)
|
|
for (const t of e) s.searchParams.delete(t)
|
|
return s.href
|
|
}
|
|
class m {
|
|
constructor() {
|
|
this.promise = new Promise((t, e) => {
|
|
;(this.resolve = t), (this.reject = e)
|
|
})
|
|
}
|
|
}
|
|
const g = new Set()
|
|
function R(t) {
|
|
return 'string' == typeof t ? new Request(t) : t
|
|
}
|
|
class v {
|
|
constructor(t, e) {
|
|
;(this.h = {}),
|
|
Object.assign(this, e),
|
|
(this.event = e.event),
|
|
(this.u = t),
|
|
(this.l = new m()),
|
|
(this.p = []),
|
|
(this.m = [...t.plugins]),
|
|
(this.g = new Map())
|
|
for (const t of this.m) this.g.set(t, {})
|
|
this.event.waitUntil(this.l.promise)
|
|
}
|
|
async fetch(t) {
|
|
const { event: e } = this
|
|
let n = R(t)
|
|
if (
|
|
'navigate' === n.mode &&
|
|
e instanceof FetchEvent &&
|
|
e.preloadResponse
|
|
) {
|
|
const t = await e.preloadResponse
|
|
if (t) return t
|
|
}
|
|
const i = this.hasCallback('fetchDidFail') ? n.clone() : null
|
|
try {
|
|
for (const t of this.iterateCallbacks('requestWillFetch'))
|
|
n = await t({ request: n.clone(), event: e })
|
|
} catch (t) {
|
|
throw new s('plugin-error-request-will-fetch', { thrownError: t })
|
|
}
|
|
const r = n.clone()
|
|
try {
|
|
let t
|
|
t = await fetch(n, 'navigate' === n.mode ? void 0 : this.u.fetchOptions)
|
|
for (const s of this.iterateCallbacks('fetchDidSucceed'))
|
|
t = await s({ event: e, request: r, response: t })
|
|
return t
|
|
} catch (t) {
|
|
throw (
|
|
(i &&
|
|
(await this.runCallbacks('fetchDidFail', {
|
|
error: t,
|
|
event: e,
|
|
originalRequest: i.clone(),
|
|
request: r.clone(),
|
|
})),
|
|
t)
|
|
)
|
|
}
|
|
}
|
|
async fetchAndCachePut(t) {
|
|
const e = await this.fetch(t),
|
|
s = e.clone()
|
|
return this.waitUntil(this.cachePut(t, s)), e
|
|
}
|
|
async cacheMatch(t) {
|
|
const e = R(t)
|
|
let s
|
|
const { cacheName: n, matchOptions: i } = this.u,
|
|
r = await this.getCacheKey(e, 'read'),
|
|
a = p({}, i, { cacheName: n })
|
|
s = await caches.match(r, a)
|
|
for (const t of this.iterateCallbacks('cachedResponseWillBeUsed'))
|
|
s =
|
|
(await t({
|
|
cacheName: n,
|
|
matchOptions: i,
|
|
cachedResponse: s,
|
|
request: r,
|
|
event: this.event,
|
|
})) || void 0
|
|
return s
|
|
}
|
|
async cachePut(t, e) {
|
|
const n = R(t)
|
|
var i
|
|
await ((i = 0), new Promise((t) => setTimeout(t, i)))
|
|
const r = await this.getCacheKey(n, 'write')
|
|
if (!e)
|
|
throw new s('cache-put-with-no-response', {
|
|
url:
|
|
((a = r.url),
|
|
new URL(String(a), location.href).href.replace(
|
|
new RegExp(`^${location.origin}`),
|
|
''
|
|
)),
|
|
})
|
|
var a
|
|
const c = await this.R(e)
|
|
if (!c) return !1
|
|
const { cacheName: o, matchOptions: h } = this.u,
|
|
u = await self.caches.open(o),
|
|
l = this.hasCallback('cacheDidUpdate'),
|
|
f = l
|
|
? await (async function (t, e, s, n) {
|
|
const i = y(e.url, s)
|
|
if (e.url === i) return t.match(e, n)
|
|
const r = p({}, n, { ignoreSearch: !0 }),
|
|
a = await t.keys(e, r)
|
|
for (const e of a) if (i === y(e.url, s)) return t.match(e, n)
|
|
})(u, r.clone(), ['__WB_REVISION__'], h)
|
|
: null
|
|
try {
|
|
await u.put(r, l ? c.clone() : c)
|
|
} catch (t) {
|
|
throw (
|
|
('QuotaExceededError' === t.name &&
|
|
(await (async function () {
|
|
for (const t of g) await t()
|
|
})()),
|
|
t)
|
|
)
|
|
}
|
|
for (const t of this.iterateCallbacks('cacheDidUpdate'))
|
|
await t({
|
|
cacheName: o,
|
|
oldResponse: f,
|
|
newResponse: c.clone(),
|
|
request: r,
|
|
event: this.event,
|
|
})
|
|
return !0
|
|
}
|
|
async getCacheKey(t, e) {
|
|
if (!this.h[e]) {
|
|
let s = t
|
|
for (const t of this.iterateCallbacks('cacheKeyWillBeUsed'))
|
|
s = R(
|
|
await t({
|
|
mode: e,
|
|
request: s,
|
|
event: this.event,
|
|
params: this.params,
|
|
})
|
|
)
|
|
this.h[e] = s
|
|
}
|
|
return this.h[e]
|
|
}
|
|
hasCallback(t) {
|
|
for (const e of this.u.plugins) if (t in e) return !0
|
|
return !1
|
|
}
|
|
async runCallbacks(t, e) {
|
|
for (const s of this.iterateCallbacks(t)) await s(e)
|
|
}
|
|
*iterateCallbacks(t) {
|
|
for (const e of this.u.plugins)
|
|
if ('function' == typeof e[t]) {
|
|
const s = this.g.get(e),
|
|
n = (n) => {
|
|
const i = p({}, n, { state: s })
|
|
return e[t](i)
|
|
}
|
|
yield n
|
|
}
|
|
}
|
|
waitUntil(t) {
|
|
return this.p.push(t), t
|
|
}
|
|
async doneWaiting() {
|
|
let t
|
|
for (; (t = this.p.shift()); ) await t
|
|
}
|
|
destroy() {
|
|
this.l.resolve()
|
|
}
|
|
async R(t) {
|
|
let e = t,
|
|
s = !1
|
|
for (const t of this.iterateCallbacks('cacheWillUpdate'))
|
|
if (
|
|
((e =
|
|
(await t({
|
|
request: this.request,
|
|
response: e,
|
|
event: this.event,
|
|
})) || void 0),
|
|
(s = !0),
|
|
!e)
|
|
)
|
|
break
|
|
return s || (e && 200 !== e.status && (e = void 0)), e
|
|
}
|
|
}
|
|
class q {
|
|
constructor(t = {}) {
|
|
;(this.cacheName = d(t.cacheName)),
|
|
(this.plugins = t.plugins || []),
|
|
(this.fetchOptions = t.fetchOptions),
|
|
(this.matchOptions = t.matchOptions)
|
|
}
|
|
handle(t) {
|
|
const [e] = this.handleAll(t)
|
|
return e
|
|
}
|
|
handleAll(t) {
|
|
t instanceof FetchEvent && (t = { event: t, request: t.request })
|
|
const e = t.event,
|
|
s = 'string' == typeof t.request ? new Request(t.request) : t.request,
|
|
n = 'params' in t ? t.params : void 0,
|
|
i = new v(this, { event: e, request: s, params: n }),
|
|
r = this.v(i, s, e)
|
|
return [r, this.q(r, i, s, e)]
|
|
}
|
|
async v(t, e, n) {
|
|
let i
|
|
await t.runCallbacks('handlerWillStart', { event: n, request: e })
|
|
try {
|
|
if (((i = await this.U(e, t)), !i || 'error' === i.type))
|
|
throw new s('no-response', { url: e.url })
|
|
} catch (s) {
|
|
for (const r of t.iterateCallbacks('handlerDidError'))
|
|
if (((i = await r({ error: s, event: n, request: e })), i)) break
|
|
if (!i) throw s
|
|
}
|
|
for (const s of t.iterateCallbacks('handlerWillRespond'))
|
|
i = await s({ event: n, request: e, response: i })
|
|
return i
|
|
}
|
|
async q(t, e, s, n) {
|
|
let i, r
|
|
try {
|
|
i = await t
|
|
} catch (r) {}
|
|
try {
|
|
await e.runCallbacks('handlerDidRespond', {
|
|
event: n,
|
|
request: s,
|
|
response: i,
|
|
}),
|
|
await e.doneWaiting()
|
|
} catch (t) {
|
|
r = t
|
|
}
|
|
if (
|
|
(await e.runCallbacks('handlerDidComplete', {
|
|
event: n,
|
|
request: s,
|
|
response: i,
|
|
error: r,
|
|
}),
|
|
e.destroy(),
|
|
r)
|
|
)
|
|
throw r
|
|
}
|
|
}
|
|
function U(t) {
|
|
t.then(() => {})
|
|
}
|
|
class x {
|
|
constructor(t, e, { onupgradeneeded: s, onversionchange: n } = {}) {
|
|
;(this._ = null),
|
|
(this.L = t),
|
|
(this.N = e),
|
|
(this.C = s),
|
|
(this.D = n || (() => this.close()))
|
|
}
|
|
get db() {
|
|
return this._
|
|
}
|
|
async open() {
|
|
if (!this._)
|
|
return (
|
|
(this._ = await new Promise((t, e) => {
|
|
let s = !1
|
|
setTimeout(() => {
|
|
;(s = !0),
|
|
e(new Error('The open request was blocked and timed out'))
|
|
}, this.OPEN_TIMEOUT)
|
|
const n = indexedDB.open(this.L, this.N)
|
|
;(n.onerror = () => e(n.error)),
|
|
(n.onupgradeneeded = (t) => {
|
|
s
|
|
? (n.transaction.abort(), n.result.close())
|
|
: 'function' == typeof this.C && this.C(t)
|
|
}),
|
|
(n.onsuccess = () => {
|
|
const e = n.result
|
|
s ? e.close() : ((e.onversionchange = this.D.bind(this)), t(e))
|
|
})
|
|
})),
|
|
this
|
|
)
|
|
}
|
|
async getKey(t, e) {
|
|
return (await this.getAllKeys(t, e, 1))[0]
|
|
}
|
|
async getAll(t, e, s) {
|
|
return await this.getAllMatching(t, { query: e, count: s })
|
|
}
|
|
async getAllKeys(t, e, s) {
|
|
return (
|
|
await this.getAllMatching(t, { query: e, count: s, includeKeys: !0 })
|
|
).map((t) => t.key)
|
|
}
|
|
async getAllMatching(
|
|
t,
|
|
{
|
|
index: e,
|
|
query: s = null,
|
|
direction: n = 'next',
|
|
count: i,
|
|
includeKeys: r = !1,
|
|
} = {}
|
|
) {
|
|
return await this.transaction([t], 'readonly', (a, c) => {
|
|
const o = a.objectStore(t),
|
|
h = e ? o.index(e) : o,
|
|
u = [],
|
|
l = h.openCursor(s, n)
|
|
l.onsuccess = () => {
|
|
const t = l.result
|
|
t
|
|
? (u.push(r ? t : t.value),
|
|
i && u.length >= i ? c(u) : t.continue())
|
|
: c(u)
|
|
}
|
|
})
|
|
}
|
|
async transaction(t, e, s) {
|
|
return (
|
|
await this.open(),
|
|
await new Promise((n, i) => {
|
|
const r = this._.transaction(t, e)
|
|
;(r.onabort = () => i(r.error)),
|
|
(r.oncomplete = () => n()),
|
|
s(r, (t) => n(t))
|
|
})
|
|
)
|
|
}
|
|
async T(t, e, s, ...n) {
|
|
return await this.transaction([e], s, (s, i) => {
|
|
const r = s.objectStore(e),
|
|
a = r[t].apply(r, n)
|
|
a.onsuccess = () => i(a.result)
|
|
})
|
|
}
|
|
close() {
|
|
this._ && (this._.close(), (this._ = null))
|
|
}
|
|
}
|
|
x.prototype.OPEN_TIMEOUT = 2e3
|
|
const b = {
|
|
readonly: ['get', 'count', 'getKey', 'getAll', 'getAllKeys'],
|
|
readwrite: ['add', 'put', 'clear', 'delete'],
|
|
}
|
|
for (const [t, e] of Object.entries(b))
|
|
for (const s of e)
|
|
s in IDBObjectStore.prototype &&
|
|
(x.prototype[s] = async function (e, ...n) {
|
|
return await this.T(s, e, t, ...n)
|
|
})
|
|
try {
|
|
self['workbox:expiration:6.1.5'] && _()
|
|
} catch (t) {}
|
|
const L = 'cache-entries',
|
|
N = (t) => {
|
|
const e = new URL(t, location.href)
|
|
return (e.hash = ''), e.href
|
|
}
|
|
class C {
|
|
constructor(t) {
|
|
;(this.P = t),
|
|
(this._ = new x('workbox-expiration', 1, {
|
|
onupgradeneeded: (t) => this.k(t),
|
|
}))
|
|
}
|
|
k(t) {
|
|
const e = t.target.result.createObjectStore(L, { keyPath: 'id' })
|
|
e.createIndex('cacheName', 'cacheName', { unique: !1 }),
|
|
e.createIndex('timestamp', 'timestamp', { unique: !1 }),
|
|
(async (t) => {
|
|
await new Promise((e, s) => {
|
|
const n = indexedDB.deleteDatabase(t)
|
|
;(n.onerror = () => {
|
|
s(n.error)
|
|
}),
|
|
(n.onblocked = () => {
|
|
s(new Error('Delete blocked'))
|
|
}),
|
|
(n.onsuccess = () => {
|
|
e()
|
|
})
|
|
})
|
|
})(this.P)
|
|
}
|
|
async setTimestamp(t, e) {
|
|
const s = {
|
|
url: (t = N(t)),
|
|
timestamp: e,
|
|
cacheName: this.P,
|
|
id: this.K(t),
|
|
}
|
|
await this._.put(L, s)
|
|
}
|
|
async getTimestamp(t) {
|
|
return (await this._.get(L, this.K(t))).timestamp
|
|
}
|
|
async expireEntries(t, e) {
|
|
const s = await this._.transaction(L, 'readwrite', (s, n) => {
|
|
const i = s
|
|
.objectStore(L)
|
|
.index('timestamp')
|
|
.openCursor(null, 'prev'),
|
|
r = []
|
|
let a = 0
|
|
i.onsuccess = () => {
|
|
const s = i.result
|
|
if (s) {
|
|
const n = s.value
|
|
n.cacheName === this.P &&
|
|
((t && n.timestamp < t) || (e && a >= e)
|
|
? r.push(s.value)
|
|
: a++),
|
|
s.continue()
|
|
} else n(r)
|
|
}
|
|
}),
|
|
n = []
|
|
for (const t of s) await this._.delete(L, t.id), n.push(t.url)
|
|
return n
|
|
}
|
|
K(t) {
|
|
return this.P + '|' + N(t)
|
|
}
|
|
}
|
|
class E {
|
|
constructor(t, e = {}) {
|
|
;(this.O = !1),
|
|
(this.W = !1),
|
|
(this.M = e.maxEntries),
|
|
(this.A = e.maxAgeSeconds),
|
|
(this.S = e.matchOptions),
|
|
(this.P = t),
|
|
(this.I = new C(t))
|
|
}
|
|
async expireEntries() {
|
|
if (this.O) return void (this.W = !0)
|
|
this.O = !0
|
|
const t = this.A ? Date.now() - 1e3 * this.A : 0,
|
|
e = await this.I.expireEntries(t, this.M),
|
|
s = await self.caches.open(this.P)
|
|
for (const t of e) await s.delete(t, this.S)
|
|
;(this.O = !1), this.W && ((this.W = !1), U(this.expireEntries()))
|
|
}
|
|
async updateTimestamp(t) {
|
|
await this.I.setTimestamp(t, Date.now())
|
|
}
|
|
async isURLExpired(t) {
|
|
if (this.A) {
|
|
return (await this.I.getTimestamp(t)) < Date.now() - 1e3 * this.A
|
|
}
|
|
return !1
|
|
}
|
|
async delete() {
|
|
;(this.W = !1), await this.I.expireEntries(1 / 0)
|
|
}
|
|
}
|
|
function D(t, e) {
|
|
const s = e()
|
|
return t.waitUntil(s), s
|
|
}
|
|
try {
|
|
self['workbox:precaching:6.1.5'] && _()
|
|
} catch (t) {}
|
|
function T(t) {
|
|
if (!t) throw new s('add-to-cache-list-unexpected-type', { entry: t })
|
|
if ('string' == typeof t) {
|
|
const e = new URL(t, location.href)
|
|
return { cacheKey: e.href, url: e.href }
|
|
}
|
|
const { revision: e, url: n } = t
|
|
if (!n) throw new s('add-to-cache-list-unexpected-type', { entry: t })
|
|
if (!e) {
|
|
const t = new URL(n, location.href)
|
|
return { cacheKey: t.href, url: t.href }
|
|
}
|
|
const i = new URL(n, location.href),
|
|
r = new URL(n, location.href)
|
|
return (
|
|
i.searchParams.set('__WB_REVISION__', e),
|
|
{ cacheKey: i.href, url: r.href }
|
|
)
|
|
}
|
|
class P {
|
|
constructor() {
|
|
;(this.updatedURLs = []),
|
|
(this.notUpdatedURLs = []),
|
|
(this.handlerWillStart = async ({ request: t, state: e }) => {
|
|
e && (e.originalRequest = t)
|
|
}),
|
|
(this.cachedResponseWillBeUsed = async ({
|
|
event: t,
|
|
state: e,
|
|
cachedResponse: s,
|
|
}) => {
|
|
if ('install' === t.type) {
|
|
const t = e.originalRequest.url
|
|
s ? this.notUpdatedURLs.push(t) : this.updatedURLs.push(t)
|
|
}
|
|
return s
|
|
})
|
|
}
|
|
}
|
|
class k {
|
|
constructor({ precacheController: t }) {
|
|
;(this.cacheKeyWillBeUsed = async ({ request: t, params: e }) => {
|
|
const s = (e && e.cacheKey) || this.j.getCacheKeyForURL(t.url)
|
|
return s ? new Request(s) : t
|
|
}),
|
|
(this.j = t)
|
|
}
|
|
}
|
|
let K, O
|
|
async function W(t, e) {
|
|
let n = null
|
|
if (t.url) {
|
|
n = new URL(t.url).origin
|
|
}
|
|
if (n !== self.location.origin)
|
|
throw new s('cross-origin-copy-response', { origin: n })
|
|
const i = t.clone(),
|
|
r = {
|
|
headers: new Headers(i.headers),
|
|
status: i.status,
|
|
statusText: i.statusText,
|
|
},
|
|
a = e ? e(r) : r,
|
|
c = (function () {
|
|
if (void 0 === K) {
|
|
const t = new Response('')
|
|
if ('body' in t)
|
|
try {
|
|
new Response(t.body), (K = !0)
|
|
} catch (t) {
|
|
K = !1
|
|
}
|
|
K = !1
|
|
}
|
|
return K
|
|
})()
|
|
? i.body
|
|
: await i.blob()
|
|
return new Response(c, a)
|
|
}
|
|
class M extends q {
|
|
constructor(t = {}) {
|
|
;(t.cacheName = w(t.cacheName)),
|
|
super(t),
|
|
(this.F = !1 !== t.fallbackToNetwork),
|
|
this.plugins.push(M.copyRedirectedCacheableResponsesPlugin)
|
|
}
|
|
async U(t, e) {
|
|
const s = await e.cacheMatch(t)
|
|
return (
|
|
s ||
|
|
(e.event && 'install' === e.event.type
|
|
? await this.B(t, e)
|
|
: await this.H(t, e))
|
|
)
|
|
}
|
|
async H(t, e) {
|
|
let n
|
|
if (!this.F)
|
|
throw new s('missing-precache-entry', {
|
|
cacheName: this.cacheName,
|
|
url: t.url,
|
|
})
|
|
return (n = await e.fetch(t)), n
|
|
}
|
|
async B(t, e) {
|
|
this.$()
|
|
const n = await e.fetch(t)
|
|
if (!(await e.cachePut(t, n.clone())))
|
|
throw new s('bad-precaching-response', { url: t.url, status: n.status })
|
|
return n
|
|
}
|
|
$() {
|
|
let t = null,
|
|
e = 0
|
|
for (const [s, n] of this.plugins.entries())
|
|
n !== M.copyRedirectedCacheableResponsesPlugin &&
|
|
(n === M.defaultPrecacheCacheabilityPlugin && (t = s),
|
|
n.cacheWillUpdate && e++)
|
|
0 === e
|
|
? this.plugins.push(M.defaultPrecacheCacheabilityPlugin)
|
|
: e > 1 && null !== t && this.plugins.splice(t, 1)
|
|
}
|
|
}
|
|
;(M.defaultPrecacheCacheabilityPlugin = {
|
|
cacheWillUpdate: async ({ response: t }) =>
|
|
!t || t.status >= 400 ? null : t,
|
|
}),
|
|
(M.copyRedirectedCacheableResponsesPlugin = {
|
|
cacheWillUpdate: async ({ response: t }) =>
|
|
t.redirected ? await W(t) : t,
|
|
})
|
|
class A {
|
|
constructor({
|
|
cacheName: t,
|
|
plugins: e = [],
|
|
fallbackToNetwork: s = !0,
|
|
} = {}) {
|
|
;(this.G = new Map()),
|
|
(this.V = new Map()),
|
|
(this.J = new Map()),
|
|
(this.u = new M({
|
|
cacheName: w(t),
|
|
plugins: [...e, new k({ precacheController: this })],
|
|
fallbackToNetwork: s,
|
|
})),
|
|
(this.install = this.install.bind(this)),
|
|
(this.activate = this.activate.bind(this))
|
|
}
|
|
get strategy() {
|
|
return this.u
|
|
}
|
|
precache(t) {
|
|
this.addToCacheList(t),
|
|
this.X ||
|
|
(self.addEventListener('install', this.install),
|
|
self.addEventListener('activate', this.activate),
|
|
(this.X = !0))
|
|
}
|
|
addToCacheList(t) {
|
|
const e = []
|
|
for (const n of t) {
|
|
'string' == typeof n
|
|
? e.push(n)
|
|
: n && void 0 === n.revision && e.push(n.url)
|
|
const { cacheKey: t, url: i } = T(n),
|
|
r = 'string' != typeof n && n.revision ? 'reload' : 'default'
|
|
if (this.G.has(i) && this.G.get(i) !== t)
|
|
throw new s('add-to-cache-list-conflicting-entries', {
|
|
firstEntry: this.G.get(i),
|
|
secondEntry: t,
|
|
})
|
|
if ('string' != typeof n && n.integrity) {
|
|
if (this.J.has(t) && this.J.get(t) !== n.integrity)
|
|
throw new s('add-to-cache-list-conflicting-integrities', { url: i })
|
|
this.J.set(t, n.integrity)
|
|
}
|
|
if ((this.G.set(i, t), this.V.set(i, r), e.length > 0)) {
|
|
const t = `Workbox is precaching URLs without revision info: ${e.join(
|
|
', '
|
|
)}\nThis is generally NOT safe. Learn more at https://bit.ly/wb-precache`
|
|
console.warn(t)
|
|
}
|
|
}
|
|
}
|
|
install(t) {
|
|
return D(t, async () => {
|
|
const e = new P()
|
|
this.strategy.plugins.push(e)
|
|
for (const [e, s] of this.G) {
|
|
const n = this.J.get(s),
|
|
i = this.V.get(e),
|
|
r = new Request(e, {
|
|
integrity: n,
|
|
cache: i,
|
|
credentials: 'same-origin',
|
|
})
|
|
await Promise.all(
|
|
this.strategy.handleAll({
|
|
params: { cacheKey: s },
|
|
request: r,
|
|
event: t,
|
|
})
|
|
)
|
|
}
|
|
const { updatedURLs: s, notUpdatedURLs: n } = e
|
|
return { updatedURLs: s, notUpdatedURLs: n }
|
|
})
|
|
}
|
|
activate(t) {
|
|
return D(t, async () => {
|
|
const t = await self.caches.open(this.strategy.cacheName),
|
|
e = await t.keys(),
|
|
s = new Set(this.G.values()),
|
|
n = []
|
|
for (const i of e) s.has(i.url) || (await t.delete(i), n.push(i.url))
|
|
return { deletedURLs: n }
|
|
})
|
|
}
|
|
getURLsToCacheKeys() {
|
|
return this.G
|
|
}
|
|
getCachedURLs() {
|
|
return [...this.G.keys()]
|
|
}
|
|
getCacheKeyForURL(t) {
|
|
const e = new URL(t, location.href)
|
|
return this.G.get(e.href)
|
|
}
|
|
async matchPrecache(t) {
|
|
const e = t instanceof Request ? t.url : t,
|
|
s = this.getCacheKeyForURL(e)
|
|
if (s) {
|
|
return (await self.caches.open(this.strategy.cacheName)).match(s)
|
|
}
|
|
}
|
|
createHandlerBoundToURL(t) {
|
|
const e = this.getCacheKeyForURL(t)
|
|
if (!e) throw new s('non-precached-url', { url: t })
|
|
return (s) => (
|
|
(s.request = new Request(t)),
|
|
(s.params = p({ cacheKey: e }, s.params)),
|
|
this.strategy.handle(s)
|
|
)
|
|
}
|
|
}
|
|
const S = () => (O || (O = new A()), O)
|
|
class I extends i {
|
|
constructor(t, e) {
|
|
super(({ request: s }) => {
|
|
const n = t.getURLsToCacheKeys()
|
|
for (const t of (function* (
|
|
t,
|
|
{
|
|
ignoreURLParametersMatching: e = [/^utm_/, /^fbclid$/],
|
|
directoryIndex: s = 'index.html',
|
|
cleanURLs: n = !0,
|
|
urlManipulation: i,
|
|
} = {}
|
|
) {
|
|
const r = new URL(t, location.href)
|
|
;(r.hash = ''), yield r.href
|
|
const a = (function (t, e = []) {
|
|
for (const s of [...t.searchParams.keys()])
|
|
e.some((t) => t.test(s)) && t.searchParams.delete(s)
|
|
return t
|
|
})(r, e)
|
|
if ((yield a.href, s && a.pathname.endsWith('/'))) {
|
|
const t = new URL(a.href)
|
|
;(t.pathname += s), yield t.href
|
|
}
|
|
if (n) {
|
|
const t = new URL(a.href)
|
|
;(t.pathname += '.html'), yield t.href
|
|
}
|
|
if (i) {
|
|
const t = i({ url: r })
|
|
for (const e of t) yield e.href
|
|
}
|
|
})(s.url, e)) {
|
|
const e = n.get(t)
|
|
if (e) return { cacheKey: e }
|
|
}
|
|
}, t.strategy)
|
|
}
|
|
}
|
|
;(t.CacheFirst = class extends q {
|
|
async U(t, e) {
|
|
let n,
|
|
i = await e.cacheMatch(t)
|
|
if (!i)
|
|
try {
|
|
i = await e.fetchAndCachePut(t)
|
|
} catch (t) {
|
|
n = t
|
|
}
|
|
if (!i) throw new s('no-response', { url: t.url, error: n })
|
|
return i
|
|
}
|
|
}),
|
|
(t.ExpirationPlugin = class {
|
|
constructor(t = {}) {
|
|
var e
|
|
;(this.cachedResponseWillBeUsed = async ({
|
|
event: t,
|
|
request: e,
|
|
cacheName: s,
|
|
cachedResponse: n,
|
|
}) => {
|
|
if (!n) return null
|
|
const i = this.Y(n),
|
|
r = this.Z(s)
|
|
U(r.expireEntries())
|
|
const a = r.updateTimestamp(e.url)
|
|
if (t)
|
|
try {
|
|
t.waitUntil(a)
|
|
} catch (t) {}
|
|
return i ? n : null
|
|
}),
|
|
(this.cacheDidUpdate = async ({ cacheName: t, request: e }) => {
|
|
const s = this.Z(t)
|
|
await s.updateTimestamp(e.url), await s.expireEntries()
|
|
}),
|
|
(this.tt = t),
|
|
(this.A = t.maxAgeSeconds),
|
|
(this.et = new Map()),
|
|
t.purgeOnQuotaError &&
|
|
((e = () => this.deleteCacheAndMetadata()), g.add(e))
|
|
}
|
|
Z(t) {
|
|
if (t === d()) throw new s('expire-custom-caches-only')
|
|
let e = this.et.get(t)
|
|
return e || ((e = new E(t, this.tt)), this.et.set(t, e)), e
|
|
}
|
|
Y(t) {
|
|
if (!this.A) return !0
|
|
const e = this.st(t)
|
|
if (null === e) return !0
|
|
return e >= Date.now() - 1e3 * this.A
|
|
}
|
|
st(t) {
|
|
if (!t.headers.has('date')) return null
|
|
const e = t.headers.get('date'),
|
|
s = new Date(e).getTime()
|
|
return isNaN(s) ? null : s
|
|
}
|
|
async deleteCacheAndMetadata() {
|
|
for (const [t, e] of this.et)
|
|
await self.caches.delete(t), await e.delete()
|
|
this.et = new Map()
|
|
}
|
|
}),
|
|
(t.NetworkFirst = class extends q {
|
|
constructor(t = {}) {
|
|
super(t),
|
|
this.plugins.some((t) => 'cacheWillUpdate' in t) ||
|
|
this.plugins.unshift(u),
|
|
(this.nt = t.networkTimeoutSeconds || 0)
|
|
}
|
|
async U(t, e) {
|
|
const n = [],
|
|
i = []
|
|
let r
|
|
if (this.nt) {
|
|
const { id: s, promise: a } = this.it({
|
|
request: t,
|
|
logs: n,
|
|
handler: e,
|
|
})
|
|
;(r = s), i.push(a)
|
|
}
|
|
const a = this.rt({ timeoutId: r, request: t, logs: n, handler: e })
|
|
i.push(a)
|
|
const c = await e.waitUntil(
|
|
(async () => (await e.waitUntil(Promise.race(i))) || (await a))()
|
|
)
|
|
if (!c) throw new s('no-response', { url: t.url })
|
|
return c
|
|
}
|
|
it({ request: t, logs: e, handler: s }) {
|
|
let n
|
|
return {
|
|
promise: new Promise((e) => {
|
|
n = setTimeout(async () => {
|
|
e(await s.cacheMatch(t))
|
|
}, 1e3 * this.nt)
|
|
}),
|
|
id: n,
|
|
}
|
|
}
|
|
async rt({ timeoutId: t, request: e, logs: s, handler: n }) {
|
|
let i, r
|
|
try {
|
|
r = await n.fetchAndCachePut(e)
|
|
} catch (t) {
|
|
i = t
|
|
}
|
|
return t && clearTimeout(t), (!i && r) || (r = await n.cacheMatch(e)), r
|
|
}
|
|
}),
|
|
(t.StaleWhileRevalidate = class extends q {
|
|
constructor(t) {
|
|
super(t),
|
|
this.plugins.some((t) => 'cacheWillUpdate' in t) ||
|
|
this.plugins.unshift(u)
|
|
}
|
|
async U(t, e) {
|
|
const n = e.fetchAndCachePut(t).catch(() => {})
|
|
let i,
|
|
r = await e.cacheMatch(t)
|
|
if (r);
|
|
else
|
|
try {
|
|
r = await n
|
|
} catch (t) {
|
|
i = t
|
|
}
|
|
if (!r) throw new s('no-response', { url: t.url, error: i })
|
|
return r
|
|
}
|
|
}),
|
|
(t.cleanupOutdatedCaches = function () {
|
|
self.addEventListener('activate', (t) => {
|
|
const e = w()
|
|
t.waitUntil(
|
|
(async (t, e = '-precache-') => {
|
|
const s = (await self.caches.keys()).filter(
|
|
(s) =>
|
|
s.includes(e) && s.includes(self.registration.scope) && s !== t
|
|
)
|
|
return await Promise.all(s.map((t) => self.caches.delete(t))), s
|
|
})(e).then((t) => {})
|
|
)
|
|
})
|
|
}),
|
|
(t.clientsClaim = function () {
|
|
self.addEventListener('activate', () => self.clients.claim())
|
|
}),
|
|
(t.precacheAndRoute = function (t, e) {
|
|
!(function (t) {
|
|
S().precache(t)
|
|
})(t),
|
|
(function (t) {
|
|
const e = S()
|
|
h(new I(e, t))
|
|
})(e)
|
|
}),
|
|
(t.registerRoute = h)
|
|
})
|
|
//# sourceMappingURL=workbox-ea903bce.js.map
|