From 13df590489def2f5d007a650ff91efe49920b454 Mon Sep 17 00:00:00 2001 From: "Thomas F. K. Jorna" Date: Sat, 31 Jul 2021 18:48:09 +0200 Subject: included new build --- public/sw.js | 267 ++++++++++++ public/workbox-ea903bce.js | 1023 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 1290 insertions(+) create mode 100644 public/sw.js create mode 100644 public/workbox-ea903bce.js (limited to 'public') diff --git a/public/sw.js b/public/sw.js new file mode 100644 index 0000000..dcbb3a6 --- /dev/null +++ b/public/sw.js @@ -0,0 +1,267 @@ +if (!self.define) { + const e = (e) => { + 'require' !== e && (e += '.js') + let s = Promise.resolve() + return ( + n[e] || + (s = new Promise(async (s) => { + if ('document' in self) { + const n = document.createElement('script') + ;(n.src = e), document.head.appendChild(n), (n.onload = s) + } else importScripts(e), s() + })), + s.then(() => { + if (!n[e]) throw new Error(`Module ${e} didn’t register its module`) + return n[e] + }) + ) + }, + s = (s, n) => { + Promise.all(s.map(e)).then((e) => n(1 === e.length ? e[0] : e)) + }, + n = { require: Promise.resolve(s) } + self.define = (s, t, r) => { + n[s] || + (n[s] = Promise.resolve().then(() => { + let n = {} + const a = { uri: location.origin + s.slice(1) } + return Promise.all( + t.map((s) => { + switch (s) { + case 'exports': + return n + case 'module': + return a + default: + return e(s) + } + }), + ).then((e) => { + const s = r(...e) + return n.default || (n.default = s), n + }) + })) + } +} +define('./sw.js', ['./workbox-ea903bce'], function (e) { + 'use strict' + importScripts(), + self.skipWaiting(), + e.clientsClaim(), + e.precacheAndRoute( + [ + { + url: '/_next/static/chunks/4.2dee5d830195ddd06029.js', + revision: 'sqy183jmJB5HZRA44nlqt', + }, + { + url: '/_next/static/chunks/906-f789bd1954ec4d176da1.js', + revision: 'sqy183jmJB5HZRA44nlqt', + }, + { + url: '/_next/static/chunks/d25bd147-65fcc4c92edba8b370fb.js', + revision: 'sqy183jmJB5HZRA44nlqt', + }, + { + url: '/_next/static/chunks/fb7d5399-0d6001c72a29ebec41eb.js', + revision: 'sqy183jmJB5HZRA44nlqt', + }, + { + url: '/_next/static/chunks/framework-2191d16384373197bc0a.js', + revision: 'sqy183jmJB5HZRA44nlqt', + }, + { + url: '/_next/static/chunks/main-1b0f1fd287f08bad6012.js', + revision: 'sqy183jmJB5HZRA44nlqt', + }, + { + url: '/_next/static/chunks/pages/_app-fbd69a3b63bd43d7f1b0.js', + revision: 'sqy183jmJB5HZRA44nlqt', + }, + { + url: '/_next/static/chunks/pages/_error-a0e21b9b223f827fe1f2.js', + revision: 'sqy183jmJB5HZRA44nlqt', + }, + { + url: '/_next/static/chunks/pages/index-5cea1a6a4f484642ff08.js', + revision: 'sqy183jmJB5HZRA44nlqt', + }, + { + url: '/_next/static/chunks/polyfills-a54b4f32bdc1ef890ddd.js', + revision: 'sqy183jmJB5HZRA44nlqt', + }, + { + url: '/_next/static/chunks/webpack-a1ea085630ce50807058.js', + revision: 'sqy183jmJB5HZRA44nlqt', + }, + { url: '/_next/static/css/331301db207a91d407e5.css', revision: 'sqy183jmJB5HZRA44nlqt' }, + { + url: '/_next/static/sqy183jmJB5HZRA44nlqt/_buildManifest.js', + revision: 'sqy183jmJB5HZRA44nlqt', + }, + { + url: '/_next/static/sqy183jmJB5HZRA44nlqt/_ssgManifest.js', + revision: 'sqy183jmJB5HZRA44nlqt', + }, + { url: '/favicon.ico', revision: 'c30c7d42707a47a3f4591831641e50dc' }, + { url: '/vercel.svg', revision: '4b4f1876502eb6721764637fe5c41702' }, + ], + { ignoreURLParametersMatching: [] }, + ), + e.cleanupOutdatedCaches(), + e.registerRoute( + '/', + new e.NetworkFirst({ + cacheName: 'start-url', + plugins: [ + { + cacheWillUpdate: async ({ request: e, response: s, event: n, state: t }) => + s && 'opaqueredirect' === s.type + ? new Response(s.body, { status: 200, statusText: 'OK', headers: s.headers }) + : s, + }, + ], + }), + 'GET', + ), + e.registerRoute( + /^https:\/\/fonts\.(?:gstatic)\.com\/.*/i, + new e.CacheFirst({ + cacheName: 'google-fonts-webfonts', + plugins: [ + new e.ExpirationPlugin({ maxEntries: 4, maxAgeSeconds: 31536e3, purgeOnQuotaError: !0 }), + ], + }), + 'GET', + ), + e.registerRoute( + /^https:\/\/fonts\.(?:googleapis)\.com\/.*/i, + new e.StaleWhileRevalidate({ + cacheName: 'google-fonts-stylesheets', + plugins: [ + new e.ExpirationPlugin({ maxEntries: 4, maxAgeSeconds: 604800, purgeOnQuotaError: !0 }), + ], + }), + 'GET', + ), + e.registerRoute( + /\.(?:eot|otf|ttc|ttf|woff|woff2|font.css)$/i, + new e.StaleWhileRevalidate({ + cacheName: 'static-font-assets', + plugins: [ + new e.ExpirationPlugin({ maxEntries: 4, maxAgeSeconds: 604800, purgeOnQuotaError: !0 }), + ], + }), + 'GET', + ), + e.registerRoute( + /\.(?:jpg|jpeg|gif|png|svg|ico|webp)$/i, + new e.StaleWhileRevalidate({ + cacheName: 'static-image-assets', + plugins: [ + new e.ExpirationPlugin({ maxEntries: 64, maxAgeSeconds: 86400, purgeOnQuotaError: !0 }), + ], + }), + 'GET', + ), + e.registerRoute( + /\/_next\/image\?url=.+$/i, + new e.StaleWhileRevalidate({ + cacheName: 'next-image', + plugins: [ + new e.ExpirationPlugin({ maxEntries: 64, maxAgeSeconds: 86400, purgeOnQuotaError: !0 }), + ], + }), + 'GET', + ), + e.registerRoute( + /\.(?:mp3|mp4)$/i, + new e.StaleWhileRevalidate({ + cacheName: 'static-media-assets', + plugins: [ + new e.ExpirationPlugin({ maxEntries: 32, maxAgeSeconds: 86400, purgeOnQuotaError: !0 }), + ], + }), + 'GET', + ), + e.registerRoute( + /\.(?:js)$/i, + new e.StaleWhileRevalidate({ + cacheName: 'static-js-assets', + plugins: [ + new e.ExpirationPlugin({ maxEntries: 32, maxAgeSeconds: 86400, purgeOnQuotaError: !0 }), + ], + }), + 'GET', + ), + e.registerRoute( + /\.(?:css|less)$/i, + new e.StaleWhileRevalidate({ + cacheName: 'static-style-assets', + plugins: [ + new e.ExpirationPlugin({ maxEntries: 32, maxAgeSeconds: 86400, purgeOnQuotaError: !0 }), + ], + }), + 'GET', + ), + e.registerRoute( + /\/_next\/data\/.+\/.+\.json$/i, + new e.StaleWhileRevalidate({ + cacheName: 'next-data', + plugins: [ + new e.ExpirationPlugin({ maxEntries: 32, maxAgeSeconds: 86400, purgeOnQuotaError: !0 }), + ], + }), + 'GET', + ), + e.registerRoute( + /\.(?:json|xml|csv)$/i, + new e.NetworkFirst({ + cacheName: 'static-data-assets', + plugins: [ + new e.ExpirationPlugin({ maxEntries: 32, maxAgeSeconds: 86400, purgeOnQuotaError: !0 }), + ], + }), + 'GET', + ), + e.registerRoute( + ({ url: e }) => { + if (!(self.origin === e.origin)) return !1 + const s = e.pathname + return !s.startsWith('/api/auth/') && !!s.startsWith('/api/') + }, + new e.NetworkFirst({ + cacheName: 'apis', + networkTimeoutSeconds: 10, + plugins: [ + new e.ExpirationPlugin({ maxEntries: 16, maxAgeSeconds: 86400, purgeOnQuotaError: !0 }), + ], + }), + 'GET', + ), + e.registerRoute( + ({ url: e }) => { + if (!(self.origin === e.origin)) return !1 + return !e.pathname.startsWith('/api/') + }, + new e.NetworkFirst({ + cacheName: 'others', + networkTimeoutSeconds: 10, + plugins: [ + new e.ExpirationPlugin({ maxEntries: 32, maxAgeSeconds: 86400, purgeOnQuotaError: !0 }), + ], + }), + 'GET', + ), + e.registerRoute( + ({ url: e }) => !(self.origin === e.origin), + new e.NetworkFirst({ + cacheName: 'cross-origin', + networkTimeoutSeconds: 10, + plugins: [ + new e.ExpirationPlugin({ maxEntries: 32, maxAgeSeconds: 3600, purgeOnQuotaError: !0 }), + ], + }), + 'GET', + ) +}) diff --git a/public/workbox-ea903bce.js b/public/workbox-ea903bce.js new file mode 100644 index 0000000..1d33a59 --- /dev/null +++ b/public/workbox-ea903bce.js @@ -0,0 +1,1023 @@ +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) +}) -- cgit v1.2.3