From dc94feb2a6c43d34591750dfa0a1b67fdbb07c31 Mon Sep 17 00:00:00 2001 From: imsyy Date: Mon, 20 Mar 2023 09:54:29 +0800 Subject: [PATCH] =?UTF-8?q?=E5=AE=8C=E5=96=84=E9=A1=B5=E9=9D=A2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .env | 6 + .gitignore | 28 + .vscode/extensions.json | 3 + README.md | 29 + dev-dist/registerSW.js | 1 + dev-dist/sw.js | 100 + dev-dist/workbox-25adc094.js | 3495 ++++++++++++++++++++++++++++++++ index.html | 13 + package.json | 35 + pnpm-lock.yaml | 3712 ++++++++++++++++++++++++++++++++++ public/ico/error.png | Bin 0 -> 2409 bytes public/ico/favicon.png | Bin 0 -> 6789 bytes public/ico/icon_error.png | Bin 0 -> 2954 bytes public/logo/36kr.png | Bin 0 -> 9168 bytes public/logo/baidu.png | Bin 0 -> 4863 bytes public/logo/bilibili.png | Bin 0 -> 5630 bytes public/logo/ithome.png | Bin 0 -> 1812 bytes public/logo/juejin.png | Bin 0 -> 6298 bytes public/logo/newsqq.png | Bin 0 -> 7936 bytes public/logo/sspai.png | Bin 0 -> 8878 bytes public/logo/thepaper.png | Bin 0 -> 8159 bytes public/logo/tieba.png | Bin 0 -> 14066 bytes public/logo/toutiao.png | Bin 0 -> 5260 bytes public/logo/weibo.png | Bin 0 -> 10723 bytes public/logo/zhihu.png | Bin 0 -> 7772 bytes src/App.vue | 103 + src/api/index.js | 14 + src/api/request.js | 69 + src/components/Footer.vue | 68 + src/components/Header.vue | 291 +++ src/components/HotList.vue | 362 ++++ src/components/Provider.vue | 100 + src/main.js | 18 + src/router/index.js | 18 + src/router/routes.js | 53 + src/store/index.js | 107 + src/style/global.scss | 14 + src/utils/getTime.js | 87 + src/views/404.vue | 38 + src/views/Home.vue | 79 + src/views/List.vue | 358 ++++ src/views/Setting.vue | 209 ++ src/views/Test.vue | 120 ++ vite.config.js | 85 + 44 files changed, 9615 insertions(+) create mode 100644 .env create mode 100644 .gitignore create mode 100644 .vscode/extensions.json create mode 100644 README.md create mode 100644 dev-dist/registerSW.js create mode 100644 dev-dist/sw.js create mode 100644 dev-dist/workbox-25adc094.js create mode 100644 index.html create mode 100644 package.json create mode 100644 pnpm-lock.yaml create mode 100644 public/ico/error.png create mode 100644 public/ico/favicon.png create mode 100644 public/ico/icon_error.png create mode 100644 public/logo/36kr.png create mode 100644 public/logo/baidu.png create mode 100644 public/logo/bilibili.png create mode 100644 public/logo/ithome.png create mode 100644 public/logo/juejin.png create mode 100644 public/logo/newsqq.png create mode 100644 public/logo/sspai.png create mode 100644 public/logo/thepaper.png create mode 100644 public/logo/tieba.png create mode 100644 public/logo/toutiao.png create mode 100644 public/logo/weibo.png create mode 100644 public/logo/zhihu.png create mode 100644 src/App.vue create mode 100644 src/api/index.js create mode 100644 src/api/request.js create mode 100644 src/components/Footer.vue create mode 100644 src/components/Header.vue create mode 100644 src/components/HotList.vue create mode 100644 src/components/Provider.vue create mode 100644 src/main.js create mode 100644 src/router/index.js create mode 100644 src/router/routes.js create mode 100644 src/store/index.js create mode 100644 src/style/global.scss create mode 100644 src/utils/getTime.js create mode 100644 src/views/404.vue create mode 100644 src/views/Home.vue create mode 100644 src/views/List.vue create mode 100644 src/views/Setting.vue create mode 100644 src/views/Test.vue create mode 100644 vite.config.js diff --git a/.env b/.env new file mode 100644 index 0000000..a4b4a9b --- /dev/null +++ b/.env @@ -0,0 +1,6 @@ +# 全局 API 地址 +# VITE_GLOBAL_API="http://localhost:6688" +VITE_GLOBAL_API="https://api-hot.imsyy.top" + +# ICP 备案号 +VITE_ICP = "豫ICP备2022018134号-1" \ No newline at end of file diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..38adffa --- /dev/null +++ b/.gitignore @@ -0,0 +1,28 @@ +# Logs +logs +*.log +npm-debug.log* +yarn-debug.log* +yarn-error.log* +pnpm-debug.log* +lerna-debug.log* + +node_modules +.DS_Store +dist +dist-ssr +coverage +*.local + +/cypress/videos/ +/cypress/screenshots/ + +# Editor directories and files +.vscode/* +!.vscode/extensions.json +.idea +*.suo +*.ntvs* +*.njsproj +*.sln +*.sw? diff --git a/.vscode/extensions.json b/.vscode/extensions.json new file mode 100644 index 0000000..c0a6e5a --- /dev/null +++ b/.vscode/extensions.json @@ -0,0 +1,3 @@ +{ + "recommendations": ["Vue.volar", "Vue.vscode-typescript-vue-plugin"] +} diff --git a/README.md b/README.md new file mode 100644 index 0000000..29fda30 --- /dev/null +++ b/README.md @@ -0,0 +1,29 @@ +# DailyHot + +This template should help get you started developing with Vue 3 in Vite. + +## Recommended IDE Setup + +[VSCode](https://code.visualstudio.com/) + [Volar](https://marketplace.visualstudio.com/items?itemName=Vue.volar) (and disable Vetur) + [TypeScript Vue Plugin (Volar)](https://marketplace.visualstudio.com/items?itemName=Vue.vscode-typescript-vue-plugin). + +## Customize configuration + +See [Vite Configuration Reference](https://vitejs.dev/config/). + +## Project Setup + +```sh +npm install +``` + +### Compile and Hot-Reload for Development + +```sh +npm run dev +``` + +### Compile and Minify for Production + +```sh +npm run build +``` diff --git a/dev-dist/registerSW.js b/dev-dist/registerSW.js new file mode 100644 index 0000000..1d5625f --- /dev/null +++ b/dev-dist/registerSW.js @@ -0,0 +1 @@ +if('serviceWorker' in navigator) navigator.serviceWorker.register('/dev-sw.js?dev-sw', { scope: '/', type: 'classic' }) \ No newline at end of file diff --git a/dev-dist/sw.js b/dev-dist/sw.js new file mode 100644 index 0000000..20176c4 --- /dev/null +++ b/dev-dist/sw.js @@ -0,0 +1,100 @@ +/** + * Copyright 2018 Google Inc. All Rights Reserved. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * http://www.apache.org/licenses/LICENSE-2.0 + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// If the loader is already loaded, just stop. +if (!self.define) { + let registry = {}; + + // Used for `eval` and `importScripts` where we can't get script URL by other means. + // In both cases, it's safe to use a global var because those functions are synchronous. + let nextDefineUri; + + const singleRequire = (uri, parentUri) => { + uri = new URL(uri + ".js", parentUri).href; + return registry[uri] || ( + + new Promise(resolve => { + if ("document" in self) { + const script = document.createElement("script"); + script.src = uri; + script.onload = resolve; + document.head.appendChild(script); + } else { + nextDefineUri = uri; + importScripts(uri); + resolve(); + } + }) + + .then(() => { + let promise = registry[uri]; + if (!promise) { + throw new Error(`Module ${uri} didn’t register its module`); + } + return promise; + }) + ); + }; + + self.define = (depsNames, factory) => { + const uri = nextDefineUri || ("document" in self ? document.currentScript.src : "") || location.href; + if (registry[uri]) { + // Module is already loading or loaded. + return; + } + let exports = {}; + const require = depUri => singleRequire(depUri, uri); + const specialDeps = { + module: { uri }, + exports, + require + }; + registry[uri] = Promise.all(depsNames.map( + depName => specialDeps[depName] || require(depName) + )).then(deps => { + factory(...deps); + return exports; + }); + }; +} +define(['./workbox-25adc094'], (function (workbox) { 'use strict'; + + self.skipWaiting(); + workbox.clientsClaim(); + + /** + * The precacheAndRoute() method efficiently caches and responds to + * requests for URLs in the manifest. + * See https://goo.gl/S9QRab + */ + workbox.precacheAndRoute([{ + "url": "registerSW.js", + "revision": "3ca0b8505b4bec776b69afdba2768812" + }, { + "revision": null, + "url": "index.html" + }], {}); + workbox.cleanupOutdatedCaches(); + workbox.registerRoute(new workbox.NavigationRoute(workbox.createHandlerBoundToURL("index.html"), { + allowlist: [/^\/$/] + })); + workbox.registerRoute(/(.*?)\.(woff2|woff|ttf)/, new workbox.CacheFirst({ + "cacheName": "file-cache", + plugins: [] + }), 'GET'); + workbox.registerRoute(/(.*?)\.(webp|png|jpe?g|svg|gif|bmp|psd|tiff|tga|eps)/, new workbox.CacheFirst({ + "cacheName": "image-cache", + plugins: [] + }), 'GET'); + +})); diff --git a/dev-dist/workbox-25adc094.js b/dev-dist/workbox-25adc094.js new file mode 100644 index 0000000..68c0ad2 --- /dev/null +++ b/dev-dist/workbox-25adc094.js @@ -0,0 +1,3495 @@ +define(['exports'], (function (exports) { 'use strict'; + + // @ts-ignore + try { + self['workbox:core:6.5.3'] && _(); + } catch (e) {} + + /* + Copyright 2019 Google LLC + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + const logger = (() => { + // Don't overwrite this value if it's already set. + // See https://github.com/GoogleChrome/workbox/pull/2284#issuecomment-560470923 + if (!('__WB_DISABLE_DEV_LOGS' in self)) { + self.__WB_DISABLE_DEV_LOGS = false; + } + let inGroup = false; + const methodToColorMap = { + debug: `#7f8c8d`, + log: `#2ecc71`, + warn: `#f39c12`, + error: `#c0392b`, + groupCollapsed: `#3498db`, + groupEnd: null // No colored prefix on groupEnd + }; + + const print = function (method, args) { + if (self.__WB_DISABLE_DEV_LOGS) { + return; + } + if (method === 'groupCollapsed') { + // Safari doesn't print all console.groupCollapsed() arguments: + // https://bugs.webkit.org/show_bug.cgi?id=182754 + if (/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) { + console[method](...args); + return; + } + } + const styles = [`background: ${methodToColorMap[method]}`, `border-radius: 0.5em`, `color: white`, `font-weight: bold`, `padding: 2px 0.5em`]; + // When in a group, the workbox prefix is not displayed. + const logPrefix = inGroup ? [] : ['%cworkbox', styles.join(';')]; + console[method](...logPrefix, ...args); + if (method === 'groupCollapsed') { + inGroup = true; + } + if (method === 'groupEnd') { + inGroup = false; + } + }; + // eslint-disable-next-line @typescript-eslint/ban-types + const api = {}; + const loggerMethods = Object.keys(methodToColorMap); + for (const key of loggerMethods) { + const method = key; + api[method] = (...args) => { + print(method, args); + }; + } + return api; + })(); + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + const messages$1 = { + 'invalid-value': ({ + paramName, + validValueDescription, + value + }) => { + if (!paramName || !validValueDescription) { + throw new Error(`Unexpected input to 'invalid-value' error.`); + } + return `The '${paramName}' parameter was given a value with an ` + `unexpected value. ${validValueDescription} Received a value of ` + `${JSON.stringify(value)}.`; + }, + 'not-an-array': ({ + moduleName, + className, + funcName, + paramName + }) => { + if (!moduleName || !className || !funcName || !paramName) { + throw new Error(`Unexpected input to 'not-an-array' error.`); + } + return `The parameter '${paramName}' passed into ` + `'${moduleName}.${className}.${funcName}()' must be an array.`; + }, + 'incorrect-type': ({ + expectedType, + paramName, + moduleName, + className, + funcName + }) => { + if (!expectedType || !paramName || !moduleName || !funcName) { + throw new Error(`Unexpected input to 'incorrect-type' error.`); + } + const classNameStr = className ? `${className}.` : ''; + return `The parameter '${paramName}' passed into ` + `'${moduleName}.${classNameStr}` + `${funcName}()' must be of type ${expectedType}.`; + }, + 'incorrect-class': ({ + expectedClassName, + paramName, + moduleName, + className, + funcName, + isReturnValueProblem + }) => { + if (!expectedClassName || !moduleName || !funcName) { + throw new Error(`Unexpected input to 'incorrect-class' error.`); + } + const classNameStr = className ? `${className}.` : ''; + if (isReturnValueProblem) { + return `The return value from ` + `'${moduleName}.${classNameStr}${funcName}()' ` + `must be an instance of class ${expectedClassName}.`; + } + return `The parameter '${paramName}' passed into ` + `'${moduleName}.${classNameStr}${funcName}()' ` + `must be an instance of class ${expectedClassName}.`; + }, + '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} 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': ({ + thrownErrorMessage + }) => { + if (!thrownErrorMessage) { + 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: '${thrownErrorMessage}'.`; + }, + '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}.`; + }, + 'opaque-streams-source': ({ + type + }) => { + const message = `One of the workbox-streams sources resulted in an ` + `'${type}' response.`; + if (type === 'opaqueredirect') { + return `${message} Please do not use a navigation request that results ` + `in a redirect as a source.`; + } + return `${message} Please ensure your sources are CORS-enabled.`; + } + }; + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + const generatorFunction = (code, details = {}) => { + const message = messages$1[code]; + if (!message) { + throw new Error(`Unable to find message for code '${code}'.`); + } + return message(details); + }; + const messageGenerator = generatorFunction; + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * Workbox errors should be thrown with this class. + * This allows use to ensure the type easily in tests, + * helps developers identify errors from workbox + * easily and allows use to optimise error + * messages correctly. + * + * @private + */ + class WorkboxError extends Error { + /** + * + * @param {string} errorCode The error code that + * identifies this particular error. + * @param {Object=} details Any relevant arguments + * that will help developers identify issues should + * be added as a key on the context object. + */ + constructor(errorCode, details) { + const message = messageGenerator(errorCode, details); + super(message); + this.name = errorCode; + this.details = details; + } + } + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /* + * This method throws if the supplied value is not an array. + * The destructed values are required to produce a meaningful error for users. + * The destructed and restructured object is so it's clear what is + * needed. + */ + const isArray = (value, details) => { + if (!Array.isArray(value)) { + throw new WorkboxError('not-an-array', details); + } + }; + const hasMethod = (object, expectedMethod, details) => { + const type = typeof object[expectedMethod]; + if (type !== 'function') { + details['expectedMethod'] = expectedMethod; + throw new WorkboxError('missing-a-method', details); + } + }; + const isType = (object, expectedType, details) => { + if (typeof object !== expectedType) { + details['expectedType'] = expectedType; + throw new WorkboxError('incorrect-type', details); + } + }; + const isInstance = (object, + // Need the general type to do the check later. + // eslint-disable-next-line @typescript-eslint/ban-types + expectedClass, details) => { + if (!(object instanceof expectedClass)) { + details['expectedClassName'] = expectedClass.name; + throw new WorkboxError('incorrect-class', details); + } + }; + const isOneOf = (value, validValues, details) => { + if (!validValues.includes(value)) { + details['validValueDescription'] = `Valid values are ${JSON.stringify(validValues)}.`; + throw new WorkboxError('invalid-value', details); + } + }; + const isArrayOfClass = (value, + // Need general type to do check later. + expectedClass, + // eslint-disable-line + details) => { + const error = new WorkboxError('not-array-of-class', details); + if (!Array.isArray(value)) { + throw error; + } + for (const item of value) { + if (!(item instanceof expectedClass)) { + throw error; + } + } + }; + const finalAssertExports = { + hasMethod, + isArray, + isInstance, + isOneOf, + isType, + isArrayOfClass + }; + + // @ts-ignore + try { + self['workbox:routing:6.5.3'] && _(); + } catch (e) {} + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * The default HTTP method, 'GET', used when there's no specific method + * configured for a route. + * + * @type {string} + * + * @private + */ + const defaultMethod = 'GET'; + /** + * The list of valid HTTP methods associated with requests that could be routed. + * + * @type {Array} + * + * @private + */ + const validMethods = ['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT']; + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * @param {function()|Object} handler Either a function, or an object with a + * 'handle' method. + * @return {Object} An object with a handle method. + * + * @private + */ + const normalizeHandler = handler => { + if (handler && typeof handler === 'object') { + { + finalAssertExports.hasMethod(handler, 'handle', { + moduleName: 'workbox-routing', + className: 'Route', + funcName: 'constructor', + paramName: 'handler' + }); + } + return handler; + } else { + { + finalAssertExports.isType(handler, 'function', { + moduleName: 'workbox-routing', + className: 'Route', + funcName: 'constructor', + paramName: 'handler' + }); + } + return { + handle: handler + }; + } + }; + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * A `Route` consists of a pair of callback functions, "match" and "handler". + * The "match" callback determine if a route should be used to "handle" a + * request by returning a non-falsy value if it can. The "handler" callback + * is called when there is a match and should return a Promise that resolves + * to a `Response`. + * + * @memberof workbox-routing + */ + class Route { + /** + * Constructor for Route class. + * + * @param {workbox-routing~matchCallback} match + * A callback function that determines whether the route matches a given + * `fetch` event by returning a non-falsy value. + * @param {workbox-routing~handlerCallback} handler A callback + * function that returns a Promise resolving to a Response. + * @param {string} [method='GET'] The HTTP method to match the Route + * against. + */ + constructor(match, handler, method = defaultMethod) { + { + finalAssertExports.isType(match, 'function', { + moduleName: 'workbox-routing', + className: 'Route', + funcName: 'constructor', + paramName: 'match' + }); + if (method) { + finalAssertExports.isOneOf(method, validMethods, { + paramName: 'method' + }); + } + } + // These values are referenced directly by Router so cannot be + // altered by minificaton. + this.handler = normalizeHandler(handler); + this.match = match; + this.method = method; + } + /** + * + * @param {workbox-routing-handlerCallback} handler A callback + * function that returns a Promise resolving to a Response + */ + setCatchHandler(handler) { + this.catchHandler = normalizeHandler(handler); + } + } + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * RegExpRoute makes it easy to create a regular expression based + * {@link 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. + * + * @memberof workbox-routing + * @extends workbox-routing.Route + */ + class RegExpRoute extends Route { + /** + * If the regular expression contains + * [capture groups]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#grouping-back-references}, + * the captured values will be passed to the + * {@link workbox-routing~handlerCallback} `params` + * argument. + * + * @param {RegExp} regExp The regular expression to match against URLs. + * @param {workbox-routing~handlerCallback} handler A callback + * function that returns a Promise resulting in a Response. + * @param {string} [method='GET'] The HTTP method to match the Route + * against. + */ + constructor(regExp, handler, method) { + { + finalAssertExports.isInstance(regExp, RegExp, { + moduleName: 'workbox-routing', + className: 'RegExpRoute', + funcName: 'constructor', + paramName: 'pattern' + }); + } + const match = ({ + url + }) => { + const result = regExp.exec(url.href); + // Return immediately if there's no match. + if (!result) { + return; + } + // Require that the match start at the first character in the URL string + // if it's a cross-origin request. + // See https://github.com/GoogleChrome/workbox/issues/281 for the context + // behind this behavior. + if (url.origin !== location.origin && result.index !== 0) { + { + logger.debug(`The regular expression '${regExp.toString()}' only partially matched ` + `against the cross-origin URL '${url.toString()}'. RegExpRoute's will only ` + `handle cross-origin requests if they match the entire URL.`); + } + return; + } + // If the route matches, but there aren't any capture groups defined, then + // this will return [], which is truthy and therefore sufficient to + // indicate a match. + // If there are capture groups, then it will return their values. + return result.slice(1); + }; + super(match, handler, method); + } + } + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + const getFriendlyURL = url => { + const urlObj = new URL(String(url), location.href); + // See https://github.com/GoogleChrome/workbox/issues/2323 + // We want to include everything, except for the origin if it's same-origin. + return urlObj.href.replace(new RegExp(`^${location.origin}`), ''); + }; + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * The Router can be used to process a `FetchEvent` using one or more + * {@link workbox-routing.Route}, responding with a `Response` 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 workbox-routing + */ + class 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 => { + // event.data is type 'any' + // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access + if (event.data && event.data.type === 'CACHE_URLS') { + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + const { + payload + } = event.data; + { + logger.debug(`Caching URLs from the window`, payload.urlsToCache); + } + const requestPromises = Promise.all(payload.urlsToCache.map(entry => { + if (typeof entry === 'string') { + entry = [entry]; + } + const request = new Request(...entry); + return this.handleRequest({ + request, + event + }); + // TODO(philipwalton): TypeScript errors without this typecast for + // some reason (probably a bug). The real type here should work but + // doesn't: `Array | undefined>`. + })); // TypeScript + event.waitUntil(requestPromises); + // If a MessageChannel was used, reply to the message on success. + if (event.ports && event.ports[0]) { + void 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 + }) { + { + finalAssertExports.isInstance(request, Request, { + moduleName: 'workbox-routing', + className: 'Router', + funcName: 'handleRequest', + paramName: 'options.request' + }); + } + const url = new URL(request.url, location.href); + if (!url.protocol.startsWith('http')) { + { + logger.debug(`Workbox Router only supports URLs that start with 'http'.`); + } + return; + } + const sameOrigin = url.origin === location.origin; + const { + params, + route + } = this.findMatchingRoute({ + event, + request, + sameOrigin, + url + }); + let handler = route && route.handler; + const debugMessages = []; + { + if (handler) { + debugMessages.push([`Found a route to handle this request:`, route]); + if (params) { + debugMessages.push([`Passing the following params to the route's handler:`, params]); + } + } + } + // If we don't have a handler because there was no matching route, then + // fall back to defaultHandler if that's defined. + const method = request.method; + if (!handler && this._defaultHandlerMap.has(method)) { + { + debugMessages.push(`Failed to find a matching route. Falling ` + `back to the default handler for ${method}.`); + } + handler = this._defaultHandlerMap.get(method); + } + if (!handler) { + { + // No handler so Workbox will do nothing. If logs is set of debug + // i.e. verbose, we should print out this information. + logger.debug(`No route found for: ${getFriendlyURL(url)}`); + } + return; + } + { + // We have a handler, meaning Workbox is going to handle the route. + // print the routing details to the console. + logger.groupCollapsed(`Router is responding to: ${getFriendlyURL(url)}`); + debugMessages.forEach(msg => { + if (Array.isArray(msg)) { + logger.log(...msg); + } else { + logger.log(msg); + } + }); + logger.groupEnd(); + } + // Wrap in try and catch in case the handle method throws a synchronous + // error. It should still callback to the catch handler. + let responsePromise; + try { + responsePromise = handler.handle({ + url, + request, + event, + params + }); + } catch (err) { + responsePromise = Promise.reject(err); + } + // Get route's catch handler, if it exists + const catchHandler = route && route.catchHandler; + if (responsePromise instanceof Promise && (this._catchHandler || catchHandler)) { + responsePromise = responsePromise.catch(async err => { + // If there's a route catch handler, process that first + if (catchHandler) { + { + // Still include URL here as it will be async from the console group + // and may not make sense without the URL + logger.groupCollapsed(`Error thrown when responding to: ` + ` ${getFriendlyURL(url)}. Falling back to route's Catch Handler.`); + logger.error(`Error thrown by:`, route); + logger.error(err); + logger.groupEnd(); + } + try { + return await catchHandler.handle({ + url, + request, + event, + params + }); + } catch (catchErr) { + if (catchErr instanceof Error) { + err = catchErr; + } + } + } + if (this._catchHandler) { + { + // Still include URL here as it will be async from the console group + // and may not make sense without the URL + logger.groupCollapsed(`Error thrown when responding to: ` + ` ${getFriendlyURL(url)}. Falling back to global Catch Handler.`); + logger.error(`Error thrown by:`, route); + logger.error(err); + logger.groupEnd(); + } + return this._catchHandler.handle({ + url, + request, + event + }); + } + throw err; + }); + } + return responsePromise; + } + /** + * Checks a request and URL (and optionally an event) against the list of + * registered routes, and if there's a match, returns the corresponding + * route along with any params generated by the match. + * + * @param {Object} options + * @param {URL} options.url + * @param {boolean} options.sameOrigin The result of comparing `url.origin` + * against the current origin. + * @param {Request} options.request The request to match. + * @param {Event} options.event The corresponding event. + * @return {Object} An object with `route` and `params` properties. + * They are populated if a matching route was found or `undefined` + * otherwise. + */ + findMatchingRoute({ + url, + sameOrigin, + request, + event + }) { + const routes = this._routes.get(request.method) || []; + for (const route of routes) { + let params; + // route.match returns type any, not possible to change right now. + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + const matchResult = route.match({ + url, + sameOrigin, + request, + event + }); + if (matchResult) { + { + // Warn developers that using an async matchCallback is almost always + // not the right thing to do. + if (matchResult instanceof Promise) { + logger.warn(`While routing ${getFriendlyURL(url)}, an async ` + `matchCallback function was used. Please convert the ` + `following route to use a synchronous matchCallback function:`, route); + } + } + // See https://github.com/GoogleChrome/workbox/issues/2079 + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + params = matchResult; + if (Array.isArray(params) && params.length === 0) { + // Instead of passing an empty array in as params, use undefined. + params = undefined; + } else if (matchResult.constructor === Object && + // eslint-disable-line + 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 {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 {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 {workbox-routing.Route} route The route to register. + */ + registerRoute(route) { + { + finalAssertExports.isType(route, 'object', { + moduleName: 'workbox-routing', + className: 'Router', + funcName: 'registerRoute', + paramName: 'route' + }); + finalAssertExports.hasMethod(route, 'match', { + moduleName: 'workbox-routing', + className: 'Router', + funcName: 'registerRoute', + paramName: 'route' + }); + finalAssertExports.isType(route.handler, 'object', { + moduleName: 'workbox-routing', + className: 'Router', + funcName: 'registerRoute', + paramName: 'route' + }); + finalAssertExports.hasMethod(route.handler, 'handle', { + moduleName: 'workbox-routing', + className: 'Router', + funcName: 'registerRoute', + paramName: 'route.handler' + }); + finalAssertExports.isType(route.method, 'string', { + moduleName: 'workbox-routing', + className: 'Router', + funcName: 'registerRoute', + paramName: 'route.method' + }); + } + if (!this._routes.has(route.method)) { + this._routes.set(route.method, []); + } + // Give precedence to all of the earlier routes by adding this additional + // route to the end of the array. + this._routes.get(route.method).push(route); + } + /** + * Unregisters a route with the router. + * + * @param {workbox-routing.Route} route The route to unregister. + */ + unregisterRoute(route) { + if (!this._routes.has(route.method)) { + throw new WorkboxError('unregister-route-but-not-found-with-method', { + method: route.method + }); + } + const routeIndex = this._routes.get(route.method).indexOf(route); + if (routeIndex > -1) { + this._routes.get(route.method).splice(routeIndex, 1); + } else { + throw new WorkboxError('unregister-route-route-not-registered'); + } + } + } + + /* + Copyright 2019 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + let defaultRouter; + /** + * Creates a new, singleton Router instance if one does not exist. If one + * does already exist, that instance is returned. + * + * @private + * @return {Router} + */ + const getOrCreateDefaultRouter = () => { + if (!defaultRouter) { + defaultRouter = new Router(); + // The helpers that use the default Router assume these listeners exist. + defaultRouter.addFetchListener(); + defaultRouter.addCacheListener(); + } + return defaultRouter; + }; + + /* + Copyright 2019 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * Easily register a RegExp, string, or function with a caching + * strategy to a singleton Router instance. + * + * This method will generate a Route for you if needed and + * call {@link workbox-routing.Router#registerRoute}. + * + * @param {RegExp|string|workbox-routing.Route~matchCallback|workbox-routing.Route} capture + * If the capture param is a `Route`, all other arguments will be ignored. + * @param {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 {workbox-routing.Route} The generated `Route`. + * + * @memberof workbox-routing + */ + function registerRoute(capture, handler, method) { + let route; + if (typeof capture === 'string') { + const captureUrl = new URL(capture, location.href); + { + if (!(capture.startsWith('/') || capture.startsWith('http'))) { + throw new WorkboxError('invalid-string', { + moduleName: 'workbox-routing', + funcName: 'registerRoute', + paramName: 'capture' + }); + } + // We want to check if Express-style wildcards are in the pathname only. + // TODO: Remove this log message in v4. + const valueToCheck = capture.startsWith('http') ? captureUrl.pathname : capture; + // See https://github.com/pillarjs/path-to-regexp#parameters + const wildcards = '[*:?+]'; + if (new RegExp(`${wildcards}`).exec(valueToCheck)) { + logger.debug(`The '$capture' parameter contains an Express-style wildcard ` + `character (${wildcards}). Strings are now always interpreted as ` + `exact matches; use a RegExp for partial or wildcard matches.`); + } + } + const matchCallback = ({ + url + }) => { + { + if (url.pathname === captureUrl.pathname && url.origin !== captureUrl.origin) { + logger.debug(`${capture} only partially matches the cross-origin URL ` + `${url.toString()}. This route will only handle cross-origin requests ` + `if they match the entire URL.`); + } + } + return url.href === captureUrl.href; + }; + // If `capture` is a string then `handler` and `method` must be present. + route = new Route(matchCallback, handler, method); + } else if (capture instanceof RegExp) { + // If `capture` is a `RegExp` then `handler` and `method` must be present. + route = new RegExpRoute(capture, handler, method); + } else if (typeof capture === 'function') { + // If `capture` is a function then `handler` and `method` must be present. + route = new Route(capture, handler, method); + } else if (capture instanceof Route) { + route = capture; + } else { + throw new WorkboxError('unsupported-route-type', { + moduleName: 'workbox-routing', + funcName: 'registerRoute', + paramName: 'capture' + }); + } + const defaultRouter = getOrCreateDefaultRouter(); + defaultRouter.registerRoute(route); + return route; + } + + /* + 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; + } + }; + + /* + 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 = Object.assign(Object.assign({}, matchOptions), { + ignoreSearch: true + }); + const cacheKeys = await cache.keys(request, keysOptions); + for (const cacheKey of cacheKeys) { + const strippedCacheKeyURL = stripParams(cacheKey.url, ignoreParams); + if (strippedRequestURL === strippedCacheKeyURL) { + return cache.match(cacheKey, matchOptions); + } + } + return; + } + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * The Deferred class composes Promises in a way that allows for them to be + * resolved or rejected from outside the constructor. In most cases promises + * should be used directly, but Deferreds can be necessary when the logic to + * resolve a promise must be separate. + * + * @private + */ + class Deferred { + /** + * Creates a promise and exposes its resolve and reject functions as methods. + */ + constructor() { + this.promise = new Promise((resolve, reject) => { + this.resolve = resolve; + this.reject = reject; + }); + } + } + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + // Callbacks to be executed whenever there's a quota error. + // Can't change Function type right now. + // eslint-disable-next-line @typescript-eslint/ban-types + const quotaErrorCallbacks = new Set(); + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * Runs all of the callback functions, one at a time sequentially, in the order + * in which they were registered. + * + * @memberof workbox-core + * @private + */ + async function executeQuotaErrorCallbacks() { + { + logger.log(`About to run ${quotaErrorCallbacks.size} ` + `callbacks to clean up caches.`); + } + for (const callback of quotaErrorCallbacks) { + await callback(); + { + logger.log(callback, 'is complete.'); + } + } + { + logger.log('Finished running callbacks.'); + } + } + + /* + Copyright 2019 Google LLC + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * Returns a promise that resolves and the passed number of milliseconds. + * This utility is an async/await-friendly version of `setTimeout`. + * + * @param {number} ms + * @return {Promise} + * @private + */ + function timeout(ms) { + return new Promise(resolve => setTimeout(resolve, ms)); + } + + // @ts-ignore + try { + self['workbox:strategies:6.5.3'] && _(); + } catch (e) {} + + /* + 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 + * {@link workbox-strategies.Strategy~handle} or + * {@link 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 workbox-strategies + */ + class StrategyHandler { + /** + * Creates a new instance associated with the passed strategy and event + * that's handling the request. + * + * The constructor also initializes the state that will be passed to each of + * the plugins handling this request. + * + * @param {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] The return value from the + * {@link 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 workbox-strategies.StrategyHandler + */ + /** + * The event associated with this request. + * @name event + * @instance + * @type {ExtendableEvent} + * @memberof 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 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 + * {@link workbox-routing~matchCallback} returned + * a truthy value (it will be that value). + * @name params + * @instance + * @type {*|undefined} + * @memberof workbox-strategies.StrategyHandler + */ + { + finalAssertExports.isInstance(options.event, ExtendableEvent, { + moduleName: 'workbox-strategies', + className: 'StrategyHandler', + funcName: 'constructor', + paramName: 'options.event' + }); + } + Object.assign(this, options); + this.event = options.event; + this._strategy = strategy; + this._handlerDeferred = new Deferred(); + this._extendLifetimePromises = []; + // Copy the plugins list (since it's mutable on the strategy), + // so any mutations don't affect this handler instance. + this._plugins = [...strategy.plugins]; + this._pluginStateMap = new Map(); + for (const plugin of this._plugins) { + this._pluginStateMap.set(plugin, {}); + } + this.event.waitUntil(this._handlerDeferred.promise); + } + /** + * Fetches a given request (and invokes any applicable plugin callback + * methods) using the `fetchOptions` (for non-navigation requests) and + * `plugins` defined on the `Strategy` object. + * + * The following plugin lifecycle methods are invoked when using this method: + * - `requestWillFetch()` + * - `fetchDidSucceed()` + * - `fetchDidFail()` + * + * @param {Request|string} input The URL or request to fetch. + * @return {Promise} + */ + async fetch(input) { + const { + event + } = this; + let request = toRequest(input); + if (request.mode === 'navigate' && event instanceof FetchEvent && event.preloadResponse) { + const possiblePreloadResponse = await event.preloadResponse; + if (possiblePreloadResponse) { + { + logger.log(`Using a preloaded navigation response for ` + `'${getFriendlyURL(request.url)}'`); + } + return possiblePreloadResponse; + } + } + // If there is a fetchDidFail plugin, we need to save a clone of the + // original request before it's either modified by a requestWillFetch + // plugin or before the original request's body is consumed via fetch(). + const originalRequest = this.hasCallback('fetchDidFail') ? request.clone() : null; + try { + for (const cb of this.iterateCallbacks('requestWillFetch')) { + request = await cb({ + request: request.clone(), + event + }); + } + } catch (err) { + if (err instanceof Error) { + throw new WorkboxError('plugin-error-request-will-fetch', { + thrownErrorMessage: err.message + }); + } + } + // The request can be altered by plugins with `requestWillFetch` making + // the original request (most likely from a `fetch` event) different + // from the Request we make. Pass both to `fetchDidFail` to aid debugging. + const pluginFilteredRequest = request.clone(); + try { + let fetchResponse; + // See https://github.com/GoogleChrome/workbox/issues/1796 + fetchResponse = await fetch(request, request.mode === 'navigate' ? undefined : this._strategy.fetchOptions); + if ("development" !== 'production') { + logger.debug(`Network request for ` + `'${getFriendlyURL(request.url)}' returned a response with ` + `status '${fetchResponse.status}'.`); + } + for (const callback of this.iterateCallbacks('fetchDidSucceed')) { + fetchResponse = await callback({ + event, + request: pluginFilteredRequest, + response: fetchResponse + }); + } + return fetchResponse; + } catch (error) { + { + logger.log(`Network request for ` + `'${getFriendlyURL(request.url)}' threw an error.`, error); + } + // `originalRequest` will only exist if a `fetchDidFail` callback + // is being used (see above). + if (originalRequest) { + await this.runCallbacks('fetchDidFail', { + error: 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(); + void 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 = Object.assign(Object.assign({}, matchOptions), { + cacheName + }); + cachedResponse = await caches.match(effectiveRequest, multiMatchOptions); + { + if (cachedResponse) { + logger.debug(`Found a cached response in '${cacheName}'.`); + } else { + logger.debug(`No cached response found in '${cacheName}'.`); + } + } + for (const callback of this.iterateCallbacks('cachedResponseWillBeUsed')) { + cachedResponse = (await callback({ + cacheName, + matchOptions, + cachedResponse, + request: effectiveRequest, + event: this.event + })) || undefined; + } + return cachedResponse; + } + /** + * Puts a request/response pair in the cache (and invokes any applicable + * plugin callback methods) using the `cacheName` and `plugins` defined on + * the strategy object. + * + * The following plugin lifecycle methods are invoked when using this method: + * - cacheKeyWillByUsed() + * - cacheWillUpdate() + * - cacheDidUpdate() + * + * @param {Request|string} key The request or URL to use as the cache key. + * @param {Response} response The response to cache. + * @return {Promise} `false` if a cacheWillUpdate caused the response + * not be cached, and `true` otherwise. + */ + async cachePut(key, response) { + const request = toRequest(key); + // Run in the next task to avoid blocking other cache reads. + // https://github.com/w3c/ServiceWorker/issues/1397 + await timeout(0); + const effectiveRequest = await this.getCacheKey(request, 'write'); + { + if (effectiveRequest.method && effectiveRequest.method !== 'GET') { + throw new WorkboxError('attempt-to-cache-non-get-request', { + url: getFriendlyURL(effectiveRequest.url), + method: effectiveRequest.method + }); + } + // See https://github.com/GoogleChrome/workbox/issues/2818 + const vary = response.headers.get('Vary'); + if (vary) { + logger.debug(`The response for ${getFriendlyURL(effectiveRequest.url)} ` + `has a 'Vary: ${vary}' header. ` + `Consider setting the {ignoreVary: true} option on your strategy ` + `to ensure cache matching and deletion works as expected.`); + } + } + if (!response) { + { + logger.error(`Cannot cache non-existent response for ` + `'${getFriendlyURL(effectiveRequest.url)}'.`); + } + throw new WorkboxError('cache-put-with-no-response', { + url: getFriendlyURL(effectiveRequest.url) + }); + } + const responseToCache = await this._ensureResponseSafeToCache(response); + if (!responseToCache) { + { + logger.debug(`Response '${getFriendlyURL(effectiveRequest.url)}' ` + `will not be cached.`, responseToCache); + } + return false; + } + const { + cacheName, + matchOptions + } = this._strategy; + const cache = await self.caches.open(cacheName); + const hasCacheUpdateCallback = this.hasCallback('cacheDidUpdate'); + const oldResponse = hasCacheUpdateCallback ? await cacheMatchIgnoreParams( + // TODO(philipwalton): the `__WB_REVISION__` param is a precaching + // feature. Consider into ways to only add this behavior if using + // precaching. + cache, effectiveRequest.clone(), ['__WB_REVISION__'], matchOptions) : null; + { + logger.debug(`Updating the '${cacheName}' cache with a new Response ` + `for ${getFriendlyURL(effectiveRequest.url)}.`); + } + try { + await cache.put(effectiveRequest, hasCacheUpdateCallback ? responseToCache.clone() : responseToCache); + } catch (error) { + if (error instanceof 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) { + const key = `${request.url} | ${mode}`; + if (!this._cacheKeys[key]) { + let effectiveRequest = request; + for (const callback of this.iterateCallbacks('cacheKeyWillBeUsed')) { + effectiveRequest = toRequest(await callback({ + mode, + request: effectiveRequest, + event: this.event, + // params has a type any can't change right now. + params: this.params // eslint-disable-line + })); + } + + this._cacheKeys[key] = effectiveRequest; + } + return this._cacheKeys[key]; + } + /** + * 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 + * {@link 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 = Object.assign(Object.assign({}, 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 + * {@link 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 + * {@link 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(null); + } + /** + * 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 (responseToCache) { + if (responseToCache.status !== 200) { + if (responseToCache.status === 0) { + logger.warn(`The response for '${this.request.url}' ` + `is an opaque response. The caching strategy that you're ` + `using will not cache opaque responses by default.`); + } else { + logger.debug(`The response for '${this.request.url}' ` + `returned a status code of '${response.status}' and won't ` + `be cached as a result.`); + } + } + } + } + } + return responseToCache; + } + } + + /* + Copyright 2020 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * An abstract base class that all other strategy classes must extend from: + * + * @memberof workbox-strategies + */ + class Strategy { + /** + * Creates a new instance of the strategy and sets all documented option + * properties as public instance properties. + * + * Note: if a custom strategy class extends the base Strategy class and does + * not need more than these properties, it does not need to define its own + * constructor. + * + * @param {Object} [options] + * @param {string} [options.cacheName] Cache name to store and retrieve + * requests. Defaults to the cache names provided by + * {@link 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 + * {@link 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 + * {@link 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 {@link 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(this, { + event, + request, + params + }); + const responseDone = this._getResponse(handler, request, event); + const handlerDone = this._awaitComplete(responseDone, handler, request, event); + // Return an array of promises, suitable for use with Promise.all(). + return [responseDone, handlerDone]; + } + async _getResponse(handler, request, event) { + await handler.runCallbacks('handlerWillStart', { + event, + request + }); + let response = undefined; + try { + response = await this._handle(request, handler); + // The "official" Strategy subclasses all throw this error automatically, + // but in case a third-party Strategy doesn't, ensure that we have a + // consistent failure when there's no response or an error response. + if (!response || response.type === 'error') { + throw new WorkboxError('no-response', { + url: request.url + }); + } + } catch (error) { + if (error instanceof Error) { + for (const callback of handler.iterateCallbacks('handlerDidError')) { + response = await callback({ + error, + event, + request + }); + if (response) { + break; + } + } + } + if (!response) { + throw error; + } else { + logger.log(`While responding to '${getFriendlyURL(request.url)}', ` + `an ${error instanceof Error ? error.toString() : ''} error occurred. Using a fallback response provided by ` + `a handlerDidError plugin.`); + } + } + for (const callback of handler.iterateCallbacks('handlerWillRespond')) { + response = await callback({ + event, + request, + response + }); + } + return response; + } + async _awaitComplete(responseDone, handler, request, event) { + let response; + let error; + try { + response = await responseDone; + } catch (error) { + // Ignore errors, as response errors should be caught via the `response` + // promise above. The `done` promise will only throw for errors in + // promises passed to `handler.waitUntil()`. + } + try { + await handler.runCallbacks('handlerDidRespond', { + event, + request, + response + }); + await handler.doneWaiting(); + } catch (waitUntilError) { + if (waitUntilError instanceof Error) { + error = waitUntilError; + } + } + await handler.runCallbacks('handlerDidComplete', { + event, + request, + response, + error: error + }); + handler.destroy(); + if (error) { + throw error; + } + } + } + /** + * Classes extending the `Strategy` based class should implement this method, + * and leverage the {@link 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 {workbox-strategies.StrategyHandler} handler + * @return {Promise} + * + * @memberof workbox-strategies.Strategy + */ + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + const messages = { + strategyStart: (strategyName, request) => `Using ${strategyName} to respond to '${getFriendlyURL(request.url)}'`, + printFinalResponse: response => { + if (response) { + logger.groupCollapsed(`View the final response here.`); + logger.log(response || '[No response returned]'); + logger.groupEnd(); + } + } + }; + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * An implementation of a [cache-first](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#cache-first-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 workbox-strategies.Strategy + * @memberof workbox-strategies + */ + class CacheFirst extends Strategy { + /** + * @private + * @param {Request|string} request A request to run this strategy for. + * @param {workbox-strategies.StrategyHandler} handler The event that + * triggered the request. + * @return {Promise} + */ + async _handle(request, handler) { + const logs = []; + { + finalAssertExports.isInstance(request, Request, { + moduleName: 'workbox-strategies', + className: this.constructor.name, + funcName: 'makeRequest', + paramName: 'request' + }); + } + let response = await handler.cacheMatch(request); + let error = undefined; + if (!response) { + { + logs.push(`No response found in the '${this.cacheName}' cache. ` + `Will respond with a network request.`); + } + try { + response = await handler.fetchAndCachePut(request); + } catch (err) { + if (err instanceof Error) { + error = err; + } + } + { + if (response) { + logs.push(`Got response from network.`); + } else { + logs.push(`Unable to get a response from the network.`); + } + } + } else { + { + logs.push(`Found a cached response in the '${this.cacheName}' cache.`); + } + } + { + logger.groupCollapsed(messages.strategyStart(this.constructor.name, request)); + for (const log of logs) { + logger.log(log); + } + messages.printFinalResponse(response); + logger.groupEnd(); + } + if (!response) { + throw new WorkboxError('no-response', { + url: request.url, + error + }); + } + return response; + } + } + + /* + Copyright 2019 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * Claim any currently available clients once the service worker + * becomes active. This is normally used in conjunction with `skipWaiting()`. + * + * @memberof workbox-core + */ + function clientsClaim() { + self.addEventListener('activate', () => self.clients.claim()); + } + + /* + 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; + } + + // @ts-ignore + try { + self['workbox:precaching:6.5.3'] && _(); + } catch (e) {} + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + // 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 workbox-precaching + */ + function createCacheKey(entry) { + if (!entry) { + throw new 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('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 + }; + } + + /* + 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') { + if (state && state.originalRequest && state.originalRequest instanceof Request) { + // TODO: `state` should never be undefined... + const url = state.originalRequest.url; + if (cachedResponse) { + this.notUpdatedURLs.push(url); + } else { + this.updatedURLs.push(url); + } + } + } + return cachedResponse; + }; + } + } + + /* + 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 + }) => { + // Params is type any, can't change right now. + /* eslint-disable */ + const cacheKey = (params === null || params === void 0 ? void 0 : params.cacheKey) || this._precacheController.getCacheKeyForURL(request.url); + /* eslint-enable */ + return cacheKey ? new Request(cacheKey, { + headers: request.headers + }) : request; + }; + this._precacheController = precacheController; + } + } + + /* + 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 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(); + } + } + + /* + 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 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(); + } + } + + /* + 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; + } + + /* + 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 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('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); + } + + /* + 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 {@link workbox-strategies.Strategy} implementation + * specifically designed to work with + * {@link 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 workbox-strategies.Strategy + * @memberof workbox-precaching + */ + class PrecacheStrategy extends Strategy { + /** + * + * @param {Object} [options] + * @param {string} [options.cacheName] Cache name to store and retrieve + * requests. Defaults to the cache names provided by + * {@link workbox-core.cacheNames}. + * @param {Array} [options.plugins] {@link https://developers.google.com/web/tools/workbox/guides/using-plugins|Plugins} + * to use in conjunction with this caching strategy. + * @param {Object} [options.fetchOptions] Values passed along to the + * {@link https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters|init} + * of all fetch() requests made by this strategy. + * @param {Object} [options.matchOptions] The + * {@link https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions|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.copyRedirectedCacheableResponsesPlugin); + } + /** + * @private + * @param {Request|string} request A request to run this strategy for. + * @param {workbox-strategies.StrategyHandler} handler The event that + * triggered the request. + * @return {Promise} + */ + async _handle(request, handler) { + const response = await handler.cacheMatch(request); + if (response) { + return response; + } + // If this is an `install` event for an entry that isn't already cached, + // then populate the cache. + if (handler.event && handler.event.type === 'install') { + return await this._handleInstall(request, handler); + } + // Getting here means something went wrong. An entry that should have been + // precached wasn't found in the cache. + return await this._handleFetch(request, handler); + } + async _handleFetch(request, handler) { + let response; + const params = handler.params || {}; + // Fall back to the network if we're configured to do so. + if (this._fallbackToNetwork) { + { + logger.warn(`The precached response for ` + `${getFriendlyURL(request.url)} in ${this.cacheName} was not ` + `found. Falling back to the network.`); + } + const integrityInManifest = params.integrity; + const integrityInRequest = request.integrity; + const noIntegrityConflict = !integrityInRequest || integrityInRequest === integrityInManifest; + // Do not add integrity if the original request is no-cors + // See https://github.com/GoogleChrome/workbox/issues/3096 + response = await handler.fetch(new Request(request, { + integrity: request.mode !== 'no-cors' ? integrityInRequest || integrityInManifest : undefined + })); + // It's only "safe" to repair the cache if we're using SRI to guarantee + // that the response matches the precache manifest's expectations, + // and there's either a) no integrity property in the incoming request + // or b) there is an integrity, and it matches the precache manifest. + // See https://github.com/GoogleChrome/workbox/issues/2858 + // Also if the original request users no-cors we don't use integrity. + // See https://github.com/GoogleChrome/workbox/issues/3096 + if (integrityInManifest && noIntegrityConflict && request.mode !== 'no-cors') { + this._useDefaultCacheabilityPluginIfNeeded(); + const wasCached = await handler.cachePut(request, response.clone()); + { + if (wasCached) { + logger.log(`A response for ${getFriendlyURL(request.url)} ` + `was used to "repair" the precache.`); + } + } + } + } else { + // This shouldn't normally happen, but there are edge cases: + // https://github.com/GoogleChrome/workbox/issues/1441 + throw new WorkboxError('missing-precache-entry', { + cacheName: this.cacheName, + url: request.url + }); + } + { + const cacheKey = params.cacheKey || (await handler.getCacheKey(request, 'read')); + // Workbox is going to handle the route. + // print the routing details to the console. + logger.groupCollapsed(`Precaching is responding to: ` + getFriendlyURL(request.url)); + logger.log(`Serving the precached url: ${getFriendlyURL(cacheKey instanceof Request ? cacheKey.url : cacheKey)}`); + logger.groupCollapsed(`View request details here.`); + logger.log(request); + logger.groupEnd(); + logger.groupCollapsed(`View response details here.`); + logger.log(response); + logger.groupEnd(); + logger.groupEnd(); + } + 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('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.copyRedirectedCacheableResponsesPlugin) { + continue; + } + // Save the default plugin's index, in case it needs to be removed. + if (plugin === PrecacheStrategy.defaultPrecacheCacheabilityPlugin) { + defaultPluginIndex = index; + } + if (plugin.cacheWillUpdate) { + cacheWillUpdatePluginCount++; + } + } + if (cacheWillUpdatePluginCount === 0) { + this.plugins.push(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.defaultPrecacheCacheabilityPlugin = { + async cacheWillUpdate({ + response + }) { + if (!response || response.status >= 400) { + return null; + } + return response; + } + }; + PrecacheStrategy.copyRedirectedCacheableResponsesPlugin = { + async cacheWillUpdate({ + response + }) { + return response.redirected ? await copyResponse(response) : response; + } + }; + + /* + Copyright 2019 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * Performs efficient precaching of assets. + * + * @memberof workbox-precaching + */ + class 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({ + 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 {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 + * {@link workbox-core.cacheNames|"precache cache"} 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) { + { + finalAssertExports.isArray(entries, { + moduleName: 'workbox-precaching', + className: 'PrecacheController', + funcName: 'addToCacheList', + paramName: 'entries' + }); + } + 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('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('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`; + { + logger.warn(warningMessage); + } + } + } + } + /** + * 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) { + // waitUntil returns Promise + // eslint-disable-next-line @typescript-eslint/no-unsafe-return + 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; + { + printInstallDetails(updatedURLs, notUpdatedURLs); + } + 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) { + // waitUntil returns Promise + // eslint-disable-next-line @typescript-eslint/no-unsafe-return + 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); + } + } + { + printCleanupDetails(deletedURLs); + } + 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); + } + /** + * @param {string} url A cache key whose SRI you want to look up. + * @return {string} The subresource integrity associated with the cache key, + * or undefined if it's not set. + */ + getIntegrityForCacheKey(cacheKey) { + return this._cacheKeysToIntegrities.get(cacheKey); + } + /** + * 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 {workbox-routing~handlerCallback} + */ + createHandlerBoundToURL(url) { + const cacheKey = this.getCacheKeyForURL(url); + if (!cacheKey) { + throw new WorkboxError('non-precached-url', { + url + }); + } + return options => { + options.request = new Request(url); + options.params = Object.assign({ + cacheKey + }, options.params); + return this.strategy.handle(options); + }; + } + } + + /* + 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 precacheController; + /** + * @return {PrecacheController} + * @private + */ + const getOrCreatePrecacheController = () => { + if (!precacheController) { + precacheController = new PrecacheController(); + } + return precacheController; + }; + + /* + 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 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; + } + + /* + 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 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; + } + } + } + + /* + 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 {@link workbox-routing.Route} that takes a + * {@link workbox-precaching.PrecacheController} + * instance and uses it to match incoming requests and handle fetching + * responses from the precache. + * + * @memberof workbox-precaching + * @extends workbox-routing.Route + */ + class PrecacheRoute extends 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 {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) { + const integrity = precacheController.getIntegrityForCacheKey(cacheKey); + return { + cacheKey, + integrity + }; + } + } + { + logger.debug(`Precaching did not find a match for ` + getFriendlyURL(request.url)); + } + return; + }; + super(match, precacheController.strategy); + } + } + + /* + 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 the {@link workbox-precaching.PrecacheRoute} + * options. + * + * @memberof workbox-precaching + */ + function addRoute(options) { + const precacheController = getOrCreatePrecacheController(); + const precacheRoute = new PrecacheRoute(precacheController, options); + registerRoute(precacheRoute); + } + + /* + 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 + * {@link workbox-core.cacheNames|"precache cache"} 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 + * {@link workbox-precaching.addRoute}. + * + * If you have a single array of files to precache, you can just call + * {@link workbox-precaching.precacheAndRoute}. + * + * @param {Array} [entries=[]] Array of entries to precache. + * + * @memberof workbox-precaching + */ + function precache(entries) { + const precacheController = getOrCreatePrecacheController(); + precacheController.precache(entries); + } + + /* + 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 + * {@link workbox-precaching.precache} and + * {@link workbox-precaching.addRoute} in a single call. + * + * @param {Array} entries Array of entries to precache. + * @param {Object} [options] See the + * {@link workbox-precaching.PrecacheRoute} options. + * + * @memberof workbox-precaching + */ + function precacheAndRoute(entries, options) { + precache(entries); + addRoute(options); + } + + /* + 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 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; + }; + + /* + 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 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 (cachesDeleted.length > 0) { + logger.log(`The following out-of-date precaches were cleaned up ` + `automatically:`, cachesDeleted); + } + } + })); + }); + } + + /* + 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 + * {@link 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 + * {@link https://fetch.spec.whatwg.org/#concept-request-mode|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 workbox-routing + * @extends workbox-routing.Route + */ + class NavigationRoute extends 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. + * + * *Note*: These RegExps may be evaluated against every destination URL during + * a navigation. Avoid using + * [complex RegExps](https://github.com/GoogleChrome/workbox/issues/3077), + * or else your users may see delays when navigating your site. + * + * @param {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 = [] + } = {}) { + { + finalAssertExports.isArrayOfClass(allowlist, RegExp, { + moduleName: 'workbox-routing', + className: 'NavigationRoute', + funcName: 'constructor', + paramName: 'options.allowlist' + }); + finalAssertExports.isArrayOfClass(denylist, RegExp, { + moduleName: 'workbox-routing', + className: 'NavigationRoute', + funcName: 'constructor', + paramName: 'options.denylist' + }); + } + 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)) { + { + logger.log(`The navigation route ${pathnameAndSearch} is not ` + `being used, since the URL matches this denylist pattern: ` + `${regExp.toString()}`); + } + return false; + } + } + if (this._allowlist.some(regExp => regExp.test(pathnameAndSearch))) { + { + logger.debug(`The navigation route ${pathnameAndSearch} ` + `is being used.`); + } + return true; + } + { + logger.log(`The navigation route ${pathnameAndSearch} is not ` + `being used, since the URL being navigated to doesn't ` + `match the allowlist.`); + } + return false; + } + } + + /* + 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 {workbox-routing~handlerCallback} + * + * @memberof workbox-precaching + */ + function createHandlerBoundToURL(url) { + const precacheController = getOrCreatePrecacheController(); + return precacheController.createHandlerBoundToURL(url); + } + + exports.CacheFirst = CacheFirst; + exports.NavigationRoute = NavigationRoute; + exports.cleanupOutdatedCaches = cleanupOutdatedCaches; + exports.clientsClaim = clientsClaim; + exports.createHandlerBoundToURL = createHandlerBoundToURL; + exports.precacheAndRoute = precacheAndRoute; + exports.registerRoute = registerRoute; + +})); diff --git a/index.html b/index.html new file mode 100644 index 0000000..f64bff5 --- /dev/null +++ b/index.html @@ -0,0 +1,13 @@ + + + + + + + 今日热榜 - 汇聚全网热点，热门尽览无余 + + +
+ + + diff --git a/package.json b/package.json new file mode 100644 index 0000000..4cf3091 --- /dev/null +++ b/package.json @@ -0,0 +1,35 @@ +{ + "name": "dailyhot", + "description": "今日热榜", + "author": "imsyy", + "github": "https://github.com/imsyy", + "version": "0.1.2", + "private": true, + "scripts": { + "dev": "vite", + "build": "vite build", + "preview": "vite preview" + }, + "dependencies": { + "@icon-park/vue-next": "^1.4.2", + "@jridgewell/sourcemap-codec": "^1.4.14", + "axios": "^1.3.3", + "lunar-calendar": "^0.1.4", + "pinia": "^2.0.28", + "pinia-plugin-persistedstate": "^3.1.0", + "sass": "^1.56.1", + "scrollreveal": "^4.0.9", + "terser": "^5.16.5", + "vue": "^3.2.45", + "vue-router": "^4.1.6", + "vuedraggable": "^4.1.0" + }, + "devDependencies": { + "@vitejs/plugin-vue": "^4.0.0", + "naive-ui": "^2.34.3", + "unplugin-auto-import": "^0.12.0", + "unplugin-vue-components": "^0.22.11", + "vite": "^4.0.0", + "vite-plugin-pwa": "^0.14.1" + } +} diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml new file mode 100644 index 0000000..87f1122 --- /dev/null +++ b/pnpm-lock.yaml @@ -0,0 +1,3712 @@ +lockfileVersion: 5.4 + +specifiers: + '@icon-park/vue-next': ^1.4.2 + '@jridgewell/sourcemap-codec': ^1.4.14 + '@vitejs/plugin-vue': ^4.0.0 + axios: ^1.3.3 + lunar-calendar: ^0.1.4 + naive-ui: ^2.34.3 + pinia: ^2.0.28 + pinia-plugin-persistedstate: ^3.1.0 + sass: ^1.56.1 + scrollreveal: ^4.0.9 + terser: ^5.16.5 + unplugin-auto-import: ^0.12.0 + unplugin-vue-components: ^0.22.11 + vite: ^4.0.0 + vite-plugin-pwa: ^0.14.1 + vue: ^3.2.45 + vue-router: ^4.1.6 + vuedraggable: ^4.1.0 + +dependencies: + '@icon-park/vue-next': 1.4.2_vue@3.2.47 + '@jridgewell/sourcemap-codec': 1.4.14 + axios: 1.3.4 + lunar-calendar: 0.1.4 + pinia: 2.0.32_vue@3.2.47 + pinia-plugin-persistedstate: 3.1.0_pinia@2.0.32 + sass: 1.58.3 + scrollreveal: 4.0.9 + terser: 5.16.5 + vue: 3.2.47 + vue-router: 4.1.6_vue@3.2.47 + vuedraggable: 4.1.0_vue@3.2.47 + +devDependencies: + '@vitejs/plugin-vue': 4.0.0_vite@4.1.4+vue@3.2.47 + naive-ui: 2.34.3_vue@3.2.47 + unplugin-auto-import: 0.12.2 + unplugin-vue-components: 0.22.12_vue@3.2.47 + vite: 4.1.4_sass@1.58.3+terser@5.16.5 + vite-plugin-pwa: 0.14.4_vite@4.1.4 + +packages: + + /@ampproject/remapping/2.2.0: + resolution: {integrity: sha512-qRmjj8nj9qmLTQXXmaR1cck3UXSRMPrbsLJAasZpF+t3riI71BXed5ebIOYwQntykeZuhjsdweEc9BxH5Jc26w==} + engines: {node: '>=6.0.0'} + dependencies: + '@jridgewell/gen-mapping': 0.1.1 + '@jridgewell/trace-mapping': 0.3.17 + dev: true + + /@antfu/utils/0.7.2: + resolution: {integrity: sha512-vy9fM3pIxZmX07dL+VX1aZe7ynZ+YyB0jY+jE6r3hOK6GNY2t6W8rzpFC4tgpbXUYABkFQwgJq2XYXlxbXAI0g==} + dev: true + + /@apideck/better-ajv-errors/0.3.6_ajv@8.12.0: + resolution: {integrity: sha512-P+ZygBLZtkp0qqOAJJVX4oX/sFo5JR3eBWwwuqHHhK0GIgQOKWrAfiAaWX0aArHkRWHMuggFEgAZNxVPwPZYaA==} + engines: {node: '>=10'} + peerDependencies: + ajv: '>=8' + dependencies: + ajv: 8.12.0 + json-schema: 0.4.0 + jsonpointer: 5.0.1 + leven: 3.1.0 + dev: true + + /@babel/code-frame/7.18.6: + resolution: {integrity: sha512-TDCmlK5eOvH+eH7cdAFlNXeVJqWIQ7gW9tY1GJIpUtFb6CmjVyq2VM3u71bOyR8CRihcCgMUYoDNyLXao3+70Q==} + engines: {node: '>=6.9.0'} + dependencies: + '@babel/highlight': 7.18.6 + dev: true + + /@babel/compat-data/7.21.0: + resolution: {integrity: sha512-gMuZsmsgxk/ENC3O/fRw5QY8A9/uxQbbCEypnLIiYYc/qVJtEV7ouxC3EllIIwNzMqAQee5tanFabWsUOutS7g==} + engines: {node: '>=6.9.0'} + dev: true + + /@babel/core/7.21.3: + resolution: {integrity: sha512-qIJONzoa/qiHghnm0l1n4i/6IIziDpzqc36FBs4pzMhDUraHqponwJLiAKm1hGLP3OSB/TVNz6rMwVGpwxxySw==} + engines: {node: '>=6.9.0'} + dependencies: + '@ampproject/remapping': 2.2.0 + '@babel/code-frame': 7.18.6 + '@babel/generator': 7.21.3 + '@babel/helper-compilation-targets': 7.20.7_@babel+core@7.21.3 + '@babel/helper-module-transforms': 7.21.2 + '@babel/helpers': 7.21.0 + '@babel/parser': 7.21.3 + '@babel/template': 7.20.7 + '@babel/traverse': 7.21.3 + '@babel/types': 7.21.3 + convert-source-map: 1.9.0 + debug: 4.3.4 + gensync: 1.0.0-beta.2 + json5: 2.2.3 + semver: 6.3.0 + transitivePeerDependencies: + - supports-color + dev: true + + /@babel/generator/7.21.3: + resolution: {integrity: sha512-QS3iR1GYC/YGUnW7IdggFeN5c1poPUurnGttOV/bZgPGV+izC/D8HnD6DLwod0fsatNyVn1G3EVWMYIF0nHbeA==} + engines: {node: '>=6.9.0'} + dependencies: + '@babel/types': 7.21.3 + '@jridgewell/gen-mapping': 0.3.2 + '@jridgewell/trace-mapping': 0.3.17 + jsesc: 2.5.2 + dev: true + + /@babel/helper-annotate-as-pure/7.18.6: + resolution: {integrity: sha512-duORpUiYrEpzKIop6iNbjnwKLAKnJ47csTyRACyEmWj0QdUrm5aqNJGHSSEQSUAvNW0ojX0dOmK9dZduvkfeXA==} + engines: {node: '>=6.9.0'} + dependencies: + '@babel/types': 7.21.3 + dev: true + + /@babel/helper-builder-binary-assignment-operator-visitor/7.18.9: + resolution: {integrity: sha512-yFQ0YCHoIqarl8BCRwBL8ulYUaZpz3bNsA7oFepAzee+8/+ImtADXNOmO5vJvsPff3qi+hvpkY/NYBTrBQgdNw==} + engines: {node: '>=6.9.0'} + dependencies: + '@babel/helper-explode-assignable-expression': 7.18.6 + '@babel/types': 7.21.3 + dev: true + + /@babel/helper-compilation-targets/7.20.7_@babel+core@7.21.3: + resolution: {integrity: sha512-4tGORmfQcrc+bvrjb5y3dG9Mx1IOZjsHqQVUz7XCNHO+iTmqxWnVg3KRygjGmpRLJGdQSKuvFinbIb0CnZwHAQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0 + dependencies: + '@babel/compat-data': 7.21.0 + '@babel/core': 7.21.3 + '@babel/helper-validator-option': 7.21.0 + browserslist: 4.21.5 + lru-cache: 5.1.1 + semver: 6.3.0 + dev: true + + /@babel/helper-create-class-features-plugin/7.21.0_@babel+core@7.21.3: + resolution: {integrity: sha512-Q8wNiMIdwsv5la5SPxNYzzkPnjgC0Sy0i7jLkVOCdllu/xcVNkr3TeZzbHBJrj+XXRqzX5uCyCoV9eu6xUG7KQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-annotate-as-pure': 7.18.6 + '@babel/helper-environment-visitor': 7.18.9 + '@babel/helper-function-name': 7.21.0 + '@babel/helper-member-expression-to-functions': 7.21.0 + '@babel/helper-optimise-call-expression': 7.18.6 + '@babel/helper-replace-supers': 7.20.7 + '@babel/helper-skip-transparent-expression-wrappers': 7.20.0 + '@babel/helper-split-export-declaration': 7.18.6 + transitivePeerDependencies: + - supports-color + dev: true + + /@babel/helper-create-regexp-features-plugin/7.21.0_@babel+core@7.21.3: + resolution: {integrity: sha512-N+LaFW/auRSWdx7SHD/HiARwXQju1vXTW4fKr4u5SgBUTm51OKEjKgj+cs00ggW3kEvNqwErnlwuq7Y3xBe4eg==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-annotate-as-pure': 7.18.6 + regexpu-core: 5.3.2 + dev: true + + /@babel/helper-define-polyfill-provider/0.3.3_@babel+core@7.21.3: + resolution: {integrity: sha512-z5aQKU4IzbqCC1XH0nAqfsFLMVSo22SBKUc0BxGrLkolTdPTructy0ToNnlO2zA4j9Q/7pjMZf0DSY+DSTYzww==} + peerDependencies: + '@babel/core': ^7.4.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-compilation-targets': 7.20.7_@babel+core@7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + debug: 4.3.4 + lodash.debounce: 4.0.8 + resolve: 1.22.1 + semver: 6.3.0 + transitivePeerDependencies: + - supports-color + dev: true + + /@babel/helper-environment-visitor/7.18.9: + resolution: {integrity: sha512-3r/aACDJ3fhQ/EVgFy0hpj8oHyHpQc+LPtJoY9SzTThAsStm4Ptegq92vqKoE3vD706ZVFWITnMnxucw+S9Ipg==} + engines: {node: '>=6.9.0'} + dev: true + + /@babel/helper-explode-assignable-expression/7.18.6: + resolution: {integrity: sha512-eyAYAsQmB80jNfg4baAtLeWAQHfHFiR483rzFK+BhETlGZaQC9bsfrugfXDCbRHLQbIA7U5NxhhOxN7p/dWIcg==} + engines: {node: '>=6.9.0'} + dependencies: + '@babel/types': 7.21.3 + dev: true + + /@babel/helper-function-name/7.21.0: + resolution: {integrity: sha512-HfK1aMRanKHpxemaY2gqBmL04iAPOPRj7DxtNbiDOrJK+gdwkiNRVpCpUJYbUT+aZyemKN8brqTOxzCaG6ExRg==} + engines: {node: '>=6.9.0'} + dependencies: + '@babel/template': 7.20.7 + '@babel/types': 7.21.3 + dev: true + + /@babel/helper-hoist-variables/7.18.6: + resolution: {integrity: sha512-UlJQPkFqFULIcyW5sbzgbkxn2FKRgwWiRexcuaR8RNJRy8+LLveqPjwZV/bwrLZCN0eUHD/x8D0heK1ozuoo6Q==} + engines: {node: '>=6.9.0'} + dependencies: + '@babel/types': 7.21.3 + dev: true + + /@babel/helper-member-expression-to-functions/7.21.0: + resolution: {integrity: sha512-Muu8cdZwNN6mRRNG6lAYErJ5X3bRevgYR2O8wN0yn7jJSnGDu6eG59RfT29JHxGUovyfrh6Pj0XzmR7drNVL3Q==} + engines: {node: '>=6.9.0'} + dependencies: + '@babel/types': 7.21.3 + dev: true + + /@babel/helper-module-imports/7.18.6: + resolution: {integrity: sha512-0NFvs3VkuSYbFi1x2Vd6tKrywq+z/cLeYC/RJNFrIX/30Bf5aiGYbtvGXolEktzJH8o5E5KJ3tT+nkxuuZFVlA==} + engines: {node: '>=6.9.0'} + dependencies: + '@babel/types': 7.21.3 + dev: true + + /@babel/helper-module-transforms/7.21.2: + resolution: {integrity: sha512-79yj2AR4U/Oqq/WOV7Lx6hUjau1Zfo4cI+JLAVYeMV5XIlbOhmjEk5ulbTc9fMpmlojzZHkUUxAiK+UKn+hNQQ==} + engines: {node: '>=6.9.0'} + dependencies: + '@babel/helper-environment-visitor': 7.18.9 + '@babel/helper-module-imports': 7.18.6 + '@babel/helper-simple-access': 7.20.2 + '@babel/helper-split-export-declaration': 7.18.6 + '@babel/helper-validator-identifier': 7.19.1 + '@babel/template': 7.20.7 + '@babel/traverse': 7.21.3 + '@babel/types': 7.21.3 + transitivePeerDependencies: + - supports-color + dev: true + + /@babel/helper-optimise-call-expression/7.18.6: + resolution: {integrity: sha512-HP59oD9/fEHQkdcbgFCnbmgH5vIQTJbxh2yf+CdM89/glUNnuzr87Q8GIjGEnOktTROemO0Pe0iPAYbqZuOUiA==} + engines: {node: '>=6.9.0'} + dependencies: + '@babel/types': 7.21.3 + dev: true + + /@babel/helper-plugin-utils/7.20.2: + resolution: {integrity: sha512-8RvlJG2mj4huQ4pZ+rU9lqKi9ZKiRmuvGuM2HlWmkmgOhbs6zEAw6IEiJ5cQqGbDzGZOhwuOQNtZMi/ENLjZoQ==} + engines: {node: '>=6.9.0'} + dev: true + + /@babel/helper-remap-async-to-generator/7.18.9_@babel+core@7.21.3: + resolution: {integrity: sha512-dI7q50YKd8BAv3VEfgg7PS7yD3Rtbi2J1XMXaalXO0W0164hYLnh8zpjRS0mte9MfVp/tltvr/cfdXPvJr1opA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-annotate-as-pure': 7.18.6 + '@babel/helper-environment-visitor': 7.18.9 + '@babel/helper-wrap-function': 7.20.5 + '@babel/types': 7.21.3 + transitivePeerDependencies: + - supports-color + dev: true + + /@babel/helper-replace-supers/7.20.7: + resolution: {integrity: sha512-vujDMtB6LVfNW13jhlCrp48QNslK6JXi7lQG736HVbHz/mbf4Dc7tIRh1Xf5C0rF7BP8iiSxGMCmY6Ci1ven3A==} + engines: {node: '>=6.9.0'} + dependencies: + '@babel/helper-environment-visitor': 7.18.9 + '@babel/helper-member-expression-to-functions': 7.21.0 + '@babel/helper-optimise-call-expression': 7.18.6 + '@babel/template': 7.20.7 + '@babel/traverse': 7.21.3 + '@babel/types': 7.21.3 + transitivePeerDependencies: + - supports-color + dev: true + + /@babel/helper-simple-access/7.20.2: + resolution: {integrity: sha512-+0woI/WPq59IrqDYbVGfshjT5Dmk/nnbdpcF8SnMhhXObpTq2KNBdLFRFrkVdbDOyUmHBCxzm5FHV1rACIkIbA==} + engines: {node: '>=6.9.0'} + dependencies: + '@babel/types': 7.21.3 + dev: true + + /@babel/helper-skip-transparent-expression-wrappers/7.20.0: + resolution: {integrity: sha512-5y1JYeNKfvnT8sZcK9DVRtpTbGiomYIHviSP3OQWmDPU3DeH4a1ZlT/N2lyQ5P8egjcRaT/Y9aNqUxK0WsnIIg==} + engines: {node: '>=6.9.0'} + dependencies: + '@babel/types': 7.21.3 + dev: true + + /@babel/helper-split-export-declaration/7.18.6: + resolution: {integrity: sha512-bde1etTx6ZyTmobl9LLMMQsaizFVZrquTEHOqKeQESMKo4PlObf+8+JA25ZsIpZhT/WEd39+vOdLXAFG/nELpA==} + engines: {node: '>=6.9.0'} + dependencies: + '@babel/types': 7.21.3 + dev: true + + /@babel/helper-string-parser/7.19.4: + resolution: {integrity: sha512-nHtDoQcuqFmwYNYPz3Rah5ph2p8PFeFCsZk9A/48dPc/rGocJ5J3hAAZ7pb76VWX3fZKu+uEr/FhH5jLx7umrw==} + engines: {node: '>=6.9.0'} + + /@babel/helper-validator-identifier/7.19.1: + resolution: {integrity: sha512-awrNfaMtnHUr653GgGEs++LlAvW6w+DcPrOliSMXWCKo597CwL5Acf/wWdNkf/tfEQE3mjkeD1YOVZOUV/od1w==} + engines: {node: '>=6.9.0'} + + /@babel/helper-validator-option/7.21.0: + resolution: {integrity: sha512-rmL/B8/f0mKS2baE9ZpyTcTavvEuWhTTW8amjzXNvYG4AwBsqTLikfXsEofsJEfKHf+HQVQbFOHy6o+4cnC/fQ==} + engines: {node: '>=6.9.0'} + dev: true + + /@babel/helper-wrap-function/7.20.5: + resolution: {integrity: sha512-bYMxIWK5mh+TgXGVqAtnu5Yn1un+v8DDZtqyzKRLUzrh70Eal2O3aZ7aPYiMADO4uKlkzOiRiZ6GX5q3qxvW9Q==} + engines: {node: '>=6.9.0'} + dependencies: + '@babel/helper-function-name': 7.21.0 + '@babel/template': 7.20.7 + '@babel/traverse': 7.21.3 + '@babel/types': 7.21.3 + transitivePeerDependencies: + - supports-color + dev: true + + /@babel/helpers/7.21.0: + resolution: {integrity: sha512-XXve0CBtOW0pd7MRzzmoyuSj0e3SEzj8pgyFxnTT1NJZL38BD1MK7yYrm8yefRPIDvNNe14xR4FdbHwpInD4rA==} + engines: {node: '>=6.9.0'} + dependencies: + '@babel/template': 7.20.7 + '@babel/traverse': 7.21.3 + '@babel/types': 7.21.3 + transitivePeerDependencies: + - supports-color + dev: true + + /@babel/highlight/7.18.6: + resolution: {integrity: sha512-u7stbOuYjaPezCuLj29hNW1v64M2Md2qupEKP1fHc7WdOA3DgLh37suiSrZYY7haUB7iBeQZ9P1uiRF359do3g==} + engines: {node: '>=6.9.0'} + dependencies: + '@babel/helper-validator-identifier': 7.19.1 + chalk: 2.4.2 + js-tokens: 4.0.0 + dev: true + + /@babel/parser/7.21.2: + resolution: {integrity: sha512-URpaIJQwEkEC2T9Kn+Ai6Xe/02iNaVCuT/PtoRz3GPVJVDpPd7mLo+VddTbhCRU9TXqW5mSrQfXZyi8kDKOVpQ==} + engines: {node: '>=6.0.0'} + hasBin: true + dependencies: + '@babel/types': 7.21.2 + + /@babel/parser/7.21.3: + resolution: {integrity: sha512-lobG0d7aOfQRXh8AyklEAgZGvA4FShxo6xQbUrrT/cNBPUdIDojlokwJsQyCC/eKia7ifqM0yP+2DRZ4WKw2RQ==} + engines: {node: '>=6.0.0'} + hasBin: true + dependencies: + '@babel/types': 7.21.3 + dev: true + + /@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/7.18.6_@babel+core@7.21.3: + resolution: {integrity: sha512-Dgxsyg54Fx1d4Nge8UnvTrED63vrwOdPmyvPzlNN/boaliRP54pm3pGzZD1SJUwrBA+Cs/xdG8kXX6Mn/RfISQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/7.20.7_@babel+core@7.21.3: + resolution: {integrity: sha512-sbr9+wNE5aXMBBFBICk01tt7sBf2Oc9ikRFEcem/ZORup9IMUdNhW7/wVLEbbtlWOsEubJet46mHAL2C8+2jKQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.13.0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + '@babel/helper-skip-transparent-expression-wrappers': 7.20.0 + '@babel/plugin-proposal-optional-chaining': 7.21.0_@babel+core@7.21.3 + dev: true + + /@babel/plugin-proposal-async-generator-functions/7.20.7_@babel+core@7.21.3: + resolution: {integrity: sha512-xMbiLsn/8RK7Wq7VeVytytS2L6qE69bXPB10YCmMdDZbKF4okCqY74pI/jJQ/8U0b/F6NrT2+14b8/P9/3AMGA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-environment-visitor': 7.18.9 + '@babel/helper-plugin-utils': 7.20.2 + '@babel/helper-remap-async-to-generator': 7.18.9_@babel+core@7.21.3 + '@babel/plugin-syntax-async-generators': 7.8.4_@babel+core@7.21.3 + transitivePeerDependencies: + - supports-color + dev: true + + /@babel/plugin-proposal-class-properties/7.18.6_@babel+core@7.21.3: + resolution: {integrity: sha512-cumfXOF0+nzZrrN8Rf0t7M+tF6sZc7vhQwYQck9q1/5w2OExlD+b4v4RpMJFaV1Z7WcDRgO6FqvxqxGlwo+RHQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-create-class-features-plugin': 7.21.0_@babel+core@7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + transitivePeerDependencies: + - supports-color + dev: true + + /@babel/plugin-proposal-class-static-block/7.21.0_@babel+core@7.21.3: + resolution: {integrity: sha512-XP5G9MWNUskFuP30IfFSEFB0Z6HzLIUcjYM4bYOPHXl7eiJ9HFv8tWj6TXTN5QODiEhDZAeI4hLok2iHFFV4hw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.12.0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-create-class-features-plugin': 7.21.0_@babel+core@7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + '@babel/plugin-syntax-class-static-block': 7.14.5_@babel+core@7.21.3 + transitivePeerDependencies: + - supports-color + dev: true + + /@babel/plugin-proposal-dynamic-import/7.18.6_@babel+core@7.21.3: + resolution: {integrity: sha512-1auuwmK+Rz13SJj36R+jqFPMJWyKEDd7lLSdOj4oJK0UTgGueSAtkrCvz9ewmgyU/P941Rv2fQwZJN8s6QruXw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + '@babel/plugin-syntax-dynamic-import': 7.8.3_@babel+core@7.21.3 + dev: true + + /@babel/plugin-proposal-export-namespace-from/7.18.9_@babel+core@7.21.3: + resolution: {integrity: sha512-k1NtHyOMvlDDFeb9G5PhUXuGj8m/wiwojgQVEhJ/fsVsMCpLyOP4h0uGEjYJKrRI+EVPlb5Jk+Gt9P97lOGwtA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + '@babel/plugin-syntax-export-namespace-from': 7.8.3_@babel+core@7.21.3 + dev: true + + /@babel/plugin-proposal-json-strings/7.18.6_@babel+core@7.21.3: + resolution: {integrity: sha512-lr1peyn9kOdbYc0xr0OdHTZ5FMqS6Di+H0Fz2I/JwMzGmzJETNeOFq2pBySw6X/KFL5EWDjlJuMsUGRFb8fQgQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + '@babel/plugin-syntax-json-strings': 7.8.3_@babel+core@7.21.3 + dev: true + + /@babel/plugin-proposal-logical-assignment-operators/7.20.7_@babel+core@7.21.3: + resolution: {integrity: sha512-y7C7cZgpMIjWlKE5T7eJwp+tnRYM89HmRvWM5EQuB5BoHEONjmQ8lSNmBUwOyy/GFRsohJED51YBF79hE1djug==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + '@babel/plugin-syntax-logical-assignment-operators': 7.10.4_@babel+core@7.21.3 + dev: true + + /@babel/plugin-proposal-nullish-coalescing-operator/7.18.6_@babel+core@7.21.3: + resolution: {integrity: sha512-wQxQzxYeJqHcfppzBDnm1yAY0jSRkUXR2z8RePZYrKwMKgMlE8+Z6LUno+bd6LvbGh8Gltvy74+9pIYkr+XkKA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3_@babel+core@7.21.3 + dev: true + + /@babel/plugin-proposal-numeric-separator/7.18.6_@babel+core@7.21.3: + resolution: {integrity: sha512-ozlZFogPqoLm8WBr5Z8UckIoE4YQ5KESVcNudyXOR8uqIkliTEgJ3RoketfG6pmzLdeZF0H/wjE9/cCEitBl7Q==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + '@babel/plugin-syntax-numeric-separator': 7.10.4_@babel+core@7.21.3 + dev: true + + /@babel/plugin-proposal-object-rest-spread/7.20.7_@babel+core@7.21.3: + resolution: {integrity: sha512-d2S98yCiLxDVmBmE8UjGcfPvNEUbA1U5q5WxaWFUGRzJSVAZqm5W6MbPct0jxnegUZ0niLeNX+IOzEs7wYg9Dg==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/compat-data': 7.21.0 + '@babel/core': 7.21.3 + '@babel/helper-compilation-targets': 7.20.7_@babel+core@7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + '@babel/plugin-syntax-object-rest-spread': 7.8.3_@babel+core@7.21.3 + '@babel/plugin-transform-parameters': 7.21.3_@babel+core@7.21.3 + dev: true + + /@babel/plugin-proposal-optional-catch-binding/7.18.6_@babel+core@7.21.3: + resolution: {integrity: sha512-Q40HEhs9DJQyaZfUjjn6vE8Cv4GmMHCYuMGIWUnlxH6400VGxOuwWsPt4FxXxJkC/5eOzgn0z21M9gMT4MOhbw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + '@babel/plugin-syntax-optional-catch-binding': 7.8.3_@babel+core@7.21.3 + dev: true + + /@babel/plugin-proposal-optional-chaining/7.21.0_@babel+core@7.21.3: + resolution: {integrity: sha512-p4zeefM72gpmEe2fkUr/OnOXpWEf8nAgk7ZYVqqfFiyIG7oFfVZcCrU64hWn5xp4tQ9LkV4bTIa5rD0KANpKNA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + '@babel/helper-skip-transparent-expression-wrappers': 7.20.0 + '@babel/plugin-syntax-optional-chaining': 7.8.3_@babel+core@7.21.3 + dev: true + + /@babel/plugin-proposal-private-methods/7.18.6_@babel+core@7.21.3: + resolution: {integrity: sha512-nutsvktDItsNn4rpGItSNV2sz1XwS+nfU0Rg8aCx3W3NOKVzdMjJRu0O5OkgDp3ZGICSTbgRpxZoWsxoKRvbeA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-create-class-features-plugin': 7.21.0_@babel+core@7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + transitivePeerDependencies: + - supports-color + dev: true + + /@babel/plugin-proposal-private-property-in-object/7.21.0_@babel+core@7.21.3: + resolution: {integrity: sha512-ha4zfehbJjc5MmXBlHec1igel5TJXXLDDRbuJ4+XT2TJcyD9/V1919BA8gMvsdHcNMBy4WBUBiRb3nw/EQUtBw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-annotate-as-pure': 7.18.6 + '@babel/helper-create-class-features-plugin': 7.21.0_@babel+core@7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + '@babel/plugin-syntax-private-property-in-object': 7.14.5_@babel+core@7.21.3 + transitivePeerDependencies: + - supports-color + dev: true + + /@babel/plugin-proposal-unicode-property-regex/7.18.6_@babel+core@7.21.3: + resolution: {integrity: sha512-2BShG/d5yoZyXZfVePH91urL5wTG6ASZU9M4o03lKK8u8UW1y08OMttBSOADTcJrnPMpvDXRG3G8fyLh4ovs8w==} + engines: {node: '>=4'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-create-regexp-features-plugin': 7.21.0_@babel+core@7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-syntax-async-generators/7.8.4_@babel+core@7.21.3: + resolution: {integrity: sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-syntax-class-properties/7.12.13_@babel+core@7.21.3: + resolution: {integrity: sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-syntax-class-static-block/7.14.5_@babel+core@7.21.3: + resolution: {integrity: sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-syntax-dynamic-import/7.8.3_@babel+core@7.21.3: + resolution: {integrity: sha512-5gdGbFon+PszYzqs83S3E5mpi7/y/8M9eC90MRTZfduQOYW76ig6SOSPNe41IG5LoP3FGBn2N0RjVDSQiS94kQ==} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-syntax-export-namespace-from/7.8.3_@babel+core@7.21.3: + resolution: {integrity: sha512-MXf5laXo6c1IbEbegDmzGPwGNTsHZmEy6QGznu5Sh2UCWvueywb2ee+CCE4zQiZstxU9BMoQO9i6zUFSY0Kj0Q==} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-syntax-import-assertions/7.20.0_@babel+core@7.21.3: + resolution: {integrity: sha512-IUh1vakzNoWalR8ch/areW7qFopR2AEw03JlG7BbrDqmQ4X3q9uuipQwSGrUn7oGiemKjtSLDhNtQHzMHr1JdQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-syntax-json-strings/7.8.3_@babel+core@7.21.3: + resolution: {integrity: sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-syntax-logical-assignment-operators/7.10.4_@babel+core@7.21.3: + resolution: {integrity: sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-syntax-nullish-coalescing-operator/7.8.3_@babel+core@7.21.3: + resolution: {integrity: sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-syntax-numeric-separator/7.10.4_@babel+core@7.21.3: + resolution: {integrity: sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-syntax-object-rest-spread/7.8.3_@babel+core@7.21.3: + resolution: {integrity: sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-syntax-optional-catch-binding/7.8.3_@babel+core@7.21.3: + resolution: {integrity: sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-syntax-optional-chaining/7.8.3_@babel+core@7.21.3: + resolution: {integrity: sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-syntax-private-property-in-object/7.14.5_@babel+core@7.21.3: + resolution: {integrity: sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-syntax-top-level-await/7.14.5_@babel+core@7.21.3: + resolution: {integrity: sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-transform-arrow-functions/7.20.7_@babel+core@7.21.3: + resolution: {integrity: sha512-3poA5E7dzDomxj9WXWwuD6A5F3kc7VXwIJO+E+J8qtDtS+pXPAhrgEyh+9GBwBgPq1Z+bB+/JD60lp5jsN7JPQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-transform-async-to-generator/7.20.7_@babel+core@7.21.3: + resolution: {integrity: sha512-Uo5gwHPT9vgnSXQxqGtpdufUiWp96gk7yiP4Mp5bm1QMkEmLXBO7PAGYbKoJ6DhAwiNkcHFBol/x5zZZkL/t0Q==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-module-imports': 7.18.6 + '@babel/helper-plugin-utils': 7.20.2 + '@babel/helper-remap-async-to-generator': 7.18.9_@babel+core@7.21.3 + transitivePeerDependencies: + - supports-color + dev: true + + /@babel/plugin-transform-block-scoped-functions/7.18.6_@babel+core@7.21.3: + resolution: {integrity: sha512-ExUcOqpPWnliRcPqves5HJcJOvHvIIWfuS4sroBUenPuMdmW+SMHDakmtS7qOo13sVppmUijqeTv7qqGsvURpQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-transform-block-scoping/7.21.0_@babel+core@7.21.3: + resolution: {integrity: sha512-Mdrbunoh9SxwFZapeHVrwFmri16+oYotcZysSzhNIVDwIAb1UV+kvnxULSYq9J3/q5MDG+4X6w8QVgD1zhBXNQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-transform-classes/7.21.0_@babel+core@7.21.3: + resolution: {integrity: sha512-RZhbYTCEUAe6ntPehC4hlslPWosNHDox+vAs4On/mCLRLfoDVHf6hVEd7kuxr1RnHwJmxFfUM3cZiZRmPxJPXQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-annotate-as-pure': 7.18.6 + '@babel/helper-compilation-targets': 7.20.7_@babel+core@7.21.3 + '@babel/helper-environment-visitor': 7.18.9 + '@babel/helper-function-name': 7.21.0 + '@babel/helper-optimise-call-expression': 7.18.6 + '@babel/helper-plugin-utils': 7.20.2 + '@babel/helper-replace-supers': 7.20.7 + '@babel/helper-split-export-declaration': 7.18.6 + globals: 11.12.0 + transitivePeerDependencies: + - supports-color + dev: true + + /@babel/plugin-transform-computed-properties/7.20.7_@babel+core@7.21.3: + resolution: {integrity: sha512-Lz7MvBK6DTjElHAmfu6bfANzKcxpyNPeYBGEafyA6E5HtRpjpZwU+u7Qrgz/2OR0z+5TvKYbPdphfSaAcZBrYQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + '@babel/template': 7.20.7 + dev: true + + /@babel/plugin-transform-destructuring/7.21.3_@babel+core@7.21.3: + resolution: {integrity: sha512-bp6hwMFzuiE4HqYEyoGJ/V2LeIWn+hLVKc4pnj++E5XQptwhtcGmSayM029d/j2X1bPKGTlsyPwAubuU22KhMA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-transform-dotall-regex/7.18.6_@babel+core@7.21.3: + resolution: {integrity: sha512-6S3jpun1eEbAxq7TdjLotAsl4WpQI9DxfkycRcKrjhQYzU87qpXdknpBg/e+TdcMehqGnLFi7tnFUBR02Vq6wg==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-create-regexp-features-plugin': 7.21.0_@babel+core@7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-transform-duplicate-keys/7.18.9_@babel+core@7.21.3: + resolution: {integrity: sha512-d2bmXCtZXYc59/0SanQKbiWINadaJXqtvIQIzd4+hNwkWBgyCd5F/2t1kXoUdvPMrxzPvhK6EMQRROxsue+mfw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-transform-exponentiation-operator/7.18.6_@babel+core@7.21.3: + resolution: {integrity: sha512-wzEtc0+2c88FVR34aQmiz56dxEkxr2g8DQb/KfaFa1JYXOFVsbhvAonFN6PwVWj++fKmku8NP80plJ5Et4wqHw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-builder-binary-assignment-operator-visitor': 7.18.9 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-transform-for-of/7.21.0_@babel+core@7.21.3: + resolution: {integrity: sha512-LlUYlydgDkKpIY7mcBWvyPPmMcOphEyYA27Ef4xpbh1IiDNLr0kZsos2nf92vz3IccvJI25QUwp86Eo5s6HmBQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-transform-function-name/7.18.9_@babel+core@7.21.3: + resolution: {integrity: sha512-WvIBoRPaJQ5yVHzcnJFor7oS5Ls0PYixlTYE63lCj2RtdQEl15M68FXQlxnG6wdraJIXRdR7KI+hQ7q/9QjrCQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-compilation-targets': 7.20.7_@babel+core@7.21.3 + '@babel/helper-function-name': 7.21.0 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-transform-literals/7.18.9_@babel+core@7.21.3: + resolution: {integrity: sha512-IFQDSRoTPnrAIrI5zoZv73IFeZu2dhu6irxQjY9rNjTT53VmKg9fenjvoiOWOkJ6mm4jKVPtdMzBY98Fp4Z4cg==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-transform-member-expression-literals/7.18.6_@babel+core@7.21.3: + resolution: {integrity: sha512-qSF1ihLGO3q+/g48k85tUjD033C29TNTVB2paCwZPVmOsjn9pClvYYrM2VeJpBY2bcNkuny0YUyTNRyRxJ54KA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-transform-modules-amd/7.20.11_@babel+core@7.21.3: + resolution: {integrity: sha512-NuzCt5IIYOW0O30UvqktzHYR2ud5bOWbY0yaxWZ6G+aFzOMJvrs5YHNikrbdaT15+KNO31nPOy5Fim3ku6Zb5g==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-module-transforms': 7.21.2 + '@babel/helper-plugin-utils': 7.20.2 + transitivePeerDependencies: + - supports-color + dev: true + + /@babel/plugin-transform-modules-commonjs/7.21.2_@babel+core@7.21.3: + resolution: {integrity: sha512-Cln+Yy04Gxua7iPdj6nOV96smLGjpElir5YwzF0LBPKoPlLDNJePNlrGGaybAJkd0zKRnOVXOgizSqPYMNYkzA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-module-transforms': 7.21.2 + '@babel/helper-plugin-utils': 7.20.2 + '@babel/helper-simple-access': 7.20.2 + transitivePeerDependencies: + - supports-color + dev: true + + /@babel/plugin-transform-modules-systemjs/7.20.11_@babel+core@7.21.3: + resolution: {integrity: sha512-vVu5g9BPQKSFEmvt2TA4Da5N+QVS66EX21d8uoOihC+OCpUoGvzVsXeqFdtAEfVa5BILAeFt+U7yVmLbQnAJmw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-hoist-variables': 7.18.6 + '@babel/helper-module-transforms': 7.21.2 + '@babel/helper-plugin-utils': 7.20.2 + '@babel/helper-validator-identifier': 7.19.1 + transitivePeerDependencies: + - supports-color + dev: true + + /@babel/plugin-transform-modules-umd/7.18.6_@babel+core@7.21.3: + resolution: {integrity: sha512-dcegErExVeXcRqNtkRU/z8WlBLnvD4MRnHgNs3MytRO1Mn1sHRyhbcpYbVMGclAqOjdW+9cfkdZno9dFdfKLfQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-module-transforms': 7.21.2 + '@babel/helper-plugin-utils': 7.20.2 + transitivePeerDependencies: + - supports-color + dev: true + + /@babel/plugin-transform-named-capturing-groups-regex/7.20.5_@babel+core@7.21.3: + resolution: {integrity: sha512-mOW4tTzi5iTLnw+78iEq3gr8Aoq4WNRGpmSlrogqaiCBoR1HFhpU4JkpQFOHfeYx3ReVIFWOQJS4aZBRvuZ6mA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-create-regexp-features-plugin': 7.21.0_@babel+core@7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-transform-new-target/7.18.6_@babel+core@7.21.3: + resolution: {integrity: sha512-DjwFA/9Iu3Z+vrAn+8pBUGcjhxKguSMlsFqeCKbhb9BAV756v0krzVK04CRDi/4aqmk8BsHb4a/gFcaA5joXRw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-transform-object-super/7.18.6_@babel+core@7.21.3: + resolution: {integrity: sha512-uvGz6zk+pZoS1aTZrOvrbj6Pp/kK2mp45t2B+bTDre2UgsZZ8EZLSJtUg7m/no0zOJUWgFONpB7Zv9W2tSaFlA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + '@babel/helper-replace-supers': 7.20.7 + transitivePeerDependencies: + - supports-color + dev: true + + /@babel/plugin-transform-parameters/7.21.3_@babel+core@7.21.3: + resolution: {integrity: sha512-Wxc+TvppQG9xWFYatvCGPvZ6+SIUxQ2ZdiBP+PHYMIjnPXD+uThCshaz4NZOnODAtBjjcVQQ/3OKs9LW28purQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-transform-property-literals/7.18.6_@babel+core@7.21.3: + resolution: {integrity: sha512-cYcs6qlgafTud3PAzrrRNbQtfpQ8+y/+M5tKmksS9+M1ckbH6kzY8MrexEM9mcA6JDsukE19iIRvAyYl463sMg==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-transform-regenerator/7.20.5_@babel+core@7.21.3: + resolution: {integrity: sha512-kW/oO7HPBtntbsahzQ0qSE3tFvkFwnbozz3NWFhLGqH75vLEg+sCGngLlhVkePlCs3Jv0dBBHDzCHxNiFAQKCQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + regenerator-transform: 0.15.1 + dev: true + + /@babel/plugin-transform-reserved-words/7.18.6_@babel+core@7.21.3: + resolution: {integrity: sha512-oX/4MyMoypzHjFrT1CdivfKZ+XvIPMFXwwxHp/r0Ddy2Vuomt4HDFGmft1TAY2yiTKiNSsh3kjBAzcM8kSdsjA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-transform-shorthand-properties/7.18.6_@babel+core@7.21.3: + resolution: {integrity: sha512-eCLXXJqv8okzg86ywZJbRn19YJHU4XUa55oz2wbHhaQVn/MM+XhukiT7SYqp/7o00dg52Rj51Ny+Ecw4oyoygw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-transform-spread/7.20.7_@babel+core@7.21.3: + resolution: {integrity: sha512-ewBbHQ+1U/VnH1fxltbJqDeWBU1oNLG8Dj11uIv3xVf7nrQu0bPGe5Rf716r7K5Qz+SqtAOVswoVunoiBtGhxw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + '@babel/helper-skip-transparent-expression-wrappers': 7.20.0 + dev: true + + /@babel/plugin-transform-sticky-regex/7.18.6_@babel+core@7.21.3: + resolution: {integrity: sha512-kfiDrDQ+PBsQDO85yj1icueWMfGfJFKN1KCkndygtu/C9+XUfydLC8Iv5UYJqRwy4zk8EcplRxEOeLyjq1gm6Q==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-transform-template-literals/7.18.9_@babel+core@7.21.3: + resolution: {integrity: sha512-S8cOWfT82gTezpYOiVaGHrCbhlHgKhQt8XH5ES46P2XWmX92yisoZywf5km75wv5sYcXDUCLMmMxOLCtthDgMA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-transform-typeof-symbol/7.18.9_@babel+core@7.21.3: + resolution: {integrity: sha512-SRfwTtF11G2aemAZWivL7PD+C9z52v9EvMqH9BuYbabyPuKUvSWks3oCg6041pT925L4zVFqaVBeECwsmlguEw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-transform-unicode-escapes/7.18.10_@babel+core@7.21.3: + resolution: {integrity: sha512-kKAdAI+YzPgGY/ftStBFXTI1LZFju38rYThnfMykS+IXy8BVx+res7s2fxf1l8I35DV2T97ezo6+SGrXz6B3iQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/plugin-transform-unicode-regex/7.18.6_@babel+core@7.21.3: + resolution: {integrity: sha512-gE7A6Lt7YLnNOL3Pb9BNeZvi+d8l7tcRrG4+pwJjK9hD2xX4mEvjlQW60G9EEmfXVYRPv9VRQcyegIVHCql/AA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-create-regexp-features-plugin': 7.21.0_@babel+core@7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + dev: true + + /@babel/preset-env/7.20.2_@babel+core@7.21.3: + resolution: {integrity: sha512-1G0efQEWR1EHkKvKHqbG+IN/QdgwfByUpM5V5QroDzGV2t3S/WXNQd693cHiHTlCFMpr9B6FkPFXDA2lQcKoDg==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/compat-data': 7.21.0 + '@babel/core': 7.21.3 + '@babel/helper-compilation-targets': 7.20.7_@babel+core@7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + '@babel/helper-validator-option': 7.21.0 + '@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression': 7.18.6_@babel+core@7.21.3 + '@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining': 7.20.7_@babel+core@7.21.3 + '@babel/plugin-proposal-async-generator-functions': 7.20.7_@babel+core@7.21.3 + '@babel/plugin-proposal-class-properties': 7.18.6_@babel+core@7.21.3 + '@babel/plugin-proposal-class-static-block': 7.21.0_@babel+core@7.21.3 + '@babel/plugin-proposal-dynamic-import': 7.18.6_@babel+core@7.21.3 + '@babel/plugin-proposal-export-namespace-from': 7.18.9_@babel+core@7.21.3 + '@babel/plugin-proposal-json-strings': 7.18.6_@babel+core@7.21.3 + '@babel/plugin-proposal-logical-assignment-operators': 7.20.7_@babel+core@7.21.3 + '@babel/plugin-proposal-nullish-coalescing-operator': 7.18.6_@babel+core@7.21.3 + '@babel/plugin-proposal-numeric-separator': 7.18.6_@babel+core@7.21.3 + '@babel/plugin-proposal-object-rest-spread': 7.20.7_@babel+core@7.21.3 + '@babel/plugin-proposal-optional-catch-binding': 7.18.6_@babel+core@7.21.3 + '@babel/plugin-proposal-optional-chaining': 7.21.0_@babel+core@7.21.3 + '@babel/plugin-proposal-private-methods': 7.18.6_@babel+core@7.21.3 + '@babel/plugin-proposal-private-property-in-object': 7.21.0_@babel+core@7.21.3 + '@babel/plugin-proposal-unicode-property-regex': 7.18.6_@babel+core@7.21.3 + '@babel/plugin-syntax-async-generators': 7.8.4_@babel+core@7.21.3 + '@babel/plugin-syntax-class-properties': 7.12.13_@babel+core@7.21.3 + '@babel/plugin-syntax-class-static-block': 7.14.5_@babel+core@7.21.3 + '@babel/plugin-syntax-dynamic-import': 7.8.3_@babel+core@7.21.3 + '@babel/plugin-syntax-export-namespace-from': 7.8.3_@babel+core@7.21.3 + '@babel/plugin-syntax-import-assertions': 7.20.0_@babel+core@7.21.3 + '@babel/plugin-syntax-json-strings': 7.8.3_@babel+core@7.21.3 + '@babel/plugin-syntax-logical-assignment-operators': 7.10.4_@babel+core@7.21.3 + '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3_@babel+core@7.21.3 + '@babel/plugin-syntax-numeric-separator': 7.10.4_@babel+core@7.21.3 + '@babel/plugin-syntax-object-rest-spread': 7.8.3_@babel+core@7.21.3 + '@babel/plugin-syntax-optional-catch-binding': 7.8.3_@babel+core@7.21.3 + '@babel/plugin-syntax-optional-chaining': 7.8.3_@babel+core@7.21.3 + '@babel/plugin-syntax-private-property-in-object': 7.14.5_@babel+core@7.21.3 + '@babel/plugin-syntax-top-level-await': 7.14.5_@babel+core@7.21.3 + '@babel/plugin-transform-arrow-functions': 7.20.7_@babel+core@7.21.3 + '@babel/plugin-transform-async-to-generator': 7.20.7_@babel+core@7.21.3 + '@babel/plugin-transform-block-scoped-functions': 7.18.6_@babel+core@7.21.3 + '@babel/plugin-transform-block-scoping': 7.21.0_@babel+core@7.21.3 + '@babel/plugin-transform-classes': 7.21.0_@babel+core@7.21.3 + '@babel/plugin-transform-computed-properties': 7.20.7_@babel+core@7.21.3 + '@babel/plugin-transform-destructuring': 7.21.3_@babel+core@7.21.3 + '@babel/plugin-transform-dotall-regex': 7.18.6_@babel+core@7.21.3 + '@babel/plugin-transform-duplicate-keys': 7.18.9_@babel+core@7.21.3 + '@babel/plugin-transform-exponentiation-operator': 7.18.6_@babel+core@7.21.3 + '@babel/plugin-transform-for-of': 7.21.0_@babel+core@7.21.3 + '@babel/plugin-transform-function-name': 7.18.9_@babel+core@7.21.3 + '@babel/plugin-transform-literals': 7.18.9_@babel+core@7.21.3 + '@babel/plugin-transform-member-expression-literals': 7.18.6_@babel+core@7.21.3 + '@babel/plugin-transform-modules-amd': 7.20.11_@babel+core@7.21.3 + '@babel/plugin-transform-modules-commonjs': 7.21.2_@babel+core@7.21.3 + '@babel/plugin-transform-modules-systemjs': 7.20.11_@babel+core@7.21.3 + '@babel/plugin-transform-modules-umd': 7.18.6_@babel+core@7.21.3 + '@babel/plugin-transform-named-capturing-groups-regex': 7.20.5_@babel+core@7.21.3 + '@babel/plugin-transform-new-target': 7.18.6_@babel+core@7.21.3 + '@babel/plugin-transform-object-super': 7.18.6_@babel+core@7.21.3 + '@babel/plugin-transform-parameters': 7.21.3_@babel+core@7.21.3 + '@babel/plugin-transform-property-literals': 7.18.6_@babel+core@7.21.3 + '@babel/plugin-transform-regenerator': 7.20.5_@babel+core@7.21.3 + '@babel/plugin-transform-reserved-words': 7.18.6_@babel+core@7.21.3 + '@babel/plugin-transform-shorthand-properties': 7.18.6_@babel+core@7.21.3 + '@babel/plugin-transform-spread': 7.20.7_@babel+core@7.21.3 + '@babel/plugin-transform-sticky-regex': 7.18.6_@babel+core@7.21.3 + '@babel/plugin-transform-template-literals': 7.18.9_@babel+core@7.21.3 + '@babel/plugin-transform-typeof-symbol': 7.18.9_@babel+core@7.21.3 + '@babel/plugin-transform-unicode-escapes': 7.18.10_@babel+core@7.21.3 + '@babel/plugin-transform-unicode-regex': 7.18.6_@babel+core@7.21.3 + '@babel/preset-modules': 0.1.5_@babel+core@7.21.3 + '@babel/types': 7.21.3 + babel-plugin-polyfill-corejs2: 0.3.3_@babel+core@7.21.3 + babel-plugin-polyfill-corejs3: 0.6.0_@babel+core@7.21.3 + babel-plugin-polyfill-regenerator: 0.4.1_@babel+core@7.21.3 + core-js-compat: 3.29.1 + semver: 6.3.0 + transitivePeerDependencies: + - supports-color + dev: true + + /@babel/preset-modules/0.1.5_@babel+core@7.21.3: + resolution: {integrity: sha512-A57th6YRG7oR3cq/yt/Y84MvGgE0eJG2F1JLhKuyG+jFxEgrd/HAMJatiFtmOiZurz+0DkrvbheCLaV5f2JfjA==} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-plugin-utils': 7.20.2 + '@babel/plugin-proposal-unicode-property-regex': 7.18.6_@babel+core@7.21.3 + '@babel/plugin-transform-dotall-regex': 7.18.6_@babel+core@7.21.3 + '@babel/types': 7.21.3 + esutils: 2.0.3 + dev: true + + /@babel/regjsgen/0.8.0: + resolution: {integrity: sha512-x/rqGMdzj+fWZvCOYForTghzbtqPDZ5gPwaoNGHdgDfF2QA/XZbCBp4Moo5scrkAMPhB7z26XM/AaHuIJdgauA==} + dev: true + + /@babel/runtime/7.21.0: + resolution: {integrity: sha512-xwII0//EObnq89Ji5AKYQaRYiW/nZ3llSv29d49IuxPhKbtJoLP+9QUUZ4nVragQVtaVGeZrpB+ZtG/Pdy/POw==} + engines: {node: '>=6.9.0'} + dependencies: + regenerator-runtime: 0.13.11 + dev: true + + /@babel/template/7.20.7: + resolution: {integrity: sha512-8SegXApWe6VoNw0r9JHpSteLKTpTiLZ4rMlGIm9JQ18KiCtyQiAMEazujAHrUS5flrcqYZa75ukev3P6QmUwUw==} + engines: {node: '>=6.9.0'} + dependencies: + '@babel/code-frame': 7.18.6 + '@babel/parser': 7.21.3 + '@babel/types': 7.21.3 + dev: true + + /@babel/traverse/7.21.3: + resolution: {integrity: sha512-XLyopNeaTancVitYZe2MlUEvgKb6YVVPXzofHgqHijCImG33b/uTurMS488ht/Hbsb2XK3U2BnSTxKVNGV3nGQ==} + engines: {node: '>=6.9.0'} + dependencies: + '@babel/code-frame': 7.18.6 + '@babel/generator': 7.21.3 + '@babel/helper-environment-visitor': 7.18.9 + '@babel/helper-function-name': 7.21.0 + '@babel/helper-hoist-variables': 7.18.6 + '@babel/helper-split-export-declaration': 7.18.6 + '@babel/parser': 7.21.3 + '@babel/types': 7.21.3 + debug: 4.3.4 + globals: 11.12.0 + transitivePeerDependencies: + - supports-color + dev: true + + /@babel/types/7.21.2: + resolution: {integrity: sha512-3wRZSs7jiFaB8AjxiiD+VqN5DTG2iRvJGQ+qYFrs/654lg6kGTQWIOFjlBo5RaXuAZjBmP3+OQH4dmhqiiyYxw==} + engines: {node: '>=6.9.0'} + dependencies: + '@babel/helper-string-parser': 7.19.4 + '@babel/helper-validator-identifier': 7.19.1 + to-fast-properties: 2.0.0 + + /@babel/types/7.21.3: + resolution: {integrity: sha512-sBGdETxC+/M4o/zKC0sl6sjWv62WFR/uzxrJ6uYyMLZOUlPnwzw0tKgVHOXxaAd5l2g8pEDM5RZ495GPQI77kg==} + engines: {node: '>=6.9.0'} + dependencies: + '@babel/helper-string-parser': 7.19.4 + '@babel/helper-validator-identifier': 7.19.1 + to-fast-properties: 2.0.0 + dev: true + + /@css-render/plugin-bem/0.15.12_css-render@0.15.12: + resolution: {integrity: sha512-Lq2jSOZn+wYQtsyaFj6QRz2EzAnd3iW5fZeHO1WSXQdVYwvwGX0ZiH3X2JQgtgYLT1yeGtrwrqJdNdMEUD2xTw==} + peerDependencies: + css-render: ~0.15.12 + dependencies: + css-render: 0.15.12 + dev: true + + /@css-render/vue3-ssr/0.15.12_vue@3.2.47: + resolution: {integrity: sha512-AQLGhhaE0F+rwybRCkKUdzBdTEM/5PZBYy+fSYe1T9z9+yxMuV/k7ZRqa4M69X+EI1W8pa4kc9Iq2VjQkZx4rg==} + peerDependencies: + vue: ^3.0.11 + dependencies: + vue: 3.2.47 + dev: true + + /@emotion/hash/0.8.0: + resolution: {integrity: sha512-kBJtf7PH6aWwZ6fka3zQ0p6SBYzx4fl1LoZXE2RrnYST9Xljm7WfKJrU4g/Xr3Beg72MLrp1AWNUmuYJTL7Cow==} + dev: true + + /@esbuild/android-arm/0.16.17: + resolution: {integrity: sha512-N9x1CMXVhtWEAMS7pNNONyA14f71VPQN9Cnavj1XQh6T7bskqiLLrSca4O0Vr8Wdcga943eThxnVp3JLnBMYtw==} + engines: {node: '>=12'} + cpu: [arm] + os: [android] + requiresBuild: true + dev: true + optional: true + + /@esbuild/android-arm64/0.16.17: + resolution: {integrity: sha512-MIGl6p5sc3RDTLLkYL1MyL8BMRN4tLMRCn+yRJJmEDvYZ2M7tmAf80hx1kbNEUX2KJ50RRtxZ4JHLvCfuB6kBg==} + engines: {node: '>=12'} + cpu: [arm64] + os: [android] + requiresBuild: true + dev: true + optional: true + + /@esbuild/android-x64/0.16.17: + resolution: {integrity: sha512-a3kTv3m0Ghh4z1DaFEuEDfz3OLONKuFvI4Xqczqx4BqLyuFaFkuaG4j2MtA6fuWEFeC5x9IvqnX7drmRq/fyAQ==} + engines: {node: '>=12'} + cpu: [x64] + os: [android] + requiresBuild: true + dev: true + optional: true + + /@esbuild/darwin-arm64/0.16.17: + resolution: {integrity: sha512-/2agbUEfmxWHi9ARTX6OQ/KgXnOWfsNlTeLcoV7HSuSTv63E4DqtAc+2XqGw1KHxKMHGZgbVCZge7HXWX9Vn+w==} + engines: {node: '>=12'} + cpu: [arm64] + os: [darwin] + requiresBuild: true + dev: true + optional: true + + /@esbuild/darwin-x64/0.16.17: + resolution: {integrity: sha512-2By45OBHulkd9Svy5IOCZt376Aa2oOkiE9QWUK9fe6Tb+WDr8hXL3dpqi+DeLiMed8tVXspzsTAvd0jUl96wmg==} + engines: {node: '>=12'} + cpu: [x64] + os: [darwin] + requiresBuild: true + dev: true + optional: true + + /@esbuild/freebsd-arm64/0.16.17: + resolution: {integrity: sha512-mt+cxZe1tVx489VTb4mBAOo2aKSnJ33L9fr25JXpqQqzbUIw/yzIzi+NHwAXK2qYV1lEFp4OoVeThGjUbmWmdw==} + engines: {node: '>=12'} + cpu: [arm64] + os: [freebsd] + requiresBuild: true + dev: true + optional: true + + /@esbuild/freebsd-x64/0.16.17: + resolution: {integrity: sha512-8ScTdNJl5idAKjH8zGAsN7RuWcyHG3BAvMNpKOBaqqR7EbUhhVHOqXRdL7oZvz8WNHL2pr5+eIT5c65kA6NHug==} + engines: {node: '>=12'} + cpu: [x64] + os: [freebsd] + requiresBuild: true + dev: true + optional: true + + /@esbuild/linux-arm/0.16.17: + resolution: {integrity: sha512-iihzrWbD4gIT7j3caMzKb/RsFFHCwqqbrbH9SqUSRrdXkXaygSZCZg1FybsZz57Ju7N/SHEgPyaR0LZ8Zbe9gQ==} + engines: {node: '>=12'} + cpu: [arm] + os: [linux] + requiresBuild: true + dev: true + optional: true + + /@esbuild/linux-arm64/0.16.17: + resolution: {integrity: sha512-7S8gJnSlqKGVJunnMCrXHU9Q8Q/tQIxk/xL8BqAP64wchPCTzuM6W3Ra8cIa1HIflAvDnNOt2jaL17vaW+1V0g==} + engines: {node: '>=12'} + cpu: [arm64] + os: [linux] + requiresBuild: true + dev: true + optional: true + + /@esbuild/linux-ia32/0.16.17: + resolution: {integrity: sha512-kiX69+wcPAdgl3Lonh1VI7MBr16nktEvOfViszBSxygRQqSpzv7BffMKRPMFwzeJGPxcio0pdD3kYQGpqQ2SSg==} + engines: {node: '>=12'} + cpu: [ia32] + os: [linux] + requiresBuild: true + dev: true + optional: true + + /@esbuild/linux-loong64/0.16.17: + resolution: {integrity: sha512-dTzNnQwembNDhd654cA4QhbS9uDdXC3TKqMJjgOWsC0yNCbpzfWoXdZvp0mY7HU6nzk5E0zpRGGx3qoQg8T2DQ==} + engines: {node: '>=12'} + cpu: [loong64] + os: [linux] + requiresBuild: true + dev: true + optional: true + + /@esbuild/linux-mips64el/0.16.17: + resolution: {integrity: sha512-ezbDkp2nDl0PfIUn0CsQ30kxfcLTlcx4Foz2kYv8qdC6ia2oX5Q3E/8m6lq84Dj/6b0FrkgD582fJMIfHhJfSw==} + engines: {node: '>=12'} + cpu: [mips64el] + os: [linux] + requiresBuild: true + dev: true + optional: true + + /@esbuild/linux-ppc64/0.16.17: + resolution: {integrity: sha512-dzS678gYD1lJsW73zrFhDApLVdM3cUF2MvAa1D8K8KtcSKdLBPP4zZSLy6LFZ0jYqQdQ29bjAHJDgz0rVbLB3g==} + engines: {node: '>=12'} + cpu: [ppc64] + os: [linux] + requiresBuild: true + dev: true + optional: true + + /@esbuild/linux-riscv64/0.16.17: + resolution: {integrity: sha512-ylNlVsxuFjZK8DQtNUwiMskh6nT0vI7kYl/4fZgV1llP5d6+HIeL/vmmm3jpuoo8+NuXjQVZxmKuhDApK0/cKw==} + engines: {node: '>=12'} + cpu: [riscv64] + os: [linux] + requiresBuild: true + dev: true + optional: true + + /@esbuild/linux-s390x/0.16.17: + resolution: {integrity: sha512-gzy7nUTO4UA4oZ2wAMXPNBGTzZFP7mss3aKR2hH+/4UUkCOyqmjXiKpzGrY2TlEUhbbejzXVKKGazYcQTZWA/w==} + engines: {node: '>=12'} + cpu: [s390x] + os: [linux] + requiresBuild: true + dev: true + optional: true + + /@esbuild/linux-x64/0.16.17: + resolution: {integrity: sha512-mdPjPxfnmoqhgpiEArqi4egmBAMYvaObgn4poorpUaqmvzzbvqbowRllQ+ZgzGVMGKaPkqUmPDOOFQRUFDmeUw==} + engines: {node: '>=12'} + cpu: [x64] + os: [linux] + requiresBuild: true + dev: true + optional: true + + /@esbuild/netbsd-x64/0.16.17: + resolution: {integrity: sha512-/PzmzD/zyAeTUsduZa32bn0ORug+Jd1EGGAUJvqfeixoEISYpGnAezN6lnJoskauoai0Jrs+XSyvDhppCPoKOA==} + engines: {node: '>=12'} + cpu: [x64] + os: [netbsd] + requiresBuild: true + dev: true + optional: true + + /@esbuild/openbsd-x64/0.16.17: + resolution: {integrity: sha512-2yaWJhvxGEz2RiftSk0UObqJa/b+rIAjnODJgv2GbGGpRwAfpgzyrg1WLK8rqA24mfZa9GvpjLcBBg8JHkoodg==} + engines: {node: '>=12'} + cpu: [x64] + os: [openbsd] + requiresBuild: true + dev: true + optional: true + + /@esbuild/sunos-x64/0.16.17: + resolution: {integrity: sha512-xtVUiev38tN0R3g8VhRfN7Zl42YCJvyBhRKw1RJjwE1d2emWTVToPLNEQj/5Qxc6lVFATDiy6LjVHYhIPrLxzw==} + engines: {node: '>=12'} + cpu: [x64] + os: [sunos] + requiresBuild: true + dev: true + optional: true + + /@esbuild/win32-arm64/0.16.17: + resolution: {integrity: sha512-ga8+JqBDHY4b6fQAmOgtJJue36scANy4l/rL97W+0wYmijhxKetzZdKOJI7olaBaMhWt8Pac2McJdZLxXWUEQw==} + engines: {node: '>=12'} + cpu: [arm64] + os: [win32] + requiresBuild: true + dev: true + optional: true + + /@esbuild/win32-ia32/0.16.17: + resolution: {integrity: sha512-WnsKaf46uSSF/sZhwnqE4L/F89AYNMiD4YtEcYekBt9Q7nj0DiId2XH2Ng2PHM54qi5oPrQ8luuzGszqi/veig==} + engines: {node: '>=12'} + cpu: [ia32] + os: [win32] + requiresBuild: true + dev: true + optional: true + + /@esbuild/win32-x64/0.16.17: + resolution: {integrity: sha512-y+EHuSchhL7FjHgvQL/0fnnFmO4T1bhvWANX6gcnqTjtnKWbTvUMCpGnv2+t+31d7RzyEAYAd4u2fnIhHL6N/Q==} + engines: {node: '>=12'} + cpu: [x64] + os: [win32] + requiresBuild: true + dev: true + optional: true + + /@icon-park/vue-next/1.4.2_vue@3.2.47: + resolution: {integrity: sha512-+QklF255wkfBOabY+xw6FAI0Bwln/RhdwCunNy/9sKdKuChtaU67QZqU67KGAvZUTeeBgsL+yaHHxqfQeGZXEQ==} + engines: {node: '>= 8.0.0', npm: '>= 5.0.0'} + peerDependencies: + vue: 3.x + dependencies: + vue: 3.2.47 + dev: false + + /@jridgewell/gen-mapping/0.1.1: + resolution: {integrity: sha512-sQXCasFk+U8lWYEe66WxRDOE9PjVz4vSM51fTu3Hw+ClTpUSQb718772vH3pyS5pShp6lvQM7SxgIDXXXmOX7w==} + engines: {node: '>=6.0.0'} + dependencies: + '@jridgewell/set-array': 1.1.2 + '@jridgewell/sourcemap-codec': 1.4.14 + dev: true + + /@jridgewell/gen-mapping/0.3.2: + resolution: {integrity: sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A==} + engines: {node: '>=6.0.0'} + dependencies: + '@jridgewell/set-array': 1.1.2 + '@jridgewell/sourcemap-codec': 1.4.14 + '@jridgewell/trace-mapping': 0.3.17 + + /@jridgewell/resolve-uri/3.1.0: + resolution: {integrity: sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==} + engines: {node: '>=6.0.0'} + + /@jridgewell/set-array/1.1.2: + resolution: {integrity: sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==} + engines: {node: '>=6.0.0'} + + /@jridgewell/source-map/0.3.2: + resolution: {integrity: sha512-m7O9o2uR8k2ObDysZYzdfhb08VuEml5oWGiosa1VdaPZ/A6QyPkAJuwN0Q1lhULOf6B7MtQmHENS743hWtCrgw==} + dependencies: + '@jridgewell/gen-mapping': 0.3.2 + '@jridgewell/trace-mapping': 0.3.17 + + /@jridgewell/sourcemap-codec/1.4.14: + resolution: {integrity: sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw==} + + /@jridgewell/trace-mapping/0.3.17: + resolution: {integrity: sha512-MCNzAp77qzKca9+W/+I0+sEpaUnZoeasnghNeVc41VZCEKaCH73Vq3BZZ/SzWIgrqE4H4ceI+p+b6C0mHf9T4g==} + dependencies: + '@jridgewell/resolve-uri': 3.1.0 + '@jridgewell/sourcemap-codec': 1.4.14 + + /@juggle/resize-observer/3.4.0: + resolution: {integrity: sha512-dfLbk+PwWvFzSxwk3n5ySL0hfBog779o8h68wK/7/APo/7cgyWp5jcXockbxdk5kFRkbeXWm4Fbi9FrdN381sA==} + dev: true + + /@nodelib/fs.scandir/2.1.5: + resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==} + engines: {node: '>= 8'} + dependencies: + '@nodelib/fs.stat': 2.0.5 + run-parallel: 1.2.0 + dev: true + + /@nodelib/fs.stat/2.0.5: + resolution: {integrity: sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==} + engines: {node: '>= 8'} + dev: true + + /@nodelib/fs.walk/1.2.8: + resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==} + engines: {node: '>= 8'} + dependencies: + '@nodelib/fs.scandir': 2.1.5 + fastq: 1.15.0 + dev: true + + /@rollup/plugin-babel/5.3.1_hqhlikriuul7byjexqnpgcmenu: + resolution: {integrity: sha512-WFfdLWU/xVWKeRQnKmIAQULUI7Il0gZnBIH/ZFO069wYIfPu+8zrfp/KMW0atmELoRDq8FbiP3VCss9MhCut7Q==} + engines: {node: '>= 10.0.0'} + peerDependencies: + '@babel/core': ^7.0.0 + '@types/babel__core': ^7.1.9 + rollup: ^1.20.0||^2.0.0 + peerDependenciesMeta: + '@types/babel__core': + optional: true + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-module-imports': 7.18.6 + '@rollup/pluginutils': 3.1.0_rollup@2.79.1 + rollup: 2.79.1 + dev: true + + /@rollup/plugin-node-resolve/11.2.1_rollup@2.79.1: + resolution: {integrity: sha512-yc2n43jcqVyGE2sqV5/YCmocy9ArjVAP/BeXyTtADTBBX6V0e5UMqwO8CdQ0kzjb6zu5P1qMzsScCMRvE9OlVg==} + engines: {node: '>= 10.0.0'} + peerDependencies: + rollup: ^1.20.0||^2.0.0 + dependencies: + '@rollup/pluginutils': 3.1.0_rollup@2.79.1 + '@types/resolve': 1.17.1 + builtin-modules: 3.3.0 + deepmerge: 4.3.1 + is-module: 1.0.0 + resolve: 1.22.1 + rollup: 2.79.1 + dev: true + + /@rollup/plugin-replace/2.4.2_rollup@2.79.1: + resolution: {integrity: sha512-IGcu+cydlUMZ5En85jxHH4qj2hta/11BHq95iHEyb2sbgiN0eCdzvUcHw5gt9pBL5lTi4JDYJ1acCoMGpTvEZg==} + peerDependencies: + rollup: ^1.20.0 || ^2.0.0 + dependencies: + '@rollup/pluginutils': 3.1.0_rollup@2.79.1 + magic-string: 0.25.9 + rollup: 2.79.1 + dev: true + + /@rollup/plugin-replace/5.0.2_rollup@3.18.0: + resolution: {integrity: sha512-M9YXNekv/C/iHHK+cvORzfRYfPbq0RDD8r0G+bMiTXjNGKulPnCT9O3Ss46WfhI6ZOCgApOP7xAdmCQJ+U2LAA==} + engines: {node: '>=14.0.0'} + peerDependencies: + rollup: ^1.20.0||^2.0.0||^3.0.0 + peerDependenciesMeta: + rollup: + optional: true + dependencies: + '@rollup/pluginutils': 5.0.2_rollup@3.18.0 + magic-string: 0.27.0 + rollup: 3.18.0 + dev: true + + /@rollup/pluginutils/3.1.0_rollup@2.79.1: + resolution: {integrity: sha512-GksZ6pr6TpIjHm8h9lSQ8pi8BE9VeubNT0OMJ3B5uZJ8pz73NPiqOtCog/x2/QzM1ENChPKxMDhiQuRHsqc+lg==} + engines: {node: '>= 8.0.0'} + peerDependencies: + rollup: ^1.20.0||^2.0.0 + dependencies: + '@types/estree': 0.0.39 + estree-walker: 1.0.1 + picomatch: 2.3.1 + rollup: 2.79.1 + dev: true + + /@rollup/pluginutils/5.0.2: + resolution: {integrity: sha512-pTd9rIsP92h+B6wWwFbW8RkZv4hiR/xKsqre4SIuAOaOEQRxi0lqLke9k2/7WegC85GgUs9pjmOjCUi3In4vwA==} + engines: {node: '>=14.0.0'} + peerDependencies: + rollup: ^1.20.0||^2.0.0||^3.0.0 + peerDependenciesMeta: + rollup: + optional: true + dependencies: + '@types/estree': 1.0.0 + estree-walker: 2.0.2 + picomatch: 2.3.1 + dev: true + + /@rollup/pluginutils/5.0.2_rollup@3.18.0: + resolution: {integrity: sha512-pTd9rIsP92h+B6wWwFbW8RkZv4hiR/xKsqre4SIuAOaOEQRxi0lqLke9k2/7WegC85GgUs9pjmOjCUi3In4vwA==} + engines: {node: '>=14.0.0'} + peerDependencies: + rollup: ^1.20.0||^2.0.0||^3.0.0 + peerDependenciesMeta: + rollup: + optional: true + dependencies: + '@types/estree': 1.0.0 + estree-walker: 2.0.2 + picomatch: 2.3.1 + rollup: 3.18.0 + dev: true + + /@surma/rollup-plugin-off-main-thread/2.2.3: + resolution: {integrity: sha512-lR8q/9W7hZpMWweNiAKU7NQerBnzQQLvi8qnTDU/fxItPhtZVMbPV3lbCwjhIlNBe9Bbr5V+KHshvWmVSG9cxQ==} + dependencies: + ejs: 3.1.9 + json5: 2.2.3 + magic-string: 0.25.9 + string.prototype.matchall: 4.0.8 + dev: true + + /@types/estree/0.0.39: + resolution: {integrity: sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==} + dev: true + + /@types/estree/1.0.0: + resolution: {integrity: sha512-WulqXMDUTYAXCjZnk6JtIHPigp55cVtDgDrO2gHRwhyJto21+1zbVCtOYB2L1F9w4qCQ0rOGWBnBe0FNTiEJIQ==} + dev: true + + /@types/katex/0.14.0: + resolution: {integrity: sha512-+2FW2CcT0K3P+JMR8YG846bmDwplKUTsWgT2ENwdQ1UdVfRk3GQrh6Mi4sTopy30gI8Uau5CEqHTDZ6YvWIUPA==} + dev: true + + /@types/lodash-es/4.17.6: + resolution: {integrity: sha512-R+zTeVUKDdfoRxpAryaQNRKk3105Rrgx2CFRClIgRGaqDTdjsm8h6IYA8ir584W3ePzkZfst5xIgDwYrlh9HLg==} + dependencies: + '@types/lodash': 4.14.191 + dev: true + + /@types/lodash/4.14.191: + resolution: {integrity: sha512-BdZ5BCCvho3EIXw6wUCXHe7rS53AIDPLE+JzwgT+OsJk53oBfbSmZZ7CX4VaRoN78N+TJpFi9QPlfIVNmJYWxQ==} + dev: true + + /@types/node/18.15.3: + resolution: {integrity: sha512-p6ua9zBxz5otCmbpb5D3U4B5Nanw6Pk3PPyX05xnxbB/fRv71N7CPmORg7uAD5P70T0xmx1pzAx/FUfa5X+3cw==} + dev: true + + /@types/resolve/1.17.1: + resolution: {integrity: sha512-yy7HuzQhj0dhGpD8RLXSZWEkLsV9ibvxvi6EiJ3bkqLAO1RGo0WbkWQiwpRlSFymTJRz0d3k5LM3kkx8ArDbLw==} + dependencies: + '@types/node': 18.15.3 + dev: true + + /@types/trusted-types/2.0.3: + resolution: {integrity: sha512-NfQ4gyz38SL8sDNrSixxU2Os1a5xcdFxipAFxYEuLUlvU2uDwS4NUpsImcf1//SlWItCVMMLiylsxbmNMToV/g==} + dev: true + + /@vitejs/plugin-vue/4.0.0_vite@4.1.4+vue@3.2.47: + resolution: {integrity: sha512-e0X4jErIxAB5oLtDqbHvHpJe/uWNkdpYV83AOG2xo2tEVSzCzewgJMtREZM30wXnM5ls90hxiOtAuVU6H5JgbA==} + engines: {node: ^14.18.0 || >=16.0.0} + peerDependencies: + vite: ^4.0.0 + vue: ^3.2.25 + dependencies: + vite: 4.1.4_sass@1.58.3+terser@5.16.5 + vue: 3.2.47 + dev: true + + /@vue/compiler-core/3.2.47: + resolution: {integrity: sha512-p4D7FDnQb7+YJmO2iPEv0SQNeNzcbHdGByJDsT4lynf63AFkOTFN07HsiRSvjGo0QrxR/o3d0hUyNCUnBU2Tig==} + dependencies: + '@babel/parser': 7.21.2 + '@vue/shared': 3.2.47 + estree-walker: 2.0.2 + source-map: 0.6.1 + + /@vue/compiler-dom/3.2.47: + resolution: {integrity: sha512-dBBnEHEPoftUiS03a4ggEig74J2YBZ2UIeyfpcRM2tavgMWo4bsEfgCGsu+uJIL/vax9S+JztH8NmQerUo7shQ==} + dependencies: + '@vue/compiler-core': 3.2.47 + '@vue/shared': 3.2.47 + + /@vue/compiler-sfc/3.2.47: + resolution: {integrity: sha512-rog05W+2IFfxjMcFw10tM9+f7i/+FFpZJJ5XHX72NP9eC2uRD+42M3pYcQqDXVYoj74kHMSEdQ/WmCjt8JFksQ==} + dependencies: + '@babel/parser': 7.21.2 + '@vue/compiler-core': 3.2.47 + '@vue/compiler-dom': 3.2.47 + '@vue/compiler-ssr': 3.2.47 + '@vue/reactivity-transform': 3.2.47 + '@vue/shared': 3.2.47 + estree-walker: 2.0.2 + magic-string: 0.25.9 + postcss: 8.4.21 + source-map: 0.6.1 + + /@vue/compiler-ssr/3.2.47: + resolution: {integrity: sha512-wVXC+gszhulcMD8wpxMsqSOpvDZ6xKXSVWkf50Guf/S+28hTAXPDYRTbLQ3EDkOP5Xz/+SY37YiwDquKbJOgZw==} + dependencies: + '@vue/compiler-dom': 3.2.47 + '@vue/shared': 3.2.47 + + /@vue/devtools-api/6.5.0: + resolution: {integrity: sha512-o9KfBeaBmCKl10usN4crU53fYtC1r7jJwdGKjPT24t348rHxgfpZ0xL3Xm/gLUYnc0oTp8LAmrxOeLyu6tbk2Q==} + dev: false + + /@vue/reactivity-transform/3.2.47: + resolution: {integrity: sha512-m8lGXw8rdnPVVIdIFhf0LeQ/ixyHkH5plYuS83yop5n7ggVJU+z5v0zecwEnX7fa7HNLBhh2qngJJkxpwEEmYA==} + dependencies: + '@babel/parser': 7.21.2 + '@vue/compiler-core': 3.2.47 + '@vue/shared': 3.2.47 + estree-walker: 2.0.2 + magic-string: 0.25.9 + + /@vue/reactivity/3.2.47: + resolution: {integrity: sha512-7khqQ/75oyyg+N/e+iwV6lpy1f5wq759NdlS1fpAhFXa8VeAIKGgk2E/C4VF59lx5b+Ezs5fpp/5WsRYXQiKxQ==} + dependencies: + '@vue/shared': 3.2.47 + + /@vue/runtime-core/3.2.47: + resolution: {integrity: sha512-RZxbLQIRB/K0ev0K9FXhNbBzT32H9iRtYbaXb0ZIz2usLms/D55dJR2t6cIEUn6vyhS3ALNvNthI+Q95C+NOpA==} + dependencies: + '@vue/reactivity': 3.2.47 + '@vue/shared': 3.2.47 + + /@vue/runtime-dom/3.2.47: + resolution: {integrity: sha512-ArXrFTjS6TsDei4qwNvgrdmHtD930KgSKGhS5M+j8QxXrDJYLqYw4RRcDy1bz1m1wMmb6j+zGLifdVHtkXA7gA==} + dependencies: + '@vue/runtime-core': 3.2.47 + '@vue/shared': 3.2.47 + csstype: 2.6.21 + + /@vue/server-renderer/3.2.47_vue@3.2.47: + resolution: {integrity: sha512-dN9gc1i8EvmP9RCzvneONXsKfBRgqFeFZLurmHOveL7oH6HiFXJw5OGu294n1nHc/HMgTy6LulU/tv5/A7f/LA==} + peerDependencies: + vue: 3.2.47 + dependencies: + '@vue/compiler-ssr': 3.2.47 + '@vue/shared': 3.2.47 + vue: 3.2.47 + + /@vue/shared/3.2.47: + resolution: {integrity: sha512-BHGyyGN3Q97EZx0taMQ+OLNuZcW3d37ZEVmEAyeoA9ERdGvm9Irc/0Fua8SNyOtV1w6BS4q25wbMzJujO9HIfQ==} + + /acorn/8.8.2: + resolution: {integrity: sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw==} + engines: {node: '>=0.4.0'} + hasBin: true + + /ajv/8.12.0: + resolution: {integrity: sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==} + dependencies: + fast-deep-equal: 3.1.3 + json-schema-traverse: 1.0.0 + require-from-string: 2.0.2 + uri-js: 4.4.1 + dev: true + + /ansi-styles/3.2.1: + resolution: {integrity: sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==} + engines: {node: '>=4'} + dependencies: + color-convert: 1.9.3 + dev: true + + /ansi-styles/4.3.0: + resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==} + engines: {node: '>=8'} + dependencies: + color-convert: 2.0.1 + dev: true + + /anymatch/3.1.3: + resolution: {integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==} + engines: {node: '>= 8'} + dependencies: + normalize-path: 3.0.0 + picomatch: 2.3.1 + + /array-buffer-byte-length/1.0.0: + resolution: {integrity: sha512-LPuwb2P+NrQw3XhxGc36+XSvuBPopovXYTR9Ew++Du9Yb/bx5AzBfrIsBoj0EZUifjQU+sHL21sseZ3jerWO/A==} + dependencies: + call-bind: 1.0.2 + is-array-buffer: 3.0.2 + dev: true + + /async-validator/4.2.5: + resolution: {integrity: sha512-7HhHjtERjqlNbZtqNqy2rckN/SpOOlmDliet+lP7k+eKZEjPk3DgyeU9lIXLdeLz0uBbbVp+9Qdow9wJWgwwfg==} + dev: true + + /async/3.2.4: + resolution: {integrity: sha512-iAB+JbDEGXhyIUavoDl9WP/Jj106Kz9DEn1DPgYw5ruDn0e3Wgi3sKFm55sASdGBNOQB8F59d9qQ7deqrHA8wQ==} + dev: true + + /asynckit/0.4.0: + resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==} + dev: false + + /at-least-node/1.0.0: + resolution: {integrity: sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==} + engines: {node: '>= 4.0.0'} + dev: true + + /available-typed-arrays/1.0.5: + resolution: {integrity: sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw==} + engines: {node: '>= 0.4'} + dev: true + + /axios/1.3.4: + resolution: {integrity: sha512-toYm+Bsyl6VC5wSkfkbbNB6ROv7KY93PEBBL6xyDczaIHasAiv4wPqQ/c4RjoQzipxRD2W5g21cOqQulZ7rHwQ==} + dependencies: + follow-redirects: 1.15.2 + form-data: 4.0.0 + proxy-from-env: 1.1.0 + transitivePeerDependencies: + - debug + dev: false + + /babel-plugin-polyfill-corejs2/0.3.3_@babel+core@7.21.3: + resolution: {integrity: sha512-8hOdmFYFSZhqg2C/JgLUQ+t52o5nirNwaWM2B9LWteozwIvM14VSwdsCAUET10qT+kmySAlseadmfeeSWFCy+Q==} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/compat-data': 7.21.0 + '@babel/core': 7.21.3 + '@babel/helper-define-polyfill-provider': 0.3.3_@babel+core@7.21.3 + semver: 6.3.0 + transitivePeerDependencies: + - supports-color + dev: true + + /babel-plugin-polyfill-corejs3/0.6.0_@babel+core@7.21.3: + resolution: {integrity: sha512-+eHqR6OPcBhJOGgsIar7xoAB1GcSwVUA3XjAd7HJNzOXT4wv6/H7KIdA/Nc60cvUlDbKApmqNvD1B1bzOt4nyA==} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-define-polyfill-provider': 0.3.3_@babel+core@7.21.3 + core-js-compat: 3.29.1 + transitivePeerDependencies: + - supports-color + dev: true + + /babel-plugin-polyfill-regenerator/0.4.1_@babel+core@7.21.3: + resolution: {integrity: sha512-NtQGmyQDXjQqQ+IzRkBVwEOz9lQ4zxAQZgoAYEtU9dJjnl1Oc98qnN7jcp+bE7O7aYzVpavXE3/VKXNzUbh7aw==} + peerDependencies: + '@babel/core': ^7.0.0-0 + dependencies: + '@babel/core': 7.21.3 + '@babel/helper-define-polyfill-provider': 0.3.3_@babel+core@7.21.3 + transitivePeerDependencies: + - supports-color + dev: true + + /balanced-match/1.0.2: + resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==} + dev: true + + /binary-extensions/2.2.0: + resolution: {integrity: sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==} + engines: {node: '>=8'} + + /brace-expansion/1.1.11: + resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==} + dependencies: + balanced-match: 1.0.2 + concat-map: 0.0.1 + dev: true + + /brace-expansion/2.0.1: + resolution: {integrity: sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==} + dependencies: + balanced-match: 1.0.2 + dev: true + + /braces/3.0.2: + resolution: {integrity: sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==} + engines: {node: '>=8'} + dependencies: + fill-range: 7.0.1 + + /browserslist/4.21.5: + resolution: {integrity: sha512-tUkiguQGW7S3IhB7N+c2MV/HZPSCPAAiYBZXLsBhFB/PCy6ZKKsZrmBayHV9fdGV/ARIfJ14NkxKzRDjvp7L6w==} + engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7} + hasBin: true + dependencies: + caniuse-lite: 1.0.30001467 + electron-to-chromium: 1.4.332 + node-releases: 2.0.10 + update-browserslist-db: 1.0.10_browserslist@4.21.5 + dev: true + + /buffer-from/1.1.2: + resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==} + + /builtin-modules/3.3.0: + resolution: {integrity: sha512-zhaCDicdLuWN5UbN5IMnFqNMhNfo919sH85y2/ea+5Yg9TsTkeZxpL+JLbp6cgYFS4sRLp3YV4S6yDuqVWHYOw==} + engines: {node: '>=6'} + dev: true + + /call-bind/1.0.2: + resolution: {integrity: sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==} + dependencies: + function-bind: 1.1.1 + get-intrinsic: 1.2.0 + dev: true + + /caniuse-lite/1.0.30001467: + resolution: {integrity: sha512-cEdN/5e+RPikvl9AHm4uuLXxeCNq8rFsQ+lPHTfe/OtypP3WwnVVbjn+6uBV7PaFL6xUFzTh+sSCOz1rKhcO+Q==} + dev: true + + /chalk/2.4.2: + resolution: {integrity: sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==} + engines: {node: '>=4'} + dependencies: + ansi-styles: 3.2.1 + escape-string-regexp: 1.0.5 + supports-color: 5.5.0 + dev: true + + /chalk/4.1.2: + resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==} + engines: {node: '>=10'} + dependencies: + ansi-styles: 4.3.0 + supports-color: 7.2.0 + dev: true + + /chokidar/3.5.3: + resolution: {integrity: sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==} + engines: {node: '>= 8.10.0'} + dependencies: + anymatch: 3.1.3 + braces: 3.0.2 + glob-parent: 5.1.2 + is-binary-path: 2.1.0 + is-glob: 4.0.3 + normalize-path: 3.0.0 + readdirp: 3.6.0 + optionalDependencies: + fsevents: 2.3.2 + + /color-convert/1.9.3: + resolution: {integrity: sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==} + dependencies: + color-name: 1.1.3 + dev: true + + /color-convert/2.0.1: + resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==} + engines: {node: '>=7.0.0'} + dependencies: + color-name: 1.1.4 + dev: true + + /color-name/1.1.3: + resolution: {integrity: sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==} + dev: true + + /color-name/1.1.4: + resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==} + dev: true + + /combined-stream/1.0.8: + resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==} + engines: {node: '>= 0.8'} + dependencies: + delayed-stream: 1.0.0 + dev: false + + /commander/2.20.3: + resolution: {integrity: sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==} + + /common-tags/1.8.2: + resolution: {integrity: sha512-gk/Z852D2Wtb//0I+kRFNKKE9dIIVirjoqPoA1wJU+XePVXZfGeBpk45+A1rKO4Q43prqWBNY/MiIeRLbPWUaA==} + engines: {node: '>=4.0.0'} + dev: true + + /concat-map/0.0.1: + resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==} + dev: true + + /convert-source-map/1.9.0: + resolution: {integrity: sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==} + dev: true + + /core-js-compat/3.29.1: + resolution: {integrity: sha512-QmchCua884D8wWskMX8tW5ydINzd8oSJVx38lx/pVkFGqztxt73GYre3pm/hyYq8bPf+MW5In4I/uRShFDsbrA==} + dependencies: + browserslist: 4.21.5 + dev: true + + /crypto-random-string/2.0.0: + resolution: {integrity: sha512-v1plID3y9r/lPhviJ1wrXpLeyUIGAZ2SHNYTEapm7/8A9nLPoyvVp3RK/EPFqn5kEznyWgYZNsRtYYIWbuG8KA==} + engines: {node: '>=8'} + dev: true + + /css-render/0.15.12: + resolution: {integrity: sha512-eWzS66patiGkTTik+ipO9qNGZ+uNuGyTmnz6/+EJIiFg8+3yZRpnMwgFo8YdXhQRsiePzehnusrxVvugNjXzbw==} + dependencies: + '@emotion/hash': 0.8.0 + csstype: 3.0.11 + dev: true + + /csstype/2.6.21: + resolution: {integrity: sha512-Z1PhmomIfypOpoMjRQB70jfvy/wxT50qW08YXO5lMIJkrdq4yOTR+AW7FqutScmB9NkLwxo+jU+kZLbofZZq/w==} + + /csstype/3.0.11: + resolution: {integrity: sha512-sa6P2wJ+CAbgyy4KFssIb/JNMLxFvKF1pCYCSXS8ZMuqZnMsrxqI2E5sPyoTpxoPU/gVZMzr2zjOfg8GIZOMsw==} + dev: true + + /date-fns-tz/1.3.8_date-fns@2.29.3: + resolution: {integrity: sha512-qwNXUFtMHTTU6CFSFjoJ80W8Fzzp24LntbjFFBgL/faqds4e5mo9mftoRLgr3Vi1trISsg4awSpYVsOQCRnapQ==} + peerDependencies: + date-fns: '>=2.0.0' + dependencies: + date-fns: 2.29.3 + dev: true + + /date-fns/2.29.3: + resolution: {integrity: sha512-dDCnyH2WnnKusqvZZ6+jA1O51Ibt8ZMRNkDZdyAyK4YfbDwa/cEmuztzG5pk6hqlp9aSBPYcjOlktquahGwGeA==} + engines: {node: '>=0.11'} + dev: true + + /debug/4.3.4: + resolution: {integrity: sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==} + engines: {node: '>=6.0'} + peerDependencies: + supports-color: '*' + peerDependenciesMeta: + supports-color: + optional: true + dependencies: + ms: 2.1.2 + dev: true + + /deepmerge/4.3.1: + resolution: {integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==} + engines: {node: '>=0.10.0'} + dev: true + + /define-properties/1.2.0: + resolution: {integrity: sha512-xvqAVKGfT1+UAvPwKTVw/njhdQ8ZhXK4lI0bCIuCMrp2up9nPnaDftrLtmpTazqd1o+UY4zgzU+avtMbDP+ldA==} + engines: {node: '>= 0.4'} + dependencies: + has-property-descriptors: 1.0.0 + object-keys: 1.1.1 + dev: true + + /delayed-stream/1.0.0: + resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==} + engines: {node: '>=0.4.0'} + dev: false + + /ejs/3.1.9: + resolution: {integrity: sha512-rC+QVNMJWv+MtPgkt0y+0rVEIdbtxVADApW9JXrUVlzHetgcyczP/E7DJmWJ4fJCZF2cPcBk0laWO9ZHMG3DmQ==} + engines: {node: '>=0.10.0'} + hasBin: true + dependencies: + jake: 10.8.5 + dev: true + + /electron-to-chromium/1.4.332: + resolution: {integrity: sha512-c1Vbv5tuUlBFp0mb3mCIjw+REEsgthRgNE8BlbEDKmvzb8rxjcVki6OkQP83vLN34s0XCxpSkq7AZNep1a6xhw==} + dev: true + + /es-abstract/1.21.2: + resolution: {integrity: sha512-y/B5POM2iBnIxCiernH1G7rC9qQoM77lLIMQLuob0zhp8C56Po81+2Nj0WFKnd0pNReDTnkYryc+zhOzpEIROg==} + engines: {node: '>= 0.4'} + dependencies: + array-buffer-byte-length: 1.0.0 + available-typed-arrays: 1.0.5 + call-bind: 1.0.2 + es-set-tostringtag: 2.0.1 + es-to-primitive: 1.2.1 + function.prototype.name: 1.1.5 + get-intrinsic: 1.2.0 + get-symbol-description: 1.0.0 + globalthis: 1.0.3 + gopd: 1.0.1 + has: 1.0.3 + has-property-descriptors: 1.0.0 + has-proto: 1.0.1 + has-symbols: 1.0.3 + internal-slot: 1.0.5 + is-array-buffer: 3.0.2 + is-callable: 1.2.7 + is-negative-zero: 2.0.2 + is-regex: 1.1.4 + is-shared-array-buffer: 1.0.2 + is-string: 1.0.7 + is-typed-array: 1.1.10 + is-weakref: 1.0.2 + object-inspect: 1.12.3 + object-keys: 1.1.1 + object.assign: 4.1.4 + regexp.prototype.flags: 1.4.3 + safe-regex-test: 1.0.0 + string.prototype.trim: 1.2.7 + string.prototype.trimend: 1.0.6 + string.prototype.trimstart: 1.0.6 + typed-array-length: 1.0.4 + unbox-primitive: 1.0.2 + which-typed-array: 1.1.9 + dev: true + + /es-set-tostringtag/2.0.1: + resolution: {integrity: sha512-g3OMbtlwY3QewlqAiMLI47KywjWZoEytKr8pf6iTC8uJq5bIAH52Z9pnQ8pVL6whrCto53JZDuUIsifGeLorTg==} + engines: {node: '>= 0.4'} + dependencies: + get-intrinsic: 1.2.0 + has: 1.0.3 + has-tostringtag: 1.0.0 + dev: true + + /es-to-primitive/1.2.1: + resolution: {integrity: sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==} + engines: {node: '>= 0.4'} + dependencies: + is-callable: 1.2.7 + is-date-object: 1.0.5 + is-symbol: 1.0.4 + dev: true + + /esbuild/0.16.17: + resolution: {integrity: sha512-G8LEkV0XzDMNwXKgM0Jwu3nY3lSTwSGY6XbxM9cr9+s0T/qSV1q1JVPBGzm3dcjhCic9+emZDmMffkwgPeOeLg==} + engines: {node: '>=12'} + hasBin: true + requiresBuild: true + optionalDependencies: + '@esbuild/android-arm': 0.16.17 + '@esbuild/android-arm64': 0.16.17 + '@esbuild/android-x64': 0.16.17 + '@esbuild/darwin-arm64': 0.16.17 + '@esbuild/darwin-x64': 0.16.17 + '@esbuild/freebsd-arm64': 0.16.17 + '@esbuild/freebsd-x64': 0.16.17 + '@esbuild/linux-arm': 0.16.17 + '@esbuild/linux-arm64': 0.16.17 + '@esbuild/linux-ia32': 0.16.17 + '@esbuild/linux-loong64': 0.16.17 + '@esbuild/linux-mips64el': 0.16.17 + '@esbuild/linux-ppc64': 0.16.17 + '@esbuild/linux-riscv64': 0.16.17 + '@esbuild/linux-s390x': 0.16.17 + '@esbuild/linux-x64': 0.16.17 + '@esbuild/netbsd-x64': 0.16.17 + '@esbuild/openbsd-x64': 0.16.17 + '@esbuild/sunos-x64': 0.16.17 + '@esbuild/win32-arm64': 0.16.17 + '@esbuild/win32-ia32': 0.16.17 + '@esbuild/win32-x64': 0.16.17 + dev: true + + /escalade/3.1.1: + resolution: {integrity: sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==} + engines: {node: '>=6'} + dev: true + + /escape-string-regexp/1.0.5: + resolution: {integrity: sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==} + engines: {node: '>=0.8.0'} + dev: true + + /escape-string-regexp/5.0.0: + resolution: {integrity: sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==} + engines: {node: '>=12'} + dev: true + + /estree-walker/1.0.1: + resolution: {integrity: sha512-1fMXF3YP4pZZVozF8j/ZLfvnR8NSIljt56UhbZ5PeeDmmGHpgpdwQt7ITlGvYaQukCvuBRMLEiKiYC+oeIg4cg==} + dev: true + + /estree-walker/2.0.2: + resolution: {integrity: sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==} + + /esutils/2.0.3: + resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==} + engines: {node: '>=0.10.0'} + dev: true + + /evtd/0.2.4: + resolution: {integrity: sha512-qaeGN5bx63s/AXgQo8gj6fBkxge+OoLddLniox5qtLAEY5HSnuSlISXVPxnSae1dWblvTh4/HoMIB+mbMsvZzw==} + dev: true + + /fast-deep-equal/3.1.3: + resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==} + dev: true + + /fast-glob/3.2.12: + resolution: {integrity: sha512-DVj4CQIYYow0BlaelwK1pHl5n5cRSJfM60UA0zK891sVInoPri2Ekj7+e1CT3/3qxXenpI+nBBmQAcJPJgaj4w==} + engines: {node: '>=8.6.0'} + dependencies: + '@nodelib/fs.stat': 2.0.5 + '@nodelib/fs.walk': 1.2.8 + glob-parent: 5.1.2 + merge2: 1.4.1 + micromatch: 4.0.5 + dev: true + + /fast-json-stable-stringify/2.1.0: + resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==} + dev: true + + /fastq/1.15.0: + resolution: {integrity: sha512-wBrocU2LCXXa+lWBt8RoIRD89Fi8OdABODa/kEnyeyjS5aZO5/GNvI5sEINADqP/h8M29UHTHUb53sUu5Ihqdw==} + dependencies: + reusify: 1.0.4 + dev: true + + /filelist/1.0.4: + resolution: {integrity: sha512-w1cEuf3S+DrLCQL7ET6kz+gmlJdbq9J7yXCSjK/OZCPA+qEN1WyF4ZAf0YYJa4/shHJra2t/d/r8SV4Ji+x+8Q==} + dependencies: + minimatch: 5.1.6 + dev: true + + /fill-range/7.0.1: + resolution: {integrity: sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==} + engines: {node: '>=8'} + dependencies: + to-regex-range: 5.0.1 + + /follow-redirects/1.15.2: + resolution: {integrity: sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA==} + engines: {node: '>=4.0'} + peerDependencies: + debug: '*' + peerDependenciesMeta: + debug: + optional: true + dev: false + + /for-each/0.3.3: + resolution: {integrity: sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==} + dependencies: + is-callable: 1.2.7 + dev: true + + /form-data/4.0.0: + resolution: {integrity: sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==} + engines: {node: '>= 6'} + dependencies: + asynckit: 0.4.0 + combined-stream: 1.0.8 + mime-types: 2.1.35 + dev: false + + /fs-extra/9.1.0: + resolution: {integrity: sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==} + engines: {node: '>=10'} + dependencies: + at-least-node: 1.0.0 + graceful-fs: 4.2.11 + jsonfile: 6.1.0 + universalify: 2.0.0 + dev: true + + /fs.realpath/1.0.0: + resolution: {integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==} + dev: true + + /fsevents/2.3.2: + resolution: {integrity: sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==} + engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0} + os: [darwin] + requiresBuild: true + optional: true + + /function-bind/1.1.1: + resolution: {integrity: sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==} + dev: true + + /function.prototype.name/1.1.5: + resolution: {integrity: sha512-uN7m/BzVKQnCUF/iW8jYea67v++2u7m5UgENbHRtdDVclOUP+FMPlCNdmk0h/ysGyo2tavMJEDqJAkJdRa1vMA==} + engines: {node: '>= 0.4'} + dependencies: + call-bind: 1.0.2 + define-properties: 1.2.0 + es-abstract: 1.21.2 + functions-have-names: 1.2.3 + dev: true + + /functions-have-names/1.2.3: + resolution: {integrity: sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==} + dev: true + + /gensync/1.0.0-beta.2: + resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==} + engines: {node: '>=6.9.0'} + dev: true + + /get-intrinsic/1.2.0: + resolution: {integrity: sha512-L049y6nFOuom5wGyRc3/gdTLO94dySVKRACj1RmJZBQXlbTMhtNIgkWkUHq+jYmZvKf14EW1EoJnnjbmoHij0Q==} + dependencies: + function-bind: 1.1.1 + has: 1.0.3 + has-symbols: 1.0.3 + dev: true + + /get-own-enumerable-property-symbols/3.0.2: + resolution: {integrity: sha512-I0UBV/XOz1XkIJHEUDMZAbzCThU/H8DxmSfmdGcKPnVhu2VfFqr34jr9777IyaTYvxjedWhqVIilEDsCdP5G6g==} + dev: true + + /get-symbol-description/1.0.0: + resolution: {integrity: sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw==} + engines: {node: '>= 0.4'} + dependencies: + call-bind: 1.0.2 + get-intrinsic: 1.2.0 + dev: true + + /glob-parent/5.1.2: + resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==} + engines: {node: '>= 6'} + dependencies: + is-glob: 4.0.3 + + /glob/7.2.3: + resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==} + dependencies: + fs.realpath: 1.0.0 + inflight: 1.0.6 + inherits: 2.0.4 + minimatch: 3.1.2 + once: 1.4.0 + path-is-absolute: 1.0.1 + dev: true + + /globals/11.12.0: + resolution: {integrity: sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==} + engines: {node: '>=4'} + dev: true + + /globalthis/1.0.3: + resolution: {integrity: sha512-sFdI5LyBiNTHjRd7cGPWapiHWMOXKyuBNX/cWJ3NfzrZQVa8GI/8cofCl74AOVqq9W5kNmguTIzJ/1s2gyI9wA==} + engines: {node: '>= 0.4'} + dependencies: + define-properties: 1.2.0 + dev: true + + /gopd/1.0.1: + resolution: {integrity: sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==} + dependencies: + get-intrinsic: 1.2.0 + dev: true + + /graceful-fs/4.2.11: + resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==} + dev: true + + /has-bigints/1.0.2: + resolution: {integrity: sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==} + dev: true + + /has-flag/3.0.0: + resolution: {integrity: sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==} + engines: {node: '>=4'} + dev: true + + /has-flag/4.0.0: + resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==} + engines: {node: '>=8'} + dev: true + + /has-property-descriptors/1.0.0: + resolution: {integrity: sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ==} + dependencies: + get-intrinsic: 1.2.0 + dev: true + + /has-proto/1.0.1: + resolution: {integrity: sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg==} + engines: {node: '>= 0.4'} + dev: true + + /has-symbols/1.0.3: + resolution: {integrity: sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==} + engines: {node: '>= 0.4'} + dev: true + + /has-tostringtag/1.0.0: + resolution: {integrity: sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==} + engines: {node: '>= 0.4'} + dependencies: + has-symbols: 1.0.3 + dev: true + + /has/1.0.3: + resolution: {integrity: sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==} + engines: {node: '>= 0.4.0'} + dependencies: + function-bind: 1.1.1 + dev: true + + /highlight.js/11.7.0: + resolution: {integrity: sha512-1rRqesRFhMO/PRF+G86evnyJkCgaZFOI+Z6kdj15TA18funfoqJXvgPCLSf0SWq3SRfg1j3HlDs8o4s3EGq1oQ==} + engines: {node: '>=12.0.0'} + dev: true + + /idb/7.1.1: + resolution: {integrity: sha512-gchesWBzyvGHRO9W8tzUWFDycow5gwjvFKfyV9FF32Y7F50yZMp7mP+T2mJIWFx49zicqyC4uefHM17o6xKIVQ==} + dev: true + + /immutable/4.2.4: + resolution: {integrity: sha512-WDxL3Hheb1JkRN3sQkyujNlL/xRjAo3rJtaU5xeufUauG66JdMr32bLj4gF+vWl84DIA3Zxw7tiAjneYzRRw+w==} + + /inflight/1.0.6: + resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==} + dependencies: + once: 1.4.0 + wrappy: 1.0.2 + dev: true + + /inherits/2.0.4: + resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==} + dev: true + + /internal-slot/1.0.5: + resolution: {integrity: sha512-Y+R5hJrzs52QCG2laLn4udYVnxsfny9CpOhNhUvk/SSSVyF6T27FzRbF0sroPidSu3X8oEAkOn2K804mjpt6UQ==} + engines: {node: '>= 0.4'} + dependencies: + get-intrinsic: 1.2.0 + has: 1.0.3 + side-channel: 1.0.4 + dev: true + + /is-array-buffer/3.0.2: + resolution: {integrity: sha512-y+FyyR/w8vfIRq4eQcM1EYgSTnmHXPqaF+IgzgraytCFq5Xh8lllDVmAZolPJiZttZLeFSINPYMaEJ7/vWUa1w==} + dependencies: + call-bind: 1.0.2 + get-intrinsic: 1.2.0 + is-typed-array: 1.1.10 + dev: true + + /is-bigint/1.0.4: + resolution: {integrity: sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==} + dependencies: + has-bigints: 1.0.2 + dev: true + + /is-binary-path/2.1.0: + resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==} + engines: {node: '>=8'} + dependencies: + binary-extensions: 2.2.0 + + /is-boolean-object/1.1.2: + resolution: {integrity: sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==} + engines: {node: '>= 0.4'} + dependencies: + call-bind: 1.0.2 + has-tostringtag: 1.0.0 + dev: true + + /is-callable/1.2.7: + resolution: {integrity: sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==} + engines: {node: '>= 0.4'} + dev: true + + /is-core-module/2.11.0: + resolution: {integrity: sha512-RRjxlvLDkD1YJwDbroBHMb+cukurkDWNyHx7D3oNB5x9rb5ogcksMC5wHCadcXoo67gVr/+3GFySh3134zi6rw==} + dependencies: + has: 1.0.3 + dev: true + + /is-date-object/1.0.5: + resolution: {integrity: sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==} + engines: {node: '>= 0.4'} + dependencies: + has-tostringtag: 1.0.0 + dev: true + + /is-dom-node-list/1.2.1: + resolution: {integrity: sha512-P1H071iT5TGG8pAHslhrLDo/tQLYc8tGuWABVqhGU4l2mm7aDNb9cx2myQ2AujEQO6B2cAujcW4a0/+6UfXInw==} + dependencies: + is-dom-node: 1.0.4 + dev: false + + /is-dom-node/1.0.4: + resolution: {integrity: sha512-NEnTHKCeyGJTL0cKdzATF8SWzyTMYf5CbNKWBvsXvyMxZG32g+a09qkeCbrfQNLTD85CbPeHb4YjIJCjyzF0yA==} + dev: false + + /is-extglob/2.1.1: + resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==} + engines: {node: '>=0.10.0'} + + /is-glob/4.0.3: + resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==} + engines: {node: '>=0.10.0'} + dependencies: + is-extglob: 2.1.1 + + /is-module/1.0.0: + resolution: {integrity: sha512-51ypPSPCoTEIN9dy5Oy+h4pShgJmPCygKfyRCISBI+JoWT/2oJvK8QPxmwv7b/p239jXrm9M1mlQbyKJ5A152g==} + dev: true + + /is-negative-zero/2.0.2: + resolution: {integrity: sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA==} + engines: {node: '>= 0.4'} + dev: true + + /is-number-object/1.0.7: + resolution: {integrity: sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==} + engines: {node: '>= 0.4'} + dependencies: + has-tostringtag: 1.0.0 + dev: true + + /is-number/7.0.0: + resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==} + engines: {node: '>=0.12.0'} + + /is-obj/1.0.1: + resolution: {integrity: sha512-l4RyHgRqGN4Y3+9JHVrNqO+tN0rV5My76uW5/nuO4K1b6vw5G8d/cmFjP9tRfEsdhZNt0IFdZuK/c2Vr4Nb+Qg==} + engines: {node: '>=0.10.0'} + dev: true + + /is-regex/1.1.4: + resolution: {integrity: sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==} + engines: {node: '>= 0.4'} + dependencies: + call-bind: 1.0.2 + has-tostringtag: 1.0.0 + dev: true + + /is-regexp/1.0.0: + resolution: {integrity: sha512-7zjFAPO4/gwyQAAgRRmqeEeyIICSdmCqa3tsVHMdBzaXXRiqopZL4Cyghg/XulGWrtABTpbnYYzzIRffLkP4oA==} + engines: {node: '>=0.10.0'} + dev: true + + /is-shared-array-buffer/1.0.2: + resolution: {integrity: sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA==} + dependencies: + call-bind: 1.0.2 + dev: true + + /is-stream/2.0.1: + resolution: {integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==} + engines: {node: '>=8'} + dev: true + + /is-string/1.0.7: + resolution: {integrity: sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==} + engines: {node: '>= 0.4'} + dependencies: + has-tostringtag: 1.0.0 + dev: true + + /is-symbol/1.0.4: + resolution: {integrity: sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==} + engines: {node: '>= 0.4'} + dependencies: + has-symbols: 1.0.3 + dev: true + + /is-typed-array/1.1.10: + resolution: {integrity: sha512-PJqgEHiWZvMpaFZ3uTc8kHPM4+4ADTlDniuQL7cU/UDA0Ql7F70yGfHph3cLNe+c9toaigv+DFzTJKhc2CtO6A==} + engines: {node: '>= 0.4'} + dependencies: + available-typed-arrays: 1.0.5 + call-bind: 1.0.2 + for-each: 0.3.3 + gopd: 1.0.1 + has-tostringtag: 1.0.0 + dev: true + + /is-weakref/1.0.2: + resolution: {integrity: sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==} + dependencies: + call-bind: 1.0.2 + dev: true + + /jake/10.8.5: + resolution: {integrity: sha512-sVpxYeuAhWt0OTWITwT98oyV0GsXyMlXCF+3L1SuafBVUIr/uILGRB+NqwkzhgXKvoJpDIpQvqkUALgdmQsQxw==} + engines: {node: '>=10'} + hasBin: true + dependencies: + async: 3.2.4 + chalk: 4.1.2 + filelist: 1.0.4 + minimatch: 3.1.2 + dev: true + + /jest-worker/26.6.2: + resolution: {integrity: sha512-KWYVV1c4i+jbMpaBC+U++4Va0cp8OisU185o73T1vo99hqi7w8tSJfUXYswwqqrjzwxa6KpRK54WhPvwf5w6PQ==} + engines: {node: '>= 10.13.0'} + dependencies: + '@types/node': 18.15.3 + merge-stream: 2.0.0 + supports-color: 7.2.0 + dev: true + + /js-tokens/4.0.0: + resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==} + dev: true + + /jsesc/0.5.0: + resolution: {integrity: sha512-uZz5UnB7u4T9LvwmFqXii7pZSouaRPorGs5who1Ip7VO0wxanFvBL7GkM6dTHlgX+jhBApRetaWpnDabOeTcnA==} + hasBin: true + dev: true + + /jsesc/2.5.2: + resolution: {integrity: sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==} + engines: {node: '>=4'} + hasBin: true + dev: true + + /json-schema-traverse/1.0.0: + resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==} + dev: true + + /json-schema/0.4.0: + resolution: {integrity: sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==} + dev: true + + /json5/2.2.3: + resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==} + engines: {node: '>=6'} + hasBin: true + dev: true + + /jsonc-parser/3.2.0: + resolution: {integrity: sha512-gfFQZrcTc8CnKXp6Y4/CBT3fTc0OVuDofpre4aEeEpSBPV5X5v4+Vmx+8snU7RLPrNHPKSgLxGo9YuQzz20o+w==} + dev: true + + /jsonfile/6.1.0: + resolution: {integrity: sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==} + dependencies: + universalify: 2.0.0 + optionalDependencies: + graceful-fs: 4.2.11 + dev: true + + /jsonpointer/5.0.1: + resolution: {integrity: sha512-p/nXbhSEcu3pZRdkW1OfJhpsVtW1gd4Wa1fnQc9YLiTfAjn0312eMKimbdIQzuZl9aa9xUGaRlP9T/CJE/ditQ==} + engines: {node: '>=0.10.0'} + dev: true + + /leven/3.1.0: + resolution: {integrity: sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==} + engines: {node: '>=6'} + dev: true + + /local-pkg/0.4.3: + resolution: {integrity: sha512-SFppqq5p42fe2qcZQqqEOiVRXl+WCP1MdT6k7BDEW1j++sp5fIY+/fdRQitvKgB5BrBcmrs5m/L0v2FrU5MY1g==} + engines: {node: '>=14'} + dev: true + + /lodash-es/4.17.21: + resolution: {integrity: sha512-mKnC+QJ9pWVzv+C4/U3rRsHapFfHvQFoFB92e52xeyGMcX6/OlIl78je1u8vePzYZSkkogMPJ2yjxxsb89cxyw==} + dev: true + + /lodash.debounce/4.0.8: + resolution: {integrity: sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==} + dev: true + + /lodash.sortby/4.7.0: + resolution: {integrity: sha512-HDWXG8isMntAyRF5vZ7xKuEvOhT4AhlRt/3czTSjvGUxjYCBVRQY48ViDHyfYz9VIoBkW4TMGQNapx+l3RUwdA==} + dev: true + + /lodash/4.17.21: + resolution: {integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==} + dev: true + + /lru-cache/5.1.1: + resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==} + dependencies: + yallist: 3.1.1 + dev: true + + /lunar-calendar/0.1.4: + resolution: {integrity: sha512-5r87vbg5yg56z/jkf3A+Ur+ZggUTiJw1VATT9P7RELQgWcTNhfJ+OLkNYroSna6r65bMqyaAgapo9vRN40L75A==} + dev: false + + /magic-string/0.25.9: + resolution: {integrity: sha512-RmF0AsMzgt25qzqqLc1+MbHmhdx0ojF2Fvs4XnOqz2ZOBXzzkEwc/dJQZCYHAn7v1jbVOjAZfK8msRn4BxO4VQ==} + dependencies: + sourcemap-codec: 1.4.8 + + /magic-string/0.27.0: + resolution: {integrity: sha512-8UnnX2PeRAPZuN12svgR9j7M1uWMovg/CEnIwIG0LFkXSJJe4PdfUGiTGl8V9bsBHFUtfVINcSyYxd7q+kx9fA==} + engines: {node: '>=12'} + dependencies: + '@jridgewell/sourcemap-codec': 1.4.14 + dev: true + + /merge-stream/2.0.0: + resolution: {integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==} + dev: true + + /merge2/1.4.1: + resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==} + engines: {node: '>= 8'} + dev: true + + /micromatch/4.0.5: + resolution: {integrity: sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==} + engines: {node: '>=8.6'} + dependencies: + braces: 3.0.2 + picomatch: 2.3.1 + dev: true + + /mime-db/1.52.0: + resolution: {integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==} + engines: {node: '>= 0.6'} + dev: false + + /mime-types/2.1.35: + resolution: {integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==} + engines: {node: '>= 0.6'} + dependencies: + mime-db: 1.52.0 + dev: false + + /minimatch/3.1.2: + resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==} + dependencies: + brace-expansion: 1.1.11 + dev: true + + /minimatch/5.1.6: + resolution: {integrity: sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==} + engines: {node: '>=10'} + dependencies: + brace-expansion: 2.0.1 + dev: true + + /miniraf/1.0.0: + resolution: {integrity: sha512-XpvhtJYzVrpXe+JoAthrT9E40NIrSDDMcdHEYL2M+lR/OCas0nadetcBBq/MWYqlgV5aDWVQ3mfAqd+fG6Y/EQ==} + dev: false + + /mlly/1.1.1: + resolution: {integrity: sha512-Jnlh4W/aI4GySPo6+DyTN17Q75KKbLTyFK8BrGhjNP4rxuUjbRWhE6gHg3bs33URWAF44FRm7gdQA348i3XxRw==} + dependencies: + acorn: 8.8.2 + pathe: 1.1.0 + pkg-types: 1.0.2 + ufo: 1.1.1 + dev: true + + /ms/2.1.2: + resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==} + dev: true + + /naive-ui/2.34.3_vue@3.2.47: + resolution: {integrity: sha512-fUMr0dzb/iGsOTWgoblPVobY5X5dihQ1eam5dA+H74oyLYAvgX4pL96xQFPBLIYqvyRFBAsN85kHN5pLqdtpxA==} + peerDependencies: + vue: ^3.0.0 + dependencies: + '@css-render/plugin-bem': 0.15.12_css-render@0.15.12 + '@css-render/vue3-ssr': 0.15.12_vue@3.2.47 + '@types/katex': 0.14.0 + '@types/lodash': 4.14.191 + '@types/lodash-es': 4.17.6 + async-validator: 4.2.5 + css-render: 0.15.12 + date-fns: 2.29.3 + date-fns-tz: 1.3.8_date-fns@2.29.3 + evtd: 0.2.4 + highlight.js: 11.7.0 + lodash: 4.17.21 + lodash-es: 4.17.21 + seemly: 0.3.6 + treemate: 0.3.11 + vdirs: 0.1.8_vue@3.2.47 + vooks: 0.2.12_vue@3.2.47 + vue: 3.2.47 + vueuc: 0.4.51_vue@3.2.47 + dev: true + + /nanoid/3.3.4: + resolution: {integrity: sha512-MqBkQh/OHTS2egovRtLk45wEyNXwF+cokD+1YPf9u5VfJiRdAiRwB2froX5Co9Rh20xs4siNPm8naNotSD6RBw==} + engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1} + hasBin: true + + /node-releases/2.0.10: + resolution: {integrity: sha512-5GFldHPXVG/YZmFzJvKK2zDSzPKhEp0+ZR5SVaoSag9fsL5YgHbUHDfnG5494ISANDcK4KwPXAx2xqVEydmd7w==} + dev: true + + /normalize-path/3.0.0: + resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==} + engines: {node: '>=0.10.0'} + + /object-inspect/1.12.3: + resolution: {integrity: sha512-geUvdk7c+eizMNUDkRpW1wJwgfOiOeHbxBR/hLXK1aT6zmVSO0jsQcs7fj6MGw89jC/cjGfLcNOrtMYtGqm81g==} + dev: true + + /object-keys/1.1.1: + resolution: {integrity: sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==} + engines: {node: '>= 0.4'} + dev: true + + /object.assign/4.1.4: + resolution: {integrity: sha512-1mxKf0e58bvyjSCtKYY4sRe9itRk3PJpquJOjeIkz885CczcI4IvJJDLPS72oowuSh+pBxUFROpX+TU++hxhZQ==} + engines: {node: '>= 0.4'} + dependencies: + call-bind: 1.0.2 + define-properties: 1.2.0 + has-symbols: 1.0.3 + object-keys: 1.1.1 + dev: true + + /once/1.4.0: + resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==} + dependencies: + wrappy: 1.0.2 + dev: true + + /path-is-absolute/1.0.1: + resolution: {integrity: sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==} + engines: {node: '>=0.10.0'} + dev: true + + /path-parse/1.0.7: + resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==} + dev: true + + /pathe/1.1.0: + resolution: {integrity: sha512-ODbEPR0KKHqECXW1GoxdDb+AZvULmXjVPy4rt+pGo2+TnjJTIPJQSVS6N63n8T2Ip+syHhbn52OewKicV0373w==} + dev: true + + /picocolors/1.0.0: + resolution: {integrity: sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==} + + /picomatch/2.3.1: + resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==} + engines: {node: '>=8.6'} + + /pinia-plugin-persistedstate/3.1.0_pinia@2.0.32: + resolution: {integrity: sha512-8UN+vYMEPBdgNLwceY08mi5olI0wkYaEb8b6hD6xW7SnBRuPydWHlEhZvUWgNb/ibuf4PvufpvtS+dmhYjJQOw==} + peerDependencies: + pinia: ^2.0.0 + dependencies: + pinia: 2.0.32_vue@3.2.47 + dev: false + + /pinia/2.0.32_vue@3.2.47: + resolution: {integrity: sha512-8Tw4OrpCSJ028UUyp0gYPP/wyjigLoEceuO/x1G+FlHVf73337e5vLm4uDmrRIoBG1hvaed/eSHnrCFjOc4nkA==} + peerDependencies: + '@vue/composition-api': ^1.4.0 + typescript: '>=4.4.4' + vue: ^2.6.14 || ^3.2.0 + peerDependenciesMeta: + '@vue/composition-api': + optional: true + typescript: + optional: true + dependencies: + '@vue/devtools-api': 6.5.0 + vue: 3.2.47 + vue-demi: 0.13.11_vue@3.2.47 + dev: false + + /pkg-types/1.0.2: + resolution: {integrity: sha512-hM58GKXOcj8WTqUXnsQyJYXdeAPbythQgEF3nTcEo+nkD49chjQ9IKm/QJy9xf6JakXptz86h7ecP2024rrLaQ==} + dependencies: + jsonc-parser: 3.2.0 + mlly: 1.1.1 + pathe: 1.1.0 + dev: true + + /postcss/8.4.21: + resolution: {integrity: sha512-tP7u/Sn/dVxK2NnruI4H9BG+x+Wxz6oeZ1cJ8P6G/PZY0IKk4k/63TDsQf2kQq3+qoJeLm2kIBUNlZe3zgb4Zg==} + engines: {node: ^10 || ^12 || >=14} + dependencies: + nanoid: 3.3.4 + picocolors: 1.0.0 + source-map-js: 1.0.2 + + /pretty-bytes/5.6.0: + resolution: {integrity: sha512-FFw039TmrBqFK8ma/7OL3sDz/VytdtJr044/QUJtH0wK9lb9jLq9tJyIxUwtQJHwar2BqtiA4iCWSwo9JLkzFg==} + engines: {node: '>=6'} + dev: true + + /pretty-bytes/6.1.0: + resolution: {integrity: sha512-Rk753HI8f4uivXi4ZCIYdhmG1V+WKzvRMg/X+M42a6t7D07RcmopXJMDNk6N++7Bl75URRGsb40ruvg7Hcp2wQ==} + engines: {node: ^14.13.1 || >=16.0.0} + dev: true + + /proxy-from-env/1.1.0: + resolution: {integrity: sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==} + dev: false + + /punycode/2.3.0: + resolution: {integrity: sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA==} + engines: {node: '>=6'} + dev: true + + /queue-microtask/1.2.3: + resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==} + dev: true + + /randombytes/2.1.0: + resolution: {integrity: sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==} + dependencies: + safe-buffer: 5.2.1 + dev: true + + /readdirp/3.6.0: + resolution: {integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==} + engines: {node: '>=8.10.0'} + dependencies: + picomatch: 2.3.1 + + /regenerate-unicode-properties/10.1.0: + resolution: {integrity: sha512-d1VudCLoIGitcU/hEg2QqvyGZQmdC0Lf8BqdOMXGFSvJP4bNV1+XqbPQeHHLD51Jh4QJJ225dlIFvY4Ly6MXmQ==} + engines: {node: '>=4'} + dependencies: + regenerate: 1.4.2 + dev: true + + /regenerate/1.4.2: + resolution: {integrity: sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==} + dev: true + + /regenerator-runtime/0.13.11: + resolution: {integrity: sha512-kY1AZVr2Ra+t+piVaJ4gxaFaReZVH40AKNo7UCX6W+dEwBo/2oZJzqfuN1qLq1oL45o56cPaTXELwrTh8Fpggg==} + dev: true + + /regenerator-transform/0.15.1: + resolution: {integrity: sha512-knzmNAcuyxV+gQCufkYcvOqX/qIIfHLv0u5x79kRxuGojfYVky1f15TzZEu2Avte8QGepvUNTnLskf8E6X6Vyg==} + dependencies: + '@babel/runtime': 7.21.0 + dev: true + + /regexp.prototype.flags/1.4.3: + resolution: {integrity: sha512-fjggEOO3slI6Wvgjwflkc4NFRCTZAu5CnNfBd5qOMYhWdn67nJBBu34/TkD++eeFmd8C9r9jfXJ27+nSiRkSUA==} + engines: {node: '>= 0.4'} + dependencies: + call-bind: 1.0.2 + define-properties: 1.2.0 + functions-have-names: 1.2.3 + dev: true + + /regexpu-core/5.3.2: + resolution: {integrity: sha512-RAM5FlZz+Lhmo7db9L298p2vHP5ZywrVXmVXpmAD9GuL5MPH6t9ROw1iA/wfHkQ76Qe7AaPF0nGuim96/IrQMQ==} + engines: {node: '>=4'} + dependencies: + '@babel/regjsgen': 0.8.0 + regenerate: 1.4.2 + regenerate-unicode-properties: 10.1.0 + regjsparser: 0.9.1 + unicode-match-property-ecmascript: 2.0.0 + unicode-match-property-value-ecmascript: 2.1.0 + dev: true + + /regjsparser/0.9.1: + resolution: {integrity: sha512-dQUtn90WanSNl+7mQKcXAgZxvUe7Z0SqXlgzv0za4LwiUhyzBC58yQO3liFoUgu8GiJVInAhJjkj1N0EtQ5nkQ==} + hasBin: true + dependencies: + jsesc: 0.5.0 + dev: true + + /rematrix/0.3.0: + resolution: {integrity: sha512-xB/9ZvJIKaDgXX0qkvV9/pLD8zK23A6TVV6F8Vhsl+SrxbBeVYutz5uszxgC6Rt3RP9LZiH8OXaYjr+x6WXWmQ==} + dev: false + + /require-from-string/2.0.2: + resolution: {integrity: sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==} + engines: {node: '>=0.10.0'} + dev: true + + /resolve/1.22.1: + resolution: {integrity: sha512-nBpuuYuY5jFsli/JIs1oldw6fOQCBioohqWZg/2hiaOybXOft4lonv85uDOKXdf8rhyK159cxU5cDcK/NKk8zw==} + hasBin: true + dependencies: + is-core-module: 2.11.0 + path-parse: 1.0.7 + supports-preserve-symlinks-flag: 1.0.0 + dev: true + + /reusify/1.0.4: + resolution: {integrity: sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==} + engines: {iojs: '>=1.0.0', node: '>=0.10.0'} + dev: true + + /rollup-plugin-terser/7.0.2_rollup@2.79.1: + resolution: {integrity: sha512-w3iIaU4OxcF52UUXiZNsNeuXIMDvFrr+ZXK6bFZ0Q60qyVfq4uLptoS4bbq3paG3x216eQllFZX7zt6TIImguQ==} + deprecated: This package has been deprecated and is no longer maintained. Please use @rollup/plugin-terser + peerDependencies: + rollup: ^2.0.0 + dependencies: + '@babel/code-frame': 7.18.6 + jest-worker: 26.6.2 + rollup: 2.79.1 + serialize-javascript: 4.0.0 + terser: 5.16.5 + dev: true + + /rollup/2.79.1: + resolution: {integrity: sha512-uKxbd0IhMZOhjAiD5oAFp7BqvkA4Dv47qpOCtaNvng4HBwdbWtdOh8f5nZNuk2rp51PMGk3bzfWu5oayNEuYnw==} + engines: {node: '>=10.0.0'} + hasBin: true + optionalDependencies: + fsevents: 2.3.2 + dev: true + + /rollup/3.18.0: + resolution: {integrity: sha512-J8C6VfEBjkvYPESMQYxKHxNOh4A5a3FlP+0BETGo34HEcE4eTlgCrO2+eWzlu2a/sHs2QUkZco+wscH7jhhgWg==} + engines: {node: '>=14.18.0', npm: '>=8.0.0'} + hasBin: true + optionalDependencies: + fsevents: 2.3.2 + dev: true + + /run-parallel/1.2.0: + resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==} + dependencies: + queue-microtask: 1.2.3 + dev: true + + /safe-buffer/5.2.1: + resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==} + dev: true + + /safe-regex-test/1.0.0: + resolution: {integrity: sha512-JBUUzyOgEwXQY1NuPtvcj/qcBDbDmEvWufhlnXZIm75DEHp+afM1r1ujJpJsV/gSM4t59tpDyPi1sd6ZaPFfsA==} + dependencies: + call-bind: 1.0.2 + get-intrinsic: 1.2.0 + is-regex: 1.1.4 + dev: true + + /sass/1.58.3: + resolution: {integrity: sha512-Q7RaEtYf6BflYrQ+buPudKR26/lH+10EmO9bBqbmPh/KeLqv8bjpTNqxe71ocONqXq+jYiCbpPUmQMS+JJPk4A==} + engines: {node: '>=12.0.0'} + hasBin: true + dependencies: + chokidar: 3.5.3 + immutable: 4.2.4 + source-map-js: 1.0.2 + + /scrollreveal/4.0.9: + resolution: {integrity: sha512-fefGvzVS8YbXbDK1+T0kvy2yqxaiBJZeGUhPeqajf+7sGqtX4xikbKGAlzQuPCpswAMswx94ZwhDjXKnRIqW1w==} + requiresBuild: true + dependencies: + miniraf: 1.0.0 + rematrix: 0.3.0 + tealight: 0.3.6 + dev: false + + /scule/1.0.0: + resolution: {integrity: sha512-4AsO/FrViE/iDNEPaAQlb77tf0csuq27EsVpy6ett584EcRTp6pTDLoGWVxCD77y5iU5FauOvhsI4o1APwPoSQ==} + dev: true + + /seemly/0.3.6: + resolution: {integrity: sha512-lEV5VB8BUKTo/AfktXJcy+JeXns26ylbMkIUco8CYREsQijuz4mrXres2Q+vMLdwkuLxJdIPQ8IlCIxLYm71Yw==} + dev: true + + /semver/6.3.0: + resolution: {integrity: sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==} + hasBin: true + dev: true + + /serialize-javascript/4.0.0: + resolution: {integrity: sha512-GaNA54380uFefWghODBWEGisLZFj00nS5ACs6yHa9nLqlLpVLO8ChDGeKRjZnV4Nh4n0Qi7nhYZD/9fCPzEqkw==} + dependencies: + randombytes: 2.1.0 + dev: true + + /side-channel/1.0.4: + resolution: {integrity: sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==} + dependencies: + call-bind: 1.0.2 + get-intrinsic: 1.2.0 + object-inspect: 1.12.3 + dev: true + + /sortablejs/1.14.0: + resolution: {integrity: sha512-pBXvQCs5/33fdN1/39pPL0NZF20LeRbLQ5jtnheIPN9JQAaufGjKdWduZn4U7wCtVuzKhmRkI0DFYHYRbB2H1w==} + dev: false + + /source-map-js/1.0.2: + resolution: {integrity: sha512-R0XvVJ9WusLiqTCEiGCmICCMplcCkIwwR11mOSD9CR5u+IXYdiseeEuXCVAjS54zqwkLcPNnmU4OeJ6tUrWhDw==} + engines: {node: '>=0.10.0'} + + /source-map-support/0.5.21: + resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==} + dependencies: + buffer-from: 1.1.2 + source-map: 0.6.1 + + /source-map/0.6.1: + resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==} + engines: {node: '>=0.10.0'} + + /source-map/0.8.0-beta.0: + resolution: {integrity: sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA==} + engines: {node: '>= 8'} + dependencies: + whatwg-url: 7.1.0 + dev: true + + /sourcemap-codec/1.4.8: + resolution: {integrity: sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==} + deprecated: Please use @jridgewell/sourcemap-codec instead + + /string.prototype.matchall/4.0.8: + resolution: {integrity: sha512-6zOCOcJ+RJAQshcTvXPHoxoQGONa3e/Lqx90wUA+wEzX78sg5Bo+1tQo4N0pohS0erG9qtCqJDjNCQBjeWVxyg==} + dependencies: + call-bind: 1.0.2 + define-properties: 1.2.0 + es-abstract: 1.21.2 + get-intrinsic: 1.2.0 + has-symbols: 1.0.3 + internal-slot: 1.0.5 + regexp.prototype.flags: 1.4.3 + side-channel: 1.0.4 + dev: true + + /string.prototype.trim/1.2.7: + resolution: {integrity: sha512-p6TmeT1T3411M8Cgg9wBTMRtY2q9+PNy9EV1i2lIXUN/btt763oIfxwN3RR8VU6wHX8j/1CFy0L+YuThm6bgOg==} + engines: {node: '>= 0.4'} + dependencies: + call-bind: 1.0.2 + define-properties: 1.2.0 + es-abstract: 1.21.2 + dev: true + + /string.prototype.trimend/1.0.6: + resolution: {integrity: sha512-JySq+4mrPf9EsDBEDYMOb/lM7XQLulwg5R/m1r0PXEFqrV0qHvl58sdTilSXtKOflCsK2E8jxf+GKC0T07RWwQ==} + dependencies: + call-bind: 1.0.2 + define-properties: 1.2.0 + es-abstract: 1.21.2 + dev: true + + /string.prototype.trimstart/1.0.6: + resolution: {integrity: sha512-omqjMDaY92pbn5HOX7f9IccLA+U1tA9GvtU4JrodiXFfYB7jPzzHpRzpglLAjtUV6bB557zwClJezTqnAiYnQA==} + dependencies: + call-bind: 1.0.2 + define-properties: 1.2.0 + es-abstract: 1.21.2 + dev: true + + /stringify-object/3.3.0: + resolution: {integrity: sha512-rHqiFh1elqCQ9WPLIC8I0Q/g/wj5J1eMkyoiD6eoQApWHP0FtlK7rqnhmabL5VUY9JQCcqwwvlOaSuutekgyrw==} + engines: {node: '>=4'} + dependencies: + get-own-enumerable-property-symbols: 3.0.2 + is-obj: 1.0.1 + is-regexp: 1.0.0 + dev: true + + /strip-comments/2.0.1: + resolution: {integrity: sha512-ZprKx+bBLXv067WTCALv8SSz5l2+XhpYCsVtSqlMnkAXMWDq+/ekVbl1ghqP9rUHTzv6sm/DwCOiYutU/yp1fw==} + engines: {node: '>=10'} + dev: true + + /strip-literal/1.0.1: + resolution: {integrity: sha512-QZTsipNpa2Ppr6v1AmJHESqJ3Uz247MUS0OjrnnZjFAvEoWqxuyFuXn2xLgMtRnijJShAa1HL0gtJyUs7u7n3Q==} + dependencies: + acorn: 8.8.2 + dev: true + + /supports-color/5.5.0: + resolution: {integrity: sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==} + engines: {node: '>=4'} + dependencies: + has-flag: 3.0.0 + dev: true + + /supports-color/7.2.0: + resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==} + engines: {node: '>=8'} + dependencies: + has-flag: 4.0.0 + dev: true + + /supports-preserve-symlinks-flag/1.0.0: + resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==} + engines: {node: '>= 0.4'} + dev: true + + /tealight/0.3.6: + resolution: {integrity: sha512-Dys3N8jFBThD9pNVpPCyUiu6DfWcTBdqWQJIvnAuVaFkGEdrPBJ43070vVbn6sTlLvn2IQK2zFW4FrVIrTo8eQ==} + dependencies: + is-dom-node: 1.0.4 + is-dom-node-list: 1.2.1 + dev: false + + /temp-dir/2.0.0: + resolution: {integrity: sha512-aoBAniQmmwtcKp/7BzsH8Cxzv8OL736p7v1ihGb5e9DJ9kTwGWHrQrVB5+lfVDzfGrdRzXch+ig7LHaY1JTOrg==} + engines: {node: '>=8'} + dev: true + + /tempy/0.6.0: + resolution: {integrity: sha512-G13vtMYPT/J8A4X2SjdtBTphZlrp1gKv6hZiOjw14RCWg6GbHuQBGtjlx75xLbYV/wEc0D7G5K4rxKP/cXk8Bw==} + engines: {node: '>=10'} + dependencies: + is-stream: 2.0.1 + temp-dir: 2.0.0 + type-fest: 0.16.0 + unique-string: 2.0.0 + dev: true + + /terser/5.16.5: + resolution: {integrity: sha512-qcwfg4+RZa3YvlFh0qjifnzBHjKGNbtDo9yivMqMFDy9Q6FSaQWSB/j1xKhsoUFJIqDOM3TsN6D5xbrMrFcHbg==} + engines: {node: '>=10'} + hasBin: true + dependencies: + '@jridgewell/source-map': 0.3.2 + acorn: 8.8.2 + commander: 2.20.3 + source-map-support: 0.5.21 + + /to-fast-properties/2.0.0: + resolution: {integrity: sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==} + engines: {node: '>=4'} + + /to-regex-range/5.0.1: + resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==} + engines: {node: '>=8.0'} + dependencies: + is-number: 7.0.0 + + /tr46/1.0.1: + resolution: {integrity: sha512-dTpowEjclQ7Kgx5SdBkqRzVhERQXov8/l9Ft9dVM9fmg0W0KQSVaXX9T4i6twCPNtYiZM53lpSSUAwJbFPOHxA==} + dependencies: + punycode: 2.3.0 + dev: true + + /treemate/0.3.11: + resolution: {integrity: sha512-M8RGFoKtZ8dF+iwJfAJTOH/SM4KluKOKRJpjCMhI8bG3qB74zrFoArKZ62ll0Fr3mqkMJiQOmWYkdYgDeITYQg==} + dev: true + + /type-fest/0.16.0: + resolution: {integrity: sha512-eaBzG6MxNzEn9kiwvtre90cXaNLkmadMWa1zQMs3XORCXNbsH/OewwbxC5ia9dCxIxnTAsSxXJaa/p5y8DlvJg==} + engines: {node: '>=10'} + dev: true + + /typed-array-length/1.0.4: + resolution: {integrity: sha512-KjZypGq+I/H7HI5HlOoGHkWUUGq+Q0TPhQurLbyrVrvnKTBgzLhIJ7j6J/XTQOi0d1RjyZ0wdas8bKs2p0x3Ng==} + dependencies: + call-bind: 1.0.2 + for-each: 0.3.3 + is-typed-array: 1.1.10 + dev: true + + /ufo/1.1.1: + resolution: {integrity: sha512-MvlCc4GHrmZdAllBc0iUDowff36Q9Ndw/UzqmEKyrfSzokTd9ZCy1i+IIk5hrYKkjoYVQyNbrw7/F8XJ2rEwTg==} + dev: true + + /unbox-primitive/1.0.2: + resolution: {integrity: sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==} + dependencies: + call-bind: 1.0.2 + has-bigints: 1.0.2 + has-symbols: 1.0.3 + which-boxed-primitive: 1.0.2 + dev: true + + /unicode-canonical-property-names-ecmascript/2.0.0: + resolution: {integrity: sha512-yY5PpDlfVIU5+y/BSCxAJRBIS1Zc2dDG3Ujq+sR0U+JjUevW2JhocOF+soROYDSaAezOzOKuyyixhD6mBknSmQ==} + engines: {node: '>=4'} + dev: true + + /unicode-match-property-ecmascript/2.0.0: + resolution: {integrity: sha512-5kaZCrbp5mmbz5ulBkDkbY0SsPOjKqVS35VpL9ulMPfSl0J0Xsm+9Evphv9CoIZFwre7aJoa94AY6seMKGVN5Q==} + engines: {node: '>=4'} + dependencies: + unicode-canonical-property-names-ecmascript: 2.0.0 + unicode-property-aliases-ecmascript: 2.1.0 + dev: true + + /unicode-match-property-value-ecmascript/2.1.0: + resolution: {integrity: sha512-qxkjQt6qjg/mYscYMC0XKRn3Rh0wFPlfxB0xkt9CfyTvpX1Ra0+rAmdX2QyAobptSEvuy4RtpPRui6XkV+8wjA==} + engines: {node: '>=4'} + dev: true + + /unicode-property-aliases-ecmascript/2.1.0: + resolution: {integrity: sha512-6t3foTQI9qne+OZoVQB/8x8rk2k1eVy1gRXhV3oFQ5T6R1dqQ1xtin3XqSlx3+ATBkliTaR/hHyJBm+LVPNM8w==} + engines: {node: '>=4'} + dev: true + + /unimport/2.2.4: + resolution: {integrity: sha512-qMgmeEGqqrrmEtm0dqxMG37J6xBtrriqxq9hILvDb+e6l2F0yTnJomLoCCp0eghLR7bYGeBsUU5Y0oyiUYhViw==} + dependencies: + '@rollup/pluginutils': 5.0.2 + escape-string-regexp: 5.0.0 + fast-glob: 3.2.12 + local-pkg: 0.4.3 + magic-string: 0.27.0 + mlly: 1.1.1 + pathe: 1.1.0 + pkg-types: 1.0.2 + scule: 1.0.0 + strip-literal: 1.0.1 + unplugin: 1.1.0 + transitivePeerDependencies: + - rollup + dev: true + + /unique-string/2.0.0: + resolution: {integrity: sha512-uNaeirEPvpZWSgzwsPGtU2zVSTrn/8L5q/IexZmH0eH6SA73CmAA5U4GwORTxQAZs95TAXLNqeLoPPNO5gZfWg==} + engines: {node: '>=8'} + dependencies: + crypto-random-string: 2.0.0 + dev: true + + /universalify/2.0.0: + resolution: {integrity: sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==} + engines: {node: '>= 10.0.0'} + dev: true + + /unplugin-auto-import/0.12.2: + resolution: {integrity: sha512-hC4w0GZjPjmLtrxV0u10XO350V9eCtQyEyifXr7B9UGD7SvbbIvKuOcHt58Zd4FAqZJXKWoXkpr9mdhBp85Usw==} + engines: {node: '>=14'} + peerDependencies: + '@vueuse/core': '*' + peerDependenciesMeta: + '@vueuse/core': + optional: true + dependencies: + '@antfu/utils': 0.7.2 + '@rollup/pluginutils': 5.0.2 + local-pkg: 0.4.3 + magic-string: 0.27.0 + unimport: 2.2.4 + unplugin: 1.1.0 + transitivePeerDependencies: + - rollup + dev: true + + /unplugin-vue-components/0.22.12_vue@3.2.47: + resolution: {integrity: sha512-FxyzsuBvMCYPIk+8cgscGBQ345tvwVu+qY5IhE++eorkyvA4Z1TiD/HCiim+Kbqozl10i4K+z+NCa2WO2jexRA==} + engines: {node: '>=14'} + peerDependencies: + '@babel/parser': ^7.15.8 + vue: 2 || 3 + peerDependenciesMeta: + '@babel/parser': + optional: true + dependencies: + '@antfu/utils': 0.7.2 + '@rollup/pluginutils': 5.0.2 + chokidar: 3.5.3 + debug: 4.3.4 + fast-glob: 3.2.12 + local-pkg: 0.4.3 + magic-string: 0.27.0 + minimatch: 5.1.6 + resolve: 1.22.1 + unplugin: 1.1.0 + vue: 3.2.47 + transitivePeerDependencies: + - rollup + - supports-color + dev: true + + /unplugin/1.1.0: + resolution: {integrity: sha512-I8obQ8Rs/hnkxokRV6g8JKOQFgYNnTd9DL58vcSt5IJ9AkK8wbrtsnzD5hi4BJlvcY536JzfEXj9L6h7j559/A==} + dependencies: + acorn: 8.8.2 + chokidar: 3.5.3 + webpack-sources: 3.2.3 + webpack-virtual-modules: 0.5.0 + dev: true + + /upath/1.2.0: + resolution: {integrity: sha512-aZwGpamFO61g3OlfT7OQCHqhGnW43ieH9WZeP7QxN/G/jS4jfqUkZxoryvJgVPEcrl5NL/ggHsSmLMHuH64Lhg==} + engines: {node: '>=4'} + dev: true + + /update-browserslist-db/1.0.10_browserslist@4.21.5: + resolution: {integrity: sha512-OztqDenkfFkbSG+tRxBeAnCVPckDBcvibKd35yDONx6OU8N7sqgwc7rCbkJ/WcYtVRZ4ba68d6byhC21GFh7sQ==} + hasBin: true + peerDependencies: + browserslist: '>= 4.21.0' + dependencies: + browserslist: 4.21.5 + escalade: 3.1.1 + picocolors: 1.0.0 + dev: true + + /uri-js/4.4.1: + resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==} + dependencies: + punycode: 2.3.0 + dev: true + + /vdirs/0.1.8_vue@3.2.47: + resolution: {integrity: sha512-H9V1zGRLQZg9b+GdMk8MXDN2Lva0zx72MPahDKc30v+DtwKjfyOSXWRIX4t2mhDubM1H09gPhWeth/BJWPHGUw==} + peerDependencies: + vue: ^3.0.11 + dependencies: + evtd: 0.2.4 + vue: 3.2.47 + dev: true + + /vite-plugin-pwa/0.14.4_vite@4.1.4: + resolution: {integrity: sha512-M7Ct0so8OlouMkTWgXnl8W1xU95glITSKIe7qswZf1tniAstO2idElGCnsrTJ5NPNSx1XqfTCOUj8j94S6FD7Q==} + peerDependencies: + vite: ^3.1.0 || ^4.0.0 + dependencies: + '@rollup/plugin-replace': 5.0.2_rollup@3.18.0 + debug: 4.3.4 + fast-glob: 3.2.12 + pretty-bytes: 6.1.0 + rollup: 3.18.0 + vite: 4.1.4_sass@1.58.3+terser@5.16.5 + workbox-build: 6.5.4 + workbox-window: 6.5.4 + transitivePeerDependencies: + - '@types/babel__core' + - supports-color + dev: true + + /vite/4.1.4_sass@1.58.3+terser@5.16.5: + resolution: {integrity: sha512-3knk/HsbSTKEin43zHu7jTwYWv81f8kgAL99G5NWBcA1LKvtvcVAC4JjBH1arBunO9kQka+1oGbrMKOjk4ZrBg==} + engines: {node: ^14.18.0 || >=16.0.0} + hasBin: true + peerDependencies: + '@types/node': '>= 14' + less: '*' + sass: '*' + stylus: '*' + sugarss: '*' + terser: ^5.4.0 + peerDependenciesMeta: + '@types/node': + optional: true + less: + optional: true + sass: + optional: true + stylus: + optional: true + sugarss: + optional: true + terser: + optional: true + dependencies: + esbuild: 0.16.17 + postcss: 8.4.21 + resolve: 1.22.1 + rollup: 3.18.0 + sass: 1.58.3 + terser: 5.16.5 + optionalDependencies: + fsevents: 2.3.2 + dev: true + + /vooks/0.2.12_vue@3.2.47: + resolution: {integrity: sha512-iox0I3RZzxtKlcgYaStQYKEzWWGAduMmq+jS7OrNdQo1FgGfPMubGL3uGHOU9n97NIvfFDBGnpSvkWyb/NSn/Q==} + peerDependencies: + vue: ^3.0.0 + dependencies: + evtd: 0.2.4 + vue: 3.2.47 + dev: true + + /vue-demi/0.13.11_vue@3.2.47: + resolution: {integrity: sha512-IR8HoEEGM65YY3ZJYAjMlKygDQn25D5ajNFNoKh9RSDMQtlzCxtfQjdQgv9jjK+m3377SsJXY8ysq8kLCZL25A==} + engines: {node: '>=12'} + hasBin: true + requiresBuild: true + peerDependencies: + '@vue/composition-api': ^1.0.0-rc.1 + vue: ^3.0.0-0 || ^2.6.0 + peerDependenciesMeta: + '@vue/composition-api': + optional: true + dependencies: + vue: 3.2.47 + dev: false + + /vue-router/4.1.6_vue@3.2.47: + resolution: {integrity: sha512-DYWYwsG6xNPmLq/FmZn8Ip+qrhFEzA14EI12MsMgVxvHFDYvlr4NXpVF5hrRH1wVcDP8fGi5F4rxuJSl8/r+EQ==} + peerDependencies: + vue: ^3.2.0 + dependencies: + '@vue/devtools-api': 6.5.0 + vue: 3.2.47 + dev: false + + /vue/3.2.47: + resolution: {integrity: sha512-60188y/9Dc9WVrAZeUVSDxRQOZ+z+y5nO2ts9jWXSTkMvayiWxCWOWtBQoYjLeccfXkiiPZWAHcV+WTPhkqJHQ==} + dependencies: + '@vue/compiler-dom': 3.2.47 + '@vue/compiler-sfc': 3.2.47 + '@vue/runtime-dom': 3.2.47 + '@vue/server-renderer': 3.2.47_vue@3.2.47 + '@vue/shared': 3.2.47 + + /vuedraggable/4.1.0_vue@3.2.47: + resolution: {integrity: sha512-FU5HCWBmsf20GpP3eudURW3WdWTKIbEIQxh9/8GE806hydR9qZqRRxRE3RjqX7PkuLuMQG/A7n3cfj9rCEchww==} + peerDependencies: + vue: ^3.0.1 + dependencies: + sortablejs: 1.14.0 + vue: 3.2.47 + dev: false + + /vueuc/0.4.51_vue@3.2.47: + resolution: {integrity: sha512-pLiMChM4f+W8czlIClGvGBYo656lc2Y0/mXFSCydcSmnCR1izlKPGMgiYBGjbY9FDkFG8a2HEVz7t0DNzBWbDw==} + peerDependencies: + vue: ^3.0.11 + dependencies: + '@css-render/vue3-ssr': 0.15.12_vue@3.2.47 + '@juggle/resize-observer': 3.4.0 + css-render: 0.15.12 + evtd: 0.2.4 + seemly: 0.3.6 + vdirs: 0.1.8_vue@3.2.47 + vooks: 0.2.12_vue@3.2.47 + vue: 3.2.47 + dev: true + + /webidl-conversions/4.0.2: + resolution: {integrity: sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg==} + dev: true + + /webpack-sources/3.2.3: + resolution: {integrity: sha512-/DyMEOrDgLKKIG0fmvtz+4dUX/3Ghozwgm6iPp8KRhvn+eQf9+Q7GWxVNMk3+uCPWfdXYC4ExGBckIXdFEfH1w==} + engines: {node: '>=10.13.0'} + dev: true + + /webpack-virtual-modules/0.5.0: + resolution: {integrity: sha512-kyDivFZ7ZM0BVOUteVbDFhlRt7Ah/CSPwJdi8hBpkK7QLumUqdLtVfm/PX/hkcnrvr0i77fO5+TjZ94Pe+C9iw==} + dev: true + + /whatwg-url/7.1.0: + resolution: {integrity: sha512-WUu7Rg1DroM7oQvGWfOiAK21n74Gg+T4elXEQYkOhtyLeWiJFoOGLXPKI/9gzIie9CtwVLm8wtw6YJdKyxSjeg==} + dependencies: + lodash.sortby: 4.7.0 + tr46: 1.0.1 + webidl-conversions: 4.0.2 + dev: true + + /which-boxed-primitive/1.0.2: + resolution: {integrity: sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==} + dependencies: + is-bigint: 1.0.4 + is-boolean-object: 1.1.2 + is-number-object: 1.0.7 + is-string: 1.0.7 + is-symbol: 1.0.4 + dev: true + + /which-typed-array/1.1.9: + resolution: {integrity: sha512-w9c4xkx6mPidwp7180ckYWfMmvxpjlZuIudNtDf4N/tTAUB8VJbX25qZoAsrtGuYNnGw3pa0AXgbGKRB8/EceA==} + engines: {node: '>= 0.4'} + dependencies: + available-typed-arrays: 1.0.5 + call-bind: 1.0.2 + for-each: 0.3.3 + gopd: 1.0.1 + has-tostringtag: 1.0.0 + is-typed-array: 1.1.10 + dev: true + + /workbox-background-sync/6.5.4: + resolution: {integrity: sha512-0r4INQZMyPky/lj4Ou98qxcThrETucOde+7mRGJl13MPJugQNKeZQOdIJe/1AchOP23cTqHcN/YVpD6r8E6I8g==} + dependencies: + idb: 7.1.1 + workbox-core: 6.5.4 + dev: true + + /workbox-broadcast-update/6.5.4: + resolution: {integrity: sha512-I/lBERoH1u3zyBosnpPEtcAVe5lwykx9Yg1k6f8/BGEPGaMMgZrwVrqL1uA9QZ1NGGFoyE6t9i7lBjOlDhFEEw==} + dependencies: + workbox-core: 6.5.4 + dev: true + + /workbox-build/6.5.4: + resolution: {integrity: sha512-kgRevLXEYvUW9WS4XoziYqZ8Q9j/2ziJYEtTrjdz5/L/cTUa2XfyMP2i7c3p34lgqJ03+mTiz13SdFef2POwbA==} + engines: {node: '>=10.0.0'} + dependencies: + '@apideck/better-ajv-errors': 0.3.6_ajv@8.12.0 + '@babel/core': 7.21.3 + '@babel/preset-env': 7.20.2_@babel+core@7.21.3 + '@babel/runtime': 7.21.0 + '@rollup/plugin-babel': 5.3.1_hqhlikriuul7byjexqnpgcmenu + '@rollup/plugin-node-resolve': 11.2.1_rollup@2.79.1 + '@rollup/plugin-replace': 2.4.2_rollup@2.79.1 + '@surma/rollup-plugin-off-main-thread': 2.2.3 + ajv: 8.12.0 + common-tags: 1.8.2 + fast-json-stable-stringify: 2.1.0 + fs-extra: 9.1.0 + glob: 7.2.3 + lodash: 4.17.21 + pretty-bytes: 5.6.0 + rollup: 2.79.1 + rollup-plugin-terser: 7.0.2_rollup@2.79.1 + source-map: 0.8.0-beta.0 + stringify-object: 3.3.0 + strip-comments: 2.0.1 + tempy: 0.6.0 + upath: 1.2.0 + workbox-background-sync: 6.5.4 + workbox-broadcast-update: 6.5.4 + workbox-cacheable-response: 6.5.4 + workbox-core: 6.5.4 + workbox-expiration: 6.5.4 + workbox-google-analytics: 6.5.4 + workbox-navigation-preload: 6.5.4 + workbox-precaching: 6.5.4 + workbox-range-requests: 6.5.4 + workbox-recipes: 6.5.4 + workbox-routing: 6.5.4 + workbox-strategies: 6.5.4 + workbox-streams: 6.5.4 + workbox-sw: 6.5.4 + workbox-window: 6.5.4 + transitivePeerDependencies: + - '@types/babel__core' + - supports-color + dev: true + + /workbox-cacheable-response/6.5.4: + resolution: {integrity: sha512-DCR9uD0Fqj8oB2TSWQEm1hbFs/85hXXoayVwFKLVuIuxwJaihBsLsp4y7J9bvZbqtPJ1KlCkmYVGQKrBU4KAug==} + dependencies: + workbox-core: 6.5.4 + dev: true + + /workbox-core/6.5.4: + resolution: {integrity: sha512-OXYb+m9wZm8GrORlV2vBbE5EC1FKu71GGp0H4rjmxmF4/HLbMCoTFws87M3dFwgpmg0v00K++PImpNQ6J5NQ6Q==} + dev: true + + /workbox-expiration/6.5.4: + resolution: {integrity: sha512-jUP5qPOpH1nXtjGGh1fRBa1wJL2QlIb5mGpct3NzepjGG2uFFBn4iiEBiI9GUmfAFR2ApuRhDydjcRmYXddiEQ==} + dependencies: + idb: 7.1.1 + workbox-core: 6.5.4 + dev: true + + /workbox-google-analytics/6.5.4: + resolution: {integrity: sha512-8AU1WuaXsD49249Wq0B2zn4a/vvFfHkpcFfqAFHNHwln3jK9QUYmzdkKXGIZl9wyKNP+RRX30vcgcyWMcZ9VAg==} + dependencies: + workbox-background-sync: 6.5.4 + workbox-core: 6.5.4 + workbox-routing: 6.5.4 + workbox-strategies: 6.5.4 + dev: true + + /workbox-navigation-preload/6.5.4: + resolution: {integrity: sha512-IIwf80eO3cr8h6XSQJF+Hxj26rg2RPFVUmJLUlM0+A2GzB4HFbQyKkrgD5y2d84g2IbJzP4B4j5dPBRzamHrng==} + dependencies: + workbox-core: 6.5.4 + dev: true + + /workbox-precaching/6.5.4: + resolution: {integrity: sha512-hSMezMsW6btKnxHB4bFy2Qfwey/8SYdGWvVIKFaUm8vJ4E53JAY+U2JwLTRD8wbLWoP6OVUdFlXsTdKu9yoLTg==} + dependencies: + workbox-core: 6.5.4 + workbox-routing: 6.5.4 + workbox-strategies: 6.5.4 + dev: true + + /workbox-range-requests/6.5.4: + resolution: {integrity: sha512-Je2qR1NXCFC8xVJ/Lux6saH6IrQGhMpDrPXWZWWS8n/RD+WZfKa6dSZwU+/QksfEadJEr/NfY+aP/CXFFK5JFg==} + dependencies: + workbox-core: 6.5.4 + dev: true + + /workbox-recipes/6.5.4: + resolution: {integrity: sha512-QZNO8Ez708NNwzLNEXTG4QYSKQ1ochzEtRLGaq+mr2PyoEIC1xFW7MrWxrONUxBFOByksds9Z4//lKAX8tHyUA==} + dependencies: + workbox-cacheable-response: 6.5.4 + workbox-core: 6.5.4 + workbox-expiration: 6.5.4 + workbox-precaching: 6.5.4 + workbox-routing: 6.5.4 + workbox-strategies: 6.5.4 + dev: true + + /workbox-routing/6.5.4: + resolution: {integrity: sha512-apQswLsbrrOsBUWtr9Lf80F+P1sHnQdYodRo32SjiByYi36IDyL2r7BH1lJtFX8fwNHDa1QOVY74WKLLS6o5Pg==} + dependencies: + workbox-core: 6.5.4 + dev: true + + /workbox-strategies/6.5.4: + resolution: {integrity: sha512-DEtsxhx0LIYWkJBTQolRxG4EI0setTJkqR4m7r4YpBdxtWJH1Mbg01Cj8ZjNOO8etqfA3IZaOPHUxCs8cBsKLw==} + dependencies: + workbox-core: 6.5.4 + dev: true + + /workbox-streams/6.5.4: + resolution: {integrity: sha512-FXKVh87d2RFXkliAIheBojBELIPnWbQdyDvsH3t74Cwhg0fDheL1T8BqSM86hZvC0ZESLsznSYWw+Va+KVbUzg==} + dependencies: + workbox-core: 6.5.4 + workbox-routing: 6.5.4 + dev: true + + /workbox-sw/6.5.4: + resolution: {integrity: sha512-vo2RQo7DILVRoH5LjGqw3nphavEjK4Qk+FenXeUsknKn14eCNedHOXWbmnvP4ipKhlE35pvJ4yl4YYf6YsJArA==} + dev: true + + /workbox-window/6.5.4: + resolution: {integrity: sha512-HnLZJDwYBE+hpG25AQBO8RUWBJRaCsI9ksQJEp3aCOFCaG5kqaToAYXFRAHxzRluM2cQbGzdQF5rjKPWPA1fug==} + dependencies: + '@types/trusted-types': 2.0.3 + workbox-core: 6.5.4 + dev: true + + /wrappy/1.0.2: + resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==} + dev: true + + /yallist/3.1.1: + resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==} + dev: true diff --git a/public/ico/error.png b/public/ico/error.png new file mode 100644 index 0000000000000000000000000000000000000000..60539b4ac0115da932d6a7d1617c46f68288984f GIT binary patch literal 2409 zcmcgu`CHOk8h4U%$%Q6M^SZ=yHM7hmEfGb-B{R3QMR6-N7ji`;_gi9WZdh87WXM=j zS4$Hex}s<|M=?#%NJ+`mQG_z&D(;BR_s(xKf53gt^PcxP?|aU9&- zRaH<>Q1>|J>JRWg0HP@G0%m60&65CANj`_fC@7f!{3rb_z0T<-Ap6O~6>%xOT0DWg z$cO0_h7Wj_5{)$K-VRl*Rsy5Z#s0!M+*&A1n-mSTK_7H}xh2msXYW>QF6d+(rTus< zne2*FxFpKaRG4}Mwz-F+1x5xi4QCZ0h&TzcA)jrRk z4)@t`)&n4Sjt-nGuBDmD3_LmP^{b0=vw_W3F+cwFe&=O4VJ)Imkg+|(D$lirizrD+ zNii*lgdLJxy_mHedyUgAdIEnfIn!EXw|xC%c(=5;Y54du+I4jh@myWrAhni;xa z;WowAKUqrpQuS_eb!suckhPnJP0p zNz`hL8|k3)GgR@Z_C!G7rxk^)2e(!yZDl=G?Z~CHC$lS!_Bp>8N+m>LL)YM{BM{Mv z+N1rnmy;B1Xw&?rKv2iBs@@A?PDC_|&~15ENA3ig6QOX)E<{qm<;z-bLB7605v9f+ zxG^anyzKMN(u=#ijF@MH5dqY(d>1hZ@TAmnW9_Qfb81cQs0>m^NLz1XV9yW$( zKCj^{X&DpmBf^Tf~94$_^ z?YD=B(x$83{T>(C+nw<>wG)!`hmNuF zE_v3=S#6E;vd(!%LHLi6)-4~7G=z7e*g0&nSA1D=hoWin{Lsu|ppUhN{XjqS*T#7m zekLPKr$F^B3hoaWzOzVfKbrXr&Ud|eTztK9q0)ZgiVHCgV zpldgFt#mgc8I4}t+A5WWYu>iamsxpBH#ak3Pi`1W+me>z#ZdO(;9yTr&+ye62M|*! zl-JbM6v~5NLqu9sONV1qF_=jHDoa1#2*fOGXgJP7J2Ik+Fo~qOk&%btI)*uB=fTU3 zv$$T<$p$oApS7|4ty1-khzy`&KMxzzGWJco$WGWP88Ef~0l*@LGzUCyf!A7o&cI4} z7Z2;3Ewaw1yxEI;OBZ)GPOCuFx*rWjuXhZFPNlWxfAQi;4xrc@Jw0w<5F9@pa#&=} zX!Jc&*}a-?KmaNRNu8InF0ZV{_fAj~L~|45$tn5NB<&KfY7 zzns5voY-(xvK%;Z-B^sREa{jSkaj@v%@~Fv?rWc=8V|chitlSl;@T`B*xuaMgyTC6 zC=!Z9MFBY6^z7vD7s1YVhhwkvPbZSaK)}%w__UY$zMQ4f$HEMnD=L(!Cmh3hejTHEN^ZfatYsL(ba+?2~w(r8>z5| z!S`Vi2b@3C6Lj`0)J=d8O)MQgqZ1OR(QT>Lokz5|@}~dF+*8srX&qzt$l zmNdWr`Yi0MPJy2mGsY?r3uSLaG*49z1S`StCGs?V@N(wFa34v#BtQGeXFvRJnXm1H z9g(&bAzk+U`#jz?MKke~0D*q<+{kh3ULdL~p3S^0xBfF}g|QyEC_@a*rTb#ek1eLO z{YXD}3J0Vo9$#yJq?hBoXy)|909D{kiz~;;w*f;2vr4WXgc$Km!wvq;=D^m3lI%4c zCC%9IS7;5#SK6G95S@IS9&Kc^bufDF8Y;dj^S3Fd#FAbHPrEvSf7<&Z z+q}5;#r*i1ytBXrC}I8@{$Z83nB1$4B{9eXeNSB+Jwdj*dh=ve2l7i!4uVY=kHwF& zMBBFH5x1naxbG{M!WJg7GBbnB4l>pK)blietD3HMZFY98exYyHqK+*F2bHlbOK(j+ z8mGgnyk?C*RBC!d&Tm~@5iBgQ*W|C#Y)sdmXN&KphVCp0JPA=Q+n`s7t~AH>J%Oj* zPkdDDx_=WWcinb|>q>c=FcB1Q8d}K3!tpb?lV~VVECFj!A&}*cyuMXtMKF3Vm&@N8 zrdWz7kEv~4UB28@*pp6Vq2td>7G4!b>sosgrVw!?AXl3m4D2+H9Kys>l>Yku;eUFS c2RjPtUXgk#{N#TFy_156n~!Uw^EKRm0Q6m&Q~&?~ literal 0 HcmV?d00001 diff --git a/public/ico/favicon.png b/public/ico/favicon.png new file mode 100644 index 0000000000000000000000000000000000000000..e74ac2ffccd3cc5093329dc0a83afa2ee0012603 GIT binary patch literal 6789 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

sZ0>j?@VXJbmaIyMWUR!|#wSIztII6Hda z*x-AR%fdP_ndOj6m|+OXmT0KIGHRN3H&rn$VmFU$!73OLyB5RG?b!xPqSemP(6pR@ z5cz`#rwBi(p^>smQbw}hBGsg(PCCK&()DMKILqsiJk+N}i3}^Qk&*XN(_h&9!{%i- zmgBa5eG@BU4Dn%4NWHSO>mn82@M$whtqMg>j|SgQ$7Ob47v%6j<_+!nn0(aXG~0X? z(QNQGOqpCKGkZ*d{Hr(luhod{$@^pr&=dC0fu9rkYDf&N? zjtQzbwVwB5od0s|B>;{Dj0COsY3SX-+Y8O)EiR@cft_xKmym%=lE85870*CL+Od=G z!>)ZOSxH~g$)njqqlMhrs`I&OC|>F%v1Ry@h3zgGV|Ifn=Xd6wgx3ZWLSx24E~5!P z2OZ4h>1urSYiBF+FD~pVAcYpr;fBS(#Z8{jhXgZBr_CR8%b$xiDrK-AL4gS z<9X0yy?ZPZin}qd2SE=oT!E@K|52e)e<|1b0Z&tQ@4BWcNd1qXB@Cu0mXDJKuBz1D z&G}0dK1TujZ~c36!L8wa1U2Fly2MVW2}Anh6iXgtnVAKTXoXPWmwW}RRyn)s;e9v?gHnRDG_Vm71GjXcIBA;RDMT9Ffeb{! z>LJQ|muErG24$rF%Fu}o?X|xLE8-HjyJGWT=k;w~d2f!3Qo>xkSSJKn->$&$xr7_|z0i3r@3-PBPc9ssRL#iyy{sFd13fzdt zlg<4~7nvv}PK}U?6D@$0FaKTRMmi~ZiY$a?;-P8FlHE5dFi&rT6&UImB%sZnSY-jL z%SyWyLdGbKsCcVUFA0fye+20GQRI~H3dvqalRm^cJ$ZOmcQ-Z?_9$iU6arVEZ+Wj) zfUx2IZ!_fyN8dAcc8z?F^H>qP3)cq_Xd?UP*kK*5Vlei=CHq;&pbyiPvqOQ>kHbGa zWQlpOlY9XZa2Az%tATjttEF4v*~QcTMQR*0sA=S(41inR74zyfDR?8*u)b|2IT`kS ztFNJ8NXKK`;&@6W!2(i}#I5+zAjsukQpvsenUq1p8cU+ftiHQr@|lu4{__;xnEL2o zRt3hU6mLjtl$u9#cs4gMpZv#{YO?)s>6t?%gSd_S?qcP-qZ!GFvSI@}i7lmk$Y*bI zQhTC74dGX*m*gLHdgRPb$&SalIjS?SC3mTsr^EQvVHEF*t(jq3iA{>Y^A%9@*;-&; z_SLBVkrHA<j=pFMGbZgp&B0%3j0#mrE<8yk34Cex#<}onBOs74e@h4A^vTTDg z-i%7FAh8nr?F=)YH2`qs;*vrsw5z^S0@flfh7!#$wG(00eYUs@iZJIjqT%UH(r`sq zNbn4uVc{@kafdj?nUao<1nRt!^_y*fWGrC9!e!noePvb5w&J^qaVbfItE=7O3aBxG z=kk*9eH!WAa0gh&sGfGOelrA-MFVzHO~du^Q`C0Ege6jZV+!|$bxb&yI~>gPn<(8! z8I@V$MGsL)4g9y}_g$5loGkZnhb3+2*513U}lBxT;NS}4z zje2kImFMphsbr3FVb}CN;x@oqfNc1~YNW;OK;o_dI9b&Dy?;&)$ux_3`T~_bgF*kR z7FTQV1}X41n#}ecpV^&%rnf&uot4nkLMxX9*vVCX@zleJ?-|Nbg_&NeE^)ZgfM=NF zb2imu<4@rA6xgC#`u!^8o34^ z8%_x)JmBQG`m*%@_3kGZoYtms&|;>h`IgH!nwU!FlI>rUFtTjlBkkAO2lHp7=dI!F;a zFqrL)W9>%;@DT{$j@lvv;KoaE3XWG7GggGze-|m>;Mh6|quO`>*MT84aEG6P>SV&M z0WJfgHKzhBNZl)T!RsF@_W{A+jTx93;c5u{hIaTS+_k5A@gxb7+uyi#LoASG8)k>D S%Eb4T07z9`l^P`*)PDiN)u&Vd literal 0 HcmV?d00001 diff --git a/public/ico/icon_error.png b/public/ico/icon_error.png new file mode 100644 index 0000000000000000000000000000000000000000..e67369df96f3788fa4b2dddbe1f29535998c9762 GIT binary patch literal 2954 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 Uo)9%S{D;=m$jY!%-#zxf00jNDVE_OC literal 0 HcmV?d00001 diff --git a/public/logo/ithome.png b/public/logo/ithome.png new file mode 100644 index 0000000000000000000000000000000000000000..a3c034ff9880caa35e9a7dba1cb936714c8e7bdc GIT binary patch literal 1812 zcma)7dobIH7XC#d1o2FlR#sHh>w2`RO=L=fSk!Bawu%xIwW0JJdL}#cCT?RmIJXB%;Dnx>6#gT%Eap+}qimxqqBha)toJW0r;R!#w>2;PLOeMkc_7IkR`^ax=c<-5jA`21 zG>&DPXHX6%%N2z90m6FV=?O^AT{%S;dG!({ee@m@-YhHrzk#~zHt`qv_VY>~%@3-f z;df$Q`y3qraF^Y|O|T=|-93NbadVQ@`U<#!iZvOogl(&A?ZK;>8%7(lu>zBLYv1@jVR^PHS3Wp76i(|8lXf zfqS;v*X>vvBNXwkZmG<4MT&}LN$VQn5trG%*FIOy;YpDxs<%)O0))pG!%>AEXaYGj zl9l|OlkxUD?VnFG!WJ)iG|V2+UXkPcP}b^#iCAaj8eXv-3>OOT;6Q*QD! z|USUGPbG$V|9+ah*n$zMlwUtTj zYo>2#>q922n1UKcuOt4@*bY2={$ETsR3h0DzN(~I;+lhmo3d1uMDfhtnHim%qHEfg zEz}E^&qhcB*tC_8=qBqpo zN;&_+ho>&vXM@u~sXoUK7TCy3809%o&{03Hwy2wu@V3LvSQlWMe#lfYo^8aYPPVY; z1i41ygSm2Ad1}e>pNe540WCkpr=?ZU9V4%zZY6%u-?R!|qCLDMg7b+|G`qHT`FLUJdw6s;hk)dKTdP&n9^)bP@P;@`rhZ6(_eA_Yl{7eTJAnEwJB*W zW(m&ruqe97pvI2Roz>5dR`CiVpbt`>oKoh-q%l5}$zx4P>dw2H;Ew5ep|w=HnV}*` zXssjO&a;aq1eXAACyr_u%_G`Ds+u}kgGk>xw8rRPulx}g;O^d(xgoR@D<^9*!T~MkM{&Hc zcN3>8GepQFjIG?>@|dZkeO3lK7=D^-03kbAs`x55)~F`+M}?Aaxv$G5E53F0bO}<(;mp0)mGp;=bp)Im zyhA5+J-RWEZ`(POl~Cb>&>rH6Z?8bhS%Rk8b(#2$Wysusma$2!_223S24ATb}6ud+yX^NYtE6tdR7_mpdPBzXTC1 zo1Wv(E}jLe)dr>Bj8}p9BhH(7n2pJNt)|}feGkjZmR3g)GEMzF*gI>Zg09bFF6R9k z21NR5{>lw&XL*iN-;l59_mdZTx2$pAHTNZ=Ys~f+ussyroHC{6aUpS~Z)o)ok)Krv zob#cYJbePvnVnD(_Ky~y+sqbltvq<9Upy*0nsV_*@)iSHWX4LA>iWAMwD)>FdI+n@ zfSy;ojuLkd)+^^;hy^tcU>1S91qoR08sCBT|2VaAF(8}b+&45T1|D0#baZo{Ib9kJ z+puwNDz(U`iEQM0mD8)f_^)Kwe`6G7-{9fB&|{Ea?Ztf(7)fD6A>KL~n=gf#Nfii4 h)SrKYuNASSw04ISZC!f$yWKYjxH)@~n;j`v{td!CJi-6~ literal 0 HcmV?d00001 diff --git a/public/logo/juejin.png b/public/logo/juejin.png new file mode 100644 index 0000000000000000000000000000000000000000..1f3ea1687139c9f7e15e7b63847238c8c12dfbdd GIT binary patch literal 6298 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 literal 0 HcmV?d00001 diff --git a/public/logo/newsqq.png b/public/logo/newsqq.png new file mode 100644 index 0000000000000000000000000000000000000000..1fe4b17b2e2af37e208eb6d6a2fb9617d57e1cf6 GIT binary patch literal 7936 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 literal 0 HcmV?d00001 diff --git a/public/logo/thepaper.png b/public/logo/thepaper.png new file mode 100644 index 0000000000000000000000000000000000000000..d1aa3e1fbfeb2edce08ccb931e50c0adcacceb95 GIT binary patch literal 8159 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 literal 0 HcmV?d00001 diff --git a/public/logo/zhihu.png b/public/logo/zhihu.png new file mode 100644 index 0000000000000000000000000000000000000000..1d8447abeb307475970cb345d4aaffba9ff6f006 GIT binary patch literal 7772 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 KvbEA?q5lIJ*{(DI literal 0 HcmV?d00001 diff --git a/src/App.vue b/src/App.vue new file mode 100644 index 0000000..681e27b --- /dev/null +++ b/src/App.vue @@ -0,0 +1,103 @@ + + + + + diff --git a/src/api/index.js b/src/api/index.js new file mode 100644 index 0000000..80400e5 --- /dev/null +++ b/src/api/index.js @@ -0,0 +1,14 @@ +import axios from "@/api/request"; + +/** + * 获取热榜分类数据 + * @param {string} type 热榜分类名称 + * @param {boolean} isNew 是否拉取最新数据 + * @returns + */ +export const getHotLists = (type, isNew) => { + return axios({ + method: "GET", + url: `/${type}${isNew ? "/new" : "/"}`, + }); +}; diff --git a/src/api/request.js b/src/api/request.js new file mode 100644 index 0000000..41023ba --- /dev/null +++ b/src/api/request.js @@ -0,0 +1,69 @@ +import axios from "axios"; + +switch (process.env.NODE_ENV) { + case "production": + axios.defaults.baseURL = import.meta.env.VITE_GLOBAL_API; + break; + case "development": + axios.defaults.baseURL = import.meta.env.VITE_GLOBAL_API; + break; + default: + axios.defaults.baseURL = import.meta.env.VITE_GLOBAL_API; + break; +} + +axios.defaults.timeout = 30000; +axios.defaults.headers = { "Content-Type": "application/json" }; + +// 请求拦截 +axios.interceptors.request.use( + (request) => { + // if (request.loadingBar != "Hidden") $loadingBar.start(); + const token = localStorage.getItem("token"); + if (token) { + request.headers.Authorization = token; + } + return request; + }, + (error) => { + // $loadingBar.error(); + $message.error("请求失败，请稍后重试"); + return Promise.reject(error); + } +); + +// 响应拦截 +axios.interceptors.response.use( + (response) => { + // $loadingBar.finish(); + return response.data; + }, + (error) => { + $loadingBar.error(); + if (error.response) { + let data = error.response.data; + switch (error.response.status) { + case 401: + $message.error(data.message ? data.message : "请登录后使用"); + break; + case 301: + $message.error(data.message ? data.message : "请求路径发生跳转"); + break; + case 404: + $message.error(data.message ? data.message : "请求资源不存在"); + break; + case 500: + $message.error(data.message ? data.message : "内部服务器错误"); + break; + default: + $message.error(data.message ? data.message : "请求失败，请稍后重试"); + break; + } + } else { + $message.error(data.message ? data.message : "请求失败，请稍后重试"); + } + return Promise.reject(error); + } +); + +export default axios; diff --git a/src/components/Footer.vue b/src/components/Footer.vue new file mode 100644 index 0000000..e195224 --- /dev/null +++ b/src/components/Footer.vue @@ -0,0 +1,68 @@ + + + + + diff --git a/src/components/Header.vue b/src/components/Header.vue new file mode 100644 index 0000000..10e5d52 --- /dev/null +++ b/src/components/Header.vue @@ -0,0 +1,291 @@ + + + + + diff --git a/src/components/HotList.vue b/src/components/HotList.vue new file mode 100644 index 0000000..08bfc85 --- /dev/null +++ b/src/components/HotList.vue @@ -0,0 +1,362 @@ + + + + + diff --git a/src/components/Provider.vue b/src/components/Provider.vue new file mode 100644 index 0000000..287cee7 --- /dev/null +++ b/src/components/Provider.vue @@ -0,0 +1,100 @@ + + + + diff --git a/src/main.js b/src/main.js new file mode 100644 index 0000000..46414c6 --- /dev/null +++ b/src/main.js @@ -0,0 +1,18 @@ +import { createApp } from "vue"; +import { createPinia } from "pinia"; +import piniaPluginPersistedstate from "pinia-plugin-persistedstate"; + +import App from "./App.vue"; +import router from "@/router"; + +// 全局样式 +import "@/style/global.scss"; + +const app = createApp(App); + +const pinia = createPinia(); +pinia.use(piniaPluginPersistedstate); +app.use(pinia); +app.use(router); + +app.mount("#app"); diff --git a/src/router/index.js b/src/router/index.js new file mode 100644 index 0000000..a24d11a --- /dev/null +++ b/src/router/index.js @@ -0,0 +1,18 @@ +import { createRouter, createWebHashHistory } from "vue-router"; +import routes from "@/router/routes"; + +const router = createRouter({ + history: createWebHashHistory(), + routes, +}); + +// 路由守卫 +router.beforeEach(() => { + $loadingBar.start(); +}); + +router.afterEach(() => { + $loadingBar.finish(); +}); + +export default router; \ No newline at end of file diff --git a/src/router/routes.js b/src/router/routes.js new file mode 100644 index 0000000..057f4b6 --- /dev/null +++ b/src/router/routes.js @@ -0,0 +1,53 @@ +const routes = [ + // 首页 + { + path: "/", + name: "home", + meta: { + title: "首页", + }, + component: () => import("@/views/Home.vue"), + }, + // 新闻列表 + { + path: "/list", + name: "list", + meta: { + title: "新闻列表", + }, + component: () => import("@/views/List.vue"), + }, + // 设置页 + { + path: "/setting", + name: "setting", + meta: { + title: "全局设置", + }, + component: () => import("@/views/Setting.vue"), + }, + // 测试页面 + { + path: "/test", + name: "test", + meta: { + title: "test", + }, + component: () => import("@/views/Test.vue"), + }, + // 404 + { + path: "/404", + name: "404", + meta: { + title: "404", + }, + component: () => import("@/views/404.vue"), + }, + { + path: "/:pathMatch(.*)", + redirect: "/404", + }, +]; + +export default routes; diff --git a/src/store/index.js b/src/store/index.js new file mode 100644 index 0000000..f5cdca4 --- /dev/null +++ b/src/store/index.js @@ -0,0 +1,107 @@ +import { defineStore } from "pinia"; + +export const mainStore = defineStore("main", { + state: () => { + return { + // 系统主题 + siteTheme: "light", + // 新闻类别 + newsArr: [ + { + label: "哔哩哔哩", + value: "bilibili", + order: 0, + show: true, + }, + { + label: "微博", + value: "weibo", + order: 1, + show: true, + }, + { + label: "知乎", + value: "zhihu", + order: 2, + show: true, + }, + { + label: "36氪", + value: "36kr", + order: 3, + show: true, + }, + { + label: "百度", + value: "baidu", + order: 4, + show: true, + }, + { + label: "少数派", + value: "sspai", + order: 5, + show: true, + }, + { + label: "IT之家", + value: "ithome", + order: 6, + show: true, + }, + { + label: "澎湃新闻", + value: "thepaper", + order: 7, + show: true, + }, + { + label: "今日头条", + value: "toutiao", + order: 8, + show: true, + }, + { + label: "百度贴吧", + value: "tieba", + order: 9, + show: true, + }, + { + label: "稀土掘金", + value: "juejin", + order: 10, + show: true, + }, + { + label: "腾讯新闻", + value: "newsqq", + order: 11, + show: true, + }, + ], + // 链接跳转方式 + linkOpenType: "open", + // 页头固定 + headerFixed: true, + // 时间数据 + timeData: null, + }; + }, + getters: {}, + actions: { + // 更改系统主题 + setSiteTheme(val) { + $message.info(`已切换至${val === "dark" ? "深色模式" : "浅色模式"}`, { + showIcon: false, + }); + this.siteTheme = val; + }, + }, + persist: [ + { + storage: localStorage, + paths: ["siteTheme", "newsArr", "linkOpenType", "headerFixed"], + }, + ], +}); diff --git a/src/style/global.scss b/src/style/global.scss new file mode 100644 index 0000000..57a342f --- /dev/null +++ b/src/style/global.scss @@ -0,0 +1,14 @@ +// 全局样式 + +* { + margin: 0; + padding: 0; + -webkit-user-select: none; + user-select: none; +} + +html, +body, +#app { + height: 100%; +} \ No newline at end of file diff --git a/src/utils/getTime.js b/src/utils/getTime.js new file mode 100644 index 0000000..7b55f53 --- /dev/null +++ b/src/utils/getTime.js @@ -0,0 +1,87 @@ +import LunarCalendar from "lunar-calendar"; + +export const formatTime = (timestamp) => { + const date = new Date(timestamp); + const now = new Date(); + const diffInSeconds = (now.getTime() - date.getTime()) / 1000; + const diffInMinutes = diffInSeconds / 60; + const diffInHours = diffInMinutes / 60; + + if (diffInSeconds < 60) { + return "刚刚更新"; + } else if (diffInMinutes < 60) { + const minutes = Math.floor(diffInMinutes); + return `${minutes}分钟前更新`; + } else if (diffInHours < 24) { + const hours = Math.floor(diffInHours); + return `${hours}小时前更新`; + } else { + const month = date.getMonth() + 1; + const day = date.getDate(); + return `${month}月${day}日`; + } +}; + +export const getCurrentTime = () => { + const time = new Date(); + const year = time.getFullYear(); + const month = + time.getMonth() + 1 < 10 + ? "0" + (time.getMonth() + 1) + : time.getMonth() + 1; + const day = time.getDate() < 10 ? "0" + time.getDate() : time.getDate(); + const hour = time.getHours() < 10 ? "0" + time.getHours() : time.getHours(); + const minute = + time.getMinutes() < 10 ? "0" + time.getMinutes() : time.getMinutes(); + const second = + time.getSeconds() < 10 ? "0" + time.getSeconds() : time.getSeconds(); + const weekday = [ + "星期日", + "星期一", + "星期二", + "星期三", + "星期四", + "星期五", + "星期六", + ]; + // 获取农历 + const lunar = LunarCalendar.solarToLunar( + time.getFullYear(), + time.getMonth() + 1, + time.getDate() + ); + const currentTime = { + time: { + year, + month, + day, + hour, + minute, + second, + weekday: weekday[time.getDay()], + text: + year + + "-" + + month + + "-" + + day + + " " + + hour + + ":" + + minute + + ":" + + second, + }, + lunar: { + data: lunar, + year: lunar.lunarYear, + month: lunar.lunarMonthName, + day: lunar.lunarDayName, + GanZhiYear: lunar.GanZhiYear, + GanZhiMonth: lunar.GanZhiMonth, + GanZhiDay: lunar.GanZhiDay, + text: lunar.lunarMonthName + lunar.lunarDayName, + }, + }; + return currentTime; +}; diff --git a/src/views/404.vue b/src/views/404.vue new file mode 100644 index 0000000..8cc38bd --- /dev/null +++ b/src/views/404.vue @@ -0,0 +1,38 @@ + + + + + diff --git a/src/views/Home.vue b/src/views/Home.vue new file mode 100644 index 0000000..06414fa --- /dev/null +++ b/src/views/Home.vue @@ -0,0 +1,79 @@ + + + + + diff --git a/src/views/List.vue b/src/views/List.vue new file mode 100644 index 0000000..1e50102 --- /dev/null +++ b/src/views/List.vue @@ -0,0 +1,358 @@ + + + + + diff --git a/src/views/Setting.vue b/src/views/Setting.vue new file mode 100644 index 0000000..325a068 --- /dev/null +++ b/src/views/Setting.vue @@ -0,0 +1,209 @@ + + + + + diff --git a/src/views/Test.vue b/src/views/Test.vue new file mode 100644 index 0000000..16d35d9 --- /dev/null +++ b/src/views/Test.vue @@ -0,0 +1,120 @@ + + + + + diff --git a/vite.config.js b/vite.config.js new file mode 100644 index 0000000..ff5d082 --- /dev/null +++ b/vite.config.js @@ -0,0 +1,85 @@ +import { fileURLToPath, URL } from "node:url"; + +import { defineConfig } from "vite"; +import vue from "@vitejs/plugin-vue"; +import AutoImport from "unplugin-auto-import/vite"; +import Components from "unplugin-vue-components/vite"; +import { NaiveUiResolver } from "unplugin-vue-components/resolvers"; +import { VitePWA } from "vite-plugin-pwa"; + +export default defineConfig({ + plugins: [ + vue(), + AutoImport({ + imports: [ + "vue", + { + "naive-ui": [ + "useDialog", + "useMessage", + "useNotification", + "useLoadingBar", + ], + }, + ], + }), + Components({ + resolvers: [NaiveUiResolver()], + }), + // PWA + VitePWA({ + registerType: "autoUpdate", + devOptions: { + enabled: true, + }, + workbox: { + cleanupOutdatedCaches: true, + runtimeCaching: [ + { + urlPattern: /(.*?)\.(woff2|woff|ttf)/, + handler: "CacheFirst", + options: { + cacheName: "file-cache", + }, + }, + { + urlPattern: /(.*?)\.(webp|png|jpe?g|svg|gif|bmp|psd|tiff|tga|eps)/, + handler: "CacheFirst", + options: { + cacheName: "image-cache", + }, + }, + ], + }, + manifest: { + name: "今日热榜", + short_name: "DailyHot", + description: "汇聚全网热点，热门尽览无余", + display: "standalone", + start_url: "/", + theme_color: "#fff", + background_color: "#efefef", + icons: [ + { + src: "/ico/favicon.png", + sizes: "200x200", + type: "image/png", + }, + ], + }, + }), + ], + resolve: { + alias: { + "@": fileURLToPath(new URL("./src", import.meta.url)), + }, + }, + build: { + minify: "terser", + terserOptions: { + compress: { + pure_funcs: ["console.log"], + }, + }, + }, +});