🎉 🔍 Add ServerSideRendering
Tim Izzo tim@octree.ch
Mon, 21 Jun 2021 17:37:42 +0200
15 files changed,
2952 insertions(+),
49 deletions(-)
jump to
M
Dockerfile
→
Dockerfile
@@ -5,3 +5,6 @@ ENV VERSION ${VERSION:-dev}
COPY backend /srv/app/backend COPY frontend /srv/app/frontend +COPY ecosystem.config.js /srv/app/ + +CMD cd /srv/app; pm2 start ecosystem.config.js; pm2 logs
M
backend/config/middleware.js
→
backend/config/middleware.js
@@ -1,14 +1,17 @@
module.exports = ({env}) => ({ timeout: 10000, load: { - after: ['parser', 'router', 'next'], + after: ['parser', 'router', 'next', 'next-proxy'], }, settings: { - next: { + 'next-proxy': { enabled: true, - dir: '/srv/app/frontend', - quiet: false, - conf: {}, + host: env('NEXT_URL', 'http://localhost:3000'), + conf: { + overrideResponseHeaders: { + 'next-proxy': true, + }, + }, }, sentry: { enabled: true,
A
backend/middlewares/next-proxy/index.js
@@ -0,0 +1,19 @@
+const proxy = require('koa-proxy'); + +module.exports = strapi => ({ + async initialize() { + const {host = '', conf = {}} = strapi.config.middleware.settings[ + 'next-proxy' + ]; + + strapi.router.get('/', proxy({host, ...conf})); + + strapi.app.use(async (ctx, next) => { + await next(); + + if (ctx.response.status === 404) { + await proxy({host, ...conf})(ctx); + } + }); + }, +});
D
backend/middlewares/next/index.js
@@ -1,28 +0,0 @@
-const next = require('next'); - -module.exports = strapi => ({ - async initialize() { - if (process.env.NODE_ENV !== 'production') return; - - const app = next({ - dev: process.env.NODE_ENV !== 'production', - ...strapi.config.middleware.settings.next, - }); - const handle = app.getRequestHandler(); - - // Prepare NextJS server - await app.prepare(); - - // Serve NextJS on index - strapi.router.get('/', ctx => handle(ctx.req, ctx.res)); - - // Serve NextJS app on non-handled endpoints - strapi.app.use(async (ctx, nxt) => { - await nxt(); - - if (ctx.response.status === 404) { - await handle(ctx.req, ctx.res); - } - }); - }, -});
M
backend/package.json
→
backend/package.json
@@ -18,6 +18,7 @@ },
"dependencies": { "axios": "^0.19.2", "knex": "^0.95.6", + "koa-proxy": "^1.0.0-alpha.3", "moment": "^2.27.0", "next": "^11.0.0", "pg": "^8.5.1",
M
backend/yarn.lock
→
backend/yarn.lock
@@ -6964,6 +6964,15 @@ integrity sha512-dJBCkl4X+zdYxbI2V2OtoGy0PUenpvp2ZLLWObc8UJhsId0iQpTFT8RVcuA0709AL2txGwRHnSPoT1bYNGa6Kg==
dependencies: passport "^0.4.0" +koa-proxy@^1.0.0-alpha.3: + version "1.0.0-alpha.3" + resolved "https://npm-8ee.hidora.com/koa-proxy/-/koa-proxy-1.0.0-alpha.3.tgz#afc61edc9dc6a195464664beccc162cfe994bf55" + integrity sha512-8ke0WoQKAsQ8BpkC9+I83lKsFaycE9fcLeTx12jQtEa5SrdTI6mNKR5M4LslHbvkX1hDhXreIszXsnom5Ej7RQ== + dependencies: + pause-stream "0.0.11" + request "^2.88.0" + request-promise-native "^1.0.5" + koa-range@0.3.0: version "0.3.0" resolved "https://npm-8ee.hidora.com/koa-range/-/koa-range-0.3.0.tgz#3588e3496473a839a1bd264d2a42b1d85bd7feac"@@ -7205,7 +7214,7 @@ version "4.17.12"
resolved "https://npm-8ee.hidora.com/lodash/-/lodash-4.17.12.tgz#a712c74fdc31f7ecb20fe44f157d802d208097ef" integrity sha512-+CiwtLnsJhX03p20mwXuvhoebatoh5B3tt+VvYlrPgZC1g36y+RRbkufX95Xa+X4I59aWEacDFYwnJZiyBh9gA== -lodash@4.17.21, lodash@^4.1.1, lodash@^4.17.11, lodash@^4.17.12, lodash@^4.17.13, lodash@^4.17.14, lodash@^4.17.15, lodash@^4.17.20, lodash@^4.17.21, lodash@^4.17.3, lodash@^4.17.4: +lodash@4.17.21, lodash@^4.1.1, lodash@^4.17.11, lodash@^4.17.12, lodash@^4.17.13, lodash@^4.17.14, lodash@^4.17.15, lodash@^4.17.19, lodash@^4.17.20, lodash@^4.17.21, lodash@^4.17.3, lodash@^4.17.4: version "4.17.21" resolved "https://npm-8ee.hidora.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c" integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==@@ -8450,6 +8459,13 @@ integrity sha512-n43JRhlUKUAlibEJhPeir1ncUID16QnEjNpwzNdO3Lm4ywrBpBZ5oLD0I6br9evr1Y9JTqwRtAh7JLoOzAQdVA==
dependencies: isarray "0.0.1" +pause-stream@0.0.11: + version "0.0.11" + resolved "https://npm-8ee.hidora.com/pause-stream/-/pause-stream-0.0.11.tgz#fe5a34b0cbce12b5aa6a2b403ee2e73b602f1445" + integrity sha1-/lo0sMvOErWqaitAPuLnO2AvFEU= + dependencies: + through "~2.3" + pause@0.0.1: version "0.0.1" resolved "https://npm-8ee.hidora.com/pause/-/pause-0.0.1.tgz#1d408b3fdb76923b9543d96fb4c9dfd535d9cb5d"@@ -9693,7 +9709,23 @@ oauth-sign "^0.9.0"
qs "^6.9.6" uuid "^8.3.2" -request@^2.83.0: +request-promise-core@1.1.4: + version "1.1.4" + resolved "https://npm-8ee.hidora.com/request-promise-core/-/request-promise-core-1.1.4.tgz#3eedd4223208d419867b78ce815167d10593a22f" + integrity sha512-TTbAfBBRdWD7aNNOoVOBH4pN/KigV6LyapYNNlAPA8JwbovRti1E88m3sYAwsLi5ryhPKsE9APwnjFTgdUjTpw== + dependencies: + lodash "^4.17.19" + +request-promise-native@^1.0.5: + version "1.0.9" + resolved "https://npm-8ee.hidora.com/request-promise-native/-/request-promise-native-1.0.9.tgz#e407120526a5efdc9a39b28a5679bf47b9d9dc28" + integrity sha512-wcW+sIUiWnKgNY0dqCpOZkUbF/I+YPi+f09JZIDa39Ec+q82CpSYniDp+ISgTTbKmnpJWASeJBPZmoxH84wt3g== + dependencies: + request-promise-core "1.1.4" + stealthy-require "^1.1.1" + tough-cookie "^2.3.3" + +request@^2.83.0, request@^2.88.0: version "2.88.2" resolved "https://npm-8ee.hidora.com/request/-/request-2.88.2.tgz#d73c918731cb5a87da047e207234146f664d12b3" integrity sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw==@@ -10494,6 +10526,11 @@ resolved "https://npm-8ee.hidora.com/std-env/-/std-env-2.3.0.tgz#66d4a4a4d5224242ed8e43f5d65cfa9095216eee"
integrity sha512-4qT5B45+Kjef2Z6pE0BkskzsH0GO7GrND0wGlTM1ioUe3v0dGYx9ZJH0Aro/YyA8fqQ5EyIKDRjZojJYMFTflw== dependencies: ci-info "^3.0.0" + +stealthy-require@^1.1.1: + version "1.1.1" + resolved "https://npm-8ee.hidora.com/stealthy-require/-/stealthy-require-1.1.1.tgz#35b09875b4ff49f26a777e509b3090a3226bf24b" + integrity sha1-NbCYdbT/SfJqd35QmzCQoyJr8ks= strapi-admin@3.6.3: version "3.6.3"@@ -11442,7 +11479,7 @@ dependencies:
readable-stream "~2.3.6" xtend "~4.0.1" -through@^2.3.6, through@~2.3.6: +through@^2.3.6, through@~2.3, through@~2.3.6: version "2.3.8" resolved "https://npm-8ee.hidora.com/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5" integrity sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=@@ -11553,7 +11590,7 @@ version "2.0.2"
resolved "https://npm-8ee.hidora.com/toposort/-/toposort-2.0.2.tgz#ae21768175d1559d48bef35420b2f4962f09c330" integrity sha1-riF2gXXRVZ1IvvNUILL0li8JwzA= -tough-cookie@~2.5.0: +tough-cookie@^2.3.3, tough-cookie@~2.5.0: version "2.5.0" resolved "https://npm-8ee.hidora.com/tough-cookie/-/tough-cookie-2.5.0.tgz#cd9fb2a0aa1d5a12b473bd9fb96fa3dcff65ade2" integrity sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==
A
ecosystem.config.js
@@ -0,0 +1,21 @@
+module.exports = { + apps: [ + { + name: "strapi", + cwd: "backend/", + script: "yarn", + args: "start", + interpreter: "bash", + restart_delay: 10000, + max_restarts: 10, + }, + { + name: "next", + cwd: "frontend/", + script: "yarn", + args: "start", + interpreter: "bash", + restart_delay: 10000, + }, + ], +};
M
frontend/lib/apolloClient.tsx
→
frontend/lib/apolloClient.tsx
@@ -46,7 +46,10 @@ cache: new InMemoryCache(),
}); }; -export const initializeApollo = (initialState: object, token: string) => { +export const initializeApollo = ( + initialState: object = {}, + token: string = '' +) => { const _apolloClient = createApolloClient(token); // If your page has Next.js data fetching methods that use Apollo Client, the initial state gets hydrated here
M
frontend/pages/_app.tsx
→
frontend/pages/_app.tsx
@@ -24,7 +24,7 @@ return (
<ApolloProvider client={apolloClient}> <Fragment> <Head> - <title>Caroster</title> + <title>{pageProps.meta?.title || 'Caroster'}</title> <meta name="viewport" content="minimum-scale=1, initial-scale=1, width=device-width"
M
frontend/pages/e/[eventId].tsx
→
frontend/pages/e/[eventId].tsx
@@ -9,26 +9,24 @@ import AddToMyEventDialog from '../../containers/AddToMyEventDialog';
import Loading from '../../containers/Loading'; import EventBar from '../../containers/EventBar'; import useToastStore from '../../stores/useToastStore'; +import {initializeApollo} from '../../lib/apolloClient'; import { - useEventQuery, useUpdateEventMutation, Event as EventType, + EventDocument, } from '../../generated/graphql'; import useEventStore from '../../stores/useEventStore'; interface Props { - eventId: string; + event: EventType; } -const Event = ({eventId}: Props) => { +const Event = ({event}: Props) => { const {t} = useTranslation(); const addToast = useToastStore(s => s.addToast); const setEvent = useEventStore(s => s.setEvent); const eventUpdate = useEventStore(s => s.event); const setIsEditing = useEventStore(s => s.setIsEditing); - const {data: {event} = {}, loading, error} = useEventQuery({ - variables: {id: eventId}, - }); const [updateEvent] = useUpdateEventMutation(); const [isAddToMyEvent, setIsAddToMyEvent] = useState(false); const [openNewCar, toggleNewCar] = useReducer(i => !i, false);@@ -66,8 +64,6 @@ return true;
} }; - if (loading) return <Loading />; - return ( <Layout pageTitle={t('event.title', {title: event.name})}@@ -91,6 +87,25 @@ />
</Layout> ); }; + +export async function getServerSideProps(context) { + const {eventId} = context.query; + const apolloClient = initializeApollo(); + const {data = {}} = await apolloClient.query({ + query: EventDocument, + variables: {id: eventId}, + }); + const {event} = data; + + return { + props: { + event, + meta: { + title: event?.name, + }, + }, + }; +} export default props => { const router = useRouter();
M
frontend/public/sw.js
→
frontend/public/sw.js
@@ -1,1 +1,128 @@
-if(!self.define){const e=e=>{"require"!==e&&(e+=".js");let s=Promise.resolve();return a[e]||(s=new Promise((async s=>{if("document"in self){const a=document.createElement("script");a.src=e,document.head.appendChild(a),a.onload=s}else importScripts(e),s()}))),s.then((()=>{if(!a[e])throw new Error(`Module ${e} didn’t register its module`);return a[e]}))},s=(s,a)=>{Promise.all(s.map(e)).then((e=>a(1===e.length?e[0]:e)))},a={require:Promise.resolve(s)};self.define=(s,n,t)=>{a[s]||(a[s]=Promise.resolve().then((()=>{let a={};const r={uri:location.origin+s.slice(1)};return Promise.all(n.map((s=>{switch(s){case"exports":return a;case"module":return r;default:return e(s)}}))).then((e=>{const s=t(...e);return a.default||(a.default=s),a}))})))}}define("./sw.js",["./workbox-ea903bce"],(function(e){"use strict";importScripts(),self.skipWaiting(),e.clientsClaim(),e.precacheAndRoute([{url:"/_next/static/JT0xld2I5wp6z9Dmh3RVV/_buildManifest.js",revision:"JT0xld2I5wp6z9Dmh3RVV"},{url:"/_next/static/JT0xld2I5wp6z9Dmh3RVV/_ssgManifest.js",revision:"JT0xld2I5wp6z9Dmh3RVV"},{url:"/_next/static/chunks/410-653db06247f2aaf5b65a.js",revision:"JT0xld2I5wp6z9Dmh3RVV"},{url:"/_next/static/chunks/506-4580d7d40598a37c5ba9.js",revision:"JT0xld2I5wp6z9Dmh3RVV"},{url:"/_next/static/chunks/83-581b598ba6fa8df8c264.js",revision:"JT0xld2I5wp6z9Dmh3RVV"},{url:"/_next/static/chunks/830-cfa8c051a6241caffd1e.js",revision:"JT0xld2I5wp6z9Dmh3RVV"},{url:"/_next/static/chunks/872-1471f7c8dcd3fee5ec9b.js",revision:"JT0xld2I5wp6z9Dmh3RVV"},{url:"/_next/static/chunks/925-26267f659e168d324a87.js",revision:"JT0xld2I5wp6z9Dmh3RVV"},{url:"/_next/static/chunks/940-b0d5631a090d1d9f503d.js",revision:"JT0xld2I5wp6z9Dmh3RVV"},{url:"/_next/static/chunks/framework-2191d16384373197bc0a.js",revision:"JT0xld2I5wp6z9Dmh3RVV"},{url:"/_next/static/chunks/main-ec0b5244d0f3a9994a2e.js",revision:"JT0xld2I5wp6z9Dmh3RVV"},{url:"/_next/static/chunks/pages/_app-7f3f78f7119390446b51.js",revision:"JT0xld2I5wp6z9Dmh3RVV"},{url:"/_next/static/chunks/pages/_error-82a806cd39f8ab3dc3ac.js",revision:"JT0xld2I5wp6z9Dmh3RVV"},{url:"/_next/static/chunks/pages/auth/confirm-6d6e0f167d2458173953.js",revision:"JT0xld2I5wp6z9Dmh3RVV"},{url:"/_next/static/chunks/pages/auth/login-4a43e2fbb93eaed6d823.js",revision:"JT0xld2I5wp6z9Dmh3RVV"},{url:"/_next/static/chunks/pages/auth/lost-password-04941488ea3d5835dfa9.js",revision:"JT0xld2I5wp6z9Dmh3RVV"},{url:"/_next/static/chunks/pages/auth/register-5cc2409de6d121f97824.js",revision:"JT0xld2I5wp6z9Dmh3RVV"},{url:"/_next/static/chunks/pages/auth/reset-804c3aff5a5d6a26d724.js",revision:"JT0xld2I5wp6z9Dmh3RVV"},{url:"/_next/static/chunks/pages/dashboard-95a97a201c707db37f0a.js",revision:"JT0xld2I5wp6z9Dmh3RVV"},{url:"/_next/static/chunks/pages/e/%5BeventId%5D-2d43d27863a435780b38.js",revision:"JT0xld2I5wp6z9Dmh3RVV"},{url:"/_next/static/chunks/pages/index-6b3abf405d9a4c7f8142.js",revision:"JT0xld2I5wp6z9Dmh3RVV"},{url:"/_next/static/chunks/pages/profile-63c45769bf2482128895.js",revision:"JT0xld2I5wp6z9Dmh3RVV"},{url:"/_next/static/chunks/polyfills-a54b4f32bdc1ef890ddd.js",revision:"JT0xld2I5wp6z9Dmh3RVV"},{url:"/_next/static/chunks/webpack-6d72c6ed51d58793f029.js",revision:"JT0xld2I5wp6z9Dmh3RVV"},{url:"/assets/Caroster_Octree_Social.jpg",revision:"563fc10a4ec83e735943c5f67d417a6e"},{url:"/assets/android-chrome-192x192.png",revision:"b288769d936ad5f9a87944e027d0096c"},{url:"/assets/android-chrome-512x512.png",revision:"c789c009674fc4a2087a8b71c24a12b7"},{url:"/assets/apple-touch-icon.png",revision:"573a4bc22886d3ef3f6c3aa0eab64d44"},{url:"/assets/favicon-16x16.png",revision:"9f98c22a36ec0001995797d29a7583b1"},{url:"/assets/favicon-32x32.png",revision:"562ff70a6694a29302644d4f85b2e920"},{url:"/assets/favicon.ico",revision:"45004f0a61722a526ca688bddc4955c4"},{url:"/assets/google-icon.svg",revision:"81ad048ed858673aaca6cc2227076b8a"},{url:"/assets/icon.png",revision:"ac122f40fd4c9fd7f1831b0dd406c950"},{url:"/assets/logo.png",revision:"d685d6b49c3aedcf4819d5cbbc873d60"},{url:"/assets/logo.svg",revision:"ac6bdc2dc62feb11a5bc8b0ad3aca84e"},{url:"/assets/site.webmanifest",revision:"053100cb84a50d2ae7f5492f7dd7f25e"},{url:"/favicon.ico",revision:"8eb6dd187ac1c4e26f8df8062bb42e09"},{url:"/manifest.json",revision:"e76480838d8eb8908456941dcb59275e"}],{ignoreURLParametersMatching:[]}),e.cleanupOutdatedCaches(),e.registerRoute("/",new e.NetworkFirst({cacheName:"start-url",plugins:[{cacheWillUpdate:async({request:e,response:s,event:a,state:n})=>s&&"opaqueredirect"===s.type?new Response(s.body,{status:200,statusText:"OK",headers:s.headers}):s}]}),"GET"),e.registerRoute(/^https:\/\/fonts\.(?:googleapis|gstatic)\.com\/.*/i,new e.CacheFirst({cacheName:"google-fonts",plugins:[new e.ExpirationPlugin({maxEntries:4,maxAgeSeconds:31536e3,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")})); +/** + * Copyright 2018 Google Inc. All Rights Reserved. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * http://www.apache.org/licenses/LICENSE-2.0 + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// If the loader is already loaded, just stop. +if (!self.define) { + const singleRequire = name => { + if (name !== 'require') { + name = name + '.js'; + } + let promise = Promise.resolve(); + if (!registry[name]) { + + promise = new Promise(async resolve => { + if ("document" in self) { + const script = document.createElement("script"); + script.src = name; + document.head.appendChild(script); + script.onload = resolve; + } else { + importScripts(name); + resolve(); + } + }); + + } + return promise.then(() => { + if (!registry[name]) { + throw new Error(`Module ${name} didn’t register its module`); + } + return registry[name]; + }); + }; + + const require = (names, resolve) => { + Promise.all(names.map(singleRequire)) + .then(modules => resolve(modules.length === 1 ? modules[0] : modules)); + }; + + const registry = { + require: Promise.resolve(require) + }; + + self.define = (moduleName, depsNames, factory) => { + if (registry[moduleName]) { + // Module is already loading or loaded. + return; + } + registry[moduleName] = Promise.resolve().then(() => { + let exports = {}; + const module = { + uri: location.origin + moduleName.slice(1) + }; + return Promise.all( + depsNames.map(depName => { + switch(depName) { + case "exports": + return exports; + case "module": + return module; + default: + return singleRequire(depName); + } + }) + ).then(deps => { + const facValue = factory(...deps); + if(!exports.default) { + exports.default = facValue; + } + return exports; + }); + }); + }; +} +define("./sw.js",['./workbox-6b19f60b'], function (workbox) { 'use strict'; + + /** + * Welcome to your Workbox-powered service worker! + * + * You'll need to register this file in your web app. + * See https://goo.gl/nhQhGp + * + * The rest of the code is auto-generated. Please don't update this file + * directly; instead, make changes to your Workbox build configuration + * and re-run your build process. + * See https://goo.gl/2aRDsh + */ + + importScripts(); + self.skipWaiting(); + workbox.clientsClaim(); + workbox.registerRoute("/", new workbox.NetworkFirst({ + "cacheName": "start-url", + plugins: [{ + cacheWillUpdate: async ({ + request, + response, + event, + state + }) => { + if (response && response.type === 'opaqueredirect') { + return new Response(response.body, { + status: 200, + statusText: 'OK', + headers: response.headers + }); + } + + return response; + } + }] + }), 'GET'); + workbox.registerRoute(/.*/i, new workbox.NetworkOnly({ + "cacheName": "dev", + plugins: [] + }), 'GET'); + +}); +//# sourceMappingURL=sw.js.map
A
frontend/public/sw.js.map
@@ -0,0 +1,1 @@
+{"version":3,"file":"sw.js","sources":["../../../../../tmp/7a0a201d2f560a8ff75bbb6234f8e973/sw.js"],"sourcesContent":["import {registerRoute as workbox_routing_registerRoute} from '/home/tim/Projets/caroster/frontend/node_modules/workbox-routing/registerRoute.mjs';\nimport {NetworkFirst as workbox_strategies_NetworkFirst} from '/home/tim/Projets/caroster/frontend/node_modules/workbox-strategies/NetworkFirst.mjs';\nimport {NetworkOnly as workbox_strategies_NetworkOnly} from '/home/tim/Projets/caroster/frontend/node_modules/workbox-strategies/NetworkOnly.mjs';\nimport {clientsClaim as workbox_core_clientsClaim} from '/home/tim/Projets/caroster/frontend/node_modules/workbox-core/clientsClaim.mjs';/**\n * Welcome to your Workbox-powered service worker!\n *\n * You'll need to register this file in your web app.\n * See https://goo.gl/nhQhGp\n *\n * The rest of the code is auto-generated. Please don't update this file\n * directly; instead, make changes to your Workbox build configuration\n * and re-run your build process.\n * See https://goo.gl/2aRDsh\n */\n\n\nimportScripts(\n \n);\n\n\n\n\n\n\n\nself.skipWaiting();\n\nworkbox_core_clientsClaim();\n\n\n\nworkbox_routing_registerRoute(\"/\", new workbox_strategies_NetworkFirst({ \"cacheName\":\"start-url\", plugins: [{ cacheWillUpdate: async ({request, response, event, state}) => { if (response && response.type === 'opaqueredirect') { return new Response(response.body, {status: 200, statusText: 'OK', headers: response.headers}); } return response; } }] }), 'GET');\nworkbox_routing_registerRoute(/.*/i, new workbox_strategies_NetworkOnly({ \"cacheName\":\"dev\", plugins: [] }), 'GET');\n\n\n\n\n"],"names":["importScripts","self","skipWaiting","workbox_core_clientsClaim","workbox_routing_registerRoute","workbox_strategies_NetworkFirst","plugins","cacheWillUpdate","request","response","event","state","type","Response","body","status","statusText","headers","workbox_strategies_NetworkOnly"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGyI;EACzI;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;EAGAA,aAAa;EAUbC,IAAI,CAACC,WAAL;AAEAC,sBAAyB;AAIzBC,uBAA6B,CAAC,GAAD,EAAM,IAAIC,oBAAJ,CAAoC;EAAE,eAAY,WAAd;EAA2BC,EAAAA,OAAO,EAAE,CAAC;EAAEC,IAAAA,eAAe,EAAE,OAAO;EAACC,MAAAA,OAAD;EAAUC,MAAAA,QAAV;EAAoBC,MAAAA,KAApB;EAA2BC,MAAAA;EAA3B,KAAP,KAA6C;EAAE,UAAIF,QAAQ,IAAIA,QAAQ,CAACG,IAAT,KAAkB,gBAAlC,EAAoD;EAAE,eAAO,IAAIC,QAAJ,CAAaJ,QAAQ,CAACK,IAAtB,EAA4B;EAACC,UAAAA,MAAM,EAAE,GAAT;EAAcC,UAAAA,UAAU,EAAE,IAA1B;EAAgCC,UAAAA,OAAO,EAAER,QAAQ,CAACQ;EAAlD,SAA5B,CAAP;EAAiG;;EAAC,aAAOR,QAAP;EAAkB;EAA5O,GAAD;EAApC,CAApC,CAAN,EAAmU,KAAnU,CAA7B;AACAL,uBAA6B,CAAC,KAAD,EAAQ,IAAIc,mBAAJ,CAAmC;EAAE,eAAY,KAAd;EAAqBZ,EAAAA,OAAO,EAAE;EAA9B,CAAnC,CAAR,EAAgF,KAAhF,CAA7B;;"}
A
frontend/public/workbox-6b19f60b.js
@@ -0,0 +1,2701 @@
+define("./workbox-6b19f60b.js",['exports'], function (exports) { 'use strict'; + + try { + self['workbox:core:6.1.5'] && _(); + } catch (e) {} + + /* + Copyright 2019 Google LLC + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + const logger = (() => { + // Don't overwrite this value if it's already set. + // See https://github.com/GoogleChrome/workbox/pull/2284#issuecomment-560470923 + if (!('__WB_DISABLE_DEV_LOGS' in self)) { + self.__WB_DISABLE_DEV_LOGS = false; + } + + let inGroup = false; + const methodToColorMap = { + debug: `#7f8c8d`, + log: `#2ecc71`, + warn: `#f39c12`, + error: `#c0392b`, + groupCollapsed: `#3498db`, + groupEnd: null + }; + + const print = function (method, args) { + if (self.__WB_DISABLE_DEV_LOGS) { + return; + } + + if (method === 'groupCollapsed') { + // Safari doesn't print all console.groupCollapsed() arguments: + // https://bugs.webkit.org/show_bug.cgi?id=182754 + 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`]; // When in a group, the workbox prefix is not displayed. + + const logPrefix = inGroup ? [] : ['%cworkbox', styles.join(';')]; + console[method](...logPrefix, ...args); + + if (method === 'groupCollapsed') { + inGroup = true; + } + + if (method === 'groupEnd') { + inGroup = false; + } + }; + + const api = {}; + const loggerMethods = Object.keys(methodToColorMap); + + for (const key of loggerMethods) { + const method = key; + + api[method] = (...args) => { + print(method, args); + }; + } + + return api; + })(); + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + const messages$1 = { + '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-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 ` + `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 ` + `setCacheDetails({${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, + 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` + (status ? ` with an HTTP status of ${status}.` : `.`); + }, + 'non-precached-url': ({ + url + }) => { + return `createHandlerBoundToURL('${url}') was called, but that URL is ` + `not precached. Please pass in a URL that is precached instead.`; + }, + 'add-to-cache-list-conflicting-integrities': ({ + url + }) => { + return `Two of the entries passed to ` + `'workbox-precaching.PrecacheController.addToCacheList()' had the URL ` + `${url} with different integrity values. Please remove one of them.`; + }, + 'missing-precache-entry': ({ + cacheName, + url + }) => { + return `Unable to find a precached response in ${cacheName} for ${url}.`; + }, + 'cross-origin-copy-response': ({ + origin + }) => { + return `workbox-core.copyResponse() can only be used with same-origin ` + `responses. It was passed a response with origin ${origin}.`; + } + }; + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + + const generatorFunction = (code, details = {}) => { + const message = messages$1[code]; + + if (!message) { + throw new Error(`Unable to find message for code '${code}'.`); + } + + return message(details); + }; + + const messageGenerator = generatorFunction; + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * Workbox errors should be thrown with this class. + * This allows use to ensure the type easily in tests, + * helps developers identify errors from workbox + * easily and allows use to optimise error + * messages correctly. + * + * @private + */ + + class WorkboxError extends Error { + /** + * + * @param {string} errorCode The error code that + * identifies this particular error. + * @param {Object=} details Any relevant arguments + * that will help developers identify issues should + * be added as a key on the context object. + */ + constructor(errorCode, details) { + const message = messageGenerator(errorCode, details); + super(message); + this.name = errorCode; + this.details = details; + } + + } + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /* + * This method throws if the supplied value is not an array. + * The destructed values are required to produce a meaningful error for users. + * The destructed and restructured object is so it's clear what is + * needed. + */ + + const isArray = (value, details) => { + if (!Array.isArray(value)) { + throw new WorkboxError('not-an-array', details); + } + }; + + const hasMethod = (object, expectedMethod, details) => { + const type = typeof object[expectedMethod]; + + if (type !== 'function') { + details['expectedMethod'] = expectedMethod; + throw new WorkboxError('missing-a-method', details); + } + }; + + const isType = (object, expectedType, details) => { + if (typeof object !== expectedType) { + details['expectedType'] = expectedType; + throw new WorkboxError('incorrect-type', details); + } + }; + + const isInstance = (object, expectedClass, details) => { + if (!(object instanceof expectedClass)) { + details['expectedClass'] = expectedClass; + throw new WorkboxError('incorrect-class', details); + } + }; + + const isOneOf = (value, validValues, details) => { + if (!validValues.includes(value)) { + details['validValueDescription'] = `Valid values are ${JSON.stringify(validValues)}.`; + throw new WorkboxError('invalid-value', details); + } + }; + + const isArrayOfClass = (value, expectedClass, details) => { + const error = new WorkboxError('not-array-of-class', details); + + if (!Array.isArray(value)) { + throw error; + } + + for (const item of value) { + if (!(item instanceof expectedClass)) { + throw error; + } + } + }; + + const finalAssertExports = { + hasMethod, + isArray, + isInstance, + isOneOf, + isType, + isArrayOfClass + }; + + try { + self['workbox:routing:6.1.5'] && _(); + } catch (e) {} + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * The default HTTP method, 'GET', used when there's no specific method + * configured for a route. + * + * @type {string} + * + * @private + */ + + const defaultMethod = 'GET'; + /** + * The list of valid HTTP methods associated with requests that could be routed. + * + * @type {Array<string>} + * + * @private + */ + + const validMethods = ['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT']; + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * @param {function()|Object} handler Either a function, or an object with a + * 'handle' method. + * @return {Object} An object with a handle method. + * + * @private + */ + + const normalizeHandler = handler => { + if (handler && typeof handler === 'object') { + { + finalAssertExports.hasMethod(handler, 'handle', { + moduleName: 'workbox-routing', + className: 'Route', + funcName: 'constructor', + paramName: 'handler' + }); + } + + return handler; + } else { + { + finalAssertExports.isType(handler, 'function', { + moduleName: 'workbox-routing', + className: 'Route', + funcName: 'constructor', + paramName: 'handler' + }); + } + + return { + handle: handler + }; + } + }; + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * A `Route` consists of a pair of callback functions, "match" and "handler". + * The "match" callback determine if a route should be used to "handle" a + * request by returning a non-falsy value if it can. The "handler" callback + * is called when there is a match and should return a Promise that resolves + * to a `Response`. + * + * @memberof module:workbox-routing + */ + + class Route { + /** + * Constructor for Route class. + * + * @param {module:workbox-routing~matchCallback} match + * A callback function that determines whether the route matches a given + * `fetch` event by returning a non-falsy value. + * @param {module:workbox-routing~handlerCallback} handler A callback + * function that returns a Promise resolving to a Response. + * @param {string} [method='GET'] The HTTP method to match the Route + * against. + */ + constructor(match, handler, method = defaultMethod) { + { + finalAssertExports.isType(match, 'function', { + moduleName: 'workbox-routing', + className: 'Route', + funcName: 'constructor', + paramName: 'match' + }); + + if (method) { + finalAssertExports.isOneOf(method, validMethods, { + paramName: 'method' + }); + } + } // These values are referenced directly by Router so cannot be + // altered by minificaton. + + + this.handler = normalizeHandler(handler); + this.match = match; + this.method = method; + } + /** + * + * @param {module:workbox-routing-handlerCallback} handler A callback + * function that returns a Promise resolving to a Response + */ + + + setCatchHandler(handler) { + this.catchHandler = normalizeHandler(handler); + } + + } + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * RegExpRoute makes it easy to create a regular expression based + * [Route]{@link module:workbox-routing.Route}. + * + * For same-origin requests the RegExp only needs to match part of the URL. For + * requests against third-party servers, you must define a RegExp that matches + * the start of the URL. + * + * [See the module docs for info.]{@link https://developers.google.com/web/tools/workbox/modules/workbox-routing} + * + * @memberof module:workbox-routing + * @extends module:workbox-routing.Route + */ + + class RegExpRoute extends Route { + /** + * If the regular expression contains + * [capture groups]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#grouping-back-references}, + * the captured values will be passed to the + * [handler's]{@link module:workbox-routing~handlerCallback} `params` + * argument. + * + * @param {RegExp} regExp The regular expression to match against URLs. + * @param {module:workbox-routing~handlerCallback} handler A callback + * function that returns a Promise resulting in a Response. + * @param {string} [method='GET'] The HTTP method to match the Route + * against. + */ + constructor(regExp, handler, method) { + { + finalAssertExports.isInstance(regExp, RegExp, { + moduleName: 'workbox-routing', + className: 'RegExpRoute', + funcName: 'constructor', + paramName: 'pattern' + }); + } + + const match = ({ + url + }) => { + const result = regExp.exec(url.href); // Return immediately if there's no match. + + if (!result) { + return; + } // Require that the match start at the first character in the URL string + // if it's a cross-origin request. + // See https://github.com/GoogleChrome/workbox/issues/281 for the context + // behind this behavior. + + + if (url.origin !== location.origin && result.index !== 0) { + { + logger.debug(`The regular expression '${regExp}' only partially matched ` + `against the cross-origin URL '${url}'. RegExpRoute's will only ` + `handle cross-origin requests if they match the entire URL.`); + } + + return; + } // If the route matches, but there aren't any capture groups defined, then + // this will return [], which is truthy and therefore sufficient to + // indicate a match. + // If there are capture groups, then it will return their values. + + + return result.slice(1); + }; + + super(match, handler, method); + } + + } + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + + const getFriendlyURL = url => { + const urlObj = new URL(String(url), location.href); // See https://github.com/GoogleChrome/workbox/issues/2323 + // We want to include everything, except for the origin if it's same-origin. + + return urlObj.href.replace(new RegExp(`^${location.origin}`), ''); + }; + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * The Router can be used to process a FetchEvent through one or more + * [Routes]{@link module:workbox-routing.Route} responding with a Request if + * a matching route exists. + * + * If no route matches a given a request, the Router will use a "default" + * handler if one is defined. + * + * Should the matching Route throw an error, the Router will use a "catch" + * handler if one is defined to gracefully deal with issues and respond with a + * Request. + * + * If a request matches multiple routes, the **earliest** registered route will + * be used to respond to the request. + * + * @memberof module:workbox-routing + */ + + class Router { + /** + * Initializes a new Router. + */ + constructor() { + this._routes = new Map(); + this._defaultHandlerMap = new Map(); + } + /** + * @return {Map<string, Array<module:workbox-routing.Route>>} routes A `Map` of HTTP + * method name ('GET', etc.) to an array of all the corresponding `Route` + * instances that are registered. + */ + + + get routes() { + return this._routes; + } + /** + * Adds a fetch event listener to respond to events when a route matches + * the event's request. + */ + + + addFetchListener() { + // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705 + self.addEventListener('fetch', event => { + const { + request + } = event; + const responsePromise = this.handleRequest({ + request, + event + }); + + if (responsePromise) { + event.respondWith(responsePromise); + } + }); + } + /** + * Adds a message event listener for URLs to cache from the window. + * This is useful to cache resources loaded on the page prior to when the + * service worker started controlling it. + * + * The format of the message data sent from the window should be as follows. + * Where the `urlsToCache` array may consist of URL strings or an array of + * URL string + `requestInit` object (the same as you'd pass to `fetch()`). + * + * ``` + * { + * type: 'CACHE_URLS', + * payload: { + * urlsToCache: [ + * './script1.js', + * './script2.js', + * ['./script3.js', {mode: 'no-cors'}], + * ], + * }, + * } + * ``` + */ + + + addCacheListener() { + // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705 + self.addEventListener('message', event => { + if (event.data && event.data.type === 'CACHE_URLS') { + const { + payload + } = event.data; + + { + logger.debug(`Caching URLs from the window`, payload.urlsToCache); + } + + const requestPromises = Promise.all(payload.urlsToCache.map(entry => { + if (typeof entry === 'string') { + entry = [entry]; + } + + const request = new Request(...entry); + return this.handleRequest({ + request, + event + }); // TODO(philipwalton): TypeScript errors without this typecast for + // some reason (probably a bug). The real type here should work but + // doesn't: `Array<Promise<Response> | undefined>`. + })); // TypeScript + + event.waitUntil(requestPromises); // If a MessageChannel was used, reply to the message on success. + + if (event.ports && event.ports[0]) { + requestPromises.then(() => event.ports[0].postMessage(true)); + } + } + }); + } + /** + * Apply the routing rules to a FetchEvent object to get a Response from an + * appropriate Route's handler. + * + * @param {Object} options + * @param {Request} options.request The request to handle. + * @param {ExtendableEvent} options.event The event that triggered the + * request. + * @return {Promise<Response>|undefined} A promise is returned if a + * registered route can handle the request. If there is no matching + * route and there's no `defaultHandler`, `undefined` is returned. + */ + + + handleRequest({ + request, + event + }) { + { + finalAssertExports.isInstance(request, Request, { + moduleName: 'workbox-routing', + className: 'Router', + funcName: 'handleRequest', + paramName: 'options.request' + }); + } + + const url = new URL(request.url, location.href); + + if (!url.protocol.startsWith('http')) { + { + logger.debug(`Workbox Router only supports URLs that start with 'http'.`); + } + + return; + } + + const sameOrigin = url.origin === location.origin; + const { + params, + route + } = this.findMatchingRoute({ + event, + request, + sameOrigin, + url + }); + let handler = route && route.handler; + const debugMessages = []; + + { + if (handler) { + debugMessages.push([`Found a route to handle this request:`, route]); + + if (params) { + debugMessages.push([`Passing the following params to the route's handler:`, params]); + } + } + } // If we don't have a handler because there was no matching route, then + // fall back to defaultHandler if that's defined. + + + const method = request.method; + + if (!handler && this._defaultHandlerMap.has(method)) { + { + debugMessages.push(`Failed to find a matching route. Falling ` + `back to the default handler for ${method}.`); + } + + handler = this._defaultHandlerMap.get(method); + } + + if (!handler) { + { + // No handler so Workbox will do nothing. If logs is set of debug + // i.e. verbose, we should print out this information. + logger.debug(`No route found for: ${getFriendlyURL(url)}`); + } + + return; + } + + { + // We have a handler, meaning Workbox is going to handle the route. + // print the routing details to the console. + logger.groupCollapsed(`Router is responding to: ${getFriendlyURL(url)}`); + debugMessages.forEach(msg => { + if (Array.isArray(msg)) { + logger.log(...msg); + } else { + logger.log(msg); + } + }); + logger.groupEnd(); + } // Wrap in try and catch in case the handle method throws a synchronous + // error. It should still callback to the catch handler. + + + let responsePromise; + + try { + responsePromise = handler.handle({ + url, + request, + event, + params + }); + } catch (err) { + responsePromise = Promise.reject(err); + } // Get route's catch handler, if it exists + + + const catchHandler = route && route.catchHandler; + + if (responsePromise instanceof Promise && (this._catchHandler || catchHandler)) { + responsePromise = responsePromise.catch(async err => { + // If there's a route catch handler, process that first + if (catchHandler) { + { + // Still include URL here as it will be async from the console group + // and may not make sense without the URL + logger.groupCollapsed(`Error thrown when responding to: ` + ` ${getFriendlyURL(url)}. Falling back to route's Catch Handler.`); + logger.error(`Error thrown by:`, route); + logger.error(err); + logger.groupEnd(); + } + + try { + return await catchHandler.handle({ + url, + request, + event, + params + }); + } catch (catchErr) { + err = catchErr; + } + } + + if (this._catchHandler) { + { + // Still include URL here as it will be async from the console group + // and may not make sense without the URL + logger.groupCollapsed(`Error thrown when responding to: ` + ` ${getFriendlyURL(url)}. Falling back to global Catch Handler.`); + logger.error(`Error thrown by:`, route); + logger.error(err); + logger.groupEnd(); + } + + return this._catchHandler.handle({ + url, + request, + event + }); + } + + throw err; + }); + } + + return responsePromise; + } + /** + * Checks a request and URL (and optionally an event) against the list of + * registered routes, and if there's a match, returns the corresponding + * route along with any params generated by the match. + * + * @param {Object} options + * @param {URL} options.url + * @param {boolean} options.sameOrigin The result of comparing `url.origin` + * against the current origin. + * @param {Request} options.request The request to match. + * @param {Event} options.event The corresponding event. + * @return {Object} An object with `route` and `params` properties. + * They are populated if a matching route was found or `undefined` + * otherwise. + */ + + + findMatchingRoute({ + url, + sameOrigin, + request, + event + }) { + const routes = this._routes.get(request.method) || []; + + for (const route of routes) { + let params; + const matchResult = route.match({ + url, + sameOrigin, + request, + event + }); + + if (matchResult) { + { + // Warn developers that using an async matchCallback is almost always + // not the right thing to do. + if (matchResult instanceof Promise) { + logger.warn(`While routing ${getFriendlyURL(url)}, an async ` + `matchCallback function was used. Please convert the ` + `following route to use a synchronous matchCallback function:`, route); + } + } // See https://github.com/GoogleChrome/workbox/issues/2079 + + + params = matchResult; + + if (Array.isArray(matchResult) && matchResult.length === 0) { + // Instead of passing an empty array in as params, use undefined. + params = undefined; + } else if (matchResult.constructor === Object && Object.keys(matchResult).length === 0) { + // Instead of passing an empty object in as params, use undefined. + params = undefined; + } else if (typeof matchResult === 'boolean') { + // For the boolean value true (rather than just something truth-y), + // don't set params. + // See https://github.com/GoogleChrome/workbox/pull/2134#issuecomment-513924353 + params = undefined; + } // Return early if have a match. + + + return { + route, + params + }; + } + } // If no match was found above, return and empty object. + + + return {}; + } + /** + * Define a default `handler` that's called when no routes explicitly + * match the incoming request. + * + * Each HTTP method ('GET', 'POST', etc.) gets its own default handler. + * + * Without a default handler, unmatched requests will go against the + * network as if there were no service worker present. + * + * @param {module:workbox-routing~handlerCallback} handler A callback + * function that returns a Promise resulting in a Response. + * @param {string} [method='GET'] The HTTP method to associate with this + * default handler. Each method has its own default. + */ + + + setDefaultHandler(handler, method = defaultMethod) { + this._defaultHandlerMap.set(method, normalizeHandler(handler)); + } + /** + * If a Route throws an error while handling a request, this `handler` + * will be called and given a chance to provide a response. + * + * @param {module:workbox-routing~handlerCallback} handler A callback + * function that returns a Promise resulting in a Response. + */ + + + setCatchHandler(handler) { + this._catchHandler = normalizeHandler(handler); + } + /** + * Registers a route with the router. + * + * @param {module:workbox-routing.Route} route The route to register. + */ + + + registerRoute(route) { + { + finalAssertExports.isType(route, 'object', { + moduleName: 'workbox-routing', + className: 'Router', + funcName: 'registerRoute', + paramName: 'route' + }); + finalAssertExports.hasMethod(route, 'match', { + moduleName: 'workbox-routing', + className: 'Router', + funcName: 'registerRoute', + paramName: 'route' + }); + finalAssertExports.isType(route.handler, 'object', { + moduleName: 'workbox-routing', + className: 'Router', + funcName: 'registerRoute', + paramName: 'route' + }); + finalAssertExports.hasMethod(route.handler, 'handle', { + moduleName: 'workbox-routing', + className: 'Router', + funcName: 'registerRoute', + paramName: 'route.handler' + }); + finalAssertExports.isType(route.method, 'string', { + moduleName: 'workbox-routing', + className: 'Router', + funcName: 'registerRoute', + paramName: 'route.method' + }); + } + + if (!this._routes.has(route.method)) { + this._routes.set(route.method, []); + } // Give precedence to all of the earlier routes by adding this additional + // route to the end of the array. + + + this._routes.get(route.method).push(route); + } + /** + * Unregisters a route with the router. + * + * @param {module:workbox-routing.Route} route The route to unregister. + */ + + + unregisterRoute(route) { + if (!this._routes.has(route.method)) { + throw new WorkboxError('unregister-route-but-not-found-with-method', { + method: route.method + }); + } + + const routeIndex = this._routes.get(route.method).indexOf(route); + + if (routeIndex > -1) { + this._routes.get(route.method).splice(routeIndex, 1); + } else { + throw new WorkboxError('unregister-route-route-not-registered'); + } + } + + } + + /* + Copyright 2019 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + let defaultRouter; + /** + * Creates a new, singleton Router instance if one does not exist. If one + * does already exist, that instance is returned. + * + * @private + * @return {Router} + */ + + const getOrCreateDefaultRouter = () => { + if (!defaultRouter) { + defaultRouter = new Router(); // The helpers that use the default Router assume these listeners exist. + + defaultRouter.addFetchListener(); + defaultRouter.addCacheListener(); + } + + return defaultRouter; + }; + + /* + Copyright 2019 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * Easily register a RegExp, string, or function with a caching + * strategy to a singleton Router instance. + * + * This method will generate a Route for you if needed and + * call [registerRoute()]{@link module:workbox-routing.Router#registerRoute}. + * + * @param {RegExp|string|module:workbox-routing.Route~matchCallback|module:workbox-routing.Route} capture + * If the capture param is a `Route`, all other arguments will be ignored. + * @param {module:workbox-routing~handlerCallback} [handler] A callback + * function that returns a Promise resulting in a Response. This parameter + * is required if `capture` is not a `Route` object. + * @param {string} [method='GET'] The HTTP method to match the Route + * against. + * @return {module:workbox-routing.Route} The generated `Route`(Useful for + * unregistering). + * + * @memberof module:workbox-routing + */ + + function registerRoute(capture, handler, method) { + let route; + + if (typeof capture === 'string') { + const captureUrl = new URL(capture, location.href); + + { + if (!(capture.startsWith('/') || capture.startsWith('http'))) { + throw new WorkboxError('invalid-string', { + moduleName: 'workbox-routing', + funcName: 'registerRoute', + paramName: 'capture' + }); + } // We want to check if Express-style wildcards are in the pathname only. + // TODO: Remove this log message in v4. + + + const valueToCheck = capture.startsWith('http') ? captureUrl.pathname : capture; // See https://github.com/pillarjs/path-to-regexp#parameters + + const wildcards = '[*:?+]'; + + if (new RegExp(`${wildcards}`).exec(valueToCheck)) { + logger.debug(`The '$capture' parameter contains an Express-style wildcard ` + `character (${wildcards}). Strings are now always interpreted as ` + `exact matches; use a RegExp for partial or wildcard matches.`); + } + } + + const matchCallback = ({ + url + }) => { + { + if (url.pathname === captureUrl.pathname && url.origin !== captureUrl.origin) { + logger.debug(`${capture} only partially matches the cross-origin URL ` + `${url}. This route will only handle cross-origin requests ` + `if they match the entire URL.`); + } + } + + return url.href === captureUrl.href; + }; // If `capture` is a string then `handler` and `method` must be present. + + + route = new Route(matchCallback, handler, method); + } else if (capture instanceof RegExp) { + // If `capture` is a `RegExp` then `handler` and `method` must be present. + route = new RegExpRoute(capture, handler, method); + } else if (typeof capture === 'function') { + // If `capture` is a function then `handler` and `method` must be present. + route = new Route(capture, handler, method); + } else if (capture instanceof Route) { + route = capture; + } else { + throw new WorkboxError('unsupported-route-type', { + moduleName: 'workbox-routing', + funcName: 'registerRoute', + paramName: 'capture' + }); + } + + const defaultRouter = getOrCreateDefaultRouter(); + defaultRouter.registerRoute(route); + return route; + } + + try { + self['workbox:strategies:6.1.5'] && _(); + } catch (e) {} + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + const cacheOkAndOpaquePlugin = { + /** + * Returns a valid response (to allow caching) if the status is 200 (OK) or + * 0 (opaque). + * + * @param {Object} options + * @param {Response} options.response + * @return {Response|null} + * + * @private + */ + cacheWillUpdate: async ({ + response + }) => { + if (response.status === 200 || response.status === 0) { + return response; + } + + return null; + } + }; + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + const _cacheNameDetails = { + googleAnalytics: 'googleAnalytics', + precache: 'precache-v2', + prefix: 'workbox', + runtime: 'runtime', + suffix: typeof registration !== 'undefined' ? registration.scope : '' + }; + + const _createCacheName = cacheName => { + return [_cacheNameDetails.prefix, cacheName, _cacheNameDetails.suffix].filter(value => value && value.length > 0).join('-'); + }; + + const eachCacheNameDetail = fn => { + for (const key of Object.keys(_cacheNameDetails)) { + fn(key); + } + }; + + const cacheNames = { + updateDetails: details => { + eachCacheNameDetail(key => { + if (typeof details[key] === 'string') { + _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; + } + }; + + function _extends() { + _extends = Object.assign || function (target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + + return target; + }; + + return _extends.apply(this, arguments); + } + + function stripParams(fullURL, ignoreParams) { + const strippedURL = new URL(fullURL); + + for (const param of ignoreParams) { + strippedURL.searchParams.delete(param); + } + + return strippedURL.href; + } + /** + * Matches an item in the cache, ignoring specific URL params. This is similar + * to the `ignoreSearch` option, but it allows you to ignore just specific + * params (while continuing to match on the others). + * + * @private + * @param {Cache} cache + * @param {Request} request + * @param {Object} matchOptions + * @param {Array<string>} ignoreParams + * @return {Promise<Response|undefined>} + */ + + + async function cacheMatchIgnoreParams(cache, request, ignoreParams, matchOptions) { + const strippedRequestURL = stripParams(request.url, ignoreParams); // If the request doesn't include any ignored params, match as normal. + + if (request.url === strippedRequestURL) { + return cache.match(request, matchOptions); + } // Otherwise, match by comparing keys + + + const keysOptions = _extends({}, matchOptions, { + ignoreSearch: true + }); + + const cacheKeys = await cache.keys(request, keysOptions); + + for (const cacheKey of cacheKeys) { + const strippedCacheKeyURL = stripParams(cacheKey.url, ignoreParams); + + if (strippedRequestURL === strippedCacheKeyURL) { + return cache.match(cacheKey, matchOptions); + } + } + + return; + } + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * The Deferred class composes Promises in a way that allows for them to be + * resolved or rejected from outside the constructor. In most cases promises + * should be used directly, but Deferreds can be necessary when the logic to + * resolve a promise must be separate. + * + * @private + */ + + class Deferred { + /** + * Creates a promise and exposes its resolve and reject functions as methods. + */ + constructor() { + this.promise = new Promise((resolve, reject) => { + this.resolve = resolve; + this.reject = reject; + }); + } + + } + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + + const quotaErrorCallbacks = new Set(); + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * Runs all of the callback functions, one at a time sequentially, in the order + * in which they were registered. + * + * @memberof module:workbox-core + * @private + */ + + 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.'); + } + } + + /* + Copyright 2019 Google LLC + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * Returns a promise that resolves and the passed number of milliseconds. + * This utility is an async/await-friendly version of `setTimeout`. + * + * @param {number} ms + * @return {Promise} + * @private + */ + + function timeout(ms) { + return new Promise(resolve => setTimeout(resolve, ms)); + } + + function toRequest(input) { + return typeof input === 'string' ? new Request(input) : input; + } + /** + * A class created every time a Strategy instance instance calls + * [handle()]{@link module:workbox-strategies.Strategy~handle} or + * [handleAll()]{@link module:workbox-strategies.Strategy~handleAll} that wraps all fetch and + * cache actions around plugin callbacks and keeps track of when the strategy + * is "done" (i.e. all added `event.waitUntil()` promises have resolved). + * + * @memberof module:workbox-strategies + */ + + + class StrategyHandler { + /** + * Creates a new instance associated with the passed strategy and event + * that's handling the request. + * + * The constructor also initializes the state that will be passed to each of + * the plugins handling this request. + * + * @param {module:workbox-strategies.Strategy} strategy + * @param {Object} options + * @param {Request|string} options.request A request to run this strategy for. + * @param {ExtendableEvent} options.event The event associated with the + * request. + * @param {URL} [options.url] + * @param {*} [options.params] + * [match callback]{@link module:workbox-routing~matchCallback}, + * (if applicable). + */ + constructor(strategy, options) { + this._cacheKeys = {}; + /** + * The request the strategy is performing (passed to the strategy's + * `handle()` or `handleAll()` method). + * @name request + * @instance + * @type {Request} + * @memberof module:workbox-strategies.StrategyHandler + */ + + /** + * The event associated with this request. + * @name event + * @instance + * @type {ExtendableEvent} + * @memberof module:workbox-strategies.StrategyHandler + */ + + /** + * A `URL` instance of `request.url` (if passed to the strategy's + * `handle()` or `handleAll()` method). + * Note: the `url` param will be present if the strategy was invoked + * from a workbox `Route` object. + * @name url + * @instance + * @type {URL|undefined} + * @memberof module:workbox-strategies.StrategyHandler + */ + + /** + * A `param` value (if passed to the strategy's + * `handle()` or `handleAll()` method). + * Note: the `param` param will be present if the strategy was invoked + * from a workbox `Route` object and the + * [match callback]{@link module:workbox-routing~matchCallback} returned + * a truthy value (it will be that value). + * @name params + * @instance + * @type {*|undefined} + * @memberof module:workbox-strategies.StrategyHandler + */ + + { + finalAssertExports.isInstance(options.event, ExtendableEvent, { + moduleName: 'workbox-strategies', + className: 'StrategyHandler', + funcName: 'constructor', + paramName: 'options.event' + }); + } + + Object.assign(this, options); + this.event = options.event; + this._strategy = strategy; + this._handlerDeferred = new Deferred(); + this._extendLifetimePromises = []; // Copy the plugins list (since it's mutable on the strategy), + // so any mutations don't affect this handler instance. + + this._plugins = [...strategy.plugins]; + this._pluginStateMap = new Map(); + + for (const plugin of this._plugins) { + this._pluginStateMap.set(plugin, {}); + } + + this.event.waitUntil(this._handlerDeferred.promise); + } + /** + * Fetches a given request (and invokes any applicable plugin callback + * methods) using the `fetchOptions` (for non-navigation requests) and + * `plugins` defined on the `Strategy` object. + * + * The following plugin lifecycle methods are invoked when using this method: + * - `requestWillFetch()` + * - `fetchDidSucceed()` + * - `fetchDidFail()` + * + * @param {Request|string} input The URL or request to fetch. + * @return {Promise<Response>} + */ + + + async fetch(input) { + const { + event + } = this; + let request = toRequest(input); + + if (request.mode === 'navigate' && event instanceof FetchEvent && event.preloadResponse) { + const possiblePreloadResponse = await event.preloadResponse; + + if (possiblePreloadResponse) { + { + logger.log(`Using a preloaded navigation response for ` + `'${getFriendlyURL(request.url)}'`); + } + + return possiblePreloadResponse; + } + } // If there is a fetchDidFail plugin, we need to save a clone of the + // original request before it's either modified by a requestWillFetch + // plugin or before the original request's body is consumed via fetch(). + + + const originalRequest = this.hasCallback('fetchDidFail') ? request.clone() : null; + + try { + for (const cb of this.iterateCallbacks('requestWillFetch')) { + request = await cb({ + request: request.clone(), + event + }); + } + } catch (err) { + throw new WorkboxError('plugin-error-request-will-fetch', { + thrownError: err + }); + } // The request can be altered by plugins with `requestWillFetch` making + // the original request (most likely from a `fetch` event) different + // from the Request we make. Pass both to `fetchDidFail` to aid debugging. + + + const pluginFilteredRequest = request.clone(); + + try { + let fetchResponse; // See https://github.com/GoogleChrome/workbox/issues/1796 + + fetchResponse = await fetch(request, request.mode === 'navigate' ? undefined : this._strategy.fetchOptions); + + if ("development" !== 'production') { + logger.debug(`Network request for ` + `'${getFriendlyURL(request.url)}' returned a response with ` + `status '${fetchResponse.status}'.`); + } + + for (const callback of this.iterateCallbacks('fetchDidSucceed')) { + fetchResponse = await callback({ + event, + request: pluginFilteredRequest, + response: fetchResponse + }); + } + + return fetchResponse; + } catch (error) { + { + logger.log(`Network request for ` + `'${getFriendlyURL(request.url)}' threw an error.`, error); + } // `originalRequest` will only exist if a `fetchDidFail` callback + // is being used (see above). + + + if (originalRequest) { + await this.runCallbacks('fetchDidFail', { + error, + event, + originalRequest: originalRequest.clone(), + request: pluginFilteredRequest.clone() + }); + } + + throw error; + } + } + /** + * Calls `this.fetch()` and (in the background) runs `this.cachePut()` on + * the response generated by `this.fetch()`. + * + * The call to `this.cachePut()` automatically invokes `this.waitUntil()`, + * so you do not have to manually call `waitUntil()` on the event. + * + * @param {Request|string} input The request or URL to fetch and cache. + * @return {Promise<Response>} + */ + + + async fetchAndCachePut(input) { + const response = await this.fetch(input); + const responseClone = response.clone(); + this.waitUntil(this.cachePut(input, responseClone)); + return response; + } + /** + * Matches a request from the cache (and invokes any applicable plugin + * callback methods) using the `cacheName`, `matchOptions`, and `plugins` + * defined on the strategy object. + * + * The following plugin lifecycle methods are invoked when using this method: + * - cacheKeyWillByUsed() + * - cachedResponseWillByUsed() + * + * @param {Request|string} key The Request or URL to use as the cache key. + * @return {Promise<Response|undefined>} A matching response, if found. + */ + + + async cacheMatch(key) { + const request = toRequest(key); + let cachedResponse; + const { + cacheName, + matchOptions + } = this._strategy; + const effectiveRequest = await this.getCacheKey(request, 'read'); + + const multiMatchOptions = _extends({}, matchOptions, { + cacheName + }); + + cachedResponse = await caches.match(effectiveRequest, multiMatchOptions); + + { + if (cachedResponse) { + logger.debug(`Found a cached response in '${cacheName}'.`); + } else { + logger.debug(`No cached response found in '${cacheName}'.`); + } + } + + for (const callback of this.iterateCallbacks('cachedResponseWillBeUsed')) { + cachedResponse = (await callback({ + cacheName, + matchOptions, + cachedResponse, + request: effectiveRequest, + event: this.event + })) || undefined; + } + + return cachedResponse; + } + /** + * Puts a request/response pair in the cache (and invokes any applicable + * plugin callback methods) using the `cacheName` and `plugins` defined on + * the strategy object. + * + * The following plugin lifecycle methods are invoked when using this method: + * - cacheKeyWillByUsed() + * - cacheWillUpdate() + * - cacheDidUpdate() + * + * @param {Request|string} key The request or URL to use as the cache key. + * @param {Response} response The response to cache. + * @return {Promise<boolean>} `false` if a cacheWillUpdate caused the response + * not be cached, and `true` otherwise. + */ + + + async cachePut(key, response) { + const request = toRequest(key); // Run in the next task to avoid blocking other cache reads. + // https://github.com/w3c/ServiceWorker/issues/1397 + + await timeout(0); + const effectiveRequest = await this.getCacheKey(request, 'write'); + + { + if (effectiveRequest.method && effectiveRequest.method !== 'GET') { + throw new WorkboxError('attempt-to-cache-non-get-request', { + url: getFriendlyURL(effectiveRequest.url), + method: effectiveRequest.method + }); + } + } + + 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) + }); + } + + const responseToCache = await this._ensureResponseSafeToCache(response); + + if (!responseToCache) { + { + logger.debug(`Response '${getFriendlyURL(effectiveRequest.url)}' ` + `will not be cached.`, responseToCache); + } + + return false; + } + + const { + cacheName, + matchOptions + } = this._strategy; + const cache = await self.caches.open(cacheName); + const hasCacheUpdateCallback = this.hasCallback('cacheDidUpdate'); + const oldResponse = hasCacheUpdateCallback ? await cacheMatchIgnoreParams( // TODO(philipwalton): the `__WB_REVISION__` param is a precaching + // feature. Consider into ways to only add this behavior if using + // precaching. + cache, effectiveRequest.clone(), ['__WB_REVISION__'], matchOptions) : null; + + { + logger.debug(`Updating the '${cacheName}' cache with a new Response ` + `for ${getFriendlyURL(effectiveRequest.url)}.`); + } + + try { + await cache.put(effectiveRequest, hasCacheUpdateCallback ? responseToCache.clone() : responseToCache); + } catch (error) { + // See https://developer.mozilla.org/en-US/docs/Web/API/DOMException#exception-QuotaExceededError + if (error.name === 'QuotaExceededError') { + await executeQuotaErrorCallbacks(); + } + + throw error; + } + + for (const callback of this.iterateCallbacks('cacheDidUpdate')) { + await callback({ + cacheName, + oldResponse, + newResponse: responseToCache.clone(), + request: effectiveRequest, + event: this.event + }); + } + + return true; + } + /** + * Checks the list of plugins for the `cacheKeyWillBeUsed` callback, and + * executes any of those callbacks found in sequence. The final `Request` + * object returned by the last plugin is treated as the cache key for cache + * reads and/or writes. If no `cacheKeyWillBeUsed` plugin callbacks have + * been registered, the passed request is returned unmodified + * + * @param {Request} request + * @param {string} mode + * @return {Promise<Request>} + */ + + + async getCacheKey(request, mode) { + if (!this._cacheKeys[mode]) { + let effectiveRequest = request; + + for (const callback of this.iterateCallbacks('cacheKeyWillBeUsed')) { + effectiveRequest = toRequest(await callback({ + mode, + request: effectiveRequest, + event: this.event, + params: this.params + })); + } + + this._cacheKeys[mode] = effectiveRequest; + } + + return this._cacheKeys[mode]; + } + /** + * Returns true if the strategy has at least one plugin with the given + * callback. + * + * @param {string} name The name of the callback to check for. + * @return {boolean} + */ + + + hasCallback(name) { + for (const plugin of this._strategy.plugins) { + if (name in plugin) { + return true; + } + } + + return false; + } + /** + * Runs all plugin callbacks matching the given name, in order, passing the + * given param object (merged ith the current plugin state) as the only + * argument. + * + * Note: since this method runs all plugins, it's not suitable for cases + * where the return value of a callback needs to be applied prior to calling + * the next callback. See + * [`iterateCallbacks()`]{@link module:workbox-strategies.StrategyHandler#iterateCallbacks} + * below for how to handle that case. + * + * @param {string} name The name of the callback to run within each plugin. + * @param {Object} param The object to pass as the first (and only) param + * when executing each callback. This object will be merged with the + * current plugin state prior to callback execution. + */ + + + async runCallbacks(name, param) { + for (const callback of this.iterateCallbacks(name)) { + // TODO(philipwalton): not sure why `any` is needed. It seems like + // this should work with `as WorkboxPluginCallbackParam[C]`. + await callback(param); + } + } + /** + * Accepts a callback and returns an iterable of matching plugin callbacks, + * where each callback is wrapped with the current handler state (i.e. when + * you call each callback, whatever object parameter you pass it will + * be merged with the plugin's current state). + * + * @param {string} name The name fo the callback to run + * @return {Array<Function>} + */ + + + *iterateCallbacks(name) { + for (const plugin of this._strategy.plugins) { + if (typeof plugin[name] === 'function') { + const state = this._pluginStateMap.get(plugin); + + const statefulCallback = param => { + const statefulParam = _extends({}, param, { + state + }); // TODO(philipwalton): not sure why `any` is needed. It seems like + // this should work with `as WorkboxPluginCallbackParam[C]`. + + + return plugin[name](statefulParam); + }; + + yield statefulCallback; + } + } + } + /** + * Adds a promise to the + * [extend lifetime promises]{@link https://w3c.github.io/ServiceWorker/#extendableevent-extend-lifetime-promises} + * of the event event associated with the request being handled (usually a + * `FetchEvent`). + * + * Note: you can await + * [`doneWaiting()`]{@link module:workbox-strategies.StrategyHandler~doneWaiting} + * to know when all added promises have settled. + * + * @param {Promise} promise A promise to add to the extend lifetime promises + * of the event that triggered the request. + */ + + + waitUntil(promise) { + this._extendLifetimePromises.push(promise); + + return promise; + } + /** + * Returns a promise that resolves once all promises passed to + * [`waitUntil()`]{@link module:workbox-strategies.StrategyHandler~waitUntil} + * have settled. + * + * Note: any work done after `doneWaiting()` settles should be manually + * passed to an event's `waitUntil()` method (not this handler's + * `waitUntil()` method), otherwise the service worker thread my be killed + * prior to your work completing. + */ + + + async doneWaiting() { + let promise; + + while (promise = this._extendLifetimePromises.shift()) { + await promise; + } + } + /** + * Stops running the strategy and immediately resolves any pending + * `waitUntil()` promises. + */ + + + destroy() { + this._handlerDeferred.resolve(); + } + /** + * This method will call cacheWillUpdate on the available plugins (or use + * status === 200) to determine if the Response is safe and valid to cache. + * + * @param {Request} options.request + * @param {Response} options.response + * @return {Promise<Response|undefined>} + * + * @private + */ + + + async _ensureResponseSafeToCache(response) { + let responseToCache = response; + let pluginsUsed = false; + + for (const callback of this.iterateCallbacks('cacheWillUpdate')) { + responseToCache = (await callback({ + request: this.request, + response: responseToCache, + event: this.event + })) || undefined; + pluginsUsed = true; + + if (!responseToCache) { + break; + } + } + + if (!pluginsUsed) { + if (responseToCache && responseToCache.status !== 200) { + responseToCache = undefined; + } + + { + if (responseToCache) { + if (responseToCache.status !== 200) { + if (responseToCache.status === 0) { + logger.warn(`The response for '${this.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 '${this.request.url}' ` + `returned a status code of '${response.status}' and won't ` + `be cached as a result.`); + } + } + } + } + } + + return responseToCache; + } + + } + + /* + Copyright 2020 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * An abstract base class that all other strategy classes must extend from: + * + * @memberof module:workbox-strategies + */ + + class Strategy { + /** + * Creates a new instance of the strategy and sets all documented option + * properties as public instance properties. + * + * Note: if a custom strategy class extends the base Strategy class and does + * not need more than these properties, it does not need to define its own + * constructor. + * + * @param {Object} [options] + * @param {string} [options.cacheName] Cache name to store and retrieve + * requests. Defaults to the cache names provided by + * [workbox-core]{@link module:workbox-core.cacheNames}. + * @param {Array<Object>} [options.plugins] [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins} + * to use in conjunction with this caching strategy. + * @param {Object} [options.fetchOptions] Values passed along to the + * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters) + * of [non-navigation](https://github.com/GoogleChrome/workbox/issues/1796) + * `fetch()` requests made by this strategy. + * @param {Object} [options.matchOptions] The + * [`CacheQueryOptions`]{@link https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions} + * for any `cache.match()` or `cache.put()` calls made by this strategy. + */ + constructor(options = {}) { + /** + * Cache name to store and retrieve + * requests. Defaults to the cache names provided by + * [workbox-core]{@link module:workbox-core.cacheNames}. + * + * @type {string} + */ + this.cacheName = cacheNames.getRuntimeName(options.cacheName); + /** + * The list + * [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins} + * used by this strategy. + * + * @type {Array<Object>} + */ + + this.plugins = options.plugins || []; + /** + * Values passed along to the + * [`init`]{@link https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters} + * of all fetch() requests made by this strategy. + * + * @type {Object} + */ + + this.fetchOptions = options.fetchOptions; + /** + * The + * [`CacheQueryOptions`]{@link https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions} + * for any `cache.match()` or `cache.put()` calls made by this strategy. + * + * @type {Object} + */ + + this.matchOptions = options.matchOptions; + } + /** + * Perform a request strategy and returns a `Promise` that will resolve with + * a `Response`, invoking all relevant plugin callbacks. + * + * When a strategy instance is registered with a Workbox + * [route]{@link module:workbox-routing.Route}, this method is automatically + * called when the route matches. + * + * Alternatively, this method can be used in a standalone `FetchEvent` + * listener by passing it to `event.respondWith()`. + * + * @param {FetchEvent|Object} options A `FetchEvent` or an object with the + * properties listed below. + * @param {Request|string} options.request A request to run this strategy for. + * @param {ExtendableEvent} options.event The event associated with the + * request. + * @param {URL} [options.url] + * @param {*} [options.params] + */ + + + handle(options) { + const [responseDone] = this.handleAll(options); + return responseDone; + } + /** + * Similar to [`handle()`]{@link module:workbox-strategies.Strategy~handle}, but + * instead of just returning a `Promise` that resolves to a `Response` it + * it will return an tuple of [response, done] promises, where the former + * (`response`) is equivalent to what `handle()` returns, and the latter is a + * Promise that will resolve once any promises that were added to + * `event.waitUntil()` as part of performing the strategy have completed. + * + * You can await the `done` promise to ensure any extra work performed by + * the strategy (usually caching responses) completes successfully. + * + * @param {FetchEvent|Object} options A `FetchEvent` or an object with the + * properties listed below. + * @param {Request|string} options.request A request to run this strategy for. + * @param {ExtendableEvent} options.event The event associated with the + * request. + * @param {URL} [options.url] + * @param {*} [options.params] + * @return {Array<Promise>} A tuple of [response, done] + * promises that can be used to determine when the response resolves as + * well as when the handler has completed all its work. + */ + + + handleAll(options) { + // Allow for flexible options to be passed. + if (options instanceof FetchEvent) { + options = { + event: options, + request: options.request + }; + } + + const event = options.event; + const request = typeof options.request === 'string' ? new Request(options.request) : options.request; + const params = 'params' in options ? options.params : undefined; + const handler = new StrategyHandler(this, { + event, + request, + params + }); + + const responseDone = this._getResponse(handler, request, event); + + const handlerDone = this._awaitComplete(responseDone, handler, request, event); // Return an array of promises, suitable for use with Promise.all(). + + + return [responseDone, handlerDone]; + } + + async _getResponse(handler, request, event) { + await handler.runCallbacks('handlerWillStart', { + event, + request + }); + let response = undefined; + + try { + response = await this._handle(request, handler); // The "official" Strategy subclasses all throw this error automatically, + // but in case a third-party Strategy doesn't, ensure that we have a + // consistent failure when there's no response or an error response. + + if (!response || response.type === 'error') { + throw new WorkboxError('no-response', { + url: request.url + }); + } + } catch (error) { + for (const callback of handler.iterateCallbacks('handlerDidError')) { + response = await callback({ + error, + event, + request + }); + + if (response) { + break; + } + } + + if (!response) { + throw error; + } else { + logger.log(`While responding to '${getFriendlyURL(request.url)}', ` + `an ${error} error occurred. Using a fallback response provided by ` + `a handlerDidError plugin.`); + } + } + + for (const callback of handler.iterateCallbacks('handlerWillRespond')) { + response = await callback({ + event, + request, + response + }); + } + + return response; + } + + async _awaitComplete(responseDone, handler, request, event) { + let response; + let error; + + try { + response = await responseDone; + } catch (error) {// Ignore errors, as response errors should be caught via the `response` + // promise above. The `done` promise will only throw for errors in + // promises passed to `handler.waitUntil()`. + } + + try { + await handler.runCallbacks('handlerDidRespond', { + event, + request, + response + }); + await handler.doneWaiting(); + } catch (waitUntilError) { + error = waitUntilError; + } + + await handler.runCallbacks('handlerDidComplete', { + event, + request, + response, + error + }); + handler.destroy(); + + if (error) { + throw error; + } + } + + } + /** + * Classes extending the `Strategy` based class should implement this method, + * and leverage the [`handler`]{@link module:workbox-strategies.StrategyHandler} + * arg to perform all fetching and cache logic, which will ensure all relevant + * cache, cache options, fetch options and plugins are used (per the current + * strategy instance). + * + * @name _handle + * @instance + * @abstract + * @function + * @param {Request} request + * @param {module:workbox-strategies.StrategyHandler} handler + * @return {Promise<Response>} + * + * @memberof module:workbox-strategies.Strategy + */ + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + const messages = { + strategyStart: (strategyName, request) => `Using ${strategyName} to respond to '${getFriendlyURL(request.url)}'`, + printFinalResponse: response => { + if (response) { + logger.groupCollapsed(`View the final response here.`); + logger.log(response || '[No response returned]'); + logger.groupEnd(); + } + } + }; + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * An implementation of a + * [network first]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#network-falling-back-to-cache} + * request strategy. + * + * By default, this strategy will cache responses with a 200 status code as + * well as [opaque responses]{@link https://developers.google.com/web/tools/workbox/guides/handle-third-party-requests}. + * Opaque responses are are cross-origin requests where the response doesn't + * support [CORS]{@link https://enable-cors.org/}. + * + * If the network request fails, and there is no cache match, this will throw + * a `WorkboxError` exception. + * + * @extends module:workbox-strategies.Strategy + * @memberof module:workbox-strategies + */ + + class NetworkFirst extends Strategy { + /** + * @param {Object} [options] + * @param {string} [options.cacheName] Cache name to store and retrieve + * requests. Defaults to cache names provided by + * [workbox-core]{@link module:workbox-core.cacheNames}. + * @param {Array<Object>} [options.plugins] [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins} + * to use in conjunction with this caching strategy. + * @param {Object} [options.fetchOptions] Values passed along to the + * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters) + * of [non-navigation](https://github.com/GoogleChrome/workbox/issues/1796) + * `fetch()` requests made by this strategy. + * @param {Object} [options.matchOptions] [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions) + * @param {number} [options.networkTimeoutSeconds] If set, any network requests + * that fail to respond within the timeout will fallback to the cache. + * + * This option can be used to combat + * "[lie-fi]{@link https://developers.google.com/web/fundamentals/performance/poor-connectivity/#lie-fi}" + * scenarios. + */ + constructor(options = {}) { + super(options); // If this instance contains no plugins with a 'cacheWillUpdate' callback, + // prepend the `cacheOkAndOpaquePlugin` plugin to the plugins list. + + if (!this.plugins.some(p => 'cacheWillUpdate' in p)) { + this.plugins.unshift(cacheOkAndOpaquePlugin); + } + + this._networkTimeoutSeconds = options.networkTimeoutSeconds || 0; + + { + if (this._networkTimeoutSeconds) { + finalAssertExports.isType(this._networkTimeoutSeconds, 'number', { + moduleName: 'workbox-strategies', + className: this.constructor.name, + funcName: 'constructor', + paramName: 'networkTimeoutSeconds' + }); + } + } + } + /** + * @private + * @param {Request|string} request A request to run this strategy for. + * @param {module:workbox-strategies.StrategyHandler} handler The event that + * triggered the request. + * @return {Promise<Response>} + */ + + + async _handle(request, handler) { + const logs = []; + + { + finalAssertExports.isInstance(request, Request, { + moduleName: 'workbox-strategies', + className: this.constructor.name, + funcName: 'handle', + paramName: 'makeRequest' + }); + } + + const promises = []; + let timeoutId; + + if (this._networkTimeoutSeconds) { + const { + id, + promise + } = this._getTimeoutPromise({ + request, + logs, + handler + }); + + timeoutId = id; + promises.push(promise); + } + + const networkPromise = this._getNetworkPromise({ + timeoutId, + request, + logs, + handler + }); + + promises.push(networkPromise); + const response = await handler.waitUntil((async () => { + // Promise.race() will resolve as soon as the first promise resolves. + return (await handler.waitUntil(Promise.race(promises))) || ( // If Promise.race() resolved with null, it might be due to a network + // timeout + a cache miss. If that were to happen, we'd rather wait until + // the networkPromise resolves instead of returning null. + // Note that it's fine to await an already-resolved promise, so we don't + // have to check to see if it's still "in flight". + await networkPromise); + })()); + + { + logger.groupCollapsed(messages.strategyStart(this.constructor.name, request)); + + for (const log of logs) { + logger.log(log); + } + + messages.printFinalResponse(response); + logger.groupEnd(); + } + + if (!response) { + throw new WorkboxError('no-response', { + url: request.url + }); + } + + return response; + } + /** + * @param {Object} options + * @param {Request} options.request + * @param {Array} options.logs A reference to the logs array + * @param {Event} options.event + * @return {Promise<Response>} + * + * @private + */ + + + _getTimeoutPromise({ + request, + logs, + handler + }) { + let timeoutId; + const timeoutPromise = new Promise(resolve => { + const onNetworkTimeout = async () => { + { + logs.push(`Timing out the network response at ` + `${this._networkTimeoutSeconds} seconds.`); + } + + resolve(await handler.cacheMatch(request)); + }; + + timeoutId = setTimeout(onNetworkTimeout, this._networkTimeoutSeconds * 1000); + }); + return { + promise: timeoutPromise, + id: timeoutId + }; + } + /** + * @param {Object} options + * @param {number|undefined} options.timeoutId + * @param {Request} options.request + * @param {Array} options.logs A reference to the logs Array. + * @param {Event} options.event + * @return {Promise<Response>} + * + * @private + */ + + + async _getNetworkPromise({ + timeoutId, + request, + logs, + handler + }) { + let error; + let response; + + try { + response = await handler.fetchAndCachePut(request); + } catch (fetchError) { + error = fetchError; + } + + if (timeoutId) { + clearTimeout(timeoutId); + } + + { + if (response) { + logs.push(`Got response from network.`); + } else { + logs.push(`Unable to get a response from the network. Will respond ` + `with a cached response.`); + } + } + + if (error || !response) { + response = await handler.cacheMatch(request); + + { + if (response) { + logs.push(`Found a cached response in the '${this.cacheName}'` + ` cache.`); + } else { + logs.push(`No response found in the '${this.cacheName}' cache.`); + } + } + } + + return response; + } + + } + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * An implementation of a + * [network-only]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#network-only} + * request strategy. + * + * This class is useful if you want to take advantage of any + * [Workbox plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}. + * + * If the network request fails, this will throw a `WorkboxError` exception. + * + * @extends module:workbox-strategies.Strategy + * @memberof module:workbox-strategies + */ + + class NetworkOnly extends Strategy { + /** + * @param {Object} [options] + * @param {Array<Object>} [options.plugins] [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins} + * to use in conjunction with this caching strategy. + * @param {Object} [options.fetchOptions] Values passed along to the + * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters) + * of [non-navigation](https://github.com/GoogleChrome/workbox/issues/1796) + * `fetch()` requests made by this strategy. + * @param {number} [options.networkTimeoutSeconds] If set, any network requests + * that fail to respond within the timeout will result in a network error. + */ + constructor(options = {}) { + super(options); + this._networkTimeoutSeconds = options.networkTimeoutSeconds || 0; + } + /** + * @private + * @param {Request|string} request A request to run this strategy for. + * @param {module:workbox-strategies.StrategyHandler} handler The event that + * triggered the request. + * @return {Promise<Response>} + */ + + + async _handle(request, handler) { + { + finalAssertExports.isInstance(request, Request, { + moduleName: 'workbox-strategies', + className: this.constructor.name, + funcName: '_handle', + paramName: 'request' + }); + } + + let error = undefined; + let response; + + try { + const promises = [handler.fetch(request)]; + + if (this._networkTimeoutSeconds) { + const timeoutPromise = timeout(this._networkTimeoutSeconds * 1000); + promises.push(timeoutPromise); + } + + response = await Promise.race(promises); + + if (!response) { + throw new Error(`Timed out the network response after ` + `${this._networkTimeoutSeconds} seconds.`); + } + } catch (err) { + error = err; + } + + { + logger.groupCollapsed(messages.strategyStart(this.constructor.name, request)); + + if (response) { + logger.log(`Got response from network.`); + } else { + logger.log(`Unable to get a response from the network.`); + } + + messages.printFinalResponse(response); + logger.groupEnd(); + } + + if (!response) { + throw new WorkboxError('no-response', { + url: request.url, + error + }); + } + + return response; + } + + } + + /* + Copyright 2019 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * Claim any currently available clients once the service worker + * becomes active. This is normally used in conjunction with `skipWaiting()`. + * + * @memberof module:workbox-core + */ + + function clientsClaim() { + self.addEventListener('activate', () => self.clients.claim()); + } + + exports.NetworkFirst = NetworkFirst; + exports.NetworkOnly = NetworkOnly; + exports.clientsClaim = clientsClaim; + exports.registerRoute = registerRoute; + +}); +//# sourceMappingURL=workbox-6b19f60b.js.map
A
frontend/public/workbox-6b19f60b.js.map
@@ -0,0 +1,1 @@
+{"version":3,"file":"workbox-6b19f60b.js","sources":["node_modules/workbox-core/_version.js","node_modules/workbox-core/_private/logger.js","node_modules/workbox-core/models/messages/messages.js","node_modules/workbox-core/models/messages/messageGenerator.js","node_modules/workbox-core/_private/WorkboxError.js","node_modules/workbox-core/_private/assert.js","node_modules/workbox-routing/_version.js","node_modules/workbox-routing/utils/constants.js","node_modules/workbox-routing/utils/normalizeHandler.js","node_modules/workbox-routing/Route.js","node_modules/workbox-routing/RegExpRoute.js","node_modules/workbox-core/_private/getFriendlyURL.js","node_modules/workbox-routing/Router.js","node_modules/workbox-routing/utils/getOrCreateDefaultRouter.js","node_modules/workbox-routing/registerRoute.js","node_modules/workbox-strategies/_version.js","node_modules/workbox-strategies/plugins/cacheOkAndOpaquePlugin.js","node_modules/workbox-core/_private/cacheNames.js","node_modules/workbox-core/_private/cacheMatchIgnoreParams.js","node_modules/workbox-core/_private/Deferred.js","node_modules/workbox-core/models/quotaErrorCallbacks.js","node_modules/workbox-core/_private/executeQuotaErrorCallbacks.js","node_modules/workbox-core/_private/timeout.js","node_modules/workbox-strategies/StrategyHandler.js","node_modules/workbox-strategies/Strategy.js","node_modules/workbox-strategies/utils/messages.js","node_modules/workbox-strategies/NetworkFirst.js","node_modules/workbox-strategies/NetworkOnly.js","node_modules/workbox-core/clientsClaim.js"],"sourcesContent":["\"use strict\";\n// @ts-ignore\ntry {\n self['workbox:core:6.1.5'] && _();\n}\ncatch (e) { }\n","/*\n Copyright 2019 Google LLC\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\nconst logger = (process.env.NODE_ENV === 'production' ? null : (() => {\n // Don't overwrite this value if it's already set.\n // See https://github.com/GoogleChrome/workbox/pull/2284#issuecomment-560470923\n if (!('__WB_DISABLE_DEV_LOGS' in self)) {\n self.__WB_DISABLE_DEV_LOGS = false;\n }\n let inGroup = false;\n const methodToColorMap = {\n debug: `#7f8c8d`,\n log: `#2ecc71`,\n warn: `#f39c12`,\n error: `#c0392b`,\n groupCollapsed: `#3498db`,\n groupEnd: null,\n };\n const print = function (method, args) {\n if (self.__WB_DISABLE_DEV_LOGS) {\n return;\n }\n if (method === 'groupCollapsed') {\n // Safari doesn't print all console.groupCollapsed() arguments:\n // https://bugs.webkit.org/show_bug.cgi?id=182754\n if (/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) {\n console[method](...args);\n return;\n }\n }\n const styles = [\n `background: ${methodToColorMap[method]}`,\n `border-radius: 0.5em`,\n `color: white`,\n `font-weight: bold`,\n `padding: 2px 0.5em`,\n ];\n // When in a group, the workbox prefix is not displayed.\n const logPrefix = inGroup ? [] : ['%cworkbox', styles.join(';')];\n console[method](...logPrefix, ...args);\n if (method === 'groupCollapsed') {\n inGroup = true;\n }\n if (method === 'groupEnd') {\n inGroup = false;\n }\n };\n const api = {};\n const loggerMethods = Object.keys(methodToColorMap);\n for (const key of loggerMethods) {\n const method = key;\n api[method] = (...args) => {\n print(method, args);\n };\n }\n return api;\n})());\nexport { logger };\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport '../../_version.js';\nexport const messages = {\n 'invalid-value': ({ paramName, validValueDescription, value }) => {\n if (!paramName || !validValueDescription) {\n throw new Error(`Unexpected input to 'invalid-value' error.`);\n }\n return `The '${paramName}' parameter was given a value with an ` +\n `unexpected value. ${validValueDescription} Received a value of ` +\n `${JSON.stringify(value)}.`;\n },\n 'not-an-array': ({ moduleName, className, funcName, paramName }) => {\n if (!moduleName || !className || !funcName || !paramName) {\n throw new Error(`Unexpected input to 'not-an-array' error.`);\n }\n return `The parameter '${paramName}' passed into ` +\n `'${moduleName}.${className}.${funcName}()' must be an array.`;\n },\n 'incorrect-type': ({ expectedType, paramName, moduleName, className, funcName }) => {\n if (!expectedType || !paramName || !moduleName || !funcName) {\n throw new Error(`Unexpected input to 'incorrect-type' error.`);\n }\n return `The parameter '${paramName}' passed into ` +\n `'${moduleName}.${className ? (className + '.') : ''}` +\n `${funcName}()' must be of type ${expectedType}.`;\n },\n 'incorrect-class': ({ expectedClass, paramName, moduleName, className, funcName, isReturnValueProblem }) => {\n if (!expectedClass || !moduleName || !funcName) {\n throw new Error(`Unexpected input to 'incorrect-class' error.`);\n }\n if (isReturnValueProblem) {\n return `The return value from ` +\n `'${moduleName}.${className ? (className + '.') : ''}${funcName}()' ` +\n `must be an instance of class ${expectedClass.name}.`;\n }\n return `The parameter '${paramName}' passed into ` +\n `'${moduleName}.${className ? (className + '.') : ''}${funcName}()' ` +\n `must be an instance of class ${expectedClass.name}.`;\n },\n 'missing-a-method': ({ expectedMethod, paramName, moduleName, className, funcName }) => {\n if (!expectedMethod || !paramName || !moduleName || !className\n || !funcName) {\n throw new Error(`Unexpected input to 'missing-a-method' error.`);\n }\n return `${moduleName}.${className}.${funcName}() expected the ` +\n `'${paramName}' parameter to expose a '${expectedMethod}' method.`;\n },\n 'add-to-cache-list-unexpected-type': ({ entry }) => {\n return `An unexpected entry was passed to ` +\n `'workbox-precaching.PrecacheController.addToCacheList()' The entry ` +\n `'${JSON.stringify(entry)}' isn't supported. You must supply an array of ` +\n `strings with one or more characters, objects with a url property or ` +\n `Request objects.`;\n },\n 'add-to-cache-list-conflicting-entries': ({ firstEntry, secondEntry }) => {\n if (!firstEntry || !secondEntry) {\n throw new Error(`Unexpected input to ` +\n `'add-to-cache-list-duplicate-entries' error.`);\n }\n return `Two of the entries passed to ` +\n `'workbox-precaching.PrecacheController.addToCacheList()' had the URL ` +\n `${firstEntry._entryId} but different revision details. Workbox is ` +\n `unable to cache and version the asset correctly. Please remove one ` +\n `of the entries.`;\n },\n 'plugin-error-request-will-fetch': ({ thrownError }) => {\n if (!thrownError) {\n throw new Error(`Unexpected input to ` +\n `'plugin-error-request-will-fetch', error.`);\n }\n return `An error was thrown by a plugins 'requestWillFetch()' method. ` +\n `The thrown error message was: '${thrownError.message}'.`;\n },\n 'invalid-cache-name': ({ cacheNameId, value }) => {\n if (!cacheNameId) {\n throw new Error(`Expected a 'cacheNameId' for error 'invalid-cache-name'`);\n }\n return `You must provide a name containing at least one character for ` +\n `setCacheDetails({${cacheNameId}: '...'}). Received a value of ` +\n `'${JSON.stringify(value)}'`;\n },\n 'unregister-route-but-not-found-with-method': ({ method }) => {\n if (!method) {\n throw new Error(`Unexpected input to ` +\n `'unregister-route-but-not-found-with-method' error.`);\n }\n return `The route you're trying to unregister was not previously ` +\n `registered for the method type '${method}'.`;\n },\n 'unregister-route-route-not-registered': () => {\n return `The route you're trying to unregister was not previously ` +\n `registered.`;\n },\n 'queue-replay-failed': ({ name }) => {\n return `Replaying the background sync queue '${name}' failed.`;\n },\n 'duplicate-queue-name': ({ name }) => {\n return `The Queue name '${name}' is already being used. ` +\n `All instances of backgroundSync.Queue must be given unique names.`;\n },\n 'expired-test-without-max-age': ({ methodName, paramName }) => {\n return `The '${methodName}()' method can only be used when the ` +\n `'${paramName}' is used in the constructor.`;\n },\n 'unsupported-route-type': ({ moduleName, className, funcName, paramName }) => {\n return `The supplied '${paramName}' parameter was an unsupported type. ` +\n `Please check the docs for ${moduleName}.${className}.${funcName} for ` +\n `valid input types.`;\n },\n 'not-array-of-class': ({ value, expectedClass, moduleName, className, funcName, paramName }) => {\n return `The supplied '${paramName}' parameter must be an array of ` +\n `'${expectedClass}' objects. Received '${JSON.stringify(value)},'. ` +\n `Please check the call to ${moduleName}.${className}.${funcName}() ` +\n `to fix the issue.`;\n },\n 'max-entries-or-age-required': ({ moduleName, className, funcName }) => {\n return `You must define either config.maxEntries or config.maxAgeSeconds` +\n `in ${moduleName}.${className}.${funcName}`;\n },\n 'statuses-or-headers-required': ({ moduleName, className, funcName }) => {\n return `You must define either config.statuses or config.headers` +\n `in ${moduleName}.${className}.${funcName}`;\n },\n 'invalid-string': ({ moduleName, funcName, paramName }) => {\n if (!paramName || !moduleName || !funcName) {\n throw new Error(`Unexpected input to 'invalid-string' error.`);\n }\n return `When using strings, the '${paramName}' parameter must start with ` +\n `'http' (for cross-origin matches) or '/' (for same-origin matches). ` +\n `Please see the docs for ${moduleName}.${funcName}() for ` +\n `more info.`;\n },\n 'channel-name-required': () => {\n return `You must provide a channelName to construct a ` +\n `BroadcastCacheUpdate instance.`;\n },\n 'invalid-responses-are-same-args': () => {\n return `The arguments passed into responsesAreSame() appear to be ` +\n `invalid. Please ensure valid Responses are used.`;\n },\n 'expire-custom-caches-only': () => {\n return `You must provide a 'cacheName' property when using the ` +\n `expiration plugin with a runtime caching strategy.`;\n },\n 'unit-must-be-bytes': ({ normalizedRangeHeader }) => {\n if (!normalizedRangeHeader) {\n throw new Error(`Unexpected input to 'unit-must-be-bytes' error.`);\n }\n return `The 'unit' portion of the Range header must be set to 'bytes'. ` +\n `The Range header provided was \"${normalizedRangeHeader}\"`;\n },\n 'single-range-only': ({ normalizedRangeHeader }) => {\n if (!normalizedRangeHeader) {\n throw new Error(`Unexpected input to 'single-range-only' error.`);\n }\n return `Multiple ranges are not supported. Please use a single start ` +\n `value, and optional end value. The Range header provided was ` +\n `\"${normalizedRangeHeader}\"`;\n },\n 'invalid-range-values': ({ normalizedRangeHeader }) => {\n if (!normalizedRangeHeader) {\n throw new Error(`Unexpected input to 'invalid-range-values' error.`);\n }\n return `The Range header is missing both start and end values. At least ` +\n `one of those values is needed. The Range header provided was ` +\n `\"${normalizedRangeHeader}\"`;\n },\n 'no-range-header': () => {\n return `No Range header was found in the Request provided.`;\n },\n 'range-not-satisfiable': ({ size, start, end }) => {\n return `The start (${start}) and end (${end}) values in the Range are ` +\n `not satisfiable by the cached response, which is ${size} bytes.`;\n },\n 'attempt-to-cache-non-get-request': ({ url, method }) => {\n return `Unable to cache '${url}' because it is a '${method}' request and ` +\n `only 'GET' requests can be cached.`;\n },\n 'cache-put-with-no-response': ({ url }) => {\n return `There was an attempt to cache '${url}' but the response was not ` +\n `defined.`;\n },\n 'no-response': ({ url, error }) => {\n let message = `The strategy could not generate a response for '${url}'.`;\n if (error) {\n message += ` The underlying error is ${error}.`;\n }\n return message;\n },\n 'bad-precaching-response': ({ url, status }) => {\n return `The precaching request for '${url}' failed` +\n (status ? ` with an HTTP status of ${status}.` : `.`);\n },\n 'non-precached-url': ({ url }) => {\n return `createHandlerBoundToURL('${url}') was called, but that URL is ` +\n `not precached. Please pass in a URL that is precached instead.`;\n },\n 'add-to-cache-list-conflicting-integrities': ({ url }) => {\n return `Two of the entries passed to ` +\n `'workbox-precaching.PrecacheController.addToCacheList()' had the URL ` +\n `${url} with different integrity values. Please remove one of them.`;\n },\n 'missing-precache-entry': ({ cacheName, url }) => {\n return `Unable to find a precached response in ${cacheName} for ${url}.`;\n },\n 'cross-origin-copy-response': ({ origin }) => {\n return `workbox-core.copyResponse() can only be used with same-origin ` +\n `responses. It was passed a response with origin ${origin}.`;\n },\n};\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport { messages } from './messages.js';\nimport '../../_version.js';\nconst fallback = (code, ...args) => {\n let msg = code;\n if (args.length > 0) {\n msg += ` :: ${JSON.stringify(args)}`;\n }\n return msg;\n};\nconst generatorFunction = (code, details = {}) => {\n const message = messages[code];\n if (!message) {\n throw new Error(`Unable to find message for code '${code}'.`);\n }\n return message(details);\n};\nexport const messageGenerator = (process.env.NODE_ENV === 'production') ?\n fallback : generatorFunction;\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport { messageGenerator } from '../models/messages/messageGenerator.js';\nimport '../_version.js';\n/**\n * Workbox errors should be thrown with this class.\n * This allows use to ensure the type easily in tests,\n * helps developers identify errors from workbox\n * easily and allows use to optimise error\n * messages correctly.\n *\n * @private\n */\nclass WorkboxError extends Error {\n /**\n *\n * @param {string} errorCode The error code that\n * identifies this particular error.\n * @param {Object=} details Any relevant arguments\n * that will help developers identify issues should\n * be added as a key on the context object.\n */\n constructor(errorCode, details) {\n const message = messageGenerator(errorCode, details);\n super(message);\n this.name = errorCode;\n this.details = details;\n }\n}\nexport { WorkboxError };\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport { WorkboxError } from '../_private/WorkboxError.js';\nimport '../_version.js';\n/*\n * This method throws if the supplied value is not an array.\n * The destructed values are required to produce a meaningful error for users.\n * The destructed and restructured object is so it's clear what is\n * needed.\n */\nconst isArray = (value, details) => {\n if (!Array.isArray(value)) {\n throw new WorkboxError('not-an-array', details);\n }\n};\nconst hasMethod = (object, expectedMethod, details) => {\n const type = typeof object[expectedMethod];\n if (type !== 'function') {\n details['expectedMethod'] = expectedMethod;\n throw new WorkboxError('missing-a-method', details);\n }\n};\nconst isType = (object, expectedType, details) => {\n if (typeof object !== expectedType) {\n details['expectedType'] = expectedType;\n throw new WorkboxError('incorrect-type', details);\n }\n};\nconst isInstance = (object, expectedClass, details) => {\n if (!(object instanceof expectedClass)) {\n details['expectedClass'] = expectedClass;\n throw new WorkboxError('incorrect-class', details);\n }\n};\nconst isOneOf = (value, validValues, details) => {\n if (!validValues.includes(value)) {\n details['validValueDescription'] =\n `Valid values are ${JSON.stringify(validValues)}.`;\n throw new WorkboxError('invalid-value', details);\n }\n};\nconst isArrayOfClass = (value, expectedClass, details) => {\n const error = new WorkboxError('not-array-of-class', details);\n if (!Array.isArray(value)) {\n throw error;\n }\n for (const item of value) {\n if (!(item instanceof expectedClass)) {\n throw error;\n }\n }\n};\nconst finalAssertExports = process.env.NODE_ENV === 'production' ? null : {\n hasMethod,\n isArray,\n isInstance,\n isOneOf,\n isType,\n isArrayOfClass,\n};\nexport { finalAssertExports as assert };\n","\"use strict\";\n// @ts-ignore\ntry {\n self['workbox:routing:6.1.5'] && _();\n}\ncatch (e) { }\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\n/**\n * The default HTTP method, 'GET', used when there's no specific method\n * configured for a route.\n *\n * @type {string}\n *\n * @private\n */\nexport const defaultMethod = 'GET';\n/**\n * The list of valid HTTP methods associated with requests that could be routed.\n *\n * @type {Array<string>}\n *\n * @private\n */\nexport const validMethods = [\n 'DELETE',\n 'GET',\n 'HEAD',\n 'PATCH',\n 'POST',\n 'PUT',\n];\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport { assert } from 'workbox-core/_private/assert.js';\nimport '../_version.js';\n/**\n * @param {function()|Object} handler Either a function, or an object with a\n * 'handle' method.\n * @return {Object} An object with a handle method.\n *\n * @private\n */\nexport const normalizeHandler = (handler) => {\n if (handler && typeof handler === 'object') {\n if (process.env.NODE_ENV !== 'production') {\n assert.hasMethod(handler, 'handle', {\n moduleName: 'workbox-routing',\n className: 'Route',\n funcName: 'constructor',\n paramName: 'handler',\n });\n }\n return handler;\n }\n else {\n if (process.env.NODE_ENV !== 'production') {\n assert.isType(handler, 'function', {\n moduleName: 'workbox-routing',\n className: 'Route',\n funcName: 'constructor',\n paramName: 'handler',\n });\n }\n return { handle: handler };\n }\n};\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { defaultMethod, validMethods } from './utils/constants.js';\nimport { normalizeHandler } from './utils/normalizeHandler.js';\nimport './_version.js';\n/**\n * A `Route` consists of a pair of callback functions, \"match\" and \"handler\".\n * The \"match\" callback determine if a route should be used to \"handle\" a\n * request by returning a non-falsy value if it can. The \"handler\" callback\n * is called when there is a match and should return a Promise that resolves\n * to a `Response`.\n *\n * @memberof module:workbox-routing\n */\nclass Route {\n /**\n * Constructor for Route class.\n *\n * @param {module:workbox-routing~matchCallback} match\n * A callback function that determines whether the route matches a given\n * `fetch` event by returning a non-falsy value.\n * @param {module:workbox-routing~handlerCallback} handler A callback\n * function that returns a Promise resolving to a Response.\n * @param {string} [method='GET'] The HTTP method to match the Route\n * against.\n */\n constructor(match, handler, method = defaultMethod) {\n if (process.env.NODE_ENV !== 'production') {\n assert.isType(match, 'function', {\n moduleName: 'workbox-routing',\n className: 'Route',\n funcName: 'constructor',\n paramName: 'match',\n });\n if (method) {\n assert.isOneOf(method, validMethods, { paramName: 'method' });\n }\n }\n // These values are referenced directly by Router so cannot be\n // altered by minificaton.\n this.handler = normalizeHandler(handler);\n this.match = match;\n this.method = method;\n }\n /**\n *\n * @param {module:workbox-routing-handlerCallback} handler A callback\n * function that returns a Promise resolving to a Response\n */\n setCatchHandler(handler) {\n this.catchHandler = normalizeHandler(handler);\n }\n}\nexport { Route };\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { Route } from './Route.js';\nimport './_version.js';\n/**\n * RegExpRoute makes it easy to create a regular expression based\n * [Route]{@link module:workbox-routing.Route}.\n *\n * For same-origin requests the RegExp only needs to match part of the URL. For\n * requests against third-party servers, you must define a RegExp that matches\n * the start of the URL.\n *\n * [See the module docs for info.]{@link https://developers.google.com/web/tools/workbox/modules/workbox-routing}\n *\n * @memberof module:workbox-routing\n * @extends module:workbox-routing.Route\n */\nclass RegExpRoute extends Route {\n /**\n * If the regular expression contains\n * [capture groups]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#grouping-back-references},\n * the captured values will be passed to the\n * [handler's]{@link module:workbox-routing~handlerCallback} `params`\n * argument.\n *\n * @param {RegExp} regExp The regular expression to match against URLs.\n * @param {module:workbox-routing~handlerCallback} handler A callback\n * function that returns a Promise resulting in a Response.\n * @param {string} [method='GET'] The HTTP method to match the Route\n * against.\n */\n constructor(regExp, handler, method) {\n if (process.env.NODE_ENV !== 'production') {\n assert.isInstance(regExp, RegExp, {\n moduleName: 'workbox-routing',\n className: 'RegExpRoute',\n funcName: 'constructor',\n paramName: 'pattern',\n });\n }\n const match = ({ url }) => {\n const result = regExp.exec(url.href);\n // Return immediately if there's no match.\n if (!result) {\n return;\n }\n // Require that the match start at the first character in the URL string\n // if it's a cross-origin request.\n // See https://github.com/GoogleChrome/workbox/issues/281 for the context\n // behind this behavior.\n if ((url.origin !== location.origin) && (result.index !== 0)) {\n if (process.env.NODE_ENV !== 'production') {\n logger.debug(`The regular expression '${regExp}' only partially matched ` +\n `against the cross-origin URL '${url}'. RegExpRoute's will only ` +\n `handle cross-origin requests if they match the entire URL.`);\n }\n return;\n }\n // If the route matches, but there aren't any capture groups defined, then\n // this will return [], which is truthy and therefore sufficient to\n // indicate a match.\n // If there are capture groups, then it will return their values.\n return result.slice(1);\n };\n super(match, handler, method);\n }\n}\nexport { RegExpRoute };\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\nconst getFriendlyURL = (url) => {\n const urlObj = new URL(String(url), location.href);\n // See https://github.com/GoogleChrome/workbox/issues/2323\n // We want to include everything, except for the origin if it's same-origin.\n return urlObj.href.replace(new RegExp(`^${location.origin}`), '');\n};\nexport { getFriendlyURL };\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';\nimport { defaultMethod } from './utils/constants.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { normalizeHandler } from './utils/normalizeHandler.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport './_version.js';\n/**\n * The Router can be used to process a FetchEvent through one or more\n * [Routes]{@link module:workbox-routing.Route} responding with a Request if\n * a matching route exists.\n *\n * If no route matches a given a request, the Router will use a \"default\"\n * handler if one is defined.\n *\n * Should the matching Route throw an error, the Router will use a \"catch\"\n * handler if one is defined to gracefully deal with issues and respond with a\n * Request.\n *\n * If a request matches multiple routes, the **earliest** registered route will\n * be used to respond to the request.\n *\n * @memberof module:workbox-routing\n */\nclass Router {\n /**\n * Initializes a new Router.\n */\n constructor() {\n this._routes = new Map();\n this._defaultHandlerMap = new Map();\n }\n /**\n * @return {Map<string, Array<module:workbox-routing.Route>>} routes A `Map` of HTTP\n * method name ('GET', etc.) to an array of all the corresponding `Route`\n * instances that are registered.\n */\n get routes() {\n return this._routes;\n }\n /**\n * Adds a fetch event listener to respond to events when a route matches\n * the event's request.\n */\n addFetchListener() {\n // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705\n self.addEventListener('fetch', ((event) => {\n const { request } = event;\n const responsePromise = this.handleRequest({ request, event });\n if (responsePromise) {\n event.respondWith(responsePromise);\n }\n }));\n }\n /**\n * Adds a message event listener for URLs to cache from the window.\n * This is useful to cache resources loaded on the page prior to when the\n * service worker started controlling it.\n *\n * The format of the message data sent from the window should be as follows.\n * Where the `urlsToCache` array may consist of URL strings or an array of\n * URL string + `requestInit` object (the same as you'd pass to `fetch()`).\n *\n * ```\n * {\n * type: 'CACHE_URLS',\n * payload: {\n * urlsToCache: [\n * './script1.js',\n * './script2.js',\n * ['./script3.js', {mode: 'no-cors'}],\n * ],\n * },\n * }\n * ```\n */\n addCacheListener() {\n // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705\n self.addEventListener('message', ((event) => {\n if (event.data && event.data.type === 'CACHE_URLS') {\n const { payload } = event.data;\n if (process.env.NODE_ENV !== 'production') {\n logger.debug(`Caching URLs from the window`, payload.urlsToCache);\n }\n const requestPromises = Promise.all(payload.urlsToCache.map((entry) => {\n if (typeof entry === 'string') {\n entry = [entry];\n }\n const request = new Request(...entry);\n return this.handleRequest({ request, event });\n // TODO(philipwalton): TypeScript errors without this typecast for\n // some reason (probably a bug). The real type here should work but\n // doesn't: `Array<Promise<Response> | undefined>`.\n })); // TypeScript\n event.waitUntil(requestPromises);\n // If a MessageChannel was used, reply to the message on success.\n if (event.ports && event.ports[0]) {\n requestPromises.then(() => event.ports[0].postMessage(true));\n }\n }\n }));\n }\n /**\n * Apply the routing rules to a FetchEvent object to get a Response from an\n * appropriate Route's handler.\n *\n * @param {Object} options\n * @param {Request} options.request The request to handle.\n * @param {ExtendableEvent} options.event The event that triggered the\n * request.\n * @return {Promise<Response>|undefined} A promise is returned if a\n * registered route can handle the request. If there is no matching\n * route and there's no `defaultHandler`, `undefined` is returned.\n */\n handleRequest({ request, event }) {\n if (process.env.NODE_ENV !== 'production') {\n assert.isInstance(request, Request, {\n moduleName: 'workbox-routing',\n className: 'Router',\n funcName: 'handleRequest',\n paramName: 'options.request',\n });\n }\n const url = new URL(request.url, location.href);\n if (!url.protocol.startsWith('http')) {\n if (process.env.NODE_ENV !== 'production') {\n logger.debug(`Workbox Router only supports URLs that start with 'http'.`);\n }\n return;\n }\n const sameOrigin = url.origin === location.origin;\n const { params, route } = this.findMatchingRoute({\n event,\n request,\n sameOrigin,\n url,\n });\n let handler = route && route.handler;\n const debugMessages = [];\n if (process.env.NODE_ENV !== 'production') {\n if (handler) {\n debugMessages.push([\n `Found a route to handle this request:`, route,\n ]);\n if (params) {\n debugMessages.push([\n `Passing the following params to the route's handler:`, params,\n ]);\n }\n }\n }\n // If we don't have a handler because there was no matching route, then\n // fall back to defaultHandler if that's defined.\n const method = request.method;\n if (!handler && this._defaultHandlerMap.has(method)) {\n if (process.env.NODE_ENV !== 'production') {\n debugMessages.push(`Failed to find a matching route. Falling ` +\n `back to the default handler for ${method}.`);\n }\n handler = this._defaultHandlerMap.get(method);\n }\n if (!handler) {\n if (process.env.NODE_ENV !== 'production') {\n // No handler so Workbox will do nothing. If logs is set of debug\n // i.e. verbose, we should print out this information.\n logger.debug(`No route found for: ${getFriendlyURL(url)}`);\n }\n return;\n }\n if (process.env.NODE_ENV !== 'production') {\n // We have a handler, meaning Workbox is going to handle the route.\n // print the routing details to the console.\n logger.groupCollapsed(`Router is responding to: ${getFriendlyURL(url)}`);\n debugMessages.forEach((msg) => {\n if (Array.isArray(msg)) {\n logger.log(...msg);\n }\n else {\n logger.log(msg);\n }\n });\n logger.groupEnd();\n }\n // Wrap in try and catch in case the handle method throws a synchronous\n // error. It should still callback to the catch handler.\n let responsePromise;\n try {\n responsePromise = handler.handle({ url, request, event, params });\n }\n catch (err) {\n responsePromise = Promise.reject(err);\n }\n // Get route's catch handler, if it exists\n const catchHandler = route && route.catchHandler;\n if (responsePromise instanceof Promise && (this._catchHandler || catchHandler)) {\n responsePromise = responsePromise.catch(async (err) => {\n // If there's a route catch handler, process that first\n if (catchHandler) {\n if (process.env.NODE_ENV !== 'production') {\n // Still include URL here as it will be async from the console group\n // and may not make sense without the URL\n logger.groupCollapsed(`Error thrown when responding to: ` +\n ` ${getFriendlyURL(url)}. Falling back to route's Catch Handler.`);\n logger.error(`Error thrown by:`, route);\n logger.error(err);\n logger.groupEnd();\n }\n try {\n return await catchHandler.handle({ url, request, event, params });\n }\n catch (catchErr) {\n err = catchErr;\n }\n }\n if (this._catchHandler) {\n if (process.env.NODE_ENV !== 'production') {\n // Still include URL here as it will be async from the console group\n // and may not make sense without the URL\n logger.groupCollapsed(`Error thrown when responding to: ` +\n ` ${getFriendlyURL(url)}. Falling back to global Catch Handler.`);\n logger.error(`Error thrown by:`, route);\n logger.error(err);\n logger.groupEnd();\n }\n return this._catchHandler.handle({ url, request, event });\n }\n throw err;\n });\n }\n return responsePromise;\n }\n /**\n * Checks a request and URL (and optionally an event) against the list of\n * registered routes, and if there's a match, returns the corresponding\n * route along with any params generated by the match.\n *\n * @param {Object} options\n * @param {URL} options.url\n * @param {boolean} options.sameOrigin The result of comparing `url.origin`\n * against the current origin.\n * @param {Request} options.request The request to match.\n * @param {Event} options.event The corresponding event.\n * @return {Object} An object with `route` and `params` properties.\n * They are populated if a matching route was found or `undefined`\n * otherwise.\n */\n findMatchingRoute({ url, sameOrigin, request, event }) {\n const routes = this._routes.get(request.method) || [];\n for (const route of routes) {\n let params;\n const matchResult = route.match({ url, sameOrigin, request, event });\n if (matchResult) {\n if (process.env.NODE_ENV !== 'production') {\n // Warn developers that using an async matchCallback is almost always\n // not the right thing to do. \n if (matchResult instanceof Promise) {\n logger.warn(`While routing ${getFriendlyURL(url)}, an async ` +\n `matchCallback function was used. Please convert the ` +\n `following route to use a synchronous matchCallback function:`, route);\n }\n }\n // See https://github.com/GoogleChrome/workbox/issues/2079\n params = matchResult;\n if (Array.isArray(matchResult) && matchResult.length === 0) {\n // Instead of passing an empty array in as params, use undefined.\n params = undefined;\n }\n else if ((matchResult.constructor === Object &&\n Object.keys(matchResult).length === 0)) {\n // Instead of passing an empty object in as params, use undefined.\n params = undefined;\n }\n else if (typeof matchResult === 'boolean') {\n // For the boolean value true (rather than just something truth-y),\n // don't set params.\n // See https://github.com/GoogleChrome/workbox/pull/2134#issuecomment-513924353\n params = undefined;\n }\n // Return early if have a match.\n return { route, params };\n }\n }\n // If no match was found above, return and empty object.\n return {};\n }\n /**\n * Define a default `handler` that's called when no routes explicitly\n * match the incoming request.\n *\n * Each HTTP method ('GET', 'POST', etc.) gets its own default handler.\n *\n * Without a default handler, unmatched requests will go against the\n * network as if there were no service worker present.\n *\n * @param {module:workbox-routing~handlerCallback} handler A callback\n * function that returns a Promise resulting in a Response.\n * @param {string} [method='GET'] The HTTP method to associate with this\n * default handler. Each method has its own default.\n */\n setDefaultHandler(handler, method = defaultMethod) {\n this._defaultHandlerMap.set(method, normalizeHandler(handler));\n }\n /**\n * If a Route throws an error while handling a request, this `handler`\n * will be called and given a chance to provide a response.\n *\n * @param {module:workbox-routing~handlerCallback} handler A callback\n * function that returns a Promise resulting in a Response.\n */\n setCatchHandler(handler) {\n this._catchHandler = normalizeHandler(handler);\n }\n /**\n * Registers a route with the router.\n *\n * @param {module:workbox-routing.Route} route The route to register.\n */\n registerRoute(route) {\n if (process.env.NODE_ENV !== 'production') {\n assert.isType(route, 'object', {\n moduleName: 'workbox-routing',\n className: 'Router',\n funcName: 'registerRoute',\n paramName: 'route',\n });\n assert.hasMethod(route, 'match', {\n moduleName: 'workbox-routing',\n className: 'Router',\n funcName: 'registerRoute',\n paramName: 'route',\n });\n assert.isType(route.handler, 'object', {\n moduleName: 'workbox-routing',\n className: 'Router',\n funcName: 'registerRoute',\n paramName: 'route',\n });\n assert.hasMethod(route.handler, 'handle', {\n moduleName: 'workbox-routing',\n className: 'Router',\n funcName: 'registerRoute',\n paramName: 'route.handler',\n });\n assert.isType(route.method, 'string', {\n moduleName: 'workbox-routing',\n className: 'Router',\n funcName: 'registerRoute',\n paramName: 'route.method',\n });\n }\n if (!this._routes.has(route.method)) {\n this._routes.set(route.method, []);\n }\n // Give precedence to all of the earlier routes by adding this additional\n // route to the end of the array.\n this._routes.get(route.method).push(route);\n }\n /**\n * Unregisters a route with the router.\n *\n * @param {module:workbox-routing.Route} route The route to unregister.\n */\n unregisterRoute(route) {\n if (!this._routes.has(route.method)) {\n throw new WorkboxError('unregister-route-but-not-found-with-method', {\n method: route.method,\n });\n }\n const routeIndex = this._routes.get(route.method).indexOf(route);\n if (routeIndex > -1) {\n this._routes.get(route.method).splice(routeIndex, 1);\n }\n else {\n throw new WorkboxError('unregister-route-route-not-registered');\n }\n }\n}\nexport { Router };\n","/*\n Copyright 2019 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport { Router } from '../Router.js';\nimport '../_version.js';\nlet defaultRouter;\n/**\n * Creates a new, singleton Router instance if one does not exist. If one\n * does already exist, that instance is returned.\n *\n * @private\n * @return {Router}\n */\nexport const getOrCreateDefaultRouter = () => {\n if (!defaultRouter) {\n defaultRouter = new Router();\n // The helpers that use the default Router assume these listeners exist.\n defaultRouter.addFetchListener();\n defaultRouter.addCacheListener();\n }\n return defaultRouter;\n};\n","/*\n Copyright 2019 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { Route } from './Route.js';\nimport { RegExpRoute } from './RegExpRoute.js';\nimport { getOrCreateDefaultRouter } from './utils/getOrCreateDefaultRouter.js';\nimport './_version.js';\n/**\n * Easily register a RegExp, string, or function with a caching\n * strategy to a singleton Router instance.\n *\n * This method will generate a Route for you if needed and\n * call [registerRoute()]{@link module:workbox-routing.Router#registerRoute}.\n *\n * @param {RegExp|string|module:workbox-routing.Route~matchCallback|module:workbox-routing.Route} capture\n * If the capture param is a `Route`, all other arguments will be ignored.\n * @param {module:workbox-routing~handlerCallback} [handler] A callback\n * function that returns a Promise resulting in a Response. This parameter\n * is required if `capture` is not a `Route` object.\n * @param {string} [method='GET'] The HTTP method to match the Route\n * against.\n * @return {module:workbox-routing.Route} The generated `Route`(Useful for\n * unregistering).\n *\n * @memberof module:workbox-routing\n */\nfunction registerRoute(capture, handler, method) {\n let route;\n if (typeof capture === 'string') {\n const captureUrl = new URL(capture, location.href);\n if (process.env.NODE_ENV !== 'production') {\n if (!(capture.startsWith('/') || capture.startsWith('http'))) {\n throw new WorkboxError('invalid-string', {\n moduleName: 'workbox-routing',\n funcName: 'registerRoute',\n paramName: 'capture',\n });\n }\n // We want to check if Express-style wildcards are in the pathname only.\n // TODO: Remove this log message in v4.\n const valueToCheck = capture.startsWith('http') ?\n captureUrl.pathname : capture;\n // See https://github.com/pillarjs/path-to-regexp#parameters\n const wildcards = '[*:?+]';\n if ((new RegExp(`${wildcards}`)).exec(valueToCheck)) {\n logger.debug(`The '$capture' parameter contains an Express-style wildcard ` +\n `character (${wildcards}). Strings are now always interpreted as ` +\n `exact matches; use a RegExp for partial or wildcard matches.`);\n }\n }\n const matchCallback = ({ url }) => {\n if (process.env.NODE_ENV !== 'production') {\n if ((url.pathname === captureUrl.pathname) &&\n (url.origin !== captureUrl.origin)) {\n logger.debug(`${capture} only partially matches the cross-origin URL ` +\n `${url}. This route will only handle cross-origin requests ` +\n `if they match the entire URL.`);\n }\n }\n return url.href === captureUrl.href;\n };\n // If `capture` is a string then `handler` and `method` must be present.\n route = new Route(matchCallback, handler, method);\n }\n else if (capture instanceof RegExp) {\n // If `capture` is a `RegExp` then `handler` and `method` must be present.\n route = new RegExpRoute(capture, handler, method);\n }\n else if (typeof capture === 'function') {\n // If `capture` is a function then `handler` and `method` must be present.\n route = new Route(capture, handler, method);\n }\n else if (capture instanceof Route) {\n route = capture;\n }\n else {\n throw new WorkboxError('unsupported-route-type', {\n moduleName: 'workbox-routing',\n funcName: 'registerRoute',\n paramName: 'capture',\n });\n }\n const defaultRouter = getOrCreateDefaultRouter();\n defaultRouter.registerRoute(route);\n return route;\n}\nexport { registerRoute };\n","\"use strict\";\n// @ts-ignore\ntry {\n self['workbox:strategies:6.1.5'] && _();\n}\ncatch (e) { }\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\nexport const cacheOkAndOpaquePlugin = {\n /**\n * Returns a valid response (to allow caching) if the status is 200 (OK) or\n * 0 (opaque).\n *\n * @param {Object} options\n * @param {Response} options.response\n * @return {Response|null}\n *\n * @private\n */\n cacheWillUpdate: async ({ response }) => {\n if (response.status === 200 || response.status === 0) {\n return response;\n }\n return null;\n },\n};\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\nconst _cacheNameDetails = {\n googleAnalytics: 'googleAnalytics',\n precache: 'precache-v2',\n prefix: 'workbox',\n runtime: 'runtime',\n suffix: typeof registration !== 'undefined' ? registration.scope : '',\n};\nconst _createCacheName = (cacheName) => {\n return [_cacheNameDetails.prefix, cacheName, _cacheNameDetails.suffix]\n .filter((value) => value && value.length > 0)\n .join('-');\n};\nconst eachCacheNameDetail = (fn) => {\n for (const key of Object.keys(_cacheNameDetails)) {\n fn(key);\n }\n};\nexport const cacheNames = {\n updateDetails: (details) => {\n eachCacheNameDetail((key) => {\n if (typeof details[key] === 'string') {\n _cacheNameDetails[key] = details[key];\n }\n });\n },\n getGoogleAnalyticsName: (userCacheName) => {\n return userCacheName || _createCacheName(_cacheNameDetails.googleAnalytics);\n },\n getPrecacheName: (userCacheName) => {\n return userCacheName || _createCacheName(_cacheNameDetails.precache);\n },\n getPrefix: () => {\n return _cacheNameDetails.prefix;\n },\n getRuntimeName: (userCacheName) => {\n return userCacheName || _createCacheName(_cacheNameDetails.runtime);\n },\n getSuffix: () => {\n return _cacheNameDetails.suffix;\n },\n};\n","/*\n Copyright 2020 Google LLC\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\nfunction stripParams(fullURL, ignoreParams) {\n const strippedURL = new URL(fullURL);\n for (const param of ignoreParams) {\n strippedURL.searchParams.delete(param);\n }\n return strippedURL.href;\n}\n/**\n * Matches an item in the cache, ignoring specific URL params. This is similar\n * to the `ignoreSearch` option, but it allows you to ignore just specific\n * params (while continuing to match on the others).\n *\n * @private\n * @param {Cache} cache\n * @param {Request} request\n * @param {Object} matchOptions\n * @param {Array<string>} ignoreParams\n * @return {Promise<Response|undefined>}\n */\nasync function cacheMatchIgnoreParams(cache, request, ignoreParams, matchOptions) {\n const strippedRequestURL = stripParams(request.url, ignoreParams);\n // If the request doesn't include any ignored params, match as normal.\n if (request.url === strippedRequestURL) {\n return cache.match(request, matchOptions);\n }\n // Otherwise, match by comparing keys\n const keysOptions = { ...matchOptions, ignoreSearch: true };\n const cacheKeys = await cache.keys(request, keysOptions);\n for (const cacheKey of cacheKeys) {\n const strippedCacheKeyURL = stripParams(cacheKey.url, ignoreParams);\n if (strippedRequestURL === strippedCacheKeyURL) {\n return cache.match(cacheKey, matchOptions);\n }\n }\n return;\n}\nexport { cacheMatchIgnoreParams };\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\n/**\n * The Deferred class composes Promises in a way that allows for them to be\n * resolved or rejected from outside the constructor. In most cases promises\n * should be used directly, but Deferreds can be necessary when the logic to\n * resolve a promise must be separate.\n *\n * @private\n */\nclass Deferred {\n /**\n * Creates a promise and exposes its resolve and reject functions as methods.\n */\n constructor() {\n this.promise = new Promise((resolve, reject) => {\n this.resolve = resolve;\n this.reject = reject;\n });\n }\n}\nexport { Deferred };\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\n// Callbacks to be executed whenever there's a quota error.\nconst quotaErrorCallbacks = new Set();\nexport { quotaErrorCallbacks };\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport { logger } from '../_private/logger.js';\nimport { quotaErrorCallbacks } from '../models/quotaErrorCallbacks.js';\nimport '../_version.js';\n/**\n * Runs all of the callback functions, one at a time sequentially, in the order\n * in which they were registered.\n *\n * @memberof module:workbox-core\n * @private\n */\nasync function executeQuotaErrorCallbacks() {\n if (process.env.NODE_ENV !== 'production') {\n logger.log(`About to run ${quotaErrorCallbacks.size} ` +\n `callbacks to clean up caches.`);\n }\n for (const callback of quotaErrorCallbacks) {\n await callback();\n if (process.env.NODE_ENV !== 'production') {\n logger.log(callback, 'is complete.');\n }\n }\n if (process.env.NODE_ENV !== 'production') {\n logger.log('Finished running callbacks.');\n }\n}\nexport { executeQuotaErrorCallbacks };\n","/*\n Copyright 2019 Google LLC\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport '../_version.js';\n/**\n * Returns a promise that resolves and the passed number of milliseconds.\n * This utility is an async/await-friendly version of `setTimeout`.\n *\n * @param {number} ms\n * @return {Promise}\n * @private\n */\nexport function timeout(ms) {\n return new Promise((resolve) => setTimeout(resolve, ms));\n}\n","/*\n Copyright 2020 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { cacheMatchIgnoreParams } from 'workbox-core/_private/cacheMatchIgnoreParams.js';\nimport { Deferred } from 'workbox-core/_private/Deferred.js';\nimport { executeQuotaErrorCallbacks } from 'workbox-core/_private/executeQuotaErrorCallbacks.js';\nimport { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { timeout } from 'workbox-core/_private/timeout.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport './_version.js';\nfunction toRequest(input) {\n return (typeof input === 'string') ? new Request(input) : input;\n}\n/**\n * A class created every time a Strategy instance instance calls\n * [handle()]{@link module:workbox-strategies.Strategy~handle} or\n * [handleAll()]{@link module:workbox-strategies.Strategy~handleAll} that wraps all fetch and\n * cache actions around plugin callbacks and keeps track of when the strategy\n * is \"done\" (i.e. all added `event.waitUntil()` promises have resolved).\n *\n * @memberof module:workbox-strategies\n */\nclass StrategyHandler {\n /**\n * Creates a new instance associated with the passed strategy and event\n * that's handling the request.\n *\n * The constructor also initializes the state that will be passed to each of\n * the plugins handling this request.\n *\n * @param {module:workbox-strategies.Strategy} strategy\n * @param {Object} options\n * @param {Request|string} options.request A request to run this strategy for.\n * @param {ExtendableEvent} options.event The event associated with the\n * request.\n * @param {URL} [options.url]\n * @param {*} [options.params]\n * [match callback]{@link module:workbox-routing~matchCallback},\n * (if applicable).\n */\n constructor(strategy, options) {\n this._cacheKeys = {};\n /**\n * The request the strategy is performing (passed to the strategy's\n * `handle()` or `handleAll()` method).\n * @name request\n * @instance\n * @type {Request}\n * @memberof module:workbox-strategies.StrategyHandler\n */\n /**\n * The event associated with this request.\n * @name event\n * @instance\n * @type {ExtendableEvent}\n * @memberof module:workbox-strategies.StrategyHandler\n */\n /**\n * A `URL` instance of `request.url` (if passed to the strategy's\n * `handle()` or `handleAll()` method).\n * Note: the `url` param will be present if the strategy was invoked\n * from a workbox `Route` object.\n * @name url\n * @instance\n * @type {URL|undefined}\n * @memberof module:workbox-strategies.StrategyHandler\n */\n /**\n * A `param` value (if passed to the strategy's\n * `handle()` or `handleAll()` method).\n * Note: the `param` param will be present if the strategy was invoked\n * from a workbox `Route` object and the\n * [match callback]{@link module:workbox-routing~matchCallback} returned\n * a truthy value (it will be that value).\n * @name params\n * @instance\n * @type {*|undefined}\n * @memberof module:workbox-strategies.StrategyHandler\n */\n if (process.env.NODE_ENV !== 'production') {\n assert.isInstance(options.event, ExtendableEvent, {\n moduleName: 'workbox-strategies',\n className: 'StrategyHandler',\n funcName: 'constructor',\n paramName: 'options.event',\n });\n }\n Object.assign(this, options);\n this.event = options.event;\n this._strategy = strategy;\n this._handlerDeferred = new Deferred();\n this._extendLifetimePromises = [];\n // Copy the plugins list (since it's mutable on the strategy),\n // so any mutations don't affect this handler instance.\n this._plugins = [...strategy.plugins];\n this._pluginStateMap = new Map();\n for (const plugin of this._plugins) {\n this._pluginStateMap.set(plugin, {});\n }\n this.event.waitUntil(this._handlerDeferred.promise);\n }\n /**\n * Fetches a given request (and invokes any applicable plugin callback\n * methods) using the `fetchOptions` (for non-navigation requests) and\n * `plugins` defined on the `Strategy` object.\n *\n * The following plugin lifecycle methods are invoked when using this method:\n * - `requestWillFetch()`\n * - `fetchDidSucceed()`\n * - `fetchDidFail()`\n *\n * @param {Request|string} input The URL or request to fetch.\n * @return {Promise<Response>}\n */\n async fetch(input) {\n const { event } = this;\n let request = toRequest(input);\n if (request.mode === 'navigate' &&\n event instanceof FetchEvent &&\n event.preloadResponse) {\n const possiblePreloadResponse = await event.preloadResponse;\n if (possiblePreloadResponse) {\n if (process.env.NODE_ENV !== 'production') {\n logger.log(`Using a preloaded navigation response for ` +\n `'${getFriendlyURL(request.url)}'`);\n }\n return possiblePreloadResponse;\n }\n }\n // If there is a fetchDidFail plugin, we need to save a clone of the\n // original request before it's either modified by a requestWillFetch\n // plugin or before the original request's body is consumed via fetch().\n const originalRequest = this.hasCallback('fetchDidFail') ?\n request.clone() : null;\n try {\n for (const cb of this.iterateCallbacks('requestWillFetch')) {\n request = await cb({ request: request.clone(), event });\n }\n }\n catch (err) {\n throw new WorkboxError('plugin-error-request-will-fetch', {\n thrownError: err,\n });\n }\n // The request can be altered by plugins with `requestWillFetch` making\n // the original request (most likely from a `fetch` event) different\n // from the Request we make. Pass both to `fetchDidFail` to aid debugging.\n const pluginFilteredRequest = request.clone();\n try {\n let fetchResponse;\n // See https://github.com/GoogleChrome/workbox/issues/1796\n fetchResponse = await fetch(request, request.mode === 'navigate' ?\n undefined : this._strategy.fetchOptions);\n if (process.env.NODE_ENV !== 'production') {\n logger.debug(`Network request for ` +\n `'${getFriendlyURL(request.url)}' returned a response with ` +\n `status '${fetchResponse.status}'.`);\n }\n for (const callback of this.iterateCallbacks('fetchDidSucceed')) {\n fetchResponse = await callback({\n event,\n request: pluginFilteredRequest,\n response: fetchResponse,\n });\n }\n return fetchResponse;\n }\n catch (error) {\n if (process.env.NODE_ENV !== 'production') {\n logger.log(`Network request for ` +\n `'${getFriendlyURL(request.url)}' threw an error.`, error);\n }\n // `originalRequest` will only exist if a `fetchDidFail` callback\n // is being used (see above).\n if (originalRequest) {\n await this.runCallbacks('fetchDidFail', {\n error,\n event,\n originalRequest: originalRequest.clone(),\n request: pluginFilteredRequest.clone(),\n });\n }\n throw error;\n }\n }\n /**\n * Calls `this.fetch()` and (in the background) runs `this.cachePut()` on\n * the response generated by `this.fetch()`.\n *\n * The call to `this.cachePut()` automatically invokes `this.waitUntil()`,\n * so you do not have to manually call `waitUntil()` on the event.\n *\n * @param {Request|string} input The request or URL to fetch and cache.\n * @return {Promise<Response>}\n */\n async fetchAndCachePut(input) {\n const response = await this.fetch(input);\n const responseClone = response.clone();\n this.waitUntil(this.cachePut(input, responseClone));\n return response;\n }\n /**\n * Matches a request from the cache (and invokes any applicable plugin\n * callback methods) using the `cacheName`, `matchOptions`, and `plugins`\n * defined on the strategy object.\n *\n * The following plugin lifecycle methods are invoked when using this method:\n * - cacheKeyWillByUsed()\n * - cachedResponseWillByUsed()\n *\n * @param {Request|string} key The Request or URL to use as the cache key.\n * @return {Promise<Response|undefined>} A matching response, if found.\n */\n async cacheMatch(key) {\n const request = toRequest(key);\n let cachedResponse;\n const { cacheName, matchOptions } = this._strategy;\n const effectiveRequest = await this.getCacheKey(request, 'read');\n const multiMatchOptions = { ...matchOptions, ...{ cacheName } };\n cachedResponse = await caches.match(effectiveRequest, multiMatchOptions);\n if (process.env.NODE_ENV !== 'production') {\n if (cachedResponse) {\n logger.debug(`Found a cached response in '${cacheName}'.`);\n }\n else {\n logger.debug(`No cached response found in '${cacheName}'.`);\n }\n }\n for (const callback of this.iterateCallbacks('cachedResponseWillBeUsed')) {\n cachedResponse = (await callback({\n cacheName,\n matchOptions,\n cachedResponse,\n request: effectiveRequest,\n event: this.event,\n })) || undefined;\n }\n return cachedResponse;\n }\n /**\n * Puts a request/response pair in the cache (and invokes any applicable\n * plugin callback methods) using the `cacheName` and `plugins` defined on\n * the strategy object.\n *\n * The following plugin lifecycle methods are invoked when using this method:\n * - cacheKeyWillByUsed()\n * - cacheWillUpdate()\n * - cacheDidUpdate()\n *\n * @param {Request|string} key The request or URL to use as the cache key.\n * @param {Response} response The response to cache.\n * @return {Promise<boolean>} `false` if a cacheWillUpdate caused the response\n * not be cached, and `true` otherwise.\n */\n async cachePut(key, response) {\n const request = toRequest(key);\n // Run in the next task to avoid blocking other cache reads.\n // https://github.com/w3c/ServiceWorker/issues/1397\n await timeout(0);\n const effectiveRequest = await this.getCacheKey(request, 'write');\n if (process.env.NODE_ENV !== 'production') {\n if (effectiveRequest.method && effectiveRequest.method !== 'GET') {\n throw new WorkboxError('attempt-to-cache-non-get-request', {\n url: getFriendlyURL(effectiveRequest.url),\n method: effectiveRequest.method,\n });\n }\n }\n if (!response) {\n if (process.env.NODE_ENV !== 'production') {\n logger.error(`Cannot cache non-existent response for ` +\n `'${getFriendlyURL(effectiveRequest.url)}'.`);\n }\n throw new WorkboxError('cache-put-with-no-response', {\n url: getFriendlyURL(effectiveRequest.url),\n });\n }\n const responseToCache = await this._ensureResponseSafeToCache(response);\n if (!responseToCache) {\n if (process.env.NODE_ENV !== 'production') {\n logger.debug(`Response '${getFriendlyURL(effectiveRequest.url)}' ` +\n `will not be cached.`, responseToCache);\n }\n return false;\n }\n const { cacheName, matchOptions } = this._strategy;\n const cache = await self.caches.open(cacheName);\n const hasCacheUpdateCallback = this.hasCallback('cacheDidUpdate');\n const oldResponse = hasCacheUpdateCallback ? await cacheMatchIgnoreParams(\n // TODO(philipwalton): the `__WB_REVISION__` param is a precaching\n // feature. Consider into ways to only add this behavior if using\n // precaching.\n cache, effectiveRequest.clone(), ['__WB_REVISION__'], matchOptions) :\n null;\n if (process.env.NODE_ENV !== 'production') {\n logger.debug(`Updating the '${cacheName}' cache with a new Response ` +\n `for ${getFriendlyURL(effectiveRequest.url)}.`);\n }\n try {\n await cache.put(effectiveRequest, hasCacheUpdateCallback ?\n responseToCache.clone() : responseToCache);\n }\n catch (error) {\n // See https://developer.mozilla.org/en-US/docs/Web/API/DOMException#exception-QuotaExceededError\n if (error.name === 'QuotaExceededError') {\n await executeQuotaErrorCallbacks();\n }\n throw error;\n }\n for (const callback of this.iterateCallbacks('cacheDidUpdate')) {\n await callback({\n cacheName,\n oldResponse,\n newResponse: responseToCache.clone(),\n request: effectiveRequest,\n event: this.event,\n });\n }\n return true;\n }\n /**\n * Checks the list of plugins for the `cacheKeyWillBeUsed` callback, and\n * executes any of those callbacks found in sequence. The final `Request`\n * object returned by the last plugin is treated as the cache key for cache\n * reads and/or writes. If no `cacheKeyWillBeUsed` plugin callbacks have\n * been registered, the passed request is returned unmodified\n *\n * @param {Request} request\n * @param {string} mode\n * @return {Promise<Request>}\n */\n async getCacheKey(request, mode) {\n if (!this._cacheKeys[mode]) {\n let effectiveRequest = request;\n for (const callback of this.iterateCallbacks('cacheKeyWillBeUsed')) {\n effectiveRequest = toRequest(await callback({\n mode,\n request: effectiveRequest,\n event: this.event,\n params: this.params,\n }));\n }\n this._cacheKeys[mode] = effectiveRequest;\n }\n return this._cacheKeys[mode];\n }\n /**\n * Returns true if the strategy has at least one plugin with the given\n * callback.\n *\n * @param {string} name The name of the callback to check for.\n * @return {boolean}\n */\n hasCallback(name) {\n for (const plugin of this._strategy.plugins) {\n if (name in plugin) {\n return true;\n }\n }\n return false;\n }\n /**\n * Runs all plugin callbacks matching the given name, in order, passing the\n * given param object (merged ith the current plugin state) as the only\n * argument.\n *\n * Note: since this method runs all plugins, it's not suitable for cases\n * where the return value of a callback needs to be applied prior to calling\n * the next callback. See\n * [`iterateCallbacks()`]{@link module:workbox-strategies.StrategyHandler#iterateCallbacks}\n * below for how to handle that case.\n *\n * @param {string} name The name of the callback to run within each plugin.\n * @param {Object} param The object to pass as the first (and only) param\n * when executing each callback. This object will be merged with the\n * current plugin state prior to callback execution.\n */\n async runCallbacks(name, param) {\n for (const callback of this.iterateCallbacks(name)) {\n // TODO(philipwalton): not sure why `any` is needed. It seems like\n // this should work with `as WorkboxPluginCallbackParam[C]`.\n await callback(param);\n }\n }\n /**\n * Accepts a callback and returns an iterable of matching plugin callbacks,\n * where each callback is wrapped with the current handler state (i.e. when\n * you call each callback, whatever object parameter you pass it will\n * be merged with the plugin's current state).\n *\n * @param {string} name The name fo the callback to run\n * @return {Array<Function>}\n */\n *iterateCallbacks(name) {\n for (const plugin of this._strategy.plugins) {\n if (typeof plugin[name] === 'function') {\n const state = this._pluginStateMap.get(plugin);\n const statefulCallback = (param) => {\n const statefulParam = { ...param, state };\n // TODO(philipwalton): not sure why `any` is needed. It seems like\n // this should work with `as WorkboxPluginCallbackParam[C]`.\n return plugin[name](statefulParam);\n };\n yield statefulCallback;\n }\n }\n }\n /**\n * Adds a promise to the\n * [extend lifetime promises]{@link https://w3c.github.io/ServiceWorker/#extendableevent-extend-lifetime-promises}\n * of the event event associated with the request being handled (usually a\n * `FetchEvent`).\n *\n * Note: you can await\n * [`doneWaiting()`]{@link module:workbox-strategies.StrategyHandler~doneWaiting}\n * to know when all added promises have settled.\n *\n * @param {Promise} promise A promise to add to the extend lifetime promises\n * of the event that triggered the request.\n */\n waitUntil(promise) {\n this._extendLifetimePromises.push(promise);\n return promise;\n }\n /**\n * Returns a promise that resolves once all promises passed to\n * [`waitUntil()`]{@link module:workbox-strategies.StrategyHandler~waitUntil}\n * have settled.\n *\n * Note: any work done after `doneWaiting()` settles should be manually\n * passed to an event's `waitUntil()` method (not this handler's\n * `waitUntil()` method), otherwise the service worker thread my be killed\n * prior to your work completing.\n */\n async doneWaiting() {\n let promise;\n while (promise = this._extendLifetimePromises.shift()) {\n await promise;\n }\n }\n /**\n * Stops running the strategy and immediately resolves any pending\n * `waitUntil()` promises.\n */\n destroy() {\n this._handlerDeferred.resolve();\n }\n /**\n * This method will call cacheWillUpdate on the available plugins (or use\n * status === 200) to determine if the Response is safe and valid to cache.\n *\n * @param {Request} options.request\n * @param {Response} options.response\n * @return {Promise<Response|undefined>}\n *\n * @private\n */\n async _ensureResponseSafeToCache(response) {\n let responseToCache = response;\n let pluginsUsed = false;\n for (const callback of this.iterateCallbacks('cacheWillUpdate')) {\n responseToCache = (await callback({\n request: this.request,\n response: responseToCache,\n event: this.event,\n })) || undefined;\n pluginsUsed = true;\n if (!responseToCache) {\n break;\n }\n }\n if (!pluginsUsed) {\n if (responseToCache && responseToCache.status !== 200) {\n responseToCache = undefined;\n }\n if (process.env.NODE_ENV !== 'production') {\n if (responseToCache) {\n if (responseToCache.status !== 200) {\n if (responseToCache.status === 0) {\n logger.warn(`The response for '${this.request.url}' ` +\n `is an opaque response. The caching strategy that you're ` +\n `using will not cache opaque responses by default.`);\n }\n else {\n logger.debug(`The response for '${this.request.url}' ` +\n `returned a status code of '${response.status}' and won't ` +\n `be cached as a result.`);\n }\n }\n }\n }\n }\n return responseToCache;\n }\n}\nexport { StrategyHandler };\n","/*\n Copyright 2020 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport { cacheNames } from 'workbox-core/_private/cacheNames.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';\nimport { StrategyHandler } from './StrategyHandler.js';\nimport './_version.js';\n/**\n * An abstract base class that all other strategy classes must extend from:\n *\n * @memberof module:workbox-strategies\n */\nclass Strategy {\n /**\n * Creates a new instance of the strategy and sets all documented option\n * properties as public instance properties.\n *\n * Note: if a custom strategy class extends the base Strategy class and does\n * not need more than these properties, it does not need to define its own\n * constructor.\n *\n * @param {Object} [options]\n * @param {string} [options.cacheName] Cache name to store and retrieve\n * requests. Defaults to the cache names provided by\n * [workbox-core]{@link module:workbox-core.cacheNames}.\n * @param {Array<Object>} [options.plugins] [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}\n * to use in conjunction with this caching strategy.\n * @param {Object} [options.fetchOptions] Values passed along to the\n * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)\n * of [non-navigation](https://github.com/GoogleChrome/workbox/issues/1796)\n * `fetch()` requests made by this strategy.\n * @param {Object} [options.matchOptions] The\n * [`CacheQueryOptions`]{@link https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions}\n * for any `cache.match()` or `cache.put()` calls made by this strategy.\n */\n constructor(options = {}) {\n /**\n * Cache name to store and retrieve\n * requests. Defaults to the cache names provided by\n * [workbox-core]{@link module:workbox-core.cacheNames}.\n *\n * @type {string}\n */\n this.cacheName = cacheNames.getRuntimeName(options.cacheName);\n /**\n * The list\n * [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}\n * used by this strategy.\n *\n * @type {Array<Object>}\n */\n this.plugins = options.plugins || [];\n /**\n * Values passed along to the\n * [`init`]{@link https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters}\n * of all fetch() requests made by this strategy.\n *\n * @type {Object}\n */\n this.fetchOptions = options.fetchOptions;\n /**\n * The\n * [`CacheQueryOptions`]{@link https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions}\n * for any `cache.match()` or `cache.put()` calls made by this strategy.\n *\n * @type {Object}\n */\n this.matchOptions = options.matchOptions;\n }\n /**\n * Perform a request strategy and returns a `Promise` that will resolve with\n * a `Response`, invoking all relevant plugin callbacks.\n *\n * When a strategy instance is registered with a Workbox\n * [route]{@link module:workbox-routing.Route}, this method is automatically\n * called when the route matches.\n *\n * Alternatively, this method can be used in a standalone `FetchEvent`\n * listener by passing it to `event.respondWith()`.\n *\n * @param {FetchEvent|Object} options A `FetchEvent` or an object with the\n * properties listed below.\n * @param {Request|string} options.request A request to run this strategy for.\n * @param {ExtendableEvent} options.event The event associated with the\n * request.\n * @param {URL} [options.url]\n * @param {*} [options.params]\n */\n handle(options) {\n const [responseDone] = this.handleAll(options);\n return responseDone;\n }\n /**\n * Similar to [`handle()`]{@link module:workbox-strategies.Strategy~handle}, but\n * instead of just returning a `Promise` that resolves to a `Response` it\n * it will return an tuple of [response, done] promises, where the former\n * (`response`) is equivalent to what `handle()` returns, and the latter is a\n * Promise that will resolve once any promises that were added to\n * `event.waitUntil()` as part of performing the strategy have completed.\n *\n * You can await the `done` promise to ensure any extra work performed by\n * the strategy (usually caching responses) completes successfully.\n *\n * @param {FetchEvent|Object} options A `FetchEvent` or an object with the\n * properties listed below.\n * @param {Request|string} options.request A request to run this strategy for.\n * @param {ExtendableEvent} options.event The event associated with the\n * request.\n * @param {URL} [options.url]\n * @param {*} [options.params]\n * @return {Array<Promise>} A tuple of [response, done]\n * promises that can be used to determine when the response resolves as\n * well as when the handler has completed all its work.\n */\n handleAll(options) {\n // Allow for flexible options to be passed.\n if (options instanceof FetchEvent) {\n options = {\n event: options,\n request: options.request,\n };\n }\n const event = options.event;\n const request = typeof options.request === 'string' ?\n new Request(options.request) :\n options.request;\n const params = 'params' in options ? options.params : undefined;\n const handler = new StrategyHandler(this, { event, request, params });\n const responseDone = this._getResponse(handler, request, event);\n const handlerDone = this._awaitComplete(responseDone, handler, request, event);\n // Return an array of promises, suitable for use with Promise.all().\n return [responseDone, handlerDone];\n }\n async _getResponse(handler, request, event) {\n await handler.runCallbacks('handlerWillStart', { event, request });\n let response = undefined;\n try {\n response = await this._handle(request, handler);\n // The \"official\" Strategy subclasses all throw this error automatically,\n // but in case a third-party Strategy doesn't, ensure that we have a\n // consistent failure when there's no response or an error response.\n if (!response || response.type === 'error') {\n throw new WorkboxError('no-response', { url: request.url });\n }\n }\n catch (error) {\n for (const callback of handler.iterateCallbacks('handlerDidError')) {\n response = await callback({ error, event, request });\n if (response) {\n break;\n }\n }\n if (!response) {\n throw error;\n }\n else if (process.env.NODE_ENV !== 'production') {\n logger.log(`While responding to '${getFriendlyURL(request.url)}', ` +\n `an ${error} error occurred. Using a fallback response provided by ` +\n `a handlerDidError plugin.`);\n }\n }\n for (const callback of handler.iterateCallbacks('handlerWillRespond')) {\n response = await callback({ event, request, response });\n }\n return response;\n }\n async _awaitComplete(responseDone, handler, request, event) {\n let response;\n let error;\n try {\n response = await responseDone;\n }\n catch (error) {\n // Ignore errors, as response errors should be caught via the `response`\n // promise above. The `done` promise will only throw for errors in\n // promises passed to `handler.waitUntil()`.\n }\n try {\n await handler.runCallbacks('handlerDidRespond', {\n event,\n request,\n response,\n });\n await handler.doneWaiting();\n }\n catch (waitUntilError) {\n error = waitUntilError;\n }\n await handler.runCallbacks('handlerDidComplete', {\n event,\n request,\n response,\n error,\n });\n handler.destroy();\n if (error) {\n throw error;\n }\n }\n}\nexport { Strategy };\n/**\n * Classes extending the `Strategy` based class should implement this method,\n * and leverage the [`handler`]{@link module:workbox-strategies.StrategyHandler}\n * arg to perform all fetching and cache logic, which will ensure all relevant\n * cache, cache options, fetch options and plugins are used (per the current\n * strategy instance).\n *\n * @name _handle\n * @instance\n * @abstract\n * @function\n * @param {Request} request\n * @param {module:workbox-strategies.StrategyHandler} handler\n * @return {Promise<Response>}\n *\n * @memberof module:workbox-strategies.Strategy\n */\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';\nimport '../_version.js';\nexport const messages = {\n strategyStart: (strategyName, request) => `Using ${strategyName} to respond to '${getFriendlyURL(request.url)}'`,\n printFinalResponse: (response) => {\n if (response) {\n logger.groupCollapsed(`View the final response here.`);\n logger.log(response || '[No response returned]');\n logger.groupEnd();\n }\n },\n};\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { cacheOkAndOpaquePlugin } from './plugins/cacheOkAndOpaquePlugin.js';\nimport { Strategy } from './Strategy.js';\nimport { messages } from './utils/messages.js';\nimport './_version.js';\n/**\n * An implementation of a\n * [network first]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#network-falling-back-to-cache}\n * request strategy.\n *\n * By default, this strategy will cache responses with a 200 status code as\n * well as [opaque responses]{@link https://developers.google.com/web/tools/workbox/guides/handle-third-party-requests}.\n * Opaque responses are are cross-origin requests where the response doesn't\n * support [CORS]{@link https://enable-cors.org/}.\n *\n * If the network request fails, and there is no cache match, this will throw\n * a `WorkboxError` exception.\n *\n * @extends module:workbox-strategies.Strategy\n * @memberof module:workbox-strategies\n */\nclass NetworkFirst extends Strategy {\n /**\n * @param {Object} [options]\n * @param {string} [options.cacheName] Cache name to store and retrieve\n * requests. Defaults to cache names provided by\n * [workbox-core]{@link module:workbox-core.cacheNames}.\n * @param {Array<Object>} [options.plugins] [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}\n * to use in conjunction with this caching strategy.\n * @param {Object} [options.fetchOptions] Values passed along to the\n * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)\n * of [non-navigation](https://github.com/GoogleChrome/workbox/issues/1796)\n * `fetch()` requests made by this strategy.\n * @param {Object} [options.matchOptions] [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)\n * @param {number} [options.networkTimeoutSeconds] If set, any network requests\n * that fail to respond within the timeout will fallback to the cache.\n *\n * This option can be used to combat\n * \"[lie-fi]{@link https://developers.google.com/web/fundamentals/performance/poor-connectivity/#lie-fi}\"\n * scenarios.\n */\n constructor(options = {}) {\n super(options);\n // If this instance contains no plugins with a 'cacheWillUpdate' callback,\n // prepend the `cacheOkAndOpaquePlugin` plugin to the plugins list.\n if (!this.plugins.some((p) => 'cacheWillUpdate' in p)) {\n this.plugins.unshift(cacheOkAndOpaquePlugin);\n }\n this._networkTimeoutSeconds = options.networkTimeoutSeconds || 0;\n if (process.env.NODE_ENV !== 'production') {\n if (this._networkTimeoutSeconds) {\n assert.isType(this._networkTimeoutSeconds, 'number', {\n moduleName: 'workbox-strategies',\n className: this.constructor.name,\n funcName: 'constructor',\n paramName: 'networkTimeoutSeconds',\n });\n }\n }\n }\n /**\n * @private\n * @param {Request|string} request A request to run this strategy for.\n * @param {module:workbox-strategies.StrategyHandler} handler The event that\n * triggered the request.\n * @return {Promise<Response>}\n */\n async _handle(request, handler) {\n const logs = [];\n if (process.env.NODE_ENV !== 'production') {\n assert.isInstance(request, Request, {\n moduleName: 'workbox-strategies',\n className: this.constructor.name,\n funcName: 'handle',\n paramName: 'makeRequest',\n });\n }\n const promises = [];\n let timeoutId;\n if (this._networkTimeoutSeconds) {\n const { id, promise } = this._getTimeoutPromise({ request, logs, handler });\n timeoutId = id;\n promises.push(promise);\n }\n const networkPromise = this._getNetworkPromise({ timeoutId, request, logs, handler });\n promises.push(networkPromise);\n const response = await handler.waitUntil((async () => {\n // Promise.race() will resolve as soon as the first promise resolves.\n return await handler.waitUntil(Promise.race(promises)) ||\n // If Promise.race() resolved with null, it might be due to a network\n // timeout + a cache miss. If that were to happen, we'd rather wait until\n // the networkPromise resolves instead of returning null.\n // Note that it's fine to await an already-resolved promise, so we don't\n // have to check to see if it's still \"in flight\".\n await networkPromise;\n })());\n if (process.env.NODE_ENV !== 'production') {\n logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));\n for (const log of logs) {\n logger.log(log);\n }\n messages.printFinalResponse(response);\n logger.groupEnd();\n }\n if (!response) {\n throw new WorkboxError('no-response', { url: request.url });\n }\n return response;\n }\n /**\n * @param {Object} options\n * @param {Request} options.request\n * @param {Array} options.logs A reference to the logs array\n * @param {Event} options.event\n * @return {Promise<Response>}\n *\n * @private\n */\n _getTimeoutPromise({ request, logs, handler }) {\n let timeoutId;\n const timeoutPromise = new Promise((resolve) => {\n const onNetworkTimeout = async () => {\n if (process.env.NODE_ENV !== 'production') {\n logs.push(`Timing out the network response at ` +\n `${this._networkTimeoutSeconds} seconds.`);\n }\n resolve(await handler.cacheMatch(request));\n };\n timeoutId = setTimeout(onNetworkTimeout, this._networkTimeoutSeconds * 1000);\n });\n return {\n promise: timeoutPromise,\n id: timeoutId,\n };\n }\n /**\n * @param {Object} options\n * @param {number|undefined} options.timeoutId\n * @param {Request} options.request\n * @param {Array} options.logs A reference to the logs Array.\n * @param {Event} options.event\n * @return {Promise<Response>}\n *\n * @private\n */\n async _getNetworkPromise({ timeoutId, request, logs, handler }) {\n let error;\n let response;\n try {\n response = await handler.fetchAndCachePut(request);\n }\n catch (fetchError) {\n error = fetchError;\n }\n if (timeoutId) {\n clearTimeout(timeoutId);\n }\n if (process.env.NODE_ENV !== 'production') {\n if (response) {\n logs.push(`Got response from network.`);\n }\n else {\n logs.push(`Unable to get a response from the network. Will respond ` +\n `with a cached response.`);\n }\n }\n if (error || !response) {\n response = await handler.cacheMatch(request);\n if (process.env.NODE_ENV !== 'production') {\n if (response) {\n logs.push(`Found a cached response in the '${this.cacheName}'` +\n ` cache.`);\n }\n else {\n logs.push(`No response found in the '${this.cacheName}' cache.`);\n }\n }\n }\n return response;\n }\n}\nexport { NetworkFirst };\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { timeout } from 'workbox-core/_private/timeout.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { Strategy } from './Strategy.js';\nimport { messages } from './utils/messages.js';\nimport './_version.js';\n/**\n * An implementation of a\n * [network-only]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#network-only}\n * request strategy.\n *\n * This class is useful if you want to take advantage of any\n * [Workbox plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}.\n *\n * If the network request fails, this will throw a `WorkboxError` exception.\n *\n * @extends module:workbox-strategies.Strategy\n * @memberof module:workbox-strategies\n */\nclass NetworkOnly extends Strategy {\n /**\n * @param {Object} [options]\n * @param {Array<Object>} [options.plugins] [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}\n * to use in conjunction with this caching strategy.\n * @param {Object} [options.fetchOptions] Values passed along to the\n * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)\n * of [non-navigation](https://github.com/GoogleChrome/workbox/issues/1796)\n * `fetch()` requests made by this strategy.\n * @param {number} [options.networkTimeoutSeconds] If set, any network requests\n * that fail to respond within the timeout will result in a network error.\n */\n constructor(options = {}) {\n super(options);\n this._networkTimeoutSeconds = options.networkTimeoutSeconds || 0;\n }\n /**\n * @private\n * @param {Request|string} request A request to run this strategy for.\n * @param {module:workbox-strategies.StrategyHandler} handler The event that\n * triggered the request.\n * @return {Promise<Response>}\n */\n async _handle(request, handler) {\n if (process.env.NODE_ENV !== 'production') {\n assert.isInstance(request, Request, {\n moduleName: 'workbox-strategies',\n className: this.constructor.name,\n funcName: '_handle',\n paramName: 'request',\n });\n }\n let error = undefined;\n let response;\n try {\n const promises = [handler.fetch(request)];\n if (this._networkTimeoutSeconds) {\n const timeoutPromise = timeout(this._networkTimeoutSeconds * 1000);\n promises.push(timeoutPromise);\n }\n response = await Promise.race(promises);\n if (!response) {\n throw new Error(`Timed out the network response after ` +\n `${this._networkTimeoutSeconds} seconds.`);\n }\n }\n catch (err) {\n error = err;\n }\n if (process.env.NODE_ENV !== 'production') {\n logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));\n if (response) {\n logger.log(`Got response from network.`);\n }\n else {\n logger.log(`Unable to get a response from the network.`);\n }\n messages.printFinalResponse(response);\n logger.groupEnd();\n }\n if (!response) {\n throw new WorkboxError('no-response', { url: request.url, error });\n }\n return response;\n }\n}\nexport { NetworkOnly };\n","/*\n Copyright 2019 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\nimport './_version.js';\n/**\n * Claim any currently available clients once the service worker\n * becomes active. This is normally used in conjunction with `skipWaiting()`.\n *\n * @memberof module:workbox-core\n */\nfunction clientsClaim() {\n self.addEventListener('activate', () => self.clients.claim());\n}\nexport { clientsClaim };\n"],"names":["self","_","e","logger","__WB_DISABLE_DEV_LOGS","inGroup","methodToColorMap","debug","log","warn","error","groupCollapsed","groupEnd","print","method","args","test","navigator","userAgent","console","styles","logPrefix","join","api","loggerMethods","Object","keys","key","messages","paramName","validValueDescription","value","Error","JSON","stringify","moduleName","className","funcName","expectedType","expectedClass","isReturnValueProblem","name","expectedMethod","entry","firstEntry","secondEntry","_entryId","thrownError","message","cacheNameId","methodName","normalizedRangeHeader","size","start","end","url","status","cacheName","origin","generatorFunction","code","details","messageGenerator","WorkboxError","constructor","errorCode","isArray","Array","hasMethod","object","type","isType","isInstance","isOneOf","validValues","includes","isArrayOfClass","item","finalAssertExports","defaultMethod","validMethods","normalizeHandler","handler","assert","handle","Route","match","setCatchHandler","catchHandler","RegExpRoute","regExp","RegExp","result","exec","href","location","index","slice","getFriendlyURL","urlObj","URL","String","replace","Router","_routes","Map","_defaultHandlerMap","routes","addFetchListener","addEventListener","event","request","responsePromise","handleRequest","respondWith","addCacheListener","data","payload","urlsToCache","requestPromises","Promise","all","map","Request","waitUntil","ports","then","postMessage","protocol","startsWith","sameOrigin","params","route","findMatchingRoute","debugMessages","push","has","get","forEach","msg","err","reject","_catchHandler","catch","catchErr","matchResult","length","undefined","setDefaultHandler","set","registerRoute","unregisterRoute","routeIndex","indexOf","splice","defaultRouter","getOrCreateDefaultRouter","capture","captureUrl","valueToCheck","pathname","wildcards","matchCallback","cacheOkAndOpaquePlugin","cacheWillUpdate","response","_cacheNameDetails","googleAnalytics","precache","prefix","runtime","suffix","registration","scope","_createCacheName","filter","eachCacheNameDetail","fn","cacheNames","updateDetails","getGoogleAnalyticsName","userCacheName","getPrecacheName","getPrefix","getRuntimeName","getSuffix","stripParams","fullURL","ignoreParams","strippedURL","param","searchParams","delete","cacheMatchIgnoreParams","cache","matchOptions","strippedRequestURL","keysOptions","ignoreSearch","cacheKeys","cacheKey","strippedCacheKeyURL","Deferred","promise","resolve","quotaErrorCallbacks","Set","executeQuotaErrorCallbacks","callback","timeout","ms","setTimeout","toRequest","input","StrategyHandler","strategy","options","_cacheKeys","ExtendableEvent","assign","_strategy","_handlerDeferred","_extendLifetimePromises","_plugins","plugins","_pluginStateMap","plugin","fetch","mode","FetchEvent","preloadResponse","possiblePreloadResponse","originalRequest","hasCallback","clone","cb","iterateCallbacks","pluginFilteredRequest","fetchResponse","fetchOptions","runCallbacks","fetchAndCachePut","responseClone","cachePut","cacheMatch","cachedResponse","effectiveRequest","getCacheKey","multiMatchOptions","caches","responseToCache","_ensureResponseSafeToCache","open","hasCacheUpdateCallback","oldResponse","put","newResponse","state","statefulCallback","statefulParam","doneWaiting","shift","destroy","pluginsUsed","Strategy","responseDone","handleAll","_getResponse","handlerDone","_awaitComplete","_handle","waitUntilError","strategyStart","strategyName","printFinalResponse","NetworkFirst","some","p","unshift","_networkTimeoutSeconds","networkTimeoutSeconds","logs","promises","timeoutId","id","_getTimeoutPromise","networkPromise","_getNetworkPromise","race","timeoutPromise","onNetworkTimeout","fetchError","clearTimeout","NetworkOnly","clientsClaim","clients","claim"],"mappings":"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"}
D
frontend/public/workbox-ea903bce.js
@@ -1,1 +0,0 @@
-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}));