/******/ (function(modules) { // webpackBootstrap /******/ // The module cache /******/ var installedModules = {}; /******/ /******/ // The require function /******/ function __webpack_require__(moduleId) { /******/ /******/ // Check if module is in cache /******/ if(installedModules[moduleId]) { /******/ return installedModules[moduleId].exports; /******/ } /******/ // Create a new module (and put it into the cache) /******/ var module = installedModules[moduleId] = { /******/ i: moduleId, /******/ l: false, /******/ exports: {} /******/ }; /******/ /******/ // Execute the module function /******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); /******/ /******/ // Flag the module as loaded /******/ module.l = true; /******/ /******/ // Return the exports of the module /******/ return module.exports; /******/ } /******/ /******/ /******/ // expose the modules object (__webpack_modules__) /******/ __webpack_require__.m = modules; /******/ /******/ // expose the module cache /******/ __webpack_require__.c = installedModules; /******/ /******/ // define getter function for harmony exports /******/ __webpack_require__.d = function(exports, name, getter) { /******/ if(!__webpack_require__.o(exports, name)) { /******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); /******/ } /******/ }; /******/ /******/ // define __esModule on exports /******/ __webpack_require__.r = function(exports) { /******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { /******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); /******/ } /******/ Object.defineProperty(exports, '__esModule', { value: true }); /******/ }; /******/ /******/ // create a fake namespace object /******/ // mode & 1: value is a module id, require it /******/ // mode & 2: merge all properties of value into the ns /******/ // mode & 4: return value when already ns object /******/ // mode & 8|1: behave like require /******/ __webpack_require__.t = function(value, mode) { /******/ if(mode & 1) value = __webpack_require__(value); /******/ if(mode & 8) return value; /******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; /******/ var ns = Object.create(null); /******/ __webpack_require__.r(ns); /******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); /******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); /******/ return ns; /******/ }; /******/ /******/ // getDefaultExport function for compatibility with non-harmony modules /******/ __webpack_require__.n = function(module) { /******/ var getter = module && module.__esModule ? /******/ function getDefault() { return module['default']; } : /******/ function getModuleExports() { return module; }; /******/ __webpack_require__.d(getter, 'a', getter); /******/ return getter; /******/ }; /******/ /******/ // Object.prototype.hasOwnProperty.call /******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; /******/ /******/ // __webpack_public_path__ /******/ __webpack_require__.p = ""; /******/ /******/ /******/ // Load entry module and return exports /******/ return __webpack_require__(__webpack_require__.s = "249e"); /******/ }) /************************************************************************/ /******/ ({ /***/ "00ee": /***/ (function(module, exports, __webpack_require__) { var wellKnownSymbol = __webpack_require__("b622"); var TO_STRING_TAG = wellKnownSymbol('toStringTag'); var test = {}; test[TO_STRING_TAG] = 'z'; module.exports = String(test) === '[object z]'; /***/ }), /***/ "06cf": /***/ (function(module, exports, __webpack_require__) { var DESCRIPTORS = __webpack_require__("83ab"); var propertyIsEnumerableModule = __webpack_require__("d1e7"); var createPropertyDescriptor = __webpack_require__("5c6c"); var toIndexedObject = __webpack_require__("fc6a"); var toPrimitive = __webpack_require__("c04e"); var has = __webpack_require__("5135"); var IE8_DOM_DEFINE = __webpack_require__("0cfb"); // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; // `Object.getOwnPropertyDescriptor` method // https://tc39.es/ecma262/#sec-object.getownpropertydescriptor exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) { O = toIndexedObject(O); P = toPrimitive(P, true); if (IE8_DOM_DEFINE) try { return $getOwnPropertyDescriptor(O, P); } catch (error) { /* empty */ } if (has(O, P)) return createPropertyDescriptor(!propertyIsEnumerableModule.f.call(O, P), O[P]); }; /***/ }), /***/ "0719": /***/ (function(module, exports, __webpack_require__) { "use strict"; // @ts-ignore try { self['workbox:core:6.1.5'] && _(); } catch (e) { } /***/ }), /***/ "0cfb": /***/ (function(module, exports, __webpack_require__) { var DESCRIPTORS = __webpack_require__("83ab"); var fails = __webpack_require__("d039"); var createElement = __webpack_require__("cc12"); // Thank's IE8 for his funny defineProperty module.exports = !DESCRIPTORS && !fails(function () { // eslint-disable-next-line es/no-object-defineproperty -- requied for testing return Object.defineProperty(createElement('div'), 'a', { get: function () { return 7; } }).a != 7; }); /***/ }), /***/ "14c3": /***/ (function(module, exports, __webpack_require__) { var classof = __webpack_require__("c6b6"); var regexpExec = __webpack_require__("9263"); // `RegExpExec` abstract operation // https://tc39.es/ecma262/#sec-regexpexec module.exports = function (R, S) { var exec = R.exec; if (typeof exec === 'function') { var result = exec.call(R, S); if (typeof result !== 'object') { throw TypeError('RegExp exec method returned something other than an Object or null'); } return result; } if (classof(R) !== 'RegExp') { throw TypeError('RegExp#exec called on incompatible receiver'); } return regexpExec.call(R, S); }; /***/ }), /***/ "1d80": /***/ (function(module, exports) { // `RequireObjectCoercible` abstract operation // https://tc39.es/ecma262/#sec-requireobjectcoercible module.exports = function (it) { if (it == undefined) throw TypeError("Can't call method on " + it); return it; }; /***/ }), /***/ "23cb": /***/ (function(module, exports, __webpack_require__) { var toInteger = __webpack_require__("a691"); var max = Math.max; var min = Math.min; // Helper for a popular repeating case of the spec: // Let integer be ? ToInteger(index). // If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length). module.exports = function (index, length) { var integer = toInteger(index); return integer < 0 ? max(integer + length, 0) : min(integer, length); }; /***/ }), /***/ "23e7": /***/ (function(module, exports, __webpack_require__) { var global = __webpack_require__("da84"); var getOwnPropertyDescriptor = __webpack_require__("06cf").f; var createNonEnumerableProperty = __webpack_require__("9112"); var redefine = __webpack_require__("6eeb"); var setGlobal = __webpack_require__("ce4e"); var copyConstructorProperties = __webpack_require__("e893"); var isForced = __webpack_require__("94ca"); /* options.target - name of the target object options.global - target is the global object options.stat - export as static methods of target options.proto - export as prototype methods of target options.real - real prototype method for the `pure` version options.forced - export even if the native feature is available options.bind - bind methods to the target, required for the `pure` version options.wrap - wrap constructors to preventing global pollution, required for the `pure` version options.unsafe - use the simple assignment of property instead of delete + defineProperty options.sham - add a flag to not completely full polyfills options.enumerable - export as enumerable property options.noTargetGet - prevent calling a getter on target */ module.exports = function (options, source) { var TARGET = options.target; var GLOBAL = options.global; var STATIC = options.stat; var FORCED, target, key, targetProperty, sourceProperty, descriptor; if (GLOBAL) { target = global; } else if (STATIC) { target = global[TARGET] || setGlobal(TARGET, {}); } else { target = (global[TARGET] || {}).prototype; } if (target) for (key in source) { sourceProperty = source[key]; if (options.noTargetGet) { descriptor = getOwnPropertyDescriptor(target, key); targetProperty = descriptor && descriptor.value; } else targetProperty = target[key]; FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); // contained in target if (!FORCED && targetProperty !== undefined) { if (typeof sourceProperty === typeof targetProperty) continue; copyConstructorProperties(sourceProperty, targetProperty); } // add a flag to not completely full polyfills if (options.sham || (targetProperty && targetProperty.sham)) { createNonEnumerableProperty(sourceProperty, 'sham', true); } // extend global redefine(target, key, sourceProperty, options); } }; /***/ }), /***/ "241c": /***/ (function(module, exports, __webpack_require__) { var internalObjectKeys = __webpack_require__("ca84"); var enumBugKeys = __webpack_require__("7839"); var hiddenKeys = enumBugKeys.concat('length', 'prototype'); // `Object.getOwnPropertyNames` method // https://tc39.es/ecma262/#sec-object.getownpropertynames // eslint-disable-next-line es/no-object-getownpropertynames -- safe exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { return internalObjectKeys(O, hiddenKeys); }; /***/ }), /***/ "249e": /***/ (function(module, __webpack_exports__, __webpack_require__) { "use strict"; // ESM COMPAT FLAG __webpack_require__.r(__webpack_exports__); // EXTERNAL MODULE: ./node_modules/core-js/modules/es.object.to-string.js var es_object_to_string = __webpack_require__("d3b7"); // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } } function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; } // EXTERNAL MODULE: ./node_modules/core-js/modules/es.regexp.exec.js var es_regexp_exec = __webpack_require__("ac1f"); // EXTERNAL MODULE: ./node_modules/core-js/modules/es.string.match.js var es_string_match = __webpack_require__("466d"); // EXTERNAL MODULE: ./node_modules/core-js/modules/es.regexp.constructor.js var es_regexp_constructor = __webpack_require__("4d63"); // EXTERNAL MODULE: ./node_modules/core-js/modules/es.regexp.to-string.js var es_regexp_to_string = __webpack_require__("25f0"); // EXTERNAL MODULE: ./node_modules/regenerator-runtime/runtime.js var runtime = __webpack_require__("96cf"); // EXTERNAL MODULE: ./node_modules/workbox-core/_version.js var _version = __webpack_require__("0719"); // CONCATENATED MODULE: ./node_modules/workbox-core/models/messages/messages.js /* 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 = { '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}.`; }, }; // CONCATENATED MODULE: ./node_modules/workbox-core/models/messages/messageGenerator.js /* 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 fallback = (code, ...args) => { let msg = code; if (args.length > 0) { msg += ` :: ${JSON.stringify(args)}`; } return msg; }; const generatorFunction = (code, details = {}) => { const message = messages[code]; if (!message) { throw new Error(`Unable to find message for code '${code}'.`); } return message(details); }; const messageGenerator = ( true) ? fallback : undefined; // CONCATENATED MODULE: ./node_modules/workbox-core/_private/WorkboxError.js /* 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_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; } } // CONCATENATED MODULE: ./node_modules/workbox-core/_private/assert.js /* 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_WorkboxError('not-an-array', details); } }; const hasMethod = (object, expectedMethod, details) => { const type = typeof object[expectedMethod]; if (type !== 'function') { details['expectedMethod'] = expectedMethod; throw new WorkboxError_WorkboxError('missing-a-method', details); } }; const isType = (object, expectedType, details) => { if (typeof object !== expectedType) { details['expectedType'] = expectedType; throw new WorkboxError_WorkboxError('incorrect-type', details); } }; const isInstance = (object, expectedClass, details) => { if (!(object instanceof expectedClass)) { details['expectedClass'] = expectedClass; throw new WorkboxError_WorkboxError('incorrect-class', details); } }; const isOneOf = (value, validValues, details) => { if (!validValues.includes(value)) { details['validValueDescription'] = `Valid values are ${JSON.stringify(validValues)}.`; throw new WorkboxError_WorkboxError('invalid-value', details); } }; const isArrayOfClass = (value, expectedClass, details) => { const error = new WorkboxError_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 = true ? null : undefined; // CONCATENATED MODULE: ./node_modules/workbox-core/_private/cacheNames.js /* 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; }, }; // CONCATENATED MODULE: ./node_modules/workbox-core/_private/logger.js /* 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 = ( true ? null : undefined); // CONCATENATED MODULE: ./node_modules/workbox-core/_private/waitUntil.js /* 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. */ /** * A utility method that makes it easier to use `event.waitUntil` with * async functions and return the result. * * @param {ExtendableEvent} event * @param {Function} asyncFn * @return {Function} * @private */ function waitUntil(event, asyncFn) { const returnPromise = asyncFn(); event.waitUntil(returnPromise); return returnPromise; } // EXTERNAL MODULE: ./node_modules/workbox-precaching/_version.js var workbox_precaching_version = __webpack_require__("c700"); // CONCATENATED MODULE: ./node_modules/workbox-precaching/utils/createCacheKey.js /* 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. */ // Name of the search parameter used to store revision info. const REVISION_SEARCH_PARAM = '__WB_REVISION__'; /** * Converts a manifest entry into a versioned URL suitable for precaching. * * @param {Object|string} entry * @return {string} A URL with versioning info. * * @private * @memberof module:workbox-precaching */ function createCacheKey(entry) { if (!entry) { throw new WorkboxError_WorkboxError('add-to-cache-list-unexpected-type', { entry }); } // If a precache manifest entry is a string, it's assumed to be a versioned // URL, like '/app.abcd1234.js'. Return as-is. if (typeof entry === 'string') { const urlObject = new URL(entry, location.href); return { cacheKey: urlObject.href, url: urlObject.href, }; } const { revision, url } = entry; if (!url) { throw new WorkboxError_WorkboxError('add-to-cache-list-unexpected-type', { entry }); } // If there's just a URL and no revision, then it's also assumed to be a // versioned URL. if (!revision) { const urlObject = new URL(url, location.href); return { cacheKey: urlObject.href, url: urlObject.href, }; } // Otherwise, construct a properly versioned URL using the custom Workbox // search parameter along with the revision info. const cacheKeyURL = new URL(url, location.href); const originalURL = new URL(url, location.href); cacheKeyURL.searchParams.set(REVISION_SEARCH_PARAM, revision); return { cacheKey: cacheKeyURL.href, url: originalURL.href, }; } // CONCATENATED MODULE: ./node_modules/workbox-precaching/utils/PrecacheInstallReportPlugin.js /* 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. */ /** * A plugin, designed to be used with PrecacheController, to determine the * of assets that were updated (or not updated) during the install event. * * @private */ class PrecacheInstallReportPlugin { constructor() { this.updatedURLs = []; this.notUpdatedURLs = []; this.handlerWillStart = async ({ request, state, }) => { // TODO: `state` should never be undefined... if (state) { state.originalRequest = request; } }; this.cachedResponseWillBeUsed = async ({ event, state, cachedResponse, }) => { if (event.type === 'install') { // TODO: `state` should never be undefined... const url = state.originalRequest.url; if (cachedResponse) { this.notUpdatedURLs.push(url); } else { this.updatedURLs.push(url); } } return cachedResponse; }; } } // CONCATENATED MODULE: ./node_modules/workbox-precaching/utils/PrecacheCacheKeyPlugin.js /* 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. */ /** * A plugin, designed to be used with PrecacheController, to translate URLs into * the corresponding cache key, based on the current revision info. * * @private */ class PrecacheCacheKeyPlugin { constructor({ precacheController }) { this.cacheKeyWillBeUsed = async ({ request, params, }) => { const cacheKey = params && params.cacheKey || this._precacheController.getCacheKeyForURL(request.url); return cacheKey ? new Request(cacheKey) : request; }; this._precacheController = precacheController; } } // CONCATENATED MODULE: ./node_modules/workbox-precaching/utils/printCleanupDetails.js /* 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 {string} groupTitle * @param {Array} deletedURLs * * @private */ const logGroup = (groupTitle, deletedURLs) => { logger.groupCollapsed(groupTitle); for (const url of deletedURLs) { logger.log(url); } logger.groupEnd(); }; /** * @param {Array} deletedURLs * * @private * @memberof module:workbox-precaching */ function printCleanupDetails(deletedURLs) { const deletionCount = deletedURLs.length; if (deletionCount > 0) { logger.groupCollapsed(`During precaching cleanup, ` + `${deletionCount} cached ` + `request${deletionCount === 1 ? ' was' : 's were'} deleted.`); logGroup('Deleted Cache Requests', deletedURLs); logger.groupEnd(); } } // CONCATENATED MODULE: ./node_modules/workbox-precaching/utils/printInstallDetails.js /* 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 {string} groupTitle * @param {Array} urls * * @private */ function _nestedGroup(groupTitle, urls) { if (urls.length === 0) { return; } logger.groupCollapsed(groupTitle); for (const url of urls) { logger.log(url); } logger.groupEnd(); } /** * @param {Array} urlsToPrecache * @param {Array} urlsAlreadyPrecached * * @private * @memberof module:workbox-precaching */ function printInstallDetails(urlsToPrecache, urlsAlreadyPrecached) { const precachedCount = urlsToPrecache.length; const alreadyPrecachedCount = urlsAlreadyPrecached.length; if (precachedCount || alreadyPrecachedCount) { let message = `Precaching ${precachedCount} file${precachedCount === 1 ? '' : 's'}.`; if (alreadyPrecachedCount > 0) { message += ` ${alreadyPrecachedCount} ` + `file${alreadyPrecachedCount === 1 ? ' is' : 's are'} already cached.`; } logger.groupCollapsed(message); _nestedGroup(`View newly precached URLs.`, urlsToPrecache); _nestedGroup(`View previously precached URLs.`, urlsAlreadyPrecached); logger.groupEnd(); } } // CONCATENATED MODULE: ./node_modules/workbox-core/_private/canConstructResponseFromBodyStream.js /* 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 supportStatus; /** * A utility function that determines whether the current browser supports * constructing a new `Response` from a `response.body` stream. * * @return {boolean} `true`, if the current browser can successfully * construct a `Response` from a `response.body` stream, `false` otherwise. * * @private */ function canConstructResponseFromBodyStream() { if (supportStatus === undefined) { const testResponse = new Response(''); if ('body' in testResponse) { try { new Response(testResponse.body); supportStatus = true; } catch (error) { supportStatus = false; } } supportStatus = false; } return supportStatus; } // CONCATENATED MODULE: ./node_modules/workbox-core/copyResponse.js /* 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. */ /** * Allows developers to copy a response and modify its `headers`, `status`, * or `statusText` values (the values settable via a * [`ResponseInit`]{@link https://developer.mozilla.org/en-US/docs/Web/API/Response/Response#Syntax} * object in the constructor). * To modify these values, pass a function as the second argument. That * function will be invoked with a single object with the response properties * `{headers, status, statusText}`. The return value of this function will * be used as the `ResponseInit` for the new `Response`. To change the values * either modify the passed parameter(s) and return it, or return a totally * new object. * * This method is intentionally limited to same-origin responses, regardless of * whether CORS was used or not. * * @param {Response} response * @param {Function} modifier * @memberof module:workbox-core */ async function copyResponse(response, modifier) { let origin = null; // If response.url isn't set, assume it's cross-origin and keep origin null. if (response.url) { const responseURL = new URL(response.url); origin = responseURL.origin; } if (origin !== self.location.origin) { throw new WorkboxError_WorkboxError('cross-origin-copy-response', { origin }); } const clonedResponse = response.clone(); // Create a fresh `ResponseInit` object by cloning the headers. const responseInit = { headers: new Headers(clonedResponse.headers), status: clonedResponse.status, statusText: clonedResponse.statusText, }; // Apply any user modifications. const modifiedResponseInit = modifier ? modifier(responseInit) : responseInit; // Create the new response from the body stream and `ResponseInit` // modifications. Note: not all browsers support the Response.body stream, // so fall back to reading the entire body into memory as a blob. const body = canConstructResponseFromBodyStream() ? clonedResponse.body : await clonedResponse.blob(); return new Response(body, modifiedResponseInit); } // CONCATENATED MODULE: ./node_modules/workbox-core/_private/getFriendlyURL.js /* 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}`), ''); }; // CONCATENATED MODULE: ./node_modules/workbox-core/_private/cacheMatchIgnoreParams.js /* 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. */ 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} ignoreParams * @return {Promise} */ 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 = { ...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; } // CONCATENATED MODULE: ./node_modules/workbox-core/_private/Deferred.js /* 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; }); } } // CONCATENATED MODULE: ./node_modules/workbox-core/models/quotaErrorCallbacks.js /* 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. */ // Callbacks to be executed whenever there's a quota error. const quotaErrorCallbacks = new Set(); // CONCATENATED MODULE: ./node_modules/workbox-core/_private/executeQuotaErrorCallbacks.js /* 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() { if (false) {} for (const callback of quotaErrorCallbacks) { await callback(); if (false) {} } if (false) {} } // CONCATENATED MODULE: ./node_modules/workbox-core/_private/timeout.js /* 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)); } // EXTERNAL MODULE: ./node_modules/workbox-strategies/_version.js var workbox_strategies_version = __webpack_require__("6aa8"); // CONCATENATED MODULE: ./node_modules/workbox-strategies/StrategyHandler.js /* 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. */ 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_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 */ if (false) {} 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} */ 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) { if (false) {} 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_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 (false) {} for (const callback of this.iterateCallbacks('fetchDidSucceed')) { fetchResponse = await callback({ event, request: pluginFilteredRequest, response: fetchResponse, }); } return fetchResponse; } catch (error) { if (false) {} // `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} */ 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} 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 = { ...matchOptions, ...{ cacheName } }; cachedResponse = await caches.match(effectiveRequest, multiMatchOptions); if (false) {} 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} `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 (false) {} if (!response) { if (false) {} throw new WorkboxError_WorkboxError('cache-put-with-no-response', { url: getFriendlyURL(effectiveRequest.url), }); } const responseToCache = await this._ensureResponseSafeToCache(response); if (!responseToCache) { if (false) {} 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; if (false) {} 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} */ 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} */ *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 = { ...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} * * @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 (false) {} } return responseToCache; } } // CONCATENATED MODULE: ./node_modules/workbox-strategies/Strategy.js /* 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_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} [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} */ 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} 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_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_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 if (false) {} } 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} * * @memberof module:workbox-strategies.Strategy */ // CONCATENATED MODULE: ./node_modules/workbox-precaching/PrecacheStrategy.js /* 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. */ /** * A [Strategy]{@link module:workbox-strategies.Strategy} implementation * specifically designed to work with * [PrecacheController]{@link module:workbox-precaching.PrecacheController} * to both cache and fetch precached assets. * * Note: an instance of this class is created automatically when creating a * `PrecacheController`; it's generally not necessary to create this yourself. * * @extends module:workbox-strategies.Strategy * @memberof module:workbox-precaching */ class PrecacheStrategy_PrecacheStrategy extends Strategy_Strategy { /** * * @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} [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`]{@link https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters} * of all 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. * @param {boolean} [options.fallbackToNetwork=true] Whether to attempt to * get the response from the network if there's a precache miss. */ constructor(options = {}) { options.cacheName = cacheNames.getPrecacheName(options.cacheName); super(options); this._fallbackToNetwork = options.fallbackToNetwork === false ? false : true; // Redirected responses cannot be used to satisfy a navigation request, so // any redirected response must be "copied" rather than cloned, so the new // response doesn't contain the `redirected` flag. See: // https://bugs.chromium.org/p/chromium/issues/detail?id=669363&desc=2#c1 this.plugins.push(PrecacheStrategy_PrecacheStrategy.copyRedirectedCacheableResponsesPlugin); } /** * @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} */ async _handle(request, handler) { const response = await handler.cacheMatch(request); if (!response) { // If this is an `install` event then populate the cache. If this is a // `fetch` event (or any other event) then respond with the cached // response. if (handler.event && handler.event.type === 'install') { return await this._handleInstall(request, handler); } return await this._handleFetch(request, handler); } return response; } async _handleFetch(request, handler) { let response; // Fall back to the network if we don't have a cached response // (perhaps due to manual cache cleanup). if (this._fallbackToNetwork) { if (false) {} response = await handler.fetch(request); } else { // This shouldn't normally happen, but there are edge cases: // https://github.com/GoogleChrome/workbox/issues/1441 throw new WorkboxError_WorkboxError('missing-precache-entry', { cacheName: this.cacheName, url: request.url, }); } if (false) {} return response; } async _handleInstall(request, handler) { this._useDefaultCacheabilityPluginIfNeeded(); const response = await handler.fetch(request); // Make sure we defer cachePut() until after we know the response // should be cached; see https://github.com/GoogleChrome/workbox/issues/2737 const wasCached = await handler.cachePut(request, response.clone()); if (!wasCached) { // Throwing here will lead to the `install` handler failing, which // we want to do if *any* of the responses aren't safe to cache. throw new WorkboxError_WorkboxError('bad-precaching-response', { url: request.url, status: response.status, }); } return response; } /** * This method is complex, as there a number of things to account for: * * The `plugins` array can be set at construction, and/or it might be added to * to at any time before the strategy is used. * * At the time the strategy is used (i.e. during an `install` event), there * needs to be at least one plugin that implements `cacheWillUpdate` in the * array, other than `copyRedirectedCacheableResponsesPlugin`. * * - If this method is called and there are no suitable `cacheWillUpdate` * plugins, we need to add `defaultPrecacheCacheabilityPlugin`. * * - If this method is called and there is exactly one `cacheWillUpdate`, then * we don't have to do anything (this might be a previously added * `defaultPrecacheCacheabilityPlugin`, or it might be a custom plugin). * * - If this method is called and there is more than one `cacheWillUpdate`, * then we need to check if one is `defaultPrecacheCacheabilityPlugin`. If so, * we need to remove it. (This situation is unlikely, but it could happen if * the strategy is used multiple times, the first without a `cacheWillUpdate`, * and then later on after manually adding a custom `cacheWillUpdate`.) * * See https://github.com/GoogleChrome/workbox/issues/2737 for more context. * * @private */ _useDefaultCacheabilityPluginIfNeeded() { let defaultPluginIndex = null; let cacheWillUpdatePluginCount = 0; for (const [index, plugin] of this.plugins.entries()) { // Ignore the copy redirected plugin when determining what to do. if (plugin === PrecacheStrategy_PrecacheStrategy.copyRedirectedCacheableResponsesPlugin) { continue; } // Save the default plugin's index, in case it needs to be removed. if (plugin === PrecacheStrategy_PrecacheStrategy.defaultPrecacheCacheabilityPlugin) { defaultPluginIndex = index; } if (plugin.cacheWillUpdate) { cacheWillUpdatePluginCount++; } } if (cacheWillUpdatePluginCount === 0) { this.plugins.push(PrecacheStrategy_PrecacheStrategy.defaultPrecacheCacheabilityPlugin); } else if (cacheWillUpdatePluginCount > 1 && defaultPluginIndex !== null) { // Only remove the default plugin; multiple custom plugins are allowed. this.plugins.splice(defaultPluginIndex, 1); } // Nothing needs to be done if cacheWillUpdatePluginCount is 1 } } PrecacheStrategy_PrecacheStrategy.defaultPrecacheCacheabilityPlugin = { async cacheWillUpdate({ response }) { if (!response || response.status >= 400) { return null; } return response; } }; PrecacheStrategy_PrecacheStrategy.copyRedirectedCacheableResponsesPlugin = { async cacheWillUpdate({ response }) { return response.redirected ? await copyResponse(response) : response; } }; // CONCATENATED MODULE: ./node_modules/workbox-precaching/PrecacheController.js /* 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. */ /** * Performs efficient precaching of assets. * * @memberof module:workbox-precaching */ class PrecacheController_PrecacheController { /** * Create a new PrecacheController. * * @param {Object} [options] * @param {string} [options.cacheName] The cache to use for precaching. * @param {string} [options.plugins] Plugins to use when precaching as well * as responding to fetch events for precached assets. * @param {boolean} [options.fallbackToNetwork=true] Whether to attempt to * get the response from the network if there's a precache miss. */ constructor({ cacheName, plugins = [], fallbackToNetwork = true } = {}) { this._urlsToCacheKeys = new Map(); this._urlsToCacheModes = new Map(); this._cacheKeysToIntegrities = new Map(); this._strategy = new PrecacheStrategy_PrecacheStrategy({ cacheName: cacheNames.getPrecacheName(cacheName), plugins: [ ...plugins, new PrecacheCacheKeyPlugin({ precacheController: this }), ], fallbackToNetwork, }); // Bind the install and activate methods to the instance. this.install = this.install.bind(this); this.activate = this.activate.bind(this); } /** * @type {module:workbox-precaching.PrecacheStrategy} The strategy created by this controller and * used to cache assets and respond to fetch events. */ get strategy() { return this._strategy; } /** * Adds items to the precache list, removing any duplicates and * stores the files in the * ["precache cache"]{@link module:workbox-core.cacheNames} when the service * worker installs. * * This method can be called multiple times. * * @param {Array} [entries=[]] Array of entries to precache. */ precache(entries) { this.addToCacheList(entries); if (!this._installAndActiveListenersAdded) { self.addEventListener('install', this.install); self.addEventListener('activate', this.activate); this._installAndActiveListenersAdded = true; } } /** * This method will add items to the precache list, removing duplicates * and ensuring the information is valid. * * @param {Array} entries * Array of entries to precache. */ addToCacheList(entries) { if (false) {} const urlsToWarnAbout = []; for (const entry of entries) { // See https://github.com/GoogleChrome/workbox/issues/2259 if (typeof entry === 'string') { urlsToWarnAbout.push(entry); } else if (entry && entry.revision === undefined) { urlsToWarnAbout.push(entry.url); } const { cacheKey, url } = createCacheKey(entry); const cacheMode = (typeof entry !== 'string' && entry.revision) ? 'reload' : 'default'; if (this._urlsToCacheKeys.has(url) && this._urlsToCacheKeys.get(url) !== cacheKey) { throw new WorkboxError_WorkboxError('add-to-cache-list-conflicting-entries', { firstEntry: this._urlsToCacheKeys.get(url), secondEntry: cacheKey, }); } if (typeof entry !== 'string' && entry.integrity) { if (this._cacheKeysToIntegrities.has(cacheKey) && this._cacheKeysToIntegrities.get(cacheKey) !== entry.integrity) { throw new WorkboxError_WorkboxError('add-to-cache-list-conflicting-integrities', { url, }); } this._cacheKeysToIntegrities.set(cacheKey, entry.integrity); } this._urlsToCacheKeys.set(url, cacheKey); this._urlsToCacheModes.set(url, cacheMode); if (urlsToWarnAbout.length > 0) { const warningMessage = `Workbox is precaching URLs without revision ` + `info: ${urlsToWarnAbout.join(', ')}\nThis is generally NOT safe. ` + `Learn more at https://bit.ly/wb-precache`; if (true) { // Use console directly to display this warning without bloating // bundle sizes by pulling in all of the logger codebase in prod. console.warn(warningMessage); } else {} } } } /** * Precaches new and updated assets. Call this method from the service worker * install event. * * Note: this method calls `event.waitUntil()` for you, so you do not need * to call it yourself in your event handlers. * * @param {ExtendableEvent} event * @return {Promise} */ install(event) { return waitUntil(event, async () => { const installReportPlugin = new PrecacheInstallReportPlugin(); this.strategy.plugins.push(installReportPlugin); // Cache entries one at a time. // See https://github.com/GoogleChrome/workbox/issues/2528 for (const [url, cacheKey] of this._urlsToCacheKeys) { const integrity = this._cacheKeysToIntegrities.get(cacheKey); const cacheMode = this._urlsToCacheModes.get(url); const request = new Request(url, { integrity, cache: cacheMode, credentials: 'same-origin', }); await Promise.all(this.strategy.handleAll({ params: { cacheKey }, request, event, })); } const { updatedURLs, notUpdatedURLs } = installReportPlugin; if (false) {} return { updatedURLs, notUpdatedURLs }; }); } /** * Deletes assets that are no longer present in the current precache manifest. * Call this method from the service worker activate event. * * Note: this method calls `event.waitUntil()` for you, so you do not need * to call it yourself in your event handlers. * * @param {ExtendableEvent} event * @return {Promise} */ activate(event) { return waitUntil(event, async () => { const cache = await self.caches.open(this.strategy.cacheName); const currentlyCachedRequests = await cache.keys(); const expectedCacheKeys = new Set(this._urlsToCacheKeys.values()); const deletedURLs = []; for (const request of currentlyCachedRequests) { if (!expectedCacheKeys.has(request.url)) { await cache.delete(request); deletedURLs.push(request.url); } } if (false) {} return { deletedURLs }; }); } /** * Returns a mapping of a precached URL to the corresponding cache key, taking * into account the revision information for the URL. * * @return {Map} A URL to cache key mapping. */ getURLsToCacheKeys() { return this._urlsToCacheKeys; } /** * Returns a list of all the URLs that have been precached by the current * service worker. * * @return {Array} The precached URLs. */ getCachedURLs() { return [...this._urlsToCacheKeys.keys()]; } /** * Returns the cache key used for storing a given URL. If that URL is * unversioned, like `/index.html', then the cache key will be the original * URL with a search parameter appended to it. * * @param {string} url A URL whose cache key you want to look up. * @return {string} The versioned URL that corresponds to a cache key * for the original URL, or undefined if that URL isn't precached. */ getCacheKeyForURL(url) { const urlObject = new URL(url, location.href); return this._urlsToCacheKeys.get(urlObject.href); } /** * This acts as a drop-in replacement for * [`cache.match()`](https://developer.mozilla.org/en-US/docs/Web/API/Cache/match) * with the following differences: * * - It knows what the name of the precache is, and only checks in that cache. * - It allows you to pass in an "original" URL without versioning parameters, * and it will automatically look up the correct cache key for the currently * active revision of that URL. * * E.g., `matchPrecache('index.html')` will find the correct precached * response for the currently active service worker, even if the actual cache * key is `'/index.html?__WB_REVISION__=1234abcd'`. * * @param {string|Request} request The key (without revisioning parameters) * to look up in the precache. * @return {Promise} */ async matchPrecache(request) { const url = request instanceof Request ? request.url : request; const cacheKey = this.getCacheKeyForURL(url); if (cacheKey) { const cache = await self.caches.open(this.strategy.cacheName); return cache.match(cacheKey); } return undefined; } /** * Returns a function that looks up `url` in the precache (taking into * account revision information), and returns the corresponding `Response`. * * @param {string} url The precached URL which will be used to lookup the * `Response`. * @return {module:workbox-routing~handlerCallback} */ createHandlerBoundToURL(url) { const cacheKey = this.getCacheKeyForURL(url); if (!cacheKey) { throw new WorkboxError_WorkboxError('non-precached-url', { url }); } return (options) => { options.request = new Request(url); options.params = { cacheKey, ...options.params }; return this.strategy.handle(options); }; } } // CONCATENATED MODULE: ./node_modules/workbox-precaching/utils/getOrCreatePrecacheController.js /* 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 getOrCreatePrecacheController_precacheController; /** * @return {PrecacheController} * @private */ const getOrCreatePrecacheController = () => { if (!getOrCreatePrecacheController_precacheController) { getOrCreatePrecacheController_precacheController = new PrecacheController_PrecacheController(); } return getOrCreatePrecacheController_precacheController; }; // CONCATENATED MODULE: ./node_modules/workbox-precaching/addPlugins.js /* 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. */ /** * Adds plugins to the precaching strategy. * * @param {Array} plugins * * @memberof module:workbox-precaching */ function addPlugins(plugins) { const precacheController = getOrCreatePrecacheController(); precacheController.strategy.plugins.push(...plugins); } // EXTERNAL MODULE: ./node_modules/workbox-routing/_version.js var workbox_routing_version = __webpack_require__("e6d2"); // CONCATENATED MODULE: ./node_modules/workbox-routing/utils/constants.js /* 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} * * @private */ const validMethods = [ 'DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT', ]; // CONCATENATED MODULE: ./node_modules/workbox-routing/utils/normalizeHandler.js /* 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') { if (false) {} return handler; } else { if (false) {} return { handle: handler }; } }; // CONCATENATED MODULE: ./node_modules/workbox-routing/Route.js /* 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_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) { if (false) {} // 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); } } // CONCATENATED MODULE: ./node_modules/workbox-routing/RegExpRoute.js /* 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_RegExpRoute extends Route_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) { if (false) {} 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)) { if (false) {} 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); } } // CONCATENATED MODULE: ./node_modules/workbox-routing/Router.js /* 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_Router { /** * Initializes a new Router. */ constructor() { this._routes = new Map(); this._defaultHandlerMap = new Map(); } /** * @return {Map>} 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; if (false) {} 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 | 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|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 }) { if (false) {} const url = new URL(request.url, location.href); if (!url.protocol.startsWith('http')) { if (false) {} return; } const sameOrigin = url.origin === location.origin; const { params, route } = this.findMatchingRoute({ event, request, sameOrigin, url, }); let handler = route && route.handler; const debugMessages = []; if (false) {} // 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)) { if (false) {} handler = this._defaultHandlerMap.get(method); } if (!handler) { if (false) {} return; } if (false) {} // 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) { if (false) {} try { return await catchHandler.handle({ url, request, event, params }); } catch (catchErr) { err = catchErr; } } if (this._catchHandler) { if (false) {} 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) { if (false) {} // 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) { if (false) {} 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_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_WorkboxError('unregister-route-route-not-registered'); } } } // CONCATENATED MODULE: ./node_modules/workbox-routing/utils/getOrCreateDefaultRouter.js /* 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 getOrCreateDefaultRouter_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 (!getOrCreateDefaultRouter_defaultRouter) { getOrCreateDefaultRouter_defaultRouter = new Router_Router(); // The helpers that use the default Router assume these listeners exist. getOrCreateDefaultRouter_defaultRouter.addFetchListener(); getOrCreateDefaultRouter_defaultRouter.addCacheListener(); } return getOrCreateDefaultRouter_defaultRouter; }; // CONCATENATED MODULE: ./node_modules/workbox-routing/registerRoute.js /* 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 (false) {} const matchCallback = ({ url }) => { if (false) {} return url.href === captureUrl.href; }; // If `capture` is a string then `handler` and `method` must be present. route = new Route_Route(matchCallback, handler, method); } else if (capture instanceof RegExp) { // If `capture` is a `RegExp` then `handler` and `method` must be present. route = new RegExpRoute_RegExpRoute(capture, handler, method); } else if (typeof capture === 'function') { // If `capture` is a function then `handler` and `method` must be present. route = new Route_Route(capture, handler, method); } else if (capture instanceof Route_Route) { route = capture; } else { throw new WorkboxError_WorkboxError('unsupported-route-type', { moduleName: 'workbox-routing', funcName: 'registerRoute', paramName: 'capture', }); } const defaultRouter = getOrCreateDefaultRouter(); defaultRouter.registerRoute(route); return route; } // CONCATENATED MODULE: ./node_modules/workbox-precaching/utils/removeIgnoredSearchParams.js /* 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. */ /** * Removes any URL search parameters that should be ignored. * * @param {URL} urlObject The original URL. * @param {Array} ignoreURLParametersMatching RegExps to test against * each search parameter name. Matches mean that the search parameter should be * ignored. * @return {URL} The URL with any ignored search parameters removed. * * @private * @memberof module:workbox-precaching */ function removeIgnoredSearchParams(urlObject, ignoreURLParametersMatching = []) { // Convert the iterable into an array at the start of the loop to make sure // deletion doesn't mess up iteration. for (const paramName of [...urlObject.searchParams.keys()]) { if (ignoreURLParametersMatching.some((regExp) => regExp.test(paramName))) { urlObject.searchParams.delete(paramName); } } return urlObject; } // CONCATENATED MODULE: ./node_modules/workbox-precaching/utils/generateURLVariations.js /* 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. */ /** * Generator function that yields possible variations on the original URL to * check, one at a time. * * @param {string} url * @param {Object} options * * @private * @memberof module:workbox-precaching */ function* generateURLVariations(url, { ignoreURLParametersMatching = [/^utm_/, /^fbclid$/], directoryIndex = 'index.html', cleanURLs = true, urlManipulation, } = {}) { const urlObject = new URL(url, location.href); urlObject.hash = ''; yield urlObject.href; const urlWithoutIgnoredParams = removeIgnoredSearchParams(urlObject, ignoreURLParametersMatching); yield urlWithoutIgnoredParams.href; if (directoryIndex && urlWithoutIgnoredParams.pathname.endsWith('/')) { const directoryURL = new URL(urlWithoutIgnoredParams.href); directoryURL.pathname += directoryIndex; yield directoryURL.href; } if (cleanURLs) { const cleanURL = new URL(urlWithoutIgnoredParams.href); cleanURL.pathname += '.html'; yield cleanURL.href; } if (urlManipulation) { const additionalURLs = urlManipulation({ url: urlObject }); for (const urlToAttempt of additionalURLs) { yield urlToAttempt.href; } } } // CONCATENATED MODULE: ./node_modules/workbox-precaching/PrecacheRoute.js /* 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. */ /** * A subclass of [Route]{@link module:workbox-routing.Route} that takes a * [PrecacheController]{@link module:workbox-precaching.PrecacheController} * instance and uses it to match incoming requests and handle fetching * responses from the precache. * * @memberof module:workbox-precaching * @extends module:workbox-routing.Route */ class PrecacheRoute_PrecacheRoute extends Route_Route { /** * @param {PrecacheController} precacheController A `PrecacheController` * instance used to both match requests and respond to fetch events. * @param {Object} [options] Options to control how requests are matched * against the list of precached URLs. * @param {string} [options.directoryIndex=index.html] The `directoryIndex` will * check cache entries for a URLs ending with '/' to see if there is a hit when * appending the `directoryIndex` value. * @param {Array} [options.ignoreURLParametersMatching=[/^utm_/, /^fbclid$/]] An * array of regex's to remove search params when looking for a cache match. * @param {boolean} [options.cleanURLs=true] The `cleanURLs` option will * check the cache for the URL with a `.html` added to the end of the end. * @param {module:workbox-precaching~urlManipulation} [options.urlManipulation] * This is a function that should take a URL and return an array of * alternative URLs that should be checked for precache matches. */ constructor(precacheController, options) { const match = ({ request }) => { const urlsToCacheKeys = precacheController.getURLsToCacheKeys(); for (const possibleURL of generateURLVariations(request.url, options)) { const cacheKey = urlsToCacheKeys.get(possibleURL); if (cacheKey) { return { cacheKey }; } } if (false) {} return; }; super(match, precacheController.strategy); } } // CONCATENATED MODULE: ./node_modules/workbox-precaching/addRoute.js /* 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. */ /** * Add a `fetch` listener to the service worker that will * respond to * [network requests]{@link https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers#Custom_responses_to_requests} * with precached assets. * * Requests for assets that aren't precached, the `FetchEvent` will not be * responded to, allowing the event to fall through to other `fetch` event * listeners. * * @param {Object} [options] See * [PrecacheRoute options]{@link module:workbox-precaching.PrecacheRoute}. * * @memberof module:workbox-precaching */ function addRoute(options) { const precacheController = getOrCreatePrecacheController(); const precacheRoute = new PrecacheRoute_PrecacheRoute(precacheController, options); registerRoute(precacheRoute); } // CONCATENATED MODULE: ./node_modules/workbox-precaching/utils/deleteOutdatedCaches.js /* 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 SUBSTRING_TO_FIND = '-precache-'; /** * Cleans up incompatible precaches that were created by older versions of * Workbox, by a service worker registered under the current scope. * * This is meant to be called as part of the `activate` event. * * This should be safe to use as long as you don't include `substringToFind` * (defaulting to `-precache-`) in your non-precache cache names. * * @param {string} currentPrecacheName The cache name currently in use for * precaching. This cache won't be deleted. * @param {string} [substringToFind='-precache-'] Cache names which include this * substring will be deleted (excluding `currentPrecacheName`). * @return {Array} A list of all the cache names that were deleted. * * @private * @memberof module:workbox-precaching */ const deleteOutdatedCaches = async (currentPrecacheName, substringToFind = SUBSTRING_TO_FIND) => { const cacheNames = await self.caches.keys(); const cacheNamesToDelete = cacheNames.filter((cacheName) => { return cacheName.includes(substringToFind) && cacheName.includes(self.registration.scope) && cacheName !== currentPrecacheName; }); await Promise.all(cacheNamesToDelete.map((cacheName) => self.caches.delete(cacheName))); return cacheNamesToDelete; }; // CONCATENATED MODULE: ./node_modules/workbox-precaching/cleanupOutdatedCaches.js /* 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. */ /** * Adds an `activate` event listener which will clean up incompatible * precaches that were created by older versions of Workbox. * * @memberof module:workbox-precaching */ function cleanupOutdatedCaches() { // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705 self.addEventListener('activate', ((event) => { const cacheName = cacheNames.getPrecacheName(); event.waitUntil(deleteOutdatedCaches(cacheName).then((cachesDeleted) => { if (false) {} })); })); } // CONCATENATED MODULE: ./node_modules/workbox-precaching/createHandlerBoundToURL.js /* 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. */ /** * Helper function that calls * {@link PrecacheController#createHandlerBoundToURL} on the default * {@link PrecacheController} instance. * * If you are creating your own {@link PrecacheController}, then call the * {@link PrecacheController#createHandlerBoundToURL} on that instance, * instead of using this function. * * @param {string} url The precached URL which will be used to lookup the * `Response`. * @param {boolean} [fallbackToNetwork=true] Whether to attempt to get the * response from the network if there's a precache miss. * @return {module:workbox-routing~handlerCallback} * * @memberof module:workbox-precaching */ function createHandlerBoundToURL(url) { const precacheController = getOrCreatePrecacheController(); return precacheController.createHandlerBoundToURL(url); } // CONCATENATED MODULE: ./node_modules/workbox-precaching/getCacheKeyForURL.js /* 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. */ /** * Takes in a URL, and returns the corresponding URL that could be used to * lookup the entry in the precache. * * If a relative URL is provided, the location of the service worker file will * be used as the base. * * For precached entries without revision information, the cache key will be the * same as the original URL. * * For precached entries with revision information, the cache key will be the * original URL with the addition of a query parameter used for keeping track of * the revision info. * * @param {string} url The URL whose cache key to look up. * @return {string} The cache key that corresponds to that URL. * * @memberof module:workbox-precaching */ function getCacheKeyForURL(url) { const precacheController = getOrCreatePrecacheController(); return precacheController.getCacheKeyForURL(url); } // CONCATENATED MODULE: ./node_modules/workbox-precaching/matchPrecache.js /* 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. */ /** * Helper function that calls * {@link PrecacheController#matchPrecache} on the default * {@link PrecacheController} instance. * * If you are creating your own {@link PrecacheController}, then call * {@link PrecacheController#matchPrecache} on that instance, * instead of using this function. * * @param {string|Request} request The key (without revisioning parameters) * to look up in the precache. * @return {Promise} * * @memberof module:workbox-precaching */ function matchPrecache(request) { const precacheController = getOrCreatePrecacheController(); return precacheController.matchPrecache(request); } // CONCATENATED MODULE: ./node_modules/workbox-precaching/precache.js /* 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. */ /** * Adds items to the precache list, removing any duplicates and * stores the files in the * ["precache cache"]{@link module:workbox-core.cacheNames} when the service * worker installs. * * This method can be called multiple times. * * Please note: This method **will not** serve any of the cached files for you. * It only precaches files. To respond to a network request you call * [addRoute()]{@link module:workbox-precaching.addRoute}. * * If you have a single array of files to precache, you can just call * [precacheAndRoute()]{@link module:workbox-precaching.precacheAndRoute}. * * @param {Array} [entries=[]] Array of entries to precache. * * @memberof module:workbox-precaching */ function precache(entries) { const precacheController = getOrCreatePrecacheController(); precacheController.precache(entries); } // CONCATENATED MODULE: ./node_modules/workbox-precaching/precacheAndRoute.js /* 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. */ /** * This method will add entries to the precache list and add a route to * respond to fetch events. * * This is a convenience method that will call * [precache()]{@link module:workbox-precaching.precache} and * [addRoute()]{@link module:workbox-precaching.addRoute} in a single call. * * @param {Array} entries Array of entries to precache. * @param {Object} [options] See * [PrecacheRoute options]{@link module:workbox-precaching.PrecacheRoute}. * * @memberof module:workbox-precaching */ function precacheAndRoute(entries, options) { precache(entries); addRoute(options); } // CONCATENATED MODULE: ./node_modules/workbox-precaching/PrecacheFallbackPlugin.js /* 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. */ /** * `PrecacheFallbackPlugin` allows you to specify an "offline fallback" * response to be used when a given strategy is unable to generate a response. * * It does this by intercepting the `handlerDidError` plugin callback * and returning a precached response, taking the expected revision parameter * into account automatically. * * Unless you explicitly pass in a `PrecacheController` instance to the * constructor, the default instance will be used. Generally speaking, most * developers will end up using the default. * * @memberof module:workbox-precaching */ class PrecacheFallbackPlugin_PrecacheFallbackPlugin { /** * Constructs a new PrecacheFallbackPlugin with the associated fallbackURL. * * @param {Object} config * @param {string} config.fallbackURL A precached URL to use as the fallback * if the associated strategy can't generate a response. * @param {PrecacheController} [config.precacheController] An optional * PrecacheController instance. If not provided, the default * PrecacheController will be used. */ constructor({ fallbackURL, precacheController }) { /** * @return {Promise} The precache response for the fallback URL. * * @private */ this.handlerDidError = () => this._precacheController.matchPrecache(this._fallbackURL); this._fallbackURL = fallbackURL; this._precacheController = precacheController || getOrCreatePrecacheController(); } } // CONCATENATED MODULE: ./node_modules/workbox-precaching/index.js /* 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. */ /** * Most consumers of this module will want to use the * [precacheAndRoute()]{@link module:workbox-precaching.precacheAndRoute} * method to add assets to the cache and respond to network requests with these * cached assets. * * If you require more control over caching and routing, you can use the * [PrecacheController]{@link module:workbox-precaching.PrecacheController} * interface. * * @module workbox-precaching */ // CONCATENATED MODULE: ./node_modules/workbox-precaching/index.mjs // CONCATENATED MODULE: ./node_modules/workbox-routing/NavigationRoute.js /* 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. */ /** * NavigationRoute makes it easy to create a * [Route]{@link module:workbox-routing.Route} that matches for browser * [navigation requests]{@link https://developers.google.com/web/fundamentals/primers/service-workers/high-performance-loading#first_what_are_navigation_requests}. * * It will only match incoming Requests whose * [`mode`]{@link https://fetch.spec.whatwg.org/#concept-request-mode} * is set to `navigate`. * * You can optionally only apply this route to a subset of navigation requests * by using one or both of the `denylist` and `allowlist` parameters. * * @memberof module:workbox-routing * @extends module:workbox-routing.Route */ class NavigationRoute_NavigationRoute extends Route_Route { /** * If both `denylist` and `allowlist` are provided, the `denylist` will * take precedence and the request will not match this route. * * The regular expressions in `allowlist` and `denylist` * are matched against the concatenated * [`pathname`]{@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/pathname} * and [`search`]{@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/search} * portions of the requested URL. * * @param {module:workbox-routing~handlerCallback} handler A callback * function that returns a Promise resulting in a Response. * @param {Object} options * @param {Array} [options.denylist] If any of these patterns match, * the route will not handle the request (even if a allowlist RegExp matches). * @param {Array} [options.allowlist=[/./]] If any of these patterns * match the URL's pathname and search parameter, the route will handle the * request (assuming the denylist doesn't match). */ constructor(handler, { allowlist = [/./], denylist = [] } = {}) { if (false) {} super((options) => this._match(options), handler); this._allowlist = allowlist; this._denylist = denylist; } /** * Routes match handler. * * @param {Object} options * @param {URL} options.url * @param {Request} options.request * @return {boolean} * * @private */ _match({ url, request }) { if (request && request.mode !== 'navigate') { return false; } const pathnameAndSearch = url.pathname + url.search; for (const regExp of this._denylist) { if (regExp.test(pathnameAndSearch)) { if (false) {} return false; } } if (this._allowlist.some((regExp) => regExp.test(pathnameAndSearch))) { if (false) {} return true; } if (false) {} return false; } } // CONCATENATED MODULE: ./node_modules/workbox-routing/setCatchHandler.js /* 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. */ /** * 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. * * @memberof module:workbox-routing */ function setCatchHandler(handler) { const defaultRouter = getOrCreateDefaultRouter(); defaultRouter.setCatchHandler(handler); } // CONCATENATED MODULE: ./node_modules/workbox-routing/setDefaultHandler.js /* 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. */ /** * Define a default `handler` that's called when no routes explicitly * match the incoming request. * * 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. * * @memberof module:workbox-routing */ function setDefaultHandler(handler) { const defaultRouter = getOrCreateDefaultRouter(); defaultRouter.setDefaultHandler(handler); } // CONCATENATED MODULE: ./node_modules/workbox-routing/index.js /* 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. */ /** * @module workbox-routing */ // CONCATENATED MODULE: ./node_modules/workbox-routing/index.mjs // CONCATENATED MODULE: ./node_modules/workbox-strategies/utils/messages.js /* 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_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(); } }, }; // CONCATENATED MODULE: ./node_modules/workbox-strategies/CacheFirst.js /* 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 [cache-first]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#cache-falling-back-to-network} * request strategy. * * A cache first strategy is useful for assets that have been revisioned, * such as URLs like `/styles/example.a8f5f1.css`, since they * can be cached for long periods of time. * * 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 CacheFirst_CacheFirst extends Strategy_Strategy { /** * @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} */ async _handle(request, handler) { const logs = []; if (false) {} let response = await handler.cacheMatch(request); let error; if (!response) { if (false) {} try { response = await handler.fetchAndCachePut(request); } catch (err) { error = err; } if (false) {} } else { if (false) {} } if (false) {} if (!response) { throw new WorkboxError_WorkboxError('no-response', { url: request.url, error }); } return response; } } // CONCATENATED MODULE: ./node_modules/workbox-strategies/CacheOnly.js /* 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 * [cache-only]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#cache-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 there is no cache match, this will throw a `WorkboxError` exception. * * @extends module:workbox-strategies.Strategy * @memberof module:workbox-strategies */ class CacheOnly_CacheOnly extends Strategy_Strategy { /** * @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} */ async _handle(request, handler) { if (false) {} const response = await handler.cacheMatch(request); if (false) {} if (!response) { throw new WorkboxError_WorkboxError('no-response', { url: request.url }); } return response; } } // CONCATENATED MODULE: ./node_modules/workbox-strategies/plugins/cacheOkAndOpaquePlugin.js /* 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; }, }; // CONCATENATED MODULE: ./node_modules/workbox-strategies/NetworkFirst.js /* 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_NetworkFirst extends Strategy_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} [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 (false) {} } /** * @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} */ async _handle(request, handler) { const logs = []; if (false) {} 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; })()); if (false) {} if (!response) { throw new WorkboxError_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} * * @private */ _getTimeoutPromise({ request, logs, handler }) { let timeoutId; const timeoutPromise = new Promise((resolve) => { const onNetworkTimeout = async () => { if (false) {} 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} * * @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 (false) {} if (error || !response) { response = await handler.cacheMatch(request); if (false) {} } return response; } } // CONCATENATED MODULE: ./node_modules/workbox-strategies/NetworkOnly.js /* 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_NetworkOnly extends Strategy_Strategy { /** * @param {Object} [options] * @param {Array} [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} */ async _handle(request, handler) { if (false) {} 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; } if (false) {} if (!response) { throw new WorkboxError_WorkboxError('no-response', { url: request.url, error }); } return response; } } // CONCATENATED MODULE: ./node_modules/workbox-strategies/StaleWhileRevalidate.js /* 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 * [stale-while-revalidate]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#stale-while-revalidate} * request strategy. * * Resources are requested from both the cache and the network in parallel. * The strategy will respond with the cached version if available, otherwise * wait for the network response. The cache is updated with the network response * with each successful request. * * 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 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 StaleWhileRevalidate_StaleWhileRevalidate extends Strategy_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} [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) */ 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); } } /** * @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} */ async _handle(request, handler) { const logs = []; if (false) {} const fetchAndCachePromise = handler .fetchAndCachePut(request) .catch(() => { // Swallow this error because a 'no-response' error will be thrown in // main handler return flow. This will be in the `waitUntil()` flow. }); let response = await handler.cacheMatch(request); let error; if (response) { if (false) {} } else { if (false) {} try { // NOTE(philipwalton): Really annoying that we have to type cast here. // https://github.com/microsoft/TypeScript/issues/20006 response = await fetchAndCachePromise; } catch (err) { error = err; } } if (false) {} if (!response) { throw new WorkboxError_WorkboxError('no-response', { url: request.url, error }); } return response; } } // CONCATENATED MODULE: ./node_modules/workbox-strategies/index.js /* 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. */ /** * There are common caching strategies that most service workers will need * and use. This module provides simple implementations of these strategies. * * @module workbox-strategies */ // CONCATENATED MODULE: ./node_modules/workbox-strategies/index.mjs // CONCATENATED MODULE: ./node_modules/workbox-core/_private/dontWaitFor.js /* 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. */ /** * A helper function that prevents a promise from being flagged as unused. * * @private **/ function dontWaitFor(promise) { // Effective no-op. promise.then(() => { }); } // CONCATENATED MODULE: ./node_modules/workbox-core/_private/DBWrapper.js /* 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 class that wraps common IndexedDB functionality in a promise-based API. * It exposes all the underlying power and functionality of IndexedDB, but * wraps the most commonly used features in a way that's much simpler to use. * * @private */ class DBWrapper { /** * @param {string} name * @param {number} version * @param {Object=} [callback] * @param {!Function} [callbacks.onupgradeneeded] * @param {!Function} [callbacks.onversionchange] Defaults to * DBWrapper.prototype._onversionchange when not specified. * @private */ constructor(name, version, { onupgradeneeded, onversionchange, } = {}) { this._db = null; this._name = name; this._version = version; this._onupgradeneeded = onupgradeneeded; this._onversionchange = onversionchange || (() => this.close()); } /** * Returns the IDBDatabase instance (not normally needed). * @return {IDBDatabase|undefined} * * @private */ get db() { return this._db; } /** * Opens a connected to an IDBDatabase, invokes any onupgradedneeded * callback, and added an onversionchange callback to the database. * * @return {IDBDatabase} * @private */ async open() { if (this._db) return; this._db = await new Promise((resolve, reject) => { // This flag is flipped to true if the timeout callback runs prior // to the request failing or succeeding. Note: we use a timeout instead // of an onblocked handler since there are cases where onblocked will // never never run. A timeout better handles all possible scenarios: // https://github.com/w3c/IndexedDB/issues/223 let openRequestTimedOut = false; setTimeout(() => { openRequestTimedOut = true; reject(new Error('The open request was blocked and timed out')); }, this.OPEN_TIMEOUT); const openRequest = indexedDB.open(this._name, this._version); openRequest.onerror = () => reject(openRequest.error); openRequest.onupgradeneeded = (evt) => { if (openRequestTimedOut) { openRequest.transaction.abort(); openRequest.result.close(); } else if (typeof this._onupgradeneeded === 'function') { this._onupgradeneeded(evt); } }; openRequest.onsuccess = () => { const db = openRequest.result; if (openRequestTimedOut) { db.close(); } else { db.onversionchange = this._onversionchange.bind(this); resolve(db); } }; }); return this; } /** * Polyfills the native `getKey()` method. Note, this is overridden at * runtime if the browser supports the native method. * * @param {string} storeName * @param {*} query * @return {Array} * @private */ async getKey(storeName, query) { return (await this.getAllKeys(storeName, query, 1))[0]; } /** * Polyfills the native `getAll()` method. Note, this is overridden at * runtime if the browser supports the native method. * * @param {string} storeName * @param {*} query * @param {number} count * @return {Array} * @private */ async getAll(storeName, query, count) { return await this.getAllMatching(storeName, { query, count }); } /** * Polyfills the native `getAllKeys()` method. Note, this is overridden at * runtime if the browser supports the native method. * * @param {string} storeName * @param {*} query * @param {number} count * @return {Array} * @private */ async getAllKeys(storeName, query, count) { const entries = await this.getAllMatching(storeName, { query, count, includeKeys: true }); return entries.map((entry) => entry.key); } /** * Supports flexible lookup in an object store by specifying an index, * query, direction, and count. This method returns an array of objects * with the signature . * * @param {string} storeName * @param {Object} [opts] * @param {string} [opts.index] The index to use (if specified). * @param {*} [opts.query] * @param {IDBCursorDirection} [opts.direction] * @param {number} [opts.count] The max number of results to return. * @param {boolean} [opts.includeKeys] When true, the structure of the * returned objects is changed from an array of values to an array of * objects in the form {key, primaryKey, value}. * @return {Array} * @private */ async getAllMatching(storeName, { index, query = null, // IE/Edge errors if query === `undefined`. direction = 'next', count, includeKeys = false, } = {}) { return await this.transaction([storeName], 'readonly', (txn, done) => { const store = txn.objectStore(storeName); const target = index ? store.index(index) : store; const results = []; const request = target.openCursor(query, direction); request.onsuccess = () => { const cursor = request.result; if (cursor) { results.push(includeKeys ? cursor : cursor.value); if (count && results.length >= count) { done(results); } else { cursor.continue(); } } else { done(results); } }; }); } /** * Accepts a list of stores, a transaction type, and a callback and * performs a transaction. A promise is returned that resolves to whatever * value the callback chooses. The callback holds all the transaction logic * and is invoked with two arguments: * 1. The IDBTransaction object * 2. A `done` function, that's used to resolve the promise when * when the transaction is done, if passed a value, the promise is * resolved to that value. * * @param {Array} storeNames An array of object store names * involved in the transaction. * @param {string} type Can be `readonly` or `readwrite`. * @param {!Function} callback * @return {*} The result of the transaction ran by the callback. * @private */ async transaction(storeNames, type, callback) { await this.open(); return await new Promise((resolve, reject) => { const txn = this._db.transaction(storeNames, type); txn.onabort = () => reject(txn.error); txn.oncomplete = () => resolve(); callback(txn, (value) => resolve(value)); }); } /** * Delegates async to a native IDBObjectStore method. * * @param {string} method The method name. * @param {string} storeName The object store name. * @param {string} type Can be `readonly` or `readwrite`. * @param {...*} args The list of args to pass to the native method. * @return {*} The result of the transaction. * @private */ async _call(method, storeName, type, ...args) { const callback = (txn, done) => { const objStore = txn.objectStore(storeName); // TODO(philipwalton): Fix this underlying TS2684 error. // @ts-ignore const request = objStore[method].apply(objStore, args); request.onsuccess = () => done(request.result); }; return await this.transaction([storeName], type, callback); } /** * Closes the connection opened by `DBWrapper.open()`. Generally this method * doesn't need to be called since: * 1. It's usually better to keep a connection open since opening * a new connection is somewhat slow. * 2. Connections are automatically closed when the reference is * garbage collected. * The primary use case for needing to close a connection is when another * reference (typically in another tab) needs to upgrade it and would be * blocked by the current, open connection. * * @private */ close() { if (this._db) { this._db.close(); this._db = null; } } } // Exposed on the prototype to let users modify the default timeout on a // per-instance or global basis. DBWrapper.prototype.OPEN_TIMEOUT = 2000; // Wrap native IDBObjectStore methods according to their mode. const methodsToWrap = { readonly: ['get', 'count', 'getKey', 'getAll', 'getAllKeys'], readwrite: ['add', 'put', 'clear', 'delete'], }; for (const [mode, methods] of Object.entries(methodsToWrap)) { for (const method of methods) { if (method in IDBObjectStore.prototype) { // Don't use arrow functions here since we're outside of the class. DBWrapper.prototype[method] = async function (storeName, ...args) { return await this._call(method, storeName, mode, ...args); }; } } } // CONCATENATED MODULE: ./node_modules/workbox-core/_private/deleteDatabase.js /* 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. */ /** * Deletes the database. * Note: this is exported separately from the DBWrapper module because most * usages of IndexedDB in workbox dont need deleting, and this way it can be * reused in tests to delete databases without creating DBWrapper instances. * * @param {string} name The database name. * @private */ const deleteDatabase = async (name) => { await new Promise((resolve, reject) => { const request = indexedDB.deleteDatabase(name); request.onerror = () => { reject(request.error); }; request.onblocked = () => { reject(new Error('Delete blocked')); }; request.onsuccess = () => { resolve(); }; }); }; // EXTERNAL MODULE: ./node_modules/workbox-expiration/_version.js var workbox_expiration_version = __webpack_require__("d8a5"); // CONCATENATED MODULE: ./node_modules/workbox-expiration/models/CacheTimestampsModel.js /* 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 DB_NAME = 'workbox-expiration'; const OBJECT_STORE_NAME = 'cache-entries'; const normalizeURL = (unNormalizedUrl) => { const url = new URL(unNormalizedUrl, location.href); url.hash = ''; return url.href; }; /** * Returns the timestamp model. * * @private */ class CacheTimestampsModel_CacheTimestampsModel { /** * * @param {string} cacheName * * @private */ constructor(cacheName) { this._cacheName = cacheName; this._db = new DBWrapper(DB_NAME, 1, { onupgradeneeded: (event) => this._handleUpgrade(event), }); } /** * Should perform an upgrade of indexedDB. * * @param {Event} event * * @private */ _handleUpgrade(event) { const db = event.target.result; // TODO(philipwalton): EdgeHTML doesn't support arrays as a keyPath, so we // have to use the `id` keyPath here and create our own values (a // concatenation of `url + cacheName`) instead of simply using // `keyPath: ['url', 'cacheName']`, which is supported in other browsers. const objStore = db.createObjectStore(OBJECT_STORE_NAME, { keyPath: 'id' }); // TODO(philipwalton): once we don't have to support EdgeHTML, we can // create a single index with the keyPath `['cacheName', 'timestamp']` // instead of doing both these indexes. objStore.createIndex('cacheName', 'cacheName', { unique: false }); objStore.createIndex('timestamp', 'timestamp', { unique: false }); // Previous versions of `workbox-expiration` used `this._cacheName` // as the IDBDatabase name. deleteDatabase(this._cacheName); } /** * @param {string} url * @param {number} timestamp * * @private */ async setTimestamp(url, timestamp) { url = normalizeURL(url); const entry = { url, timestamp, cacheName: this._cacheName, // Creating an ID from the URL and cache name won't be necessary once // Edge switches to Chromium and all browsers we support work with // array keyPaths. id: this._getId(url), }; await this._db.put(OBJECT_STORE_NAME, entry); } /** * Returns the timestamp stored for a given URL. * * @param {string} url * @return {number} * * @private */ async getTimestamp(url) { const entry = await this._db.get(OBJECT_STORE_NAME, this._getId(url)); return entry.timestamp; } /** * Iterates through all the entries in the object store (from newest to * oldest) and removes entries once either `maxCount` is reached or the * entry's timestamp is less than `minTimestamp`. * * @param {number} minTimestamp * @param {number} maxCount * @return {Array} * * @private */ async expireEntries(minTimestamp, maxCount) { const entriesToDelete = await this._db.transaction(OBJECT_STORE_NAME, 'readwrite', (txn, done) => { const store = txn.objectStore(OBJECT_STORE_NAME); const request = store.index('timestamp').openCursor(null, 'prev'); const entriesToDelete = []; let entriesNotDeletedCount = 0; request.onsuccess = () => { const cursor = request.result; if (cursor) { const result = cursor.value; // TODO(philipwalton): once we can use a multi-key index, we // won't have to check `cacheName` here. if (result.cacheName === this._cacheName) { // Delete an entry if it's older than the max age or // if we already have the max number allowed. if ((minTimestamp && result.timestamp < minTimestamp) || (maxCount && entriesNotDeletedCount >= maxCount)) { // TODO(philipwalton): we should be able to delete the // entry right here, but doing so causes an iteration // bug in Safari stable (fixed in TP). Instead we can // store the keys of the entries to delete, and then // delete the separate transactions. // https://github.com/GoogleChrome/workbox/issues/1978 // cursor.delete(); // We only need to return the URL, not the whole entry. entriesToDelete.push(cursor.value); } else { entriesNotDeletedCount++; } } cursor.continue(); } else { done(entriesToDelete); } }; }); // TODO(philipwalton): once the Safari bug in the following issue is fixed, // we should be able to remove this loop and do the entry deletion in the // cursor loop above: // https://github.com/GoogleChrome/workbox/issues/1978 const urlsDeleted = []; for (const entry of entriesToDelete) { await this._db.delete(OBJECT_STORE_NAME, entry.id); urlsDeleted.push(entry.url); } return urlsDeleted; } /** * Takes a URL and returns an ID that will be unique in the object store. * * @param {string} url * @return {string} * * @private */ _getId(url) { // Creating an ID from the URL and cache name won't be necessary once // Edge switches to Chromium and all browsers we support work with // array keyPaths. return this._cacheName + '|' + normalizeURL(url); } } // CONCATENATED MODULE: ./node_modules/workbox-expiration/CacheExpiration.js /* 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 `CacheExpiration` class allows you define an expiration and / or * limit on the number of responses stored in a * [`Cache`](https://developer.mozilla.org/en-US/docs/Web/API/Cache). * * @memberof module:workbox-expiration */ class CacheExpiration_CacheExpiration { /** * To construct a new CacheExpiration instance you must provide at least * one of the `config` properties. * * @param {string} cacheName Name of the cache to apply restrictions to. * @param {Object} config * @param {number} [config.maxEntries] The maximum number of entries to cache. * Entries used the least will be removed as the maximum is reached. * @param {number} [config.maxAgeSeconds] The maximum age of an entry before * it's treated as stale and removed. * @param {Object} [config.matchOptions] The [`CacheQueryOptions`](https://developer.mozilla.org/en-US/docs/Web/API/Cache/delete#Parameters) * that will be used when calling `delete()` on the cache. */ constructor(cacheName, config = {}) { this._isRunning = false; this._rerunRequested = false; if (false) {} this._maxEntries = config.maxEntries; this._maxAgeSeconds = config.maxAgeSeconds; this._matchOptions = config.matchOptions; this._cacheName = cacheName; this._timestampModel = new CacheTimestampsModel_CacheTimestampsModel(cacheName); } /** * Expires entries for the given cache and given criteria. */ async expireEntries() { if (this._isRunning) { this._rerunRequested = true; return; } this._isRunning = true; const minTimestamp = this._maxAgeSeconds ? Date.now() - (this._maxAgeSeconds * 1000) : 0; const urlsExpired = await this._timestampModel.expireEntries(minTimestamp, this._maxEntries); // Delete URLs from the cache const cache = await self.caches.open(this._cacheName); for (const url of urlsExpired) { await cache.delete(url, this._matchOptions); } if (false) {} this._isRunning = false; if (this._rerunRequested) { this._rerunRequested = false; dontWaitFor(this.expireEntries()); } } /** * Update the timestamp for the given URL. This ensures the when * removing entries based on maximum entries, most recently used * is accurate or when expiring, the timestamp is up-to-date. * * @param {string} url */ async updateTimestamp(url) { if (false) {} await this._timestampModel.setTimestamp(url, Date.now()); } /** * Can be used to check if a URL has expired or not before it's used. * * This requires a look up from IndexedDB, so can be slow. * * Note: This method will not remove the cached entry, call * `expireEntries()` to remove indexedDB and Cache entries. * * @param {string} url * @return {boolean} */ async isURLExpired(url) { if (!this._maxAgeSeconds) { if (false) {} return false; } else { const timestamp = await this._timestampModel.getTimestamp(url); const expireOlderThan = Date.now() - (this._maxAgeSeconds * 1000); return (timestamp < expireOlderThan); } } /** * Removes the IndexedDB object store used to keep track of cache expiration * metadata. */ async delete() { // Make sure we don't attempt another rerun if we're called in the middle of // a cache expiration. this._rerunRequested = false; await this._timestampModel.expireEntries(Infinity); // Expires all. } } // CONCATENATED MODULE: ./node_modules/workbox-core/registerQuotaErrorCallback.js /* 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. */ /** * Adds a function to the set of quotaErrorCallbacks that will be executed if * there's a quota error. * * @param {Function} callback * @memberof module:workbox-core */ function registerQuotaErrorCallback(callback) { if (false) {} quotaErrorCallbacks.add(callback); if (false) {} } // CONCATENATED MODULE: ./node_modules/workbox-expiration/ExpirationPlugin.js /* 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 plugin can be used in a `workbox-strategy` to regularly enforce a * limit on the age and / or the number of cached requests. * * It can only be used with `workbox-strategy` instances that have a * [custom `cacheName` property set](/web/tools/workbox/guides/configure-workbox#custom_cache_names_in_strategies). * In other words, it can't be used to expire entries in strategy that uses the * default runtime cache name. * * Whenever a cached request is used or updated, this plugin will look * at the associated cache and remove any old or extra requests. * * When using `maxAgeSeconds`, requests may be used *once* after expiring * because the expiration clean up will not have occurred until *after* the * cached request has been used. If the request has a "Date" header, then * a light weight expiration check is performed and the request will not be * used immediately. * * When using `maxEntries`, the entry least-recently requested will be removed * from the cache first. * * @memberof module:workbox-expiration */ class ExpirationPlugin_ExpirationPlugin { /** * @param {Object} config * @param {number} [config.maxEntries] The maximum number of entries to cache. * Entries used the least will be removed as the maximum is reached. * @param {number} [config.maxAgeSeconds] The maximum age of an entry before * it's treated as stale and removed. * @param {Object} [config.matchOptions] The [`CacheQueryOptions`](https://developer.mozilla.org/en-US/docs/Web/API/Cache/delete#Parameters) * that will be used when calling `delete()` on the cache. * @param {boolean} [config.purgeOnQuotaError] Whether to opt this cache in to * automatic deletion if the available storage quota has been exceeded. */ constructor(config = {}) { /** * A "lifecycle" callback that will be triggered automatically by the * `workbox-strategies` handlers when a `Response` is about to be returned * from a [Cache](https://developer.mozilla.org/en-US/docs/Web/API/Cache) to * the handler. It allows the `Response` to be inspected for freshness and * prevents it from being used if the `Response`'s `Date` header value is * older than the configured `maxAgeSeconds`. * * @param {Object} options * @param {string} options.cacheName Name of the cache the response is in. * @param {Response} options.cachedResponse The `Response` object that's been * read from a cache and whose freshness should be checked. * @return {Response} Either the `cachedResponse`, if it's * fresh, or `null` if the `Response` is older than `maxAgeSeconds`. * * @private */ this.cachedResponseWillBeUsed = async ({ event, request, cacheName, cachedResponse }) => { if (!cachedResponse) { return null; } const isFresh = this._isResponseDateFresh(cachedResponse); // Expire entries to ensure that even if the expiration date has // expired, it'll only be used once. const cacheExpiration = this._getCacheExpiration(cacheName); dontWaitFor(cacheExpiration.expireEntries()); // Update the metadata for the request URL to the current timestamp, // but don't `await` it as we don't want to block the response. const updateTimestampDone = cacheExpiration.updateTimestamp(request.url); if (event) { try { event.waitUntil(updateTimestampDone); } catch (error) { if (false) {} } } return isFresh ? cachedResponse : null; }; /** * A "lifecycle" callback that will be triggered automatically by the * `workbox-strategies` handlers when an entry is added to a cache. * * @param {Object} options * @param {string} options.cacheName Name of the cache that was updated. * @param {string} options.request The Request for the cached entry. * * @private */ this.cacheDidUpdate = async ({ cacheName, request }) => { if (false) {} const cacheExpiration = this._getCacheExpiration(cacheName); await cacheExpiration.updateTimestamp(request.url); await cacheExpiration.expireEntries(); }; if (false) {} this._config = config; this._maxAgeSeconds = config.maxAgeSeconds; this._cacheExpirations = new Map(); if (config.purgeOnQuotaError) { registerQuotaErrorCallback(() => this.deleteCacheAndMetadata()); } } /** * A simple helper method to return a CacheExpiration instance for a given * cache name. * * @param {string} cacheName * @return {CacheExpiration} * * @private */ _getCacheExpiration(cacheName) { if (cacheName === cacheNames.getRuntimeName()) { throw new WorkboxError_WorkboxError('expire-custom-caches-only'); } let cacheExpiration = this._cacheExpirations.get(cacheName); if (!cacheExpiration) { cacheExpiration = new CacheExpiration_CacheExpiration(cacheName, this._config); this._cacheExpirations.set(cacheName, cacheExpiration); } return cacheExpiration; } /** * @param {Response} cachedResponse * @return {boolean} * * @private */ _isResponseDateFresh(cachedResponse) { if (!this._maxAgeSeconds) { // We aren't expiring by age, so return true, it's fresh return true; } // Check if the 'date' header will suffice a quick expiration check. // See https://github.com/GoogleChromeLabs/sw-toolbox/issues/164 for // discussion. const dateHeaderTimestamp = this._getDateHeaderTimestamp(cachedResponse); if (dateHeaderTimestamp === null) { // Unable to parse date, so assume it's fresh. return true; } // If we have a valid headerTime, then our response is fresh iff the // headerTime plus maxAgeSeconds is greater than the current time. const now = Date.now(); return dateHeaderTimestamp >= now - (this._maxAgeSeconds * 1000); } /** * This method will extract the data header and parse it into a useful * value. * * @param {Response} cachedResponse * @return {number|null} * * @private */ _getDateHeaderTimestamp(cachedResponse) { if (!cachedResponse.headers.has('date')) { return null; } const dateHeader = cachedResponse.headers.get('date'); const parsedDate = new Date(dateHeader); const headerTime = parsedDate.getTime(); // If the Date header was invalid for some reason, parsedDate.getTime() // will return NaN. if (isNaN(headerTime)) { return null; } return headerTime; } /** * This is a helper method that performs two operations: * * - Deletes *all* the underlying Cache instances associated with this plugin * instance, by calling caches.delete() on your behalf. * - Deletes the metadata from IndexedDB used to keep track of expiration * details for each Cache instance. * * When using cache expiration, calling this method is preferable to calling * `caches.delete()` directly, since this will ensure that the IndexedDB * metadata is also cleanly removed and open IndexedDB instances are deleted. * * Note that if you're *not* using cache expiration for a given cache, calling * `caches.delete()` and passing in the cache's name should be sufficient. * There is no Workbox-specific method needed for cleanup in that case. */ async deleteCacheAndMetadata() { // Do this one at a time instead of all at once via `Promise.all()` to // reduce the chance of inconsistency if a promise rejects. for (const [cacheName, cacheExpiration] of this._cacheExpirations) { await self.caches.delete(cacheName); await cacheExpiration.delete(); } // Reset this._cacheExpirations to its initial state. this._cacheExpirations = new Map(); } } // CONCATENATED MODULE: ./node_modules/workbox-expiration/index.js /* 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. */ /** * @module workbox-expiration */ // CONCATENATED MODULE: ./node_modules/workbox-expiration/index.mjs // CONCATENATED MODULE: ./src/sw.js // These JavaScript module imports need to be bundled: var OFFLINE_CACHE_NAME = 'offline-html'; var script_name = typeof window !== 'undefined' ? localStorage.getItem('SCRIPT_NAME') : '/'; var OFFLINE_PAGE_URL = script_name + 'offline/'; self.addEventListener('install', /*#__PURE__*/function () { var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(event) { return regeneratorRuntime.wrap(function _callee$(_context) { while (1) { switch (_context.prev = _context.next) { case 0: event.waitUntil(caches.open(OFFLINE_CACHE_NAME).then(function (cache) { return cache.add(new Request(OFFLINE_PAGE_URL, { cache: "reload" })); })); case 1: case "end": return _context.stop(); } } }, _callee); })); return function (_x) { return _ref.apply(this, arguments); }; }()); // since the mode is inject manifest this needs to be present but because // precacheAndRoute is cache first and i currently dont really know how to // do versioning i will not use it [{'url':'static/vue/css/chunk-vendors.css'},{'url':'static/vue/css/food_list_view.css'},{'url':'static/vue/css/keyword_list_view.css'},{'url':'static/vue/food_list_view.html'},{'url':'static/vue/import_response_view.html'},{'url':'static/vue/js/food_list_view.js'},{'url':'static/vue/js/import_response_view.js'},{'url':'static/vue/js/keyword_list_view.js'},{'url':'static/vue/js/offline_view.js'},{'url':'static/vue/js/recipe_search_view.js'},{'url':'static/vue/js/recipe_view.js'},{'url':'static/vue/js/supermarket_view.js'},{'url':'static/vue/js/user_file_view.js'},{'url':'static/vue/keyword_list_view.html'},{'url':'static/vue/manifest.json'},{'url':'static/vue/offline_view.html'},{'url':'static/vue/recipe_search_view.html'},{'url':'static/vue/recipe_view.html'},{'url':'static/vue/supermarket_view.html'},{'url':'static/vue/user_file_view.html'}]; // default handler if everything else fails setCatchHandler(function (_ref2) { var event = _ref2.event; switch (event.request.destination) { case 'document': console.log('Triggered fallback HTML'); return caches.open(OFFLINE_CACHE_NAME).then(function (cache) { return cache.match(OFFLINE_PAGE_URL); }); default: console.log('Triggered response ERROR'); return Response.error(); } }); registerRoute(function (_ref3) { var request = _ref3.request; return request.destination === 'image'; }, new CacheFirst_CacheFirst({ cacheName: 'images', plugins: [new ExpirationPlugin_ExpirationPlugin({ maxEntries: 20 })] })); registerRoute(function (_ref4) { var request = _ref4.request; return request.destination === 'script' || request.destination === 'style'; }, new StaleWhileRevalidate_StaleWhileRevalidate({ cacheName: 'assets' })); registerRoute(new RegExp('jsreverse'), new StaleWhileRevalidate_StaleWhileRevalidate({ cacheName: 'assets' })); registerRoute(new RegExp('jsi18n'), new StaleWhileRevalidate_StaleWhileRevalidate({ cacheName: 'assets' })); registerRoute(new RegExp('api/recipe/([0-9]+)'), new NetworkFirst_NetworkFirst({ cacheName: 'api-recipe', plugins: [new ExpirationPlugin_ExpirationPlugin({ maxEntries: 50 })] })); registerRoute(new RegExp('api/*'), new NetworkFirst_NetworkFirst({ cacheName: 'api', plugins: [new ExpirationPlugin_ExpirationPlugin({ maxEntries: 50 })] })); registerRoute(function (_ref5) { var request = _ref5.request; return request.destination === 'document'; }, new NetworkFirst_NetworkFirst({ cacheName: 'html', plugins: [new ExpirationPlugin_ExpirationPlugin({ maxAgeSeconds: 60 * 60 * 24 * 30, maxEntries: 50 })] })); /***/ }), /***/ "25f0": /***/ (function(module, exports, __webpack_require__) { "use strict"; var redefine = __webpack_require__("6eeb"); var anObject = __webpack_require__("825a"); var fails = __webpack_require__("d039"); var flags = __webpack_require__("ad6d"); var TO_STRING = 'toString'; var RegExpPrototype = RegExp.prototype; var nativeToString = RegExpPrototype[TO_STRING]; var NOT_GENERIC = fails(function () { return nativeToString.call({ source: 'a', flags: 'b' }) != '/a/b'; }); // FF44- RegExp#toString has a wrong name var INCORRECT_NAME = nativeToString.name != TO_STRING; // `RegExp.prototype.toString` method // https://tc39.es/ecma262/#sec-regexp.prototype.tostring if (NOT_GENERIC || INCORRECT_NAME) { redefine(RegExp.prototype, TO_STRING, function toString() { var R = anObject(this); var p = String(R.source); var rf = R.flags; var f = String(rf === undefined && R instanceof RegExp && !('flags' in RegExpPrototype) ? flags.call(R) : rf); return '/' + p + '/' + f; }, { unsafe: true }); } /***/ }), /***/ "2626": /***/ (function(module, exports, __webpack_require__) { "use strict"; var getBuiltIn = __webpack_require__("d066"); var definePropertyModule = __webpack_require__("9bf2"); var wellKnownSymbol = __webpack_require__("b622"); var DESCRIPTORS = __webpack_require__("83ab"); var SPECIES = wellKnownSymbol('species'); module.exports = function (CONSTRUCTOR_NAME) { var Constructor = getBuiltIn(CONSTRUCTOR_NAME); var defineProperty = definePropertyModule.f; if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) { defineProperty(Constructor, SPECIES, { configurable: true, get: function () { return this; } }); } }; /***/ }), /***/ "2d00": /***/ (function(module, exports, __webpack_require__) { var global = __webpack_require__("da84"); var userAgent = __webpack_require__("342f"); var process = global.process; var versions = process && process.versions; var v8 = versions && versions.v8; var match, version; if (v8) { match = v8.split('.'); version = match[0] < 4 ? 1 : match[0] + match[1]; } else if (userAgent) { match = userAgent.match(/Edge\/(\d+)/); if (!match || match[1] >= 74) { match = userAgent.match(/Chrome\/(\d+)/); if (match) version = match[1]; } } module.exports = version && +version; /***/ }), /***/ "342f": /***/ (function(module, exports, __webpack_require__) { var getBuiltIn = __webpack_require__("d066"); module.exports = getBuiltIn('navigator', 'userAgent') || ''; /***/ }), /***/ "3bbe": /***/ (function(module, exports, __webpack_require__) { var isObject = __webpack_require__("861d"); module.exports = function (it) { if (!isObject(it) && it !== null) { throw TypeError("Can't set " + String(it) + ' as a prototype'); } return it; }; /***/ }), /***/ "428f": /***/ (function(module, exports, __webpack_require__) { var global = __webpack_require__("da84"); module.exports = global; /***/ }), /***/ "44ad": /***/ (function(module, exports, __webpack_require__) { var fails = __webpack_require__("d039"); var classof = __webpack_require__("c6b6"); var split = ''.split; // fallback for non-array-like ES3 and non-enumerable old V8 strings module.exports = fails(function () { // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346 // eslint-disable-next-line no-prototype-builtins -- safe return !Object('z').propertyIsEnumerable(0); }) ? function (it) { return classof(it) == 'String' ? split.call(it, '') : Object(it); } : Object; /***/ }), /***/ "44e7": /***/ (function(module, exports, __webpack_require__) { var isObject = __webpack_require__("861d"); var classof = __webpack_require__("c6b6"); var wellKnownSymbol = __webpack_require__("b622"); var MATCH = wellKnownSymbol('match'); // `IsRegExp` abstract operation // https://tc39.es/ecma262/#sec-isregexp module.exports = function (it) { var isRegExp; return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : classof(it) == 'RegExp'); }; /***/ }), /***/ "466d": /***/ (function(module, exports, __webpack_require__) { "use strict"; var fixRegExpWellKnownSymbolLogic = __webpack_require__("d784"); var anObject = __webpack_require__("825a"); var toLength = __webpack_require__("50c4"); var requireObjectCoercible = __webpack_require__("1d80"); var advanceStringIndex = __webpack_require__("8aa5"); var regExpExec = __webpack_require__("14c3"); // @@match logic fixRegExpWellKnownSymbolLogic('match', 1, function (MATCH, nativeMatch, maybeCallNative) { return [ // `String.prototype.match` method // https://tc39.es/ecma262/#sec-string.prototype.match function match(regexp) { var O = requireObjectCoercible(this); var matcher = regexp == undefined ? undefined : regexp[MATCH]; return matcher !== undefined ? matcher.call(regexp, O) : new RegExp(regexp)[MATCH](String(O)); }, // `RegExp.prototype[@@match]` method // https://tc39.es/ecma262/#sec-regexp.prototype-@@match function (regexp) { var res = maybeCallNative(nativeMatch, regexp, this); if (res.done) return res.value; var rx = anObject(regexp); var S = String(this); if (!rx.global) return regExpExec(rx, S); var fullUnicode = rx.unicode; rx.lastIndex = 0; var A = []; var n = 0; var result; while ((result = regExpExec(rx, S)) !== null) { var matchStr = String(result[0]); A[n] = matchStr; if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode); n++; } return n === 0 ? null : A; } ]; }); /***/ }), /***/ "4930": /***/ (function(module, exports, __webpack_require__) { /* eslint-disable es/no-symbol -- required for testing */ var V8_VERSION = __webpack_require__("2d00"); var fails = __webpack_require__("d039"); // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing module.exports = !!Object.getOwnPropertySymbols && !fails(function () { var symbol = Symbol(); // Chrome 38 Symbol has incorrect toString conversion // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances return !String(symbol) || !(Object(symbol) instanceof Symbol) || // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances !Symbol.sham && V8_VERSION && V8_VERSION < 41; }); /***/ }), /***/ "4d63": /***/ (function(module, exports, __webpack_require__) { var DESCRIPTORS = __webpack_require__("83ab"); var global = __webpack_require__("da84"); var isForced = __webpack_require__("94ca"); var inheritIfRequired = __webpack_require__("7156"); var defineProperty = __webpack_require__("9bf2").f; var getOwnPropertyNames = __webpack_require__("241c").f; var isRegExp = __webpack_require__("44e7"); var getFlags = __webpack_require__("ad6d"); var stickyHelpers = __webpack_require__("9f7f"); var redefine = __webpack_require__("6eeb"); var fails = __webpack_require__("d039"); var enforceInternalState = __webpack_require__("69f3").enforce; var setSpecies = __webpack_require__("2626"); var wellKnownSymbol = __webpack_require__("b622"); var MATCH = wellKnownSymbol('match'); var NativeRegExp = global.RegExp; var RegExpPrototype = NativeRegExp.prototype; var re1 = /a/g; var re2 = /a/g; // "new" should create a new object, old webkit bug var CORRECT_NEW = new NativeRegExp(re1) !== re1; var UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y; var FORCED = DESCRIPTORS && isForced('RegExp', (!CORRECT_NEW || UNSUPPORTED_Y || fails(function () { re2[MATCH] = false; // RegExp constructor can alter flags and IsRegExp works correct with @@match return NativeRegExp(re1) != re1 || NativeRegExp(re2) == re2 || NativeRegExp(re1, 'i') != '/a/i'; }))); // `RegExp` constructor // https://tc39.es/ecma262/#sec-regexp-constructor if (FORCED) { var RegExpWrapper = function RegExp(pattern, flags) { var thisIsRegExp = this instanceof RegExpWrapper; var patternIsRegExp = isRegExp(pattern); var flagsAreUndefined = flags === undefined; var sticky; if (!thisIsRegExp && patternIsRegExp && pattern.constructor === RegExpWrapper && flagsAreUndefined) { return pattern; } if (CORRECT_NEW) { if (patternIsRegExp && !flagsAreUndefined) pattern = pattern.source; } else if (pattern instanceof RegExpWrapper) { if (flagsAreUndefined) flags = getFlags.call(pattern); pattern = pattern.source; } if (UNSUPPORTED_Y) { sticky = !!flags && flags.indexOf('y') > -1; if (sticky) flags = flags.replace(/y/g, ''); } var result = inheritIfRequired( CORRECT_NEW ? new NativeRegExp(pattern, flags) : NativeRegExp(pattern, flags), thisIsRegExp ? this : RegExpPrototype, RegExpWrapper ); if (UNSUPPORTED_Y && sticky) { var state = enforceInternalState(result); state.sticky = true; } return result; }; var proxy = function (key) { key in RegExpWrapper || defineProperty(RegExpWrapper, key, { configurable: true, get: function () { return NativeRegExp[key]; }, set: function (it) { NativeRegExp[key] = it; } }); }; var keys = getOwnPropertyNames(NativeRegExp); var index = 0; while (keys.length > index) proxy(keys[index++]); RegExpPrototype.constructor = RegExpWrapper; RegExpWrapper.prototype = RegExpPrototype; redefine(global, 'RegExp', RegExpWrapper); } // https://tc39.es/ecma262/#sec-get-regexp-@@species setSpecies('RegExp'); /***/ }), /***/ "4d64": /***/ (function(module, exports, __webpack_require__) { var toIndexedObject = __webpack_require__("fc6a"); var toLength = __webpack_require__("50c4"); var toAbsoluteIndex = __webpack_require__("23cb"); // `Array.prototype.{ indexOf, includes }` methods implementation var createMethod = function (IS_INCLUDES) { return function ($this, el, fromIndex) { var O = toIndexedObject($this); var length = toLength(O.length); var index = toAbsoluteIndex(fromIndex, length); var value; // Array#includes uses SameValueZero equality algorithm // eslint-disable-next-line no-self-compare -- NaN check if (IS_INCLUDES && el != el) while (length > index) { value = O[index++]; // eslint-disable-next-line no-self-compare -- NaN check if (value != value) return true; // Array#indexOf ignores holes, Array#includes - not } else for (;length > index; index++) { if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0; } return !IS_INCLUDES && -1; }; }; module.exports = { // `Array.prototype.includes` method // https://tc39.es/ecma262/#sec-array.prototype.includes includes: createMethod(true), // `Array.prototype.indexOf` method // https://tc39.es/ecma262/#sec-array.prototype.indexof indexOf: createMethod(false) }; /***/ }), /***/ "50c4": /***/ (function(module, exports, __webpack_require__) { var toInteger = __webpack_require__("a691"); var min = Math.min; // `ToLength` abstract operation // https://tc39.es/ecma262/#sec-tolength module.exports = function (argument) { return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991 }; /***/ }), /***/ "5135": /***/ (function(module, exports, __webpack_require__) { var toObject = __webpack_require__("7b0b"); var hasOwnProperty = {}.hasOwnProperty; module.exports = Object.hasOwn || function hasOwn(it, key) { return hasOwnProperty.call(toObject(it), key); }; /***/ }), /***/ "5692": /***/ (function(module, exports, __webpack_require__) { var IS_PURE = __webpack_require__("c430"); var store = __webpack_require__("c6cd"); (module.exports = function (key, value) { return store[key] || (store[key] = value !== undefined ? value : {}); })('versions', []).push({ version: '3.14.0', mode: IS_PURE ? 'pure' : 'global', copyright: '© 2021 Denis Pushkarev (zloirock.ru)' }); /***/ }), /***/ "56ef": /***/ (function(module, exports, __webpack_require__) { var getBuiltIn = __webpack_require__("d066"); var getOwnPropertyNamesModule = __webpack_require__("241c"); var getOwnPropertySymbolsModule = __webpack_require__("7418"); var anObject = __webpack_require__("825a"); // all object keys, includes non-enumerable and symbols module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) { var keys = getOwnPropertyNamesModule.f(anObject(it)); var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys; }; /***/ }), /***/ "5c6c": /***/ (function(module, exports) { module.exports = function (bitmap, value) { return { enumerable: !(bitmap & 1), configurable: !(bitmap & 2), writable: !(bitmap & 4), value: value }; }; /***/ }), /***/ "6547": /***/ (function(module, exports, __webpack_require__) { var toInteger = __webpack_require__("a691"); var requireObjectCoercible = __webpack_require__("1d80"); // `String.prototype.{ codePointAt, at }` methods implementation var createMethod = function (CONVERT_TO_STRING) { return function ($this, pos) { var S = String(requireObjectCoercible($this)); var position = toInteger(pos); var size = S.length; var first, second; if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined; first = S.charCodeAt(position); return first < 0xD800 || first > 0xDBFF || position + 1 === size || (second = S.charCodeAt(position + 1)) < 0xDC00 || second > 0xDFFF ? CONVERT_TO_STRING ? S.charAt(position) : first : CONVERT_TO_STRING ? S.slice(position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000; }; }; module.exports = { // `String.prototype.codePointAt` method // https://tc39.es/ecma262/#sec-string.prototype.codepointat codeAt: createMethod(false), // `String.prototype.at` method // https://github.com/mathiasbynens/String.prototype.at charAt: createMethod(true) }; /***/ }), /***/ "69f3": /***/ (function(module, exports, __webpack_require__) { var NATIVE_WEAK_MAP = __webpack_require__("7f9a"); var global = __webpack_require__("da84"); var isObject = __webpack_require__("861d"); var createNonEnumerableProperty = __webpack_require__("9112"); var objectHas = __webpack_require__("5135"); var shared = __webpack_require__("c6cd"); var sharedKey = __webpack_require__("f772"); var hiddenKeys = __webpack_require__("d012"); var OBJECT_ALREADY_INITIALIZED = 'Object already initialized'; var WeakMap = global.WeakMap; var set, get, has; var enforce = function (it) { return has(it) ? get(it) : set(it, {}); }; var getterFor = function (TYPE) { return function (it) { var state; if (!isObject(it) || (state = get(it)).type !== TYPE) { throw TypeError('Incompatible receiver, ' + TYPE + ' required'); } return state; }; }; if (NATIVE_WEAK_MAP || shared.state) { var store = shared.state || (shared.state = new WeakMap()); var wmget = store.get; var wmhas = store.has; var wmset = store.set; set = function (it, metadata) { if (wmhas.call(store, it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED); metadata.facade = it; wmset.call(store, it, metadata); return metadata; }; get = function (it) { return wmget.call(store, it) || {}; }; has = function (it) { return wmhas.call(store, it); }; } else { var STATE = sharedKey('state'); hiddenKeys[STATE] = true; set = function (it, metadata) { if (objectHas(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED); metadata.facade = it; createNonEnumerableProperty(it, STATE, metadata); return metadata; }; get = function (it) { return objectHas(it, STATE) ? it[STATE] : {}; }; has = function (it) { return objectHas(it, STATE); }; } module.exports = { set: set, get: get, has: has, enforce: enforce, getterFor: getterFor }; /***/ }), /***/ "6aa8": /***/ (function(module, exports, __webpack_require__) { "use strict"; // @ts-ignore try { self['workbox:strategies:6.1.5'] && _(); } catch (e) { } /***/ }), /***/ "6eeb": /***/ (function(module, exports, __webpack_require__) { var global = __webpack_require__("da84"); var createNonEnumerableProperty = __webpack_require__("9112"); var has = __webpack_require__("5135"); var setGlobal = __webpack_require__("ce4e"); var inspectSource = __webpack_require__("8925"); var InternalStateModule = __webpack_require__("69f3"); var getInternalState = InternalStateModule.get; var enforceInternalState = InternalStateModule.enforce; var TEMPLATE = String(String).split('String'); (module.exports = function (O, key, value, options) { var unsafe = options ? !!options.unsafe : false; var simple = options ? !!options.enumerable : false; var noTargetGet = options ? !!options.noTargetGet : false; var state; if (typeof value == 'function') { if (typeof key == 'string' && !has(value, 'name')) { createNonEnumerableProperty(value, 'name', key); } state = enforceInternalState(value); if (!state.source) { state.source = TEMPLATE.join(typeof key == 'string' ? key : ''); } } if (O === global) { if (simple) O[key] = value; else setGlobal(key, value); return; } else if (!unsafe) { delete O[key]; } else if (!noTargetGet && O[key]) { simple = true; } if (simple) O[key] = value; else createNonEnumerableProperty(O, key, value); // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative })(Function.prototype, 'toString', function toString() { return typeof this == 'function' && getInternalState(this).source || inspectSource(this); }); /***/ }), /***/ "7156": /***/ (function(module, exports, __webpack_require__) { var isObject = __webpack_require__("861d"); var setPrototypeOf = __webpack_require__("d2bb"); // makes subclassing work correct for wrapped built-ins module.exports = function ($this, dummy, Wrapper) { var NewTarget, NewTargetPrototype; if ( // it can work only with native `setPrototypeOf` setPrototypeOf && // we haven't completely correct pre-ES6 way for getting `new.target`, so use this typeof (NewTarget = dummy.constructor) == 'function' && NewTarget !== Wrapper && isObject(NewTargetPrototype = NewTarget.prototype) && NewTargetPrototype !== Wrapper.prototype ) setPrototypeOf($this, NewTargetPrototype); return $this; }; /***/ }), /***/ "7418": /***/ (function(module, exports) { // eslint-disable-next-line es/no-object-getownpropertysymbols -- safe exports.f = Object.getOwnPropertySymbols; /***/ }), /***/ "7839": /***/ (function(module, exports) { // IE8- don't enum bug keys module.exports = [ 'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'valueOf' ]; /***/ }), /***/ "7b0b": /***/ (function(module, exports, __webpack_require__) { var requireObjectCoercible = __webpack_require__("1d80"); // `ToObject` abstract operation // https://tc39.es/ecma262/#sec-toobject module.exports = function (argument) { return Object(requireObjectCoercible(argument)); }; /***/ }), /***/ "7f9a": /***/ (function(module, exports, __webpack_require__) { var global = __webpack_require__("da84"); var inspectSource = __webpack_require__("8925"); var WeakMap = global.WeakMap; module.exports = typeof WeakMap === 'function' && /native code/.test(inspectSource(WeakMap)); /***/ }), /***/ "825a": /***/ (function(module, exports, __webpack_require__) { var isObject = __webpack_require__("861d"); module.exports = function (it) { if (!isObject(it)) { throw TypeError(String(it) + ' is not an object'); } return it; }; /***/ }), /***/ "83ab": /***/ (function(module, exports, __webpack_require__) { var fails = __webpack_require__("d039"); // Detect IE8's incomplete defineProperty implementation module.exports = !fails(function () { // eslint-disable-next-line es/no-object-defineproperty -- required for testing return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7; }); /***/ }), /***/ "861d": /***/ (function(module, exports) { module.exports = function (it) { return typeof it === 'object' ? it !== null : typeof it === 'function'; }; /***/ }), /***/ "8925": /***/ (function(module, exports, __webpack_require__) { var store = __webpack_require__("c6cd"); var functionToString = Function.toString; // this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper if (typeof store.inspectSource != 'function') { store.inspectSource = function (it) { return functionToString.call(it); }; } module.exports = store.inspectSource; /***/ }), /***/ "8aa5": /***/ (function(module, exports, __webpack_require__) { "use strict"; var charAt = __webpack_require__("6547").charAt; // `AdvanceStringIndex` abstract operation // https://tc39.es/ecma262/#sec-advancestringindex module.exports = function (S, index, unicode) { return index + (unicode ? charAt(S, index).length : 1); }; /***/ }), /***/ "90e3": /***/ (function(module, exports) { var id = 0; var postfix = Math.random(); module.exports = function (key) { return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36); }; /***/ }), /***/ "9112": /***/ (function(module, exports, __webpack_require__) { var DESCRIPTORS = __webpack_require__("83ab"); var definePropertyModule = __webpack_require__("9bf2"); var createPropertyDescriptor = __webpack_require__("5c6c"); module.exports = DESCRIPTORS ? function (object, key, value) { return definePropertyModule.f(object, key, createPropertyDescriptor(1, value)); } : function (object, key, value) { object[key] = value; return object; }; /***/ }), /***/ "9263": /***/ (function(module, exports, __webpack_require__) { "use strict"; /* eslint-disable regexp/no-assertion-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */ /* eslint-disable regexp/no-useless-quantifier -- testing */ var regexpFlags = __webpack_require__("ad6d"); var stickyHelpers = __webpack_require__("9f7f"); var shared = __webpack_require__("5692"); var nativeExec = RegExp.prototype.exec; var nativeReplace = shared('native-string-replace', String.prototype.replace); var patchedExec = nativeExec; var UPDATES_LAST_INDEX_WRONG = (function () { var re1 = /a/; var re2 = /b*/g; nativeExec.call(re1, 'a'); nativeExec.call(re2, 'a'); return re1.lastIndex !== 0 || re2.lastIndex !== 0; })(); var UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y || stickyHelpers.BROKEN_CARET; // nonparticipating capturing group, copied from es5-shim's String#split patch. var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined; var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y; if (PATCH) { patchedExec = function exec(str) { var re = this; var lastIndex, reCopy, match, i; var sticky = UNSUPPORTED_Y && re.sticky; var flags = regexpFlags.call(re); var source = re.source; var charsAdded = 0; var strCopy = str; if (sticky) { flags = flags.replace('y', ''); if (flags.indexOf('g') === -1) { flags += 'g'; } strCopy = String(str).slice(re.lastIndex); // Support anchored sticky behavior. if (re.lastIndex > 0 && (!re.multiline || re.multiline && str[re.lastIndex - 1] !== '\n')) { source = '(?: ' + source + ')'; strCopy = ' ' + strCopy; charsAdded++; } // ^(? + rx + ) is needed, in combination with some str slicing, to // simulate the 'y' flag. reCopy = new RegExp('^(?:' + source + ')', flags); } if (NPCG_INCLUDED) { reCopy = new RegExp('^' + source + '$(?!\\s)', flags); } if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex; match = nativeExec.call(sticky ? reCopy : re, strCopy); if (sticky) { if (match) { match.input = match.input.slice(charsAdded); match[0] = match[0].slice(charsAdded); match.index = re.lastIndex; re.lastIndex += match[0].length; } else re.lastIndex = 0; } else if (UPDATES_LAST_INDEX_WRONG && match) { re.lastIndex = re.global ? match.index + match[0].length : lastIndex; } if (NPCG_INCLUDED && match && match.length > 1) { // Fix browsers whose `exec` methods don't consistently return `undefined` // for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/ nativeReplace.call(match[0], reCopy, function () { for (i = 1; i < arguments.length - 2; i++) { if (arguments[i] === undefined) match[i] = undefined; } }); } return match; }; } module.exports = patchedExec; /***/ }), /***/ "94ca": /***/ (function(module, exports, __webpack_require__) { var fails = __webpack_require__("d039"); var replacement = /#|\.prototype\./; var isForced = function (feature, detection) { var value = data[normalize(feature)]; return value == POLYFILL ? true : value == NATIVE ? false : typeof detection == 'function' ? fails(detection) : !!detection; }; var normalize = isForced.normalize = function (string) { return String(string).replace(replacement, '.').toLowerCase(); }; var data = isForced.data = {}; var NATIVE = isForced.NATIVE = 'N'; var POLYFILL = isForced.POLYFILL = 'P'; module.exports = isForced; /***/ }), /***/ "96cf": /***/ (function(module, exports, __webpack_require__) { /** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ var runtime = (function (exports) { "use strict"; var Op = Object.prototype; var hasOwn = Op.hasOwnProperty; var undefined; // More compressible than void 0. var $Symbol = typeof Symbol === "function" ? Symbol : {}; var iteratorSymbol = $Symbol.iterator || "@@iterator"; var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator"; var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; function define(obj, key, value) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); return obj[key]; } try { // IE 8 has a broken Object.defineProperty that only works on DOM objects. define({}, ""); } catch (err) { define = function(obj, key, value) { return obj[key] = value; }; } function wrap(innerFn, outerFn, self, tryLocsList) { // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator. var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator; var generator = Object.create(protoGenerator.prototype); var context = new Context(tryLocsList || []); // The ._invoke method unifies the implementations of the .next, // .throw, and .return methods. generator._invoke = makeInvokeMethod(innerFn, self, context); return generator; } exports.wrap = wrap; // Try/catch helper to minimize deoptimizations. Returns a completion // record like context.tryEntries[i].completion. This interface could // have been (and was previously) designed to take a closure to be // invoked without arguments, but in all the cases we care about we // already have an existing method we want to call, so there's no need // to create a new function object. We can even get away with assuming // the method takes exactly one argument, since that happens to be true // in every case, so we don't have to touch the arguments object. The // only additional allocation required is the completion record, which // has a stable shape and so hopefully should be cheap to allocate. function tryCatch(fn, obj, arg) { try { return { type: "normal", arg: fn.call(obj, arg) }; } catch (err) { return { type: "throw", arg: err }; } } var GenStateSuspendedStart = "suspendedStart"; var GenStateSuspendedYield = "suspendedYield"; var GenStateExecuting = "executing"; var GenStateCompleted = "completed"; // Returning this object from the innerFn has the same effect as // breaking out of the dispatch switch statement. var ContinueSentinel = {}; // Dummy constructor functions that we use as the .constructor and // .constructor.prototype properties for functions that return Generator // objects. For full spec compliance, you may wish to configure your // minifier not to mangle the names of these two functions. function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} // This is a polyfill for %IteratorPrototype% for environments that // don't natively support it. var IteratorPrototype = {}; IteratorPrototype[iteratorSymbol] = function () { return this; }; var getProto = Object.getPrototypeOf; var NativeIteratorPrototype = getProto && getProto(getProto(values([]))); if (NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) { // This environment has a native %IteratorPrototype%; use it instead // of the polyfill. IteratorPrototype = NativeIteratorPrototype; } var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype); GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype; GeneratorFunctionPrototype.constructor = GeneratorFunction; GeneratorFunction.displayName = define( GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction" ); // Helper for defining the .next, .throw, and .return methods of the // Iterator interface in terms of a single ._invoke method. function defineIteratorMethods(prototype) { ["next", "throw", "return"].forEach(function(method) { define(prototype, method, function(arg) { return this._invoke(method, arg); }); }); } exports.isGeneratorFunction = function(genFun) { var ctor = typeof genFun === "function" && genFun.constructor; return ctor ? ctor === GeneratorFunction || // For the native GeneratorFunction constructor, the best we can // do is to check its .name property. (ctor.displayName || ctor.name) === "GeneratorFunction" : false; }; exports.mark = function(genFun) { if (Object.setPrototypeOf) { Object.setPrototypeOf(genFun, GeneratorFunctionPrototype); } else { genFun.__proto__ = GeneratorFunctionPrototype; define(genFun, toStringTagSymbol, "GeneratorFunction"); } genFun.prototype = Object.create(Gp); return genFun; }; // Within the body of any async function, `await x` is transformed to // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test // `hasOwn.call(value, "__await")` to determine if the yielded value is // meant to be awaited. exports.awrap = function(arg) { return { __await: arg }; }; function AsyncIterator(generator, PromiseImpl) { function invoke(method, arg, resolve, reject) { var record = tryCatch(generator[method], generator, arg); if (record.type === "throw") { reject(record.arg); } else { var result = record.arg; var value = result.value; if (value && typeof value === "object" && hasOwn.call(value, "__await")) { return PromiseImpl.resolve(value.__await).then(function(value) { invoke("next", value, resolve, reject); }, function(err) { invoke("throw", err, resolve, reject); }); } return PromiseImpl.resolve(value).then(function(unwrapped) { // When a yielded Promise is resolved, its final value becomes // the .value of the Promise<{value,done}> result for the // current iteration. result.value = unwrapped; resolve(result); }, function(error) { // If a rejected Promise was yielded, throw the rejection back // into the async generator function so it can be handled there. return invoke("throw", error, resolve, reject); }); } } var previousPromise; function enqueue(method, arg) { function callInvokeWithMethodAndArg() { return new PromiseImpl(function(resolve, reject) { invoke(method, arg, resolve, reject); }); } return previousPromise = // If enqueue has been called before, then we want to wait until // all previous Promises have been resolved before calling invoke, // so that results are always delivered in the correct order. If // enqueue has not been called before, then it is important to // call invoke immediately, without waiting on a callback to fire, // so that the async generator function has the opportunity to do // any necessary setup in a predictable way. This predictability // is why the Promise constructor synchronously invokes its // executor callback, and why async functions synchronously // execute code before the first await. Since we implement simple // async functions in terms of async generators, it is especially // important to get this right, even though it requires care. previousPromise ? previousPromise.then( callInvokeWithMethodAndArg, // Avoid propagating failures to Promises returned by later // invocations of the iterator. callInvokeWithMethodAndArg ) : callInvokeWithMethodAndArg(); } // Define the unified helper method that is used to implement .next, // .throw, and .return (see defineIteratorMethods). this._invoke = enqueue; } defineIteratorMethods(AsyncIterator.prototype); AsyncIterator.prototype[asyncIteratorSymbol] = function () { return this; }; exports.AsyncIterator = AsyncIterator; // Note that simple async functions are implemented on top of // AsyncIterator objects; they just return a Promise for the value of // the final result produced by the iterator. exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) { if (PromiseImpl === void 0) PromiseImpl = Promise; var iter = new AsyncIterator( wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl ); return exports.isGeneratorFunction(outerFn) ? iter // If outerFn is a generator, return the full iterator. : iter.next().then(function(result) { return result.done ? result.value : iter.next(); }); }; function makeInvokeMethod(innerFn, self, context) { var state = GenStateSuspendedStart; return function invoke(method, arg) { if (state === GenStateExecuting) { throw new Error("Generator is already running"); } if (state === GenStateCompleted) { if (method === "throw") { throw arg; } // Be forgiving, per 25.3.3.3.3 of the spec: // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume return doneResult(); } context.method = method; context.arg = arg; while (true) { var delegate = context.delegate; if (delegate) { var delegateResult = maybeInvokeDelegate(delegate, context); if (delegateResult) { if (delegateResult === ContinueSentinel) continue; return delegateResult; } } if (context.method === "next") { // Setting context._sent for legacy support of Babel's // function.sent implementation. context.sent = context._sent = context.arg; } else if (context.method === "throw") { if (state === GenStateSuspendedStart) { state = GenStateCompleted; throw context.arg; } context.dispatchException(context.arg); } else if (context.method === "return") { context.abrupt("return", context.arg); } state = GenStateExecuting; var record = tryCatch(innerFn, self, context); if (record.type === "normal") { // If an exception is thrown from innerFn, we leave state === // GenStateExecuting and loop back for another invocation. state = context.done ? GenStateCompleted : GenStateSuspendedYield; if (record.arg === ContinueSentinel) { continue; } return { value: record.arg, done: context.done }; } else if (record.type === "throw") { state = GenStateCompleted; // Dispatch the exception by looping back around to the // context.dispatchException(context.arg) call above. context.method = "throw"; context.arg = record.arg; } } }; } // Call delegate.iterator[context.method](context.arg) and handle the // result, either by returning a { value, done } result from the // delegate iterator, or by modifying context.method and context.arg, // setting context.delegate to null, and returning the ContinueSentinel. function maybeInvokeDelegate(delegate, context) { var method = delegate.iterator[context.method]; if (method === undefined) { // A .throw or .return when the delegate iterator has no .throw // method always terminates the yield* loop. context.delegate = null; if (context.method === "throw") { // Note: ["return"] must be used for ES3 parsing compatibility. if (delegate.iterator["return"]) { // If the delegate iterator has a return method, give it a // chance to clean up. context.method = "return"; context.arg = undefined; maybeInvokeDelegate(delegate, context); if (context.method === "throw") { // If maybeInvokeDelegate(context) changed context.method from // "return" to "throw", let that override the TypeError below. return ContinueSentinel; } } context.method = "throw"; context.arg = new TypeError( "The iterator does not provide a 'throw' method"); } return ContinueSentinel; } var record = tryCatch(method, delegate.iterator, context.arg); if (record.type === "throw") { context.method = "throw"; context.arg = record.arg; context.delegate = null; return ContinueSentinel; } var info = record.arg; if (! info) { context.method = "throw"; context.arg = new TypeError("iterator result is not an object"); context.delegate = null; return ContinueSentinel; } if (info.done) { // Assign the result of the finished delegate to the temporary // variable specified by delegate.resultName (see delegateYield). context[delegate.resultName] = info.value; // Resume execution at the desired location (see delegateYield). context.next = delegate.nextLoc; // If context.method was "throw" but the delegate handled the // exception, let the outer generator proceed normally. If // context.method was "next", forget context.arg since it has been // "consumed" by the delegate iterator. If context.method was // "return", allow the original .return call to continue in the // outer generator. if (context.method !== "return") { context.method = "next"; context.arg = undefined; } } else { // Re-yield the result returned by the delegate method. return info; } // The delegate iterator is finished, so forget it and continue with // the outer generator. context.delegate = null; return ContinueSentinel; } // Define Generator.prototype.{next,throw,return} in terms of the // unified ._invoke helper method. defineIteratorMethods(Gp); define(Gp, toStringTagSymbol, "Generator"); // A Generator should always return itself as the iterator object when the // @@iterator function is called on it. Some browsers' implementations of the // iterator prototype chain incorrectly implement this, causing the Generator // object to not be returned from this call. This ensures that doesn't happen. // See https://github.com/facebook/regenerator/issues/274 for more details. Gp[iteratorSymbol] = function() { return this; }; Gp.toString = function() { return "[object Generator]"; }; function pushTryEntry(locs) { var entry = { tryLoc: locs[0] }; if (1 in locs) { entry.catchLoc = locs[1]; } if (2 in locs) { entry.finallyLoc = locs[2]; entry.afterLoc = locs[3]; } this.tryEntries.push(entry); } function resetTryEntry(entry) { var record = entry.completion || {}; record.type = "normal"; delete record.arg; entry.completion = record; } function Context(tryLocsList) { // The root entry object (effectively a try statement without a catch // or a finally block) gives us a place to store values thrown from // locations where there is no enclosing try statement. this.tryEntries = [{ tryLoc: "root" }]; tryLocsList.forEach(pushTryEntry, this); this.reset(true); } exports.keys = function(object) { var keys = []; for (var key in object) { keys.push(key); } keys.reverse(); // Rather than returning an object with a next method, we keep // things simple and return the next function itself. return function next() { while (keys.length) { var key = keys.pop(); if (key in object) { next.value = key; next.done = false; return next; } } // To avoid creating an additional object, we just hang the .value // and .done properties off the next function object itself. This // also ensures that the minifier will not anonymize the function. next.done = true; return next; }; }; function values(iterable) { if (iterable) { var iteratorMethod = iterable[iteratorSymbol]; if (iteratorMethod) { return iteratorMethod.call(iterable); } if (typeof iterable.next === "function") { return iterable; } if (!isNaN(iterable.length)) { var i = -1, next = function next() { while (++i < iterable.length) { if (hasOwn.call(iterable, i)) { next.value = iterable[i]; next.done = false; return next; } } next.value = undefined; next.done = true; return next; }; return next.next = next; } } // Return an iterator with no values. return { next: doneResult }; } exports.values = values; function doneResult() { return { value: undefined, done: true }; } Context.prototype = { constructor: Context, reset: function(skipTempReset) { this.prev = 0; this.next = 0; // Resetting context._sent for legacy support of Babel's // function.sent implementation. this.sent = this._sent = undefined; this.done = false; this.delegate = null; this.method = "next"; this.arg = undefined; this.tryEntries.forEach(resetTryEntry); if (!skipTempReset) { for (var name in this) { // Not sure about the optimal order of these conditions: if (name.charAt(0) === "t" && hasOwn.call(this, name) && !isNaN(+name.slice(1))) { this[name] = undefined; } } } }, stop: function() { this.done = true; var rootEntry = this.tryEntries[0]; var rootRecord = rootEntry.completion; if (rootRecord.type === "throw") { throw rootRecord.arg; } return this.rval; }, dispatchException: function(exception) { if (this.done) { throw exception; } var context = this; function handle(loc, caught) { record.type = "throw"; record.arg = exception; context.next = loc; if (caught) { // If the dispatched exception was caught by a catch block, // then let that catch block handle the exception normally. context.method = "next"; context.arg = undefined; } return !! caught; } for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; var record = entry.completion; if (entry.tryLoc === "root") { // Exception thrown outside of any try block that could handle // it, so set the completion value of the entire function to // throw the exception. return handle("end"); } if (entry.tryLoc <= this.prev) { var hasCatch = hasOwn.call(entry, "catchLoc"); var hasFinally = hasOwn.call(entry, "finallyLoc"); if (hasCatch && hasFinally) { if (this.prev < entry.catchLoc) { return handle(entry.catchLoc, true); } else if (this.prev < entry.finallyLoc) { return handle(entry.finallyLoc); } } else if (hasCatch) { if (this.prev < entry.catchLoc) { return handle(entry.catchLoc, true); } } else if (hasFinally) { if (this.prev < entry.finallyLoc) { return handle(entry.finallyLoc); } } else { throw new Error("try statement without catch or finally"); } } } }, abrupt: function(type, arg) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) { var finallyEntry = entry; break; } } if (finallyEntry && (type === "break" || type === "continue") && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc) { // Ignore the finally entry if control is not jumping to a // location outside the try/catch block. finallyEntry = null; } var record = finallyEntry ? finallyEntry.completion : {}; record.type = type; record.arg = arg; if (finallyEntry) { this.method = "next"; this.next = finallyEntry.finallyLoc; return ContinueSentinel; } return this.complete(record); }, complete: function(record, afterLoc) { if (record.type === "throw") { throw record.arg; } if (record.type === "break" || record.type === "continue") { this.next = record.arg; } else if (record.type === "return") { this.rval = this.arg = record.arg; this.method = "return"; this.next = "end"; } else if (record.type === "normal" && afterLoc) { this.next = afterLoc; } return ContinueSentinel; }, finish: function(finallyLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.finallyLoc === finallyLoc) { this.complete(entry.completion, entry.afterLoc); resetTryEntry(entry); return ContinueSentinel; } } }, "catch": function(tryLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc === tryLoc) { var record = entry.completion; if (record.type === "throw") { var thrown = record.arg; resetTryEntry(entry); } return thrown; } } // The context.catch method must only be called with a location // argument that corresponds to a known catch block. throw new Error("illegal catch attempt"); }, delegateYield: function(iterable, resultName, nextLoc) { this.delegate = { iterator: values(iterable), resultName: resultName, nextLoc: nextLoc }; if (this.method === "next") { // Deliberately forget the last sent value so that we don't // accidentally pass it on to the delegate. this.arg = undefined; } return ContinueSentinel; } }; // Regardless of whether this script is executing as a CommonJS module // or not, return the runtime object so that we can declare the variable // regeneratorRuntime in the outer scope, which allows this module to be // injected easily by `bin/regenerator --include-runtime script.js`. return exports; }( // If this script is executing as a CommonJS module, use module.exports // as the regeneratorRuntime namespace. Otherwise create a new empty // object. Either way, the resulting object will be used to initialize // the regeneratorRuntime variable at the top of this file. true ? module.exports : undefined )); try { regeneratorRuntime = runtime; } catch (accidentalStrictMode) { // This module should not be running in strict mode, so the above // assignment should always work unless something is misconfigured. Just // in case runtime.js accidentally runs in strict mode, we can escape // strict mode using a global Function call. This could conceivably fail // if a Content Security Policy forbids using Function, but in that case // the proper solution is to fix the accidental strict mode problem. If // you've misconfigured your bundler to force strict mode and applied a // CSP to forbid Function, and you're not willing to fix either of those // problems, please detail your unique predicament in a GitHub issue. Function("r", "regeneratorRuntime = r")(runtime); } /***/ }), /***/ "9bf2": /***/ (function(module, exports, __webpack_require__) { var DESCRIPTORS = __webpack_require__("83ab"); var IE8_DOM_DEFINE = __webpack_require__("0cfb"); var anObject = __webpack_require__("825a"); var toPrimitive = __webpack_require__("c04e"); // eslint-disable-next-line es/no-object-defineproperty -- safe var $defineProperty = Object.defineProperty; // `Object.defineProperty` method // https://tc39.es/ecma262/#sec-object.defineproperty exports.f = DESCRIPTORS ? $defineProperty : function defineProperty(O, P, Attributes) { anObject(O); P = toPrimitive(P, true); anObject(Attributes); if (IE8_DOM_DEFINE) try { return $defineProperty(O, P, Attributes); } catch (error) { /* empty */ } if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported'); if ('value' in Attributes) O[P] = Attributes.value; return O; }; /***/ }), /***/ "9f7f": /***/ (function(module, exports, __webpack_require__) { "use strict"; var fails = __webpack_require__("d039"); // babel-minify transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError, // so we use an intermediate function. function RE(s, f) { return RegExp(s, f); } exports.UNSUPPORTED_Y = fails(function () { // babel-minify transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError var re = RE('a', 'y'); re.lastIndex = 2; return re.exec('abcd') != null; }); exports.BROKEN_CARET = fails(function () { // https://bugzilla.mozilla.org/show_bug.cgi?id=773687 var re = RE('^r', 'gy'); re.lastIndex = 2; return re.exec('str') != null; }); /***/ }), /***/ "a691": /***/ (function(module, exports) { var ceil = Math.ceil; var floor = Math.floor; // `ToInteger` abstract operation // https://tc39.es/ecma262/#sec-tointeger module.exports = function (argument) { return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument); }; /***/ }), /***/ "ac1f": /***/ (function(module, exports, __webpack_require__) { "use strict"; var $ = __webpack_require__("23e7"); var exec = __webpack_require__("9263"); // `RegExp.prototype.exec` method // https://tc39.es/ecma262/#sec-regexp.prototype.exec $({ target: 'RegExp', proto: true, forced: /./.exec !== exec }, { exec: exec }); /***/ }), /***/ "ad6d": /***/ (function(module, exports, __webpack_require__) { "use strict"; var anObject = __webpack_require__("825a"); // `RegExp.prototype.flags` getter implementation // https://tc39.es/ecma262/#sec-get-regexp.prototype.flags module.exports = function () { var that = anObject(this); var result = ''; if (that.global) result += 'g'; if (that.ignoreCase) result += 'i'; if (that.multiline) result += 'm'; if (that.dotAll) result += 's'; if (that.unicode) result += 'u'; if (that.sticky) result += 'y'; return result; }; /***/ }), /***/ "b041": /***/ (function(module, exports, __webpack_require__) { "use strict"; var TO_STRING_TAG_SUPPORT = __webpack_require__("00ee"); var classof = __webpack_require__("f5df"); // `Object.prototype.toString` method implementation // https://tc39.es/ecma262/#sec-object.prototype.tostring module.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() { return '[object ' + classof(this) + ']'; }; /***/ }), /***/ "b622": /***/ (function(module, exports, __webpack_require__) { var global = __webpack_require__("da84"); var shared = __webpack_require__("5692"); var has = __webpack_require__("5135"); var uid = __webpack_require__("90e3"); var NATIVE_SYMBOL = __webpack_require__("4930"); var USE_SYMBOL_AS_UID = __webpack_require__("fdbf"); var WellKnownSymbolsStore = shared('wks'); var Symbol = global.Symbol; var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid; module.exports = function (name) { if (!has(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) { if (NATIVE_SYMBOL && has(Symbol, name)) { WellKnownSymbolsStore[name] = Symbol[name]; } else { WellKnownSymbolsStore[name] = createWellKnownSymbol('Symbol.' + name); } } return WellKnownSymbolsStore[name]; }; /***/ }), /***/ "c04e": /***/ (function(module, exports, __webpack_require__) { var isObject = __webpack_require__("861d"); // `ToPrimitive` abstract operation // https://tc39.es/ecma262/#sec-toprimitive // instead of the ES6 spec version, we didn't implement @@toPrimitive case // and the second argument - flag - preferred type is a string module.exports = function (input, PREFERRED_STRING) { if (!isObject(input)) return input; var fn, val; if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val; if (typeof (fn = input.valueOf) == 'function' && !isObject(val = fn.call(input))) return val; if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val; throw TypeError("Can't convert object to primitive value"); }; /***/ }), /***/ "c430": /***/ (function(module, exports) { module.exports = false; /***/ }), /***/ "c6b6": /***/ (function(module, exports) { var toString = {}.toString; module.exports = function (it) { return toString.call(it).slice(8, -1); }; /***/ }), /***/ "c6cd": /***/ (function(module, exports, __webpack_require__) { var global = __webpack_require__("da84"); var setGlobal = __webpack_require__("ce4e"); var SHARED = '__core-js_shared__'; var store = global[SHARED] || setGlobal(SHARED, {}); module.exports = store; /***/ }), /***/ "c700": /***/ (function(module, exports, __webpack_require__) { "use strict"; // @ts-ignore try { self['workbox:precaching:6.1.5'] && _(); } catch (e) { } /***/ }), /***/ "c8ba": /***/ (function(module, exports) { var g; // This works in non-strict mode g = (function() { return this; })(); try { // This works if eval is allowed (see CSP) g = g || new Function("return this")(); } catch (e) { // This works if the window reference is available if (typeof window === "object") g = window; } // g can still be undefined, but nothing to do about it... // We return undefined, instead of nothing here, so it's // easier to handle this case. if(!global) { ...} module.exports = g; /***/ }), /***/ "ca84": /***/ (function(module, exports, __webpack_require__) { var has = __webpack_require__("5135"); var toIndexedObject = __webpack_require__("fc6a"); var indexOf = __webpack_require__("4d64").indexOf; var hiddenKeys = __webpack_require__("d012"); module.exports = function (object, names) { var O = toIndexedObject(object); var i = 0; var result = []; var key; for (key in O) !has(hiddenKeys, key) && has(O, key) && result.push(key); // Don't enum bug & hidden keys while (names.length > i) if (has(O, key = names[i++])) { ~indexOf(result, key) || result.push(key); } return result; }; /***/ }), /***/ "cc12": /***/ (function(module, exports, __webpack_require__) { var global = __webpack_require__("da84"); var isObject = __webpack_require__("861d"); var document = global.document; // typeof document.createElement is 'object' in old IE var EXISTS = isObject(document) && isObject(document.createElement); module.exports = function (it) { return EXISTS ? document.createElement(it) : {}; }; /***/ }), /***/ "ce4e": /***/ (function(module, exports, __webpack_require__) { var global = __webpack_require__("da84"); var createNonEnumerableProperty = __webpack_require__("9112"); module.exports = function (key, value) { try { createNonEnumerableProperty(global, key, value); } catch (error) { global[key] = value; } return value; }; /***/ }), /***/ "d012": /***/ (function(module, exports) { module.exports = {}; /***/ }), /***/ "d039": /***/ (function(module, exports) { module.exports = function (exec) { try { return !!exec(); } catch (error) { return true; } }; /***/ }), /***/ "d066": /***/ (function(module, exports, __webpack_require__) { var path = __webpack_require__("428f"); var global = __webpack_require__("da84"); var aFunction = function (variable) { return typeof variable == 'function' ? variable : undefined; }; module.exports = function (namespace, method) { return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global[namespace]) : path[namespace] && path[namespace][method] || global[namespace] && global[namespace][method]; }; /***/ }), /***/ "d1e7": /***/ (function(module, exports, __webpack_require__) { "use strict"; var $propertyIsEnumerable = {}.propertyIsEnumerable; // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; // Nashorn ~ JDK8 bug var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1); // `Object.prototype.propertyIsEnumerable` method implementation // https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) { var descriptor = getOwnPropertyDescriptor(this, V); return !!descriptor && descriptor.enumerable; } : $propertyIsEnumerable; /***/ }), /***/ "d2bb": /***/ (function(module, exports, __webpack_require__) { /* eslint-disable no-proto -- safe */ var anObject = __webpack_require__("825a"); var aPossiblePrototype = __webpack_require__("3bbe"); // `Object.setPrototypeOf` method // https://tc39.es/ecma262/#sec-object.setprototypeof // Works with __proto__ only. Old v8 can't work with null proto objects. // eslint-disable-next-line es/no-object-setprototypeof -- safe module.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () { var CORRECT_SETTER = false; var test = {}; var setter; try { // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe setter = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set; setter.call(test, []); CORRECT_SETTER = test instanceof Array; } catch (error) { /* empty */ } return function setPrototypeOf(O, proto) { anObject(O); aPossiblePrototype(proto); if (CORRECT_SETTER) setter.call(O, proto); else O.__proto__ = proto; return O; }; }() : undefined); /***/ }), /***/ "d3b7": /***/ (function(module, exports, __webpack_require__) { var TO_STRING_TAG_SUPPORT = __webpack_require__("00ee"); var redefine = __webpack_require__("6eeb"); var toString = __webpack_require__("b041"); // `Object.prototype.toString` method // https://tc39.es/ecma262/#sec-object.prototype.tostring if (!TO_STRING_TAG_SUPPORT) { redefine(Object.prototype, 'toString', toString, { unsafe: true }); } /***/ }), /***/ "d784": /***/ (function(module, exports, __webpack_require__) { "use strict"; // TODO: Remove from `core-js@4` since it's moved to entry points __webpack_require__("ac1f"); var redefine = __webpack_require__("6eeb"); var regexpExec = __webpack_require__("9263"); var fails = __webpack_require__("d039"); var wellKnownSymbol = __webpack_require__("b622"); var createNonEnumerableProperty = __webpack_require__("9112"); var SPECIES = wellKnownSymbol('species'); var RegExpPrototype = RegExp.prototype; var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () { // #replace needs built-in support for named groups. // #match works fine because it just return the exec results, even if it has // a "grops" property. var re = /./; re.exec = function () { var result = []; result.groups = { a: '7' }; return result; }; return ''.replace(re, '$') !== '7'; }); // IE <= 11 replaces $0 with the whole match, as if it was $& // https://stackoverflow.com/questions/6024666/getting-ie-to-replace-a-regex-with-the-literal-string-0 var REPLACE_KEEPS_$0 = (function () { // eslint-disable-next-line regexp/prefer-escape-replacement-dollar-char -- required for testing return 'a'.replace(/./, '$0') === '$0'; })(); var REPLACE = wellKnownSymbol('replace'); // Safari <= 13.0.3(?) substitutes nth capture where n>m with an empty string var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = (function () { if (/./[REPLACE]) { return /./[REPLACE]('a', '$0') === ''; } return false; })(); // Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec // Weex JS has frozen built-in prototypes, so use try / catch wrapper var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = !fails(function () { // eslint-disable-next-line regexp/no-empty-group -- required for testing var re = /(?:)/; var originalExec = re.exec; re.exec = function () { return originalExec.apply(this, arguments); }; var result = 'ab'.split(re); return result.length !== 2 || result[0] !== 'a' || result[1] !== 'b'; }); module.exports = function (KEY, length, exec, sham) { var SYMBOL = wellKnownSymbol(KEY); var DELEGATES_TO_SYMBOL = !fails(function () { // String methods call symbol-named RegEp methods var O = {}; O[SYMBOL] = function () { return 7; }; return ''[KEY](O) != 7; }); var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails(function () { // Symbol-named RegExp methods call .exec var execCalled = false; var re = /a/; if (KEY === 'split') { // We can't use real regex here since it causes deoptimization // and serious performance degradation in V8 // https://github.com/zloirock/core-js/issues/306 re = {}; // RegExp[@@split] doesn't call the regex's exec method, but first creates // a new one. We need to return the patched regex when creating the new one. re.constructor = {}; re.constructor[SPECIES] = function () { return re; }; re.flags = ''; re[SYMBOL] = /./[SYMBOL]; } re.exec = function () { execCalled = true; return null; }; re[SYMBOL](''); return !execCalled; }); if ( !DELEGATES_TO_SYMBOL || !DELEGATES_TO_EXEC || (KEY === 'replace' && !( REPLACE_SUPPORTS_NAMED_GROUPS && REPLACE_KEEPS_$0 && !REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE )) || (KEY === 'split' && !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC) ) { var nativeRegExpMethod = /./[SYMBOL]; var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) { var $exec = regexp.exec; if ($exec === regexpExec || $exec === RegExpPrototype.exec) { if (DELEGATES_TO_SYMBOL && !forceStringMethod) { // The native String method already delegates to @@method (this // polyfilled function), leasing to infinite recursion. // We avoid it by directly calling the native @@method method. return { done: true, value: nativeRegExpMethod.call(regexp, str, arg2) }; } return { done: true, value: nativeMethod.call(str, regexp, arg2) }; } return { done: false }; }, { REPLACE_KEEPS_$0: REPLACE_KEEPS_$0, REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE: REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE }); var stringMethod = methods[0]; var regexMethod = methods[1]; redefine(String.prototype, KEY, stringMethod); redefine(RegExpPrototype, SYMBOL, length == 2 // 21.2.5.8 RegExp.prototype[@@replace](string, replaceValue) // 21.2.5.11 RegExp.prototype[@@split](string, limit) ? function (string, arg) { return regexMethod.call(string, this, arg); } // 21.2.5.6 RegExp.prototype[@@match](string) // 21.2.5.9 RegExp.prototype[@@search](string) : function (string) { return regexMethod.call(string, this); } ); } if (sham) createNonEnumerableProperty(RegExpPrototype[SYMBOL], 'sham', true); }; /***/ }), /***/ "d8a5": /***/ (function(module, exports, __webpack_require__) { "use strict"; // @ts-ignore try { self['workbox:expiration:6.1.5'] && _(); } catch (e) { } /***/ }), /***/ "da84": /***/ (function(module, exports, __webpack_require__) { /* WEBPACK VAR INJECTION */(function(global) {var check = function (it) { return it && it.Math == Math && it; }; // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 module.exports = // eslint-disable-next-line es/no-global-this -- safe check(typeof globalThis == 'object' && globalThis) || check(typeof window == 'object' && window) || // eslint-disable-next-line no-restricted-globals -- safe check(typeof self == 'object' && self) || check(typeof global == 'object' && global) || // eslint-disable-next-line no-new-func -- fallback (function () { return this; })() || Function('return this')(); /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__("c8ba"))) /***/ }), /***/ "e6d2": /***/ (function(module, exports, __webpack_require__) { "use strict"; // @ts-ignore try { self['workbox:routing:6.1.5'] && _(); } catch (e) { } /***/ }), /***/ "e893": /***/ (function(module, exports, __webpack_require__) { var has = __webpack_require__("5135"); var ownKeys = __webpack_require__("56ef"); var getOwnPropertyDescriptorModule = __webpack_require__("06cf"); var definePropertyModule = __webpack_require__("9bf2"); module.exports = function (target, source) { var keys = ownKeys(source); var defineProperty = definePropertyModule.f; var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; for (var i = 0; i < keys.length; i++) { var key = keys[i]; if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key)); } }; /***/ }), /***/ "f5df": /***/ (function(module, exports, __webpack_require__) { var TO_STRING_TAG_SUPPORT = __webpack_require__("00ee"); var classofRaw = __webpack_require__("c6b6"); var wellKnownSymbol = __webpack_require__("b622"); var TO_STRING_TAG = wellKnownSymbol('toStringTag'); // ES3 wrong here var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments'; // fallback for IE11 Script Access Denied error var tryGet = function (it, key) { try { return it[key]; } catch (error) { /* empty */ } }; // getting tag from ES6+ `Object.prototype.toString` module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) { var O, tag, result; return it === undefined ? 'Undefined' : it === null ? 'Null' // @@toStringTag case : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == 'string' ? tag // builtinTag case : CORRECT_ARGUMENTS ? classofRaw(O) // ES3 arguments fallback : (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result; }; /***/ }), /***/ "f772": /***/ (function(module, exports, __webpack_require__) { var shared = __webpack_require__("5692"); var uid = __webpack_require__("90e3"); var keys = shared('keys'); module.exports = function (key) { return keys[key] || (keys[key] = uid(key)); }; /***/ }), /***/ "fc6a": /***/ (function(module, exports, __webpack_require__) { // toObject with fallback for non-array-like ES3 strings var IndexedObject = __webpack_require__("44ad"); var requireObjectCoercible = __webpack_require__("1d80"); module.exports = function (it) { return IndexedObject(requireObjectCoercible(it)); }; /***/ }), /***/ "fdbf": /***/ (function(module, exports, __webpack_require__) { /* eslint-disable es/no-symbol -- required for testing */ var NATIVE_SYMBOL = __webpack_require__("4930"); module.exports = NATIVE_SYMBOL && !Symbol.sham && typeof Symbol.iterator == 'symbol'; /***/ }) /******/ });