From 60c922e200167b7ae058b0c8cbaf535505585453 Mon Sep 17 00:00:00 2001 From: Xoconoch Date: Sun, 27 Jul 2025 12:36:08 -0600 Subject: [PATCH] Implemented PWA --- spotizerr-ui/dev-dist/registerSW.js | 1 + spotizerr-ui/dev-dist/sw.js | 107 + spotizerr-ui/dev-dist/workbox-f70c5944.js | 4618 +++++++++++++++++ spotizerr-ui/index.html | 19 + spotizerr-ui/package.json | 8 +- spotizerr-ui/pnpm-lock.yaml | 3711 ++++++++++++- spotizerr-ui/pnpm-workspace.yaml | 2 + .../public/apple-touch-icon-180x180.png | Bin 0 -> 4980 bytes spotizerr-ui/public/favicon-128x128.png | Bin 0 -> 3150 bytes spotizerr-ui/public/favicon-16x16.png | Bin 0 -> 387 bytes spotizerr-ui/public/favicon-256x256.png | Bin 0 -> 6815 bytes spotizerr-ui/public/favicon-32x32.png | Bin 0 -> 758 bytes spotizerr-ui/public/favicon-48x48.png | Bin 0 -> 1216 bytes spotizerr-ui/public/favicon-64x64.png | Bin 0 -> 1537 bytes spotizerr-ui/public/favicon-96x96.png | Bin 0 -> 2224 bytes spotizerr-ui/public/favicon.ico | Bin 4286 -> 14510 bytes spotizerr-ui/public/pwa-192x192.png | Bin 0 -> 4892 bytes spotizerr-ui/public/pwa-512x512-maskable.png | Bin 0 -> 16762 bytes spotizerr-ui/public/pwa-512x512.png | Bin 0 -> 17208 bytes spotizerr-ui/public/spotizerr.png | Bin 0 -> 67022 bytes spotizerr-ui/public/spotizerr.svg | 7 + spotizerr-ui/scripts/generate-icons.js | 199 + spotizerr-ui/src/index.css | 146 +- spotizerr-ui/src/main.tsx | 42 +- spotizerr-ui/src/router.tsx | 2 +- spotizerr-ui/src/routes/playlist.tsx | 2 +- spotizerr-ui/src/routes/root.tsx | 90 +- spotizerr-ui/vite.config.ts | 86 +- 28 files changed, 8904 insertions(+), 136 deletions(-) create mode 100644 spotizerr-ui/dev-dist/registerSW.js create mode 100644 spotizerr-ui/dev-dist/sw.js create mode 100644 spotizerr-ui/dev-dist/workbox-f70c5944.js create mode 100644 spotizerr-ui/pnpm-workspace.yaml create mode 100644 spotizerr-ui/public/apple-touch-icon-180x180.png create mode 100644 spotizerr-ui/public/favicon-128x128.png create mode 100644 spotizerr-ui/public/favicon-16x16.png create mode 100644 spotizerr-ui/public/favicon-256x256.png create mode 100644 spotizerr-ui/public/favicon-32x32.png create mode 100644 spotizerr-ui/public/favicon-48x48.png create mode 100644 spotizerr-ui/public/favicon-64x64.png create mode 100644 spotizerr-ui/public/favicon-96x96.png mode change 100755 => 100644 spotizerr-ui/public/favicon.ico create mode 100644 spotizerr-ui/public/pwa-192x192.png create mode 100644 spotizerr-ui/public/pwa-512x512-maskable.png create mode 100644 spotizerr-ui/public/pwa-512x512.png create mode 100644 spotizerr-ui/public/spotizerr.png create mode 100644 spotizerr-ui/public/spotizerr.svg create mode 100644 spotizerr-ui/scripts/generate-icons.js diff --git a/spotizerr-ui/dev-dist/registerSW.js b/spotizerr-ui/dev-dist/registerSW.js new file mode 100644 index 0000000..1d5625f --- /dev/null +++ b/spotizerr-ui/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/spotizerr-ui/dev-dist/sw.js b/spotizerr-ui/dev-dist/sw.js new file mode 100644 index 0000000..186f65d --- /dev/null +++ b/spotizerr-ui/dev-dist/sw.js @@ -0,0 +1,107 @@ +/** + * 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-f70c5944'], (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" + }, { + "url": "index.html", + "revision": "0.qqj3c2rpjk8" + }], {}); + workbox.cleanupOutdatedCaches(); + workbox.registerRoute(new workbox.NavigationRoute(workbox.createHandlerBoundToURL("index.html"), { + allowlist: [/^\/$/], + denylist: [/^\/_/, /\/[^/?]+\.[^/]+$/] + })); + workbox.registerRoute(/^https:\/\/api\./i, new workbox.NetworkFirst({ + "cacheName": "api-cache", + plugins: [new workbox.ExpirationPlugin({ + maxEntries: 100, + maxAgeSeconds: 86400 + })] + }), 'GET'); + workbox.registerRoute(/\.(?:png|jpg|jpeg|svg|gif|webp)$/, new workbox.CacheFirst({ + "cacheName": "images-cache", + plugins: [new workbox.ExpirationPlugin({ + maxEntries: 500, + maxAgeSeconds: 2592000 + })] + }), 'GET'); + +})); diff --git a/spotizerr-ui/dev-dist/workbox-f70c5944.js b/spotizerr-ui/dev-dist/workbox-f70c5944.js new file mode 100644 index 0000000..cb884e5 --- /dev/null +++ b/spotizerr-ui/dev-dist/workbox-f70c5944.js @@ -0,0 +1,4618 @@ +define(['exports'], (function (exports) { 'use strict'; + + // @ts-ignore + try { + self['workbox:core:7.2.0'] && _(); + } 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 globalThis)) { + 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:7.2.0'] && _(); + } 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 2019 Google LLC + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * A helper function that prevents a promise from being flagged as unused. + * + * @private + **/ + function dontWaitFor(promise) { + // Effective no-op. + void promise.then(() => {}); + } + + /* + 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 2019 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * Adds a function to the set of quotaErrorCallbacks that will be executed if + * there's a quota error. + * + * @param {Function} callback + * @memberof workbox-core + */ + // Can't change Function type + // eslint-disable-next-line @typescript-eslint/ban-types + function registerQuotaErrorCallback(callback) { + { + finalAssertExports.isType(callback, 'function', { + moduleName: 'workbox-core', + funcName: 'register', + paramName: 'callback' + }); + } + quotaErrorCallbacks.add(callback); + { + logger.log('Registered a callback to respond to quota errors.', callback); + } + } + + function _extends() { + return _extends = Object.assign ? Object.assign.bind() : function (n) { + for (var e = 1; e < arguments.length; e++) { + var t = arguments[e]; + for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); + } + return n; + }, _extends.apply(null, arguments); + } + + const instanceOfAny = (object, constructors) => constructors.some(c => object instanceof c); + let idbProxyableTypes; + let cursorAdvanceMethods; + // This is a function to prevent it throwing up in node environments. + function getIdbProxyableTypes() { + return idbProxyableTypes || (idbProxyableTypes = [IDBDatabase, IDBObjectStore, IDBIndex, IDBCursor, IDBTransaction]); + } + // This is a function to prevent it throwing up in node environments. + function getCursorAdvanceMethods() { + return cursorAdvanceMethods || (cursorAdvanceMethods = [IDBCursor.prototype.advance, IDBCursor.prototype.continue, IDBCursor.prototype.continuePrimaryKey]); + } + const cursorRequestMap = new WeakMap(); + const transactionDoneMap = new WeakMap(); + const transactionStoreNamesMap = new WeakMap(); + const transformCache = new WeakMap(); + const reverseTransformCache = new WeakMap(); + function promisifyRequest(request) { + const promise = new Promise((resolve, reject) => { + const unlisten = () => { + request.removeEventListener('success', success); + request.removeEventListener('error', error); + }; + const success = () => { + resolve(wrap(request.result)); + unlisten(); + }; + const error = () => { + reject(request.error); + unlisten(); + }; + request.addEventListener('success', success); + request.addEventListener('error', error); + }); + promise.then(value => { + // Since cursoring reuses the IDBRequest (*sigh*), we cache it for later retrieval + // (see wrapFunction). + if (value instanceof IDBCursor) { + cursorRequestMap.set(value, request); + } + // Catching to avoid "Uncaught Promise exceptions" + }).catch(() => {}); + // This mapping exists in reverseTransformCache but doesn't doesn't exist in transformCache. This + // is because we create many promises from a single IDBRequest. + reverseTransformCache.set(promise, request); + return promise; + } + function cacheDonePromiseForTransaction(tx) { + // Early bail if we've already created a done promise for this transaction. + if (transactionDoneMap.has(tx)) return; + const done = new Promise((resolve, reject) => { + const unlisten = () => { + tx.removeEventListener('complete', complete); + tx.removeEventListener('error', error); + tx.removeEventListener('abort', error); + }; + const complete = () => { + resolve(); + unlisten(); + }; + const error = () => { + reject(tx.error || new DOMException('AbortError', 'AbortError')); + unlisten(); + }; + tx.addEventListener('complete', complete); + tx.addEventListener('error', error); + tx.addEventListener('abort', error); + }); + // Cache it for later retrieval. + transactionDoneMap.set(tx, done); + } + let idbProxyTraps = { + get(target, prop, receiver) { + if (target instanceof IDBTransaction) { + // Special handling for transaction.done. + if (prop === 'done') return transactionDoneMap.get(target); + // Polyfill for objectStoreNames because of Edge. + if (prop === 'objectStoreNames') { + return target.objectStoreNames || transactionStoreNamesMap.get(target); + } + // Make tx.store return the only store in the transaction, or undefined if there are many. + if (prop === 'store') { + return receiver.objectStoreNames[1] ? undefined : receiver.objectStore(receiver.objectStoreNames[0]); + } + } + // Else transform whatever we get back. + return wrap(target[prop]); + }, + set(target, prop, value) { + target[prop] = value; + return true; + }, + has(target, prop) { + if (target instanceof IDBTransaction && (prop === 'done' || prop === 'store')) { + return true; + } + return prop in target; + } + }; + function replaceTraps(callback) { + idbProxyTraps = callback(idbProxyTraps); + } + function wrapFunction(func) { + // Due to expected object equality (which is enforced by the caching in `wrap`), we + // only create one new func per func. + // Edge doesn't support objectStoreNames (booo), so we polyfill it here. + if (func === IDBDatabase.prototype.transaction && !('objectStoreNames' in IDBTransaction.prototype)) { + return function (storeNames, ...args) { + const tx = func.call(unwrap(this), storeNames, ...args); + transactionStoreNamesMap.set(tx, storeNames.sort ? storeNames.sort() : [storeNames]); + return wrap(tx); + }; + } + // Cursor methods are special, as the behaviour is a little more different to standard IDB. In + // IDB, you advance the cursor and wait for a new 'success' on the IDBRequest that gave you the + // cursor. It's kinda like a promise that can resolve with many values. That doesn't make sense + // with real promises, so each advance methods returns a new promise for the cursor object, or + // undefined if the end of the cursor has been reached. + if (getCursorAdvanceMethods().includes(func)) { + return function (...args) { + // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use + // the original object. + func.apply(unwrap(this), args); + return wrap(cursorRequestMap.get(this)); + }; + } + return function (...args) { + // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use + // the original object. + return wrap(func.apply(unwrap(this), args)); + }; + } + function transformCachableValue(value) { + if (typeof value === 'function') return wrapFunction(value); + // This doesn't return, it just creates a 'done' promise for the transaction, + // which is later returned for transaction.done (see idbObjectHandler). + if (value instanceof IDBTransaction) cacheDonePromiseForTransaction(value); + if (instanceOfAny(value, getIdbProxyableTypes())) return new Proxy(value, idbProxyTraps); + // Return the same value back if we're not going to transform it. + return value; + } + function wrap(value) { + // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because + // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached. + if (value instanceof IDBRequest) return promisifyRequest(value); + // If we've already transformed this value before, reuse the transformed value. + // This is faster, but it also provides object equality. + if (transformCache.has(value)) return transformCache.get(value); + const newValue = transformCachableValue(value); + // Not all types are transformed. + // These may be primitive types, so they can't be WeakMap keys. + if (newValue !== value) { + transformCache.set(value, newValue); + reverseTransformCache.set(newValue, value); + } + return newValue; + } + const unwrap = value => reverseTransformCache.get(value); + + /** + * Open a database. + * + * @param name Name of the database. + * @param version Schema version. + * @param callbacks Additional callbacks. + */ + function openDB(name, version, { + blocked, + upgrade, + blocking, + terminated + } = {}) { + const request = indexedDB.open(name, version); + const openPromise = wrap(request); + if (upgrade) { + request.addEventListener('upgradeneeded', event => { + upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event); + }); + } + if (blocked) { + request.addEventListener('blocked', event => blocked( + // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405 + event.oldVersion, event.newVersion, event)); + } + openPromise.then(db => { + if (terminated) db.addEventListener('close', () => terminated()); + if (blocking) { + db.addEventListener('versionchange', event => blocking(event.oldVersion, event.newVersion, event)); + } + }).catch(() => {}); + return openPromise; + } + /** + * Delete a database. + * + * @param name Name of the database. + */ + function deleteDB(name, { + blocked + } = {}) { + const request = indexedDB.deleteDatabase(name); + if (blocked) { + request.addEventListener('blocked', event => blocked( + // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405 + event.oldVersion, event)); + } + return wrap(request).then(() => undefined); + } + const readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count']; + const writeMethods = ['put', 'add', 'delete', 'clear']; + const cachedMethods = new Map(); + function getMethod(target, prop) { + if (!(target instanceof IDBDatabase && !(prop in target) && typeof prop === 'string')) { + return; + } + if (cachedMethods.get(prop)) return cachedMethods.get(prop); + const targetFuncName = prop.replace(/FromIndex$/, ''); + const useIndex = prop !== targetFuncName; + const isWrite = writeMethods.includes(targetFuncName); + if ( + // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge. + !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) || !(isWrite || readMethods.includes(targetFuncName))) { + return; + } + const method = async function (storeName, ...args) { + // isWrite ? 'readwrite' : undefined gzipps better, but fails in Edge :( + const tx = this.transaction(storeName, isWrite ? 'readwrite' : 'readonly'); + let target = tx.store; + if (useIndex) target = target.index(args.shift()); + // Must reject if op rejects. + // If it's a write operation, must reject if tx.done rejects. + // Must reject with op rejection first. + // Must resolve with op value. + // Must handle both promises (no unhandled rejections) + return (await Promise.all([target[targetFuncName](...args), isWrite && tx.done]))[0]; + }; + cachedMethods.set(prop, method); + return method; + } + replaceTraps(oldTraps => _extends({}, oldTraps, { + get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver), + has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop) + })); + + // @ts-ignore + try { + self['workbox:expiration:7.2.0'] && _(); + } catch (e) {} + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + const DB_NAME = 'workbox-expiration'; + const CACHE_OBJECT_STORE = 'cache-entries'; + const normalizeURL = unNormalizedUrl => { + const url = new URL(unNormalizedUrl, location.href); + url.hash = ''; + return url.href; + }; + /** + * Returns the timestamp model. + * + * @private + */ + class CacheTimestampsModel { + /** + * + * @param {string} cacheName + * + * @private + */ + constructor(cacheName) { + this._db = null; + this._cacheName = cacheName; + } + /** + * Performs an upgrade of indexedDB. + * + * @param {IDBPDatabase} db + * + * @private + */ + _upgradeDb(db) { + // TODO(philipwalton): EdgeHTML doesn't support arrays as a keyPath, so we + // have to use the `id` keyPath here and create our own values (a + // concatenation of `url + cacheName`) instead of simply using + // `keyPath: ['url', 'cacheName']`, which is supported in other browsers. + const objStore = db.createObjectStore(CACHE_OBJECT_STORE, { + keyPath: 'id' + }); + // TODO(philipwalton): once we don't have to support EdgeHTML, we can + // create a single index with the keyPath `['cacheName', 'timestamp']` + // instead of doing both these indexes. + objStore.createIndex('cacheName', 'cacheName', { + unique: false + }); + objStore.createIndex('timestamp', 'timestamp', { + unique: false + }); + } + /** + * Performs an upgrade of indexedDB and deletes deprecated DBs. + * + * @param {IDBPDatabase} db + * + * @private + */ + _upgradeDbAndDeleteOldDbs(db) { + this._upgradeDb(db); + if (this._cacheName) { + void deleteDB(this._cacheName); + } + } + /** + * @param {string} url + * @param {number} timestamp + * + * @private + */ + async setTimestamp(url, timestamp) { + url = normalizeURL(url); + const entry = { + url, + timestamp, + cacheName: this._cacheName, + // Creating an ID from the URL and cache name won't be necessary once + // Edge switches to Chromium and all browsers we support work with + // array keyPaths. + id: this._getId(url) + }; + const db = await this.getDb(); + const tx = db.transaction(CACHE_OBJECT_STORE, 'readwrite', { + durability: 'relaxed' + }); + await tx.store.put(entry); + await tx.done; + } + /** + * Returns the timestamp stored for a given URL. + * + * @param {string} url + * @return {number | undefined} + * + * @private + */ + async getTimestamp(url) { + const db = await this.getDb(); + const entry = await db.get(CACHE_OBJECT_STORE, this._getId(url)); + return entry === null || entry === void 0 ? void 0 : entry.timestamp; + } + /** + * Iterates through all the entries in the object store (from newest to + * oldest) and removes entries once either `maxCount` is reached or the + * entry's timestamp is less than `minTimestamp`. + * + * @param {number} minTimestamp + * @param {number} maxCount + * @return {Array} + * + * @private + */ + async expireEntries(minTimestamp, maxCount) { + const db = await this.getDb(); + let cursor = await db.transaction(CACHE_OBJECT_STORE).store.index('timestamp').openCursor(null, 'prev'); + const entriesToDelete = []; + let entriesNotDeletedCount = 0; + while (cursor) { + const result = cursor.value; + // TODO(philipwalton): once we can use a multi-key index, we + // won't have to check `cacheName` here. + if (result.cacheName === this._cacheName) { + // Delete an entry if it's older than the max age or + // if we already have the max number allowed. + if (minTimestamp && result.timestamp < minTimestamp || maxCount && entriesNotDeletedCount >= maxCount) { + // TODO(philipwalton): we should be able to delete the + // entry right here, but doing so causes an iteration + // bug in Safari stable (fixed in TP). Instead we can + // store the keys of the entries to delete, and then + // delete the separate transactions. + // https://github.com/GoogleChrome/workbox/issues/1978 + // cursor.delete(); + // We only need to return the URL, not the whole entry. + entriesToDelete.push(cursor.value); + } else { + entriesNotDeletedCount++; + } + } + cursor = await cursor.continue(); + } + // TODO(philipwalton): once the Safari bug in the following issue is fixed, + // we should be able to remove this loop and do the entry deletion in the + // cursor loop above: + // https://github.com/GoogleChrome/workbox/issues/1978 + const urlsDeleted = []; + for (const entry of entriesToDelete) { + await db.delete(CACHE_OBJECT_STORE, entry.id); + urlsDeleted.push(entry.url); + } + return urlsDeleted; + } + /** + * Takes a URL and returns an ID that will be unique in the object store. + * + * @param {string} url + * @return {string} + * + * @private + */ + _getId(url) { + // Creating an ID from the URL and cache name won't be necessary once + // Edge switches to Chromium and all browsers we support work with + // array keyPaths. + return this._cacheName + '|' + normalizeURL(url); + } + /** + * Returns an open connection to the database. + * + * @private + */ + async getDb() { + if (!this._db) { + this._db = await openDB(DB_NAME, 1, { + upgrade: this._upgradeDbAndDeleteOldDbs.bind(this) + }); + } + return this._db; + } + } + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * The `CacheExpiration` class allows you define an expiration and / or + * limit on the number of responses stored in a + * [`Cache`](https://developer.mozilla.org/en-US/docs/Web/API/Cache). + * + * @memberof workbox-expiration + */ + class CacheExpiration { + /** + * To construct a new CacheExpiration instance you must provide at least + * one of the `config` properties. + * + * @param {string} cacheName Name of the cache to apply restrictions to. + * @param {Object} config + * @param {number} [config.maxEntries] The maximum number of entries to cache. + * Entries used the least will be removed as the maximum is reached. + * @param {number} [config.maxAgeSeconds] The maximum age of an entry before + * it's treated as stale and removed. + * @param {Object} [config.matchOptions] The [`CacheQueryOptions`](https://developer.mozilla.org/en-US/docs/Web/API/Cache/delete#Parameters) + * that will be used when calling `delete()` on the cache. + */ + constructor(cacheName, config = {}) { + this._isRunning = false; + this._rerunRequested = false; + { + finalAssertExports.isType(cacheName, 'string', { + moduleName: 'workbox-expiration', + className: 'CacheExpiration', + funcName: 'constructor', + paramName: 'cacheName' + }); + if (!(config.maxEntries || config.maxAgeSeconds)) { + throw new WorkboxError('max-entries-or-age-required', { + moduleName: 'workbox-expiration', + className: 'CacheExpiration', + funcName: 'constructor' + }); + } + if (config.maxEntries) { + finalAssertExports.isType(config.maxEntries, 'number', { + moduleName: 'workbox-expiration', + className: 'CacheExpiration', + funcName: 'constructor', + paramName: 'config.maxEntries' + }); + } + if (config.maxAgeSeconds) { + finalAssertExports.isType(config.maxAgeSeconds, 'number', { + moduleName: 'workbox-expiration', + className: 'CacheExpiration', + funcName: 'constructor', + paramName: 'config.maxAgeSeconds' + }); + } + } + this._maxEntries = config.maxEntries; + this._maxAgeSeconds = config.maxAgeSeconds; + this._matchOptions = config.matchOptions; + this._cacheName = cacheName; + this._timestampModel = new CacheTimestampsModel(cacheName); + } + /** + * Expires entries for the given cache and given criteria. + */ + async expireEntries() { + if (this._isRunning) { + this._rerunRequested = true; + return; + } + this._isRunning = true; + const minTimestamp = this._maxAgeSeconds ? Date.now() - this._maxAgeSeconds * 1000 : 0; + const urlsExpired = await this._timestampModel.expireEntries(minTimestamp, this._maxEntries); + // Delete URLs from the cache + const cache = await self.caches.open(this._cacheName); + for (const url of urlsExpired) { + await cache.delete(url, this._matchOptions); + } + { + if (urlsExpired.length > 0) { + logger.groupCollapsed(`Expired ${urlsExpired.length} ` + `${urlsExpired.length === 1 ? 'entry' : 'entries'} and removed ` + `${urlsExpired.length === 1 ? 'it' : 'them'} from the ` + `'${this._cacheName}' cache.`); + logger.log(`Expired the following ${urlsExpired.length === 1 ? 'URL' : 'URLs'}:`); + urlsExpired.forEach(url => logger.log(` ${url}`)); + logger.groupEnd(); + } else { + logger.debug(`Cache expiration ran and found no entries to remove.`); + } + } + this._isRunning = false; + if (this._rerunRequested) { + this._rerunRequested = false; + dontWaitFor(this.expireEntries()); + } + } + /** + * Update the timestamp for the given URL. This ensures the when + * removing entries based on maximum entries, most recently used + * is accurate or when expiring, the timestamp is up-to-date. + * + * @param {string} url + */ + async updateTimestamp(url) { + { + finalAssertExports.isType(url, 'string', { + moduleName: 'workbox-expiration', + className: 'CacheExpiration', + funcName: 'updateTimestamp', + paramName: 'url' + }); + } + await this._timestampModel.setTimestamp(url, Date.now()); + } + /** + * Can be used to check if a URL has expired or not before it's used. + * + * This requires a look up from IndexedDB, so can be slow. + * + * Note: This method will not remove the cached entry, call + * `expireEntries()` to remove indexedDB and Cache entries. + * + * @param {string} url + * @return {boolean} + */ + async isURLExpired(url) { + if (!this._maxAgeSeconds) { + { + throw new WorkboxError(`expired-test-without-max-age`, { + methodName: 'isURLExpired', + paramName: 'maxAgeSeconds' + }); + } + } else { + const timestamp = await this._timestampModel.getTimestamp(url); + const expireOlderThan = Date.now() - this._maxAgeSeconds * 1000; + return timestamp !== undefined ? timestamp < expireOlderThan : true; + } + } + /** + * Removes the IndexedDB object store used to keep track of cache expiration + * metadata. + */ + async delete() { + // Make sure we don't attempt another rerun if we're called in the middle of + // a cache expiration. + this._rerunRequested = false; + await this._timestampModel.expireEntries(Infinity); // Expires all. + } + } + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * This plugin can be used in a `workbox-strategy` to regularly enforce a + * limit on the age and / or the number of cached requests. + * + * It can only be used with `workbox-strategy` instances that have a + * [custom `cacheName` property set](/web/tools/workbox/guides/configure-workbox#custom_cache_names_in_strategies). + * In other words, it can't be used to expire entries in strategy that uses the + * default runtime cache name. + * + * Whenever a cached response is used or updated, this plugin will look + * at the associated cache and remove any old or extra responses. + * + * When using `maxAgeSeconds`, responses may be used *once* after expiring + * because the expiration clean up will not have occurred until *after* the + * cached response has been used. If the response has a "Date" header, then + * a light weight expiration check is performed and the response will not be + * used immediately. + * + * When using `maxEntries`, the entry least-recently requested will be removed + * from the cache first. + * + * @memberof workbox-expiration + */ + class ExpirationPlugin { + /** + * @param {ExpirationPluginOptions} config + * @param {number} [config.maxEntries] The maximum number of entries to cache. + * Entries used the least will be removed as the maximum is reached. + * @param {number} [config.maxAgeSeconds] The maximum age of an entry before + * it's treated as stale and removed. + * @param {Object} [config.matchOptions] The [`CacheQueryOptions`](https://developer.mozilla.org/en-US/docs/Web/API/Cache/delete#Parameters) + * that will be used when calling `delete()` on the cache. + * @param {boolean} [config.purgeOnQuotaError] Whether to opt this cache in to + * automatic deletion if the available storage quota has been exceeded. + */ + constructor(config = {}) { + /** + * A "lifecycle" callback that will be triggered automatically by the + * `workbox-strategies` handlers when a `Response` is about to be returned + * from a [Cache](https://developer.mozilla.org/en-US/docs/Web/API/Cache) to + * the handler. It allows the `Response` to be inspected for freshness and + * prevents it from being used if the `Response`'s `Date` header value is + * older than the configured `maxAgeSeconds`. + * + * @param {Object} options + * @param {string} options.cacheName Name of the cache the response is in. + * @param {Response} options.cachedResponse The `Response` object that's been + * read from a cache and whose freshness should be checked. + * @return {Response} Either the `cachedResponse`, if it's + * fresh, or `null` if the `Response` is older than `maxAgeSeconds`. + * + * @private + */ + this.cachedResponseWillBeUsed = async ({ + event, + request, + cacheName, + cachedResponse + }) => { + if (!cachedResponse) { + return null; + } + const isFresh = this._isResponseDateFresh(cachedResponse); + // Expire entries to ensure that even if the expiration date has + // expired, it'll only be used once. + const cacheExpiration = this._getCacheExpiration(cacheName); + dontWaitFor(cacheExpiration.expireEntries()); + // Update the metadata for the request URL to the current timestamp, + // but don't `await` it as we don't want to block the response. + const updateTimestampDone = cacheExpiration.updateTimestamp(request.url); + if (event) { + try { + event.waitUntil(updateTimestampDone); + } catch (error) { + { + // The event may not be a fetch event; only log the URL if it is. + if ('request' in event) { + logger.warn(`Unable to ensure service worker stays alive when ` + `updating cache entry for ` + `'${getFriendlyURL(event.request.url)}'.`); + } + } + } + } + return isFresh ? cachedResponse : null; + }; + /** + * A "lifecycle" callback that will be triggered automatically by the + * `workbox-strategies` handlers when an entry is added to a cache. + * + * @param {Object} options + * @param {string} options.cacheName Name of the cache that was updated. + * @param {string} options.request The Request for the cached entry. + * + * @private + */ + this.cacheDidUpdate = async ({ + cacheName, + request + }) => { + { + finalAssertExports.isType(cacheName, 'string', { + moduleName: 'workbox-expiration', + className: 'Plugin', + funcName: 'cacheDidUpdate', + paramName: 'cacheName' + }); + finalAssertExports.isInstance(request, Request, { + moduleName: 'workbox-expiration', + className: 'Plugin', + funcName: 'cacheDidUpdate', + paramName: 'request' + }); + } + const cacheExpiration = this._getCacheExpiration(cacheName); + await cacheExpiration.updateTimestamp(request.url); + await cacheExpiration.expireEntries(); + }; + { + if (!(config.maxEntries || config.maxAgeSeconds)) { + throw new WorkboxError('max-entries-or-age-required', { + moduleName: 'workbox-expiration', + className: 'Plugin', + funcName: 'constructor' + }); + } + if (config.maxEntries) { + finalAssertExports.isType(config.maxEntries, 'number', { + moduleName: 'workbox-expiration', + className: 'Plugin', + funcName: 'constructor', + paramName: 'config.maxEntries' + }); + } + if (config.maxAgeSeconds) { + finalAssertExports.isType(config.maxAgeSeconds, 'number', { + moduleName: 'workbox-expiration', + className: 'Plugin', + funcName: 'constructor', + paramName: 'config.maxAgeSeconds' + }); + } + } + this._config = config; + this._maxAgeSeconds = config.maxAgeSeconds; + this._cacheExpirations = new Map(); + if (config.purgeOnQuotaError) { + registerQuotaErrorCallback(() => this.deleteCacheAndMetadata()); + } + } + /** + * A simple helper method to return a CacheExpiration instance for a given + * cache name. + * + * @param {string} cacheName + * @return {CacheExpiration} + * + * @private + */ + _getCacheExpiration(cacheName) { + if (cacheName === cacheNames.getRuntimeName()) { + throw new WorkboxError('expire-custom-caches-only'); + } + let cacheExpiration = this._cacheExpirations.get(cacheName); + if (!cacheExpiration) { + cacheExpiration = new CacheExpiration(cacheName, this._config); + this._cacheExpirations.set(cacheName, cacheExpiration); + } + return cacheExpiration; + } + /** + * @param {Response} cachedResponse + * @return {boolean} + * + * @private + */ + _isResponseDateFresh(cachedResponse) { + if (!this._maxAgeSeconds) { + // We aren't expiring by age, so return true, it's fresh + return true; + } + // Check if the 'date' header will suffice a quick expiration check. + // See https://github.com/GoogleChromeLabs/sw-toolbox/issues/164 for + // discussion. + const dateHeaderTimestamp = this._getDateHeaderTimestamp(cachedResponse); + if (dateHeaderTimestamp === null) { + // Unable to parse date, so assume it's fresh. + return true; + } + // If we have a valid headerTime, then our response is fresh iff the + // headerTime plus maxAgeSeconds is greater than the current time. + const now = Date.now(); + return dateHeaderTimestamp >= now - this._maxAgeSeconds * 1000; + } + /** + * This method will extract the data header and parse it into a useful + * value. + * + * @param {Response} cachedResponse + * @return {number|null} + * + * @private + */ + _getDateHeaderTimestamp(cachedResponse) { + if (!cachedResponse.headers.has('date')) { + return null; + } + const dateHeader = cachedResponse.headers.get('date'); + const parsedDate = new Date(dateHeader); + const headerTime = parsedDate.getTime(); + // If the Date header was invalid for some reason, parsedDate.getTime() + // will return NaN. + if (isNaN(headerTime)) { + return null; + } + return headerTime; + } + /** + * This is a helper method that performs two operations: + * + * - Deletes *all* the underlying Cache instances associated with this plugin + * instance, by calling caches.delete() on your behalf. + * - Deletes the metadata from IndexedDB used to keep track of expiration + * details for each Cache instance. + * + * When using cache expiration, calling this method is preferable to calling + * `caches.delete()` directly, since this will ensure that the IndexedDB + * metadata is also cleanly removed and open IndexedDB instances are deleted. + * + * Note that if you're *not* using cache expiration for a given cache, calling + * `caches.delete()` and passing in the cache's name should be sufficient. + * There is no Workbox-specific method needed for cleanup in that case. + */ + async deleteCacheAndMetadata() { + // Do this one at a time instead of all at once via `Promise.all()` to + // reduce the chance of inconsistency if a promise rejects. + for (const [cacheName, cacheExpiration] of this._cacheExpirations) { + await self.caches.delete(cacheName); + await cacheExpiration.delete(); + } + // Reset this._cacheExpirations to its initial state. + this._cacheExpirations = new Map(); + } + } + + // @ts-ignore + try { + self['workbox:strategies:7.2.0'] && _(); + } catch (e) {} + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + const cacheOkAndOpaquePlugin = { + /** + * Returns a valid response (to allow caching) if the status is 200 (OK) or + * 0 (opaque). + * + * @param {Object} options + * @param {Response} options.response + * @return {Response|null} + * + * @private + */ + cacheWillUpdate: async ({ + response + }) => { + if (response.status === 200 || response.status === 0) { + return response; + } + return null; + } + }; + + /* + Copyright 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. + */ + /** + * 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)); + } + + /* + 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: + * - cacheKeyWillBeUsed() + * - cachedResponseWillBeUsed() + * + * @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: + * - cacheKeyWillBeUsed() + * - 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 + * [network first](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#network-first-falling-back-to-cache) + * request strategy. + * + * By default, this strategy will cache responses with a 200 status code as + * well as [opaque responses](https://developer.chrome.com/docs/workbox/caching-resources-during-runtime/#opaque-responses). + * Opaque responses are are cross-origin requests where the response doesn't + * support [CORS](https://enable-cors.org/). + * + * 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 NetworkFirst extends Strategy { + /** + * @param {Object} [options] + * @param {string} [options.cacheName] Cache name to store and retrieve + * requests. Defaults to 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] [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions) + * @param {number} [options.networkTimeoutSeconds] If set, any network requests + * that fail to respond within the timeout will fallback to the cache. + * + * This option can be used to combat + * "[lie-fi]{@link https://developers.google.com/web/fundamentals/performance/poor-connectivity/#lie-fi}" + * scenarios. + */ + constructor(options = {}) { + super(options); + // If this instance contains no plugins with a 'cacheWillUpdate' callback, + // prepend the `cacheOkAndOpaquePlugin` plugin to the plugins list. + if (!this.plugins.some(p => 'cacheWillUpdate' in p)) { + this.plugins.unshift(cacheOkAndOpaquePlugin); + } + this._networkTimeoutSeconds = options.networkTimeoutSeconds || 0; + { + if (this._networkTimeoutSeconds) { + finalAssertExports.isType(this._networkTimeoutSeconds, 'number', { + moduleName: 'workbox-strategies', + className: this.constructor.name, + funcName: 'constructor', + paramName: 'networkTimeoutSeconds' + }); + } + } + } + /** + * @private + * @param {Request|string} request A request to run this strategy for. + * @param {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: 'handle', + paramName: 'makeRequest' + }); + } + const promises = []; + let timeoutId; + if (this._networkTimeoutSeconds) { + const { + id, + promise + } = this._getTimeoutPromise({ + request, + logs, + handler + }); + timeoutId = id; + promises.push(promise); + } + const networkPromise = this._getNetworkPromise({ + timeoutId, + request, + logs, + handler + }); + promises.push(networkPromise); + const response = await handler.waitUntil((async () => { + // Promise.race() will resolve as soon as the first promise resolves. + return (await handler.waitUntil(Promise.race(promises))) || ( + // If Promise.race() resolved with null, it might be due to a network + // timeout + a cache miss. If that were to happen, we'd rather wait until + // the networkPromise resolves instead of returning null. + // Note that it's fine to await an already-resolved promise, so we don't + // have to check to see if it's still "in flight". + await networkPromise); + })()); + { + logger.groupCollapsed(messages.strategyStart(this.constructor.name, request)); + for (const log of logs) { + logger.log(log); + } + messages.printFinalResponse(response); + logger.groupEnd(); + } + if (!response) { + throw new WorkboxError('no-response', { + url: request.url + }); + } + return response; + } + /** + * @param {Object} options + * @param {Request} options.request + * @param {Array} options.logs A reference to the logs array + * @param {Event} options.event + * @return {Promise} + * + * @private + */ + _getTimeoutPromise({ + request, + logs, + handler + }) { + let timeoutId; + const timeoutPromise = new Promise(resolve => { + const onNetworkTimeout = async () => { + { + logs.push(`Timing out the network response at ` + `${this._networkTimeoutSeconds} seconds.`); + } + resolve(await handler.cacheMatch(request)); + }; + timeoutId = setTimeout(onNetworkTimeout, this._networkTimeoutSeconds * 1000); + }); + return { + promise: timeoutPromise, + id: timeoutId + }; + } + /** + * @param {Object} options + * @param {number|undefined} options.timeoutId + * @param {Request} options.request + * @param {Array} options.logs A reference to the logs Array. + * @param {Event} options.event + * @return {Promise} + * + * @private + */ + async _getNetworkPromise({ + timeoutId, + request, + logs, + handler + }) { + let error; + let response; + try { + response = await handler.fetchAndCachePut(request); + } catch (fetchError) { + if (fetchError instanceof Error) { + error = fetchError; + } + } + if (timeoutId) { + clearTimeout(timeoutId); + } + { + if (response) { + logs.push(`Got response from network.`); + } else { + logs.push(`Unable to get a response from the network. Will respond ` + `with a cached response.`); + } + } + if (error || !response) { + response = await handler.cacheMatch(request); + { + if (response) { + logs.push(`Found a cached response in the '${this.cacheName}'` + ` cache.`); + } else { + logs.push(`No response found in the '${this.cacheName}' cache.`); + } + } + } + return response; + } + } + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * An implementation of a [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:7.2.0'] && _(); + } 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.ExpirationPlugin = ExpirationPlugin; + exports.NavigationRoute = NavigationRoute; + exports.NetworkFirst = NetworkFirst; + exports.cleanupOutdatedCaches = cleanupOutdatedCaches; + exports.clientsClaim = clientsClaim; + exports.createHandlerBoundToURL = createHandlerBoundToURL; + exports.precacheAndRoute = precacheAndRoute; + exports.registerRoute = registerRoute; + +})); diff --git a/spotizerr-ui/index.html b/spotizerr-ui/index.html index 675b561..f1da355 100644 --- a/spotizerr-ui/index.html +++ b/spotizerr-ui/index.html @@ -3,8 +3,27 @@ + + Spotizerr + + + + + + + + + + + + + + + + +
diff --git a/spotizerr-ui/package.json b/spotizerr-ui/package.json index f40b2d6..7e56235 100644 --- a/spotizerr-ui/package.json +++ b/spotizerr-ui/package.json @@ -8,7 +8,8 @@ "build": "tsc -b && vite build", "lint": "eslint . --fix", "format": "prettier --write .", - "preview": "vite preview" + "preview": "vite preview", + "generate-icons": "node scripts/generate-icons.js" }, "dependencies": { "@tailwindcss/postcss": "^4.1.8", @@ -42,9 +43,12 @@ "eslint-plugin-react-refresh": "^0.4.19", "globals": "^16.0.0", "prettier": "^3.5.3", + "sharp": "^0.34.3", + "to-ico": "^1.1.5", "typescript": "~5.8.3", "typescript-eslint": "^8.30.1", - "vite": "^6.3.5" + "vite": "^6.3.5", + "vite-plugin-pwa": "^1.0.2" }, "packageManager": "pnpm@10.12.1+sha512.f0dda8580f0ee9481c5c79a1d927b9164f2c478e90992ad268bbb2465a736984391d6333d2c327913578b2804af33474ca554ba29c04a8b13060a717675ae3ac" } diff --git a/spotizerr-ui/pnpm-lock.yaml b/spotizerr-ui/pnpm-lock.yaml index bdad168..b5a8dd6 100644 --- a/spotizerr-ui/pnpm-lock.yaml +++ b/spotizerr-ui/pnpm-lock.yaml @@ -13,7 +13,7 @@ importers: version: 4.1.8 '@tailwindcss/vite': specifier: ^4.1.8 - version: 4.1.8(vite@6.3.5(@types/node@22.15.30)(jiti@2.4.2)(lightningcss@1.30.1)) + version: 4.1.8(vite@6.3.5(@types/node@22.15.30)(jiti@2.4.2)(lightningcss@1.30.1)(terser@5.43.1)) '@tanstack/react-query': specifier: ^5.80.6 version: 5.80.6(react@19.1.0) @@ -74,7 +74,7 @@ importers: version: 19.1.6(@types/react@19.1.6) '@vitejs/plugin-react': specifier: ^4.4.1 - version: 4.5.1(vite@6.3.5(@types/node@22.15.30)(jiti@2.4.2)(lightningcss@1.30.1)) + version: 4.5.1(vite@6.3.5(@types/node@22.15.30)(jiti@2.4.2)(lightningcss@1.30.1)(terser@5.43.1)) eslint: specifier: ^9.25.0 version: 9.28.0(jiti@2.4.2) @@ -96,6 +96,12 @@ importers: prettier: specifier: ^3.5.3 version: 3.5.3 + sharp: + specifier: ^0.34.3 + version: 0.34.3 + to-ico: + specifier: ^1.1.5 + version: 1.1.5 typescript: specifier: ~5.8.3 version: 5.8.3 @@ -104,7 +110,10 @@ importers: version: 8.33.1(eslint@9.28.0(jiti@2.4.2))(typescript@5.8.3) vite: specifier: ^6.3.5 - version: 6.3.5(@types/node@22.15.30)(jiti@2.4.2)(lightningcss@1.30.1) + version: 6.3.5(@types/node@22.15.30)(jiti@2.4.2)(lightningcss@1.30.1)(terser@5.43.1) + vite-plugin-pwa: + specifier: ^1.0.2 + version: 1.0.2(vite@6.3.5(@types/node@22.15.30)(jiti@2.4.2)(lightningcss@1.30.1)(terser@5.43.1))(workbox-build@7.3.0(@types/babel__core@7.20.5))(workbox-window@7.3.0) packages: @@ -116,6 +125,12 @@ packages: resolution: {integrity: sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==} engines: {node: '>=6.0.0'} + '@apideck/better-ajv-errors@0.3.6': + resolution: {integrity: sha512-P+ZygBLZtkp0qqOAJJVX4oX/sFo5JR3eBWwwuqHHhK0GIgQOKWrAfiAaWX0aArHkRWHMuggFEgAZNxVPwPZYaA==} + engines: {node: '>=10'} + peerDependencies: + ajv: '>=8' + '@babel/code-frame@7.27.1': resolution: {integrity: sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==} engines: {node: '>=6.9.0'} @@ -124,6 +139,10 @@ packages: resolution: {integrity: sha512-KiRAp/VoJaWkkte84TvUd9qjdbZAdiqyvMxrGl1N6vzFogKmaLgoM3L1kgtLicp2HP5fBJS8JrZKLVIZGVJAVg==} engines: {node: '>=6.9.0'} + '@babel/compat-data@7.28.0': + resolution: {integrity: sha512-60X7qkglvrap8mn1lh2ebxXdZYtUcpd7gsmy9kLaBJ4i/WdY8PqTSdxyA8qraikqKQK5C1KRBKXqznrVapyNaw==} + engines: {node: '>=6.9.0'} + '@babel/core@7.27.4': resolution: {integrity: sha512-bXYxrXFubeYdvB0NhD/NBB3Qi6aZeV20GOWVI47t2dkecCEoneR4NPVcb7abpXDEvejgrUfFtG6vG/zxAKmg+g==} engines: {node: '>=6.9.0'} @@ -132,10 +151,43 @@ packages: resolution: {integrity: sha512-ZGhA37l0e/g2s1Cnzdix0O3aLYm66eF8aufiVteOgnwxgnRP8GoyMj7VWsgWnQbVKXyge7hqrFh2K2TQM6t1Hw==} engines: {node: '>=6.9.0'} + '@babel/generator@7.28.0': + resolution: {integrity: sha512-lJjzvrbEeWrhB4P3QBsH7tey117PjLZnDbLiQEKjQ/fNJTjuq4HSqgFA+UNSwZT8D7dxxbnuSBMsa1lrWzKlQg==} + engines: {node: '>=6.9.0'} + + '@babel/helper-annotate-as-pure@7.27.3': + resolution: {integrity: sha512-fXSwMQqitTGeHLBC08Eq5yXz2m37E4pJX1qAU1+2cNedz/ifv/bVXft90VeSav5nFO61EcNgwr0aJxbyPaWBPg==} + engines: {node: '>=6.9.0'} + '@babel/helper-compilation-targets@7.27.2': resolution: {integrity: sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ==} engines: {node: '>=6.9.0'} + '@babel/helper-create-class-features-plugin@7.27.1': + resolution: {integrity: sha512-QwGAmuvM17btKU5VqXfb+Giw4JcN0hjuufz3DYnpeVDvZLAObloM77bhMXiqry3Iio+Ai4phVRDwl6WU10+r5A==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0 + + '@babel/helper-create-regexp-features-plugin@7.27.1': + resolution: {integrity: sha512-uVDC72XVf8UbrH5qQTc18Agb8emwjTiZrQE11Nv3CuBEZmVvTwwE9CBUEvHku06gQCAyYf8Nv6ja1IN+6LMbxQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0 + + '@babel/helper-define-polyfill-provider@0.6.5': + resolution: {integrity: sha512-uJnGFcPsWQK8fvjgGP5LZUZZsYGIoPeRjSF5PGwrelYgq7Q15/Ft9NGFp1zglwgIv//W0uG4BevRuSJRyylZPg==} + peerDependencies: + '@babel/core': ^7.4.0 || ^8.0.0-0 <8.0.0 + + '@babel/helper-globals@7.28.0': + resolution: {integrity: sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==} + engines: {node: '>=6.9.0'} + + '@babel/helper-member-expression-to-functions@7.27.1': + resolution: {integrity: sha512-E5chM8eWjTp/aNoVpcbfM7mLxu9XGLWYise2eBKGQomAk/Mb4XoxyqXTZbuTohbsl8EKqdlMhnDI2CCLfcs9wA==} + engines: {node: '>=6.9.0'} + '@babel/helper-module-imports@7.27.1': resolution: {integrity: sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w==} engines: {node: '>=6.9.0'} @@ -146,10 +198,30 @@ packages: peerDependencies: '@babel/core': ^7.0.0 + '@babel/helper-optimise-call-expression@7.27.1': + resolution: {integrity: sha512-URMGH08NzYFhubNSGJrpUEphGKQwMQYBySzat5cAByY1/YgIRkULnIy3tAMeszlL/so2HbeilYloUmSpd7GdVw==} + engines: {node: '>=6.9.0'} + '@babel/helper-plugin-utils@7.27.1': resolution: {integrity: sha512-1gn1Up5YXka3YYAHGKpbideQ5Yjf1tDa9qYcgysz+cNCXukyLl6DjPXhD3VRwSb8c0J9tA4b2+rHEZtc6R0tlw==} engines: {node: '>=6.9.0'} + '@babel/helper-remap-async-to-generator@7.27.1': + resolution: {integrity: sha512-7fiA521aVw8lSPeI4ZOD3vRFkoqkJcS+z4hFo82bFSH/2tNd6eJ5qCVMS5OzDmZh/kaHQeBaeyxK6wljcPtveA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0 + + '@babel/helper-replace-supers@7.27.1': + resolution: {integrity: sha512-7EHz6qDZc8RYS5ElPoShMheWvEgERonFCs7IAonWLLUTXW59DP14bCZt89/GKyreYn8g3S83m21FelHKbeDCKA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0 + + '@babel/helper-skip-transparent-expression-wrappers@7.27.1': + resolution: {integrity: sha512-Tub4ZKEXqbPjXgWLl2+3JpQAYBJ8+ikpQ2Ocj/q/r0LwE3UhENh7EUabyHjz2kCEsrRY83ew2DQdHluuiDQFzg==} + engines: {node: '>=6.9.0'} + '@babel/helper-string-parser@7.27.1': resolution: {integrity: sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==} engines: {node: '>=6.9.0'} @@ -162,6 +234,10 @@ packages: resolution: {integrity: sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==} engines: {node: '>=6.9.0'} + '@babel/helper-wrap-function@7.27.1': + resolution: {integrity: sha512-NFJK2sHUvrjo8wAU/nQTWU890/zB2jj0qBcCbZbbf+005cAsv6tMjXz31fBign6M5ov1o0Bllu+9nbqkfsjjJQ==} + engines: {node: '>=6.9.0'} + '@babel/helpers@7.27.6': resolution: {integrity: sha512-muE8Tt8M22638HU31A3CgfSUciwz1fhATfoVai05aPXGor//CdWDCbnlY1yvBPo07njuVOCNGCSp/GTt12lIug==} engines: {node: '>=6.9.0'} @@ -171,6 +247,299 @@ packages: engines: {node: '>=6.0.0'} hasBin: true + '@babel/parser@7.28.0': + resolution: {integrity: sha512-jVZGvOxOuNSsuQuLRTh13nU0AogFlw32w/MT+LV6D3sP5WdbW61E77RnkbaO2dUvmPAYrBDJXGn5gGS6tH4j8g==} + engines: {node: '>=6.0.0'} + hasBin: true + + '@babel/plugin-bugfix-firefox-class-in-computed-class-key@7.27.1': + resolution: {integrity: sha512-QPG3C9cCVRQLxAVwmefEmwdTanECuUBMQZ/ym5kiw3XKCGA7qkuQLcjWWHcrD/GKbn/WmJwaezfuuAOcyKlRPA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0 + + '@babel/plugin-bugfix-safari-class-field-initializer-scope@7.27.1': + resolution: {integrity: sha512-qNeq3bCKnGgLkEXUuFry6dPlGfCdQNZbn7yUAPCInwAJHMU7THJfrBSozkcWq5sNM6RcF3S8XyQL2A52KNR9IA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0 + + '@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@7.27.1': + resolution: {integrity: sha512-g4L7OYun04N1WyqMNjldFwlfPCLVkgB54A/YCXICZYBsvJJE3kByKv9c9+R/nAfmIfjl2rKYLNyMHboYbZaWaA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0 + + '@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@7.27.1': + resolution: {integrity: sha512-oO02gcONcD5O1iTLi/6frMJBIwWEHceWGSGqrpCmEL8nogiS6J9PBlE48CaK20/Jx1LuRml9aDftLgdjXT8+Cw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.13.0 + + '@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly@7.27.1': + resolution: {integrity: sha512-6BpaYGDavZqkI6yT+KSPdpZFfpnd68UKXbcjI9pJ13pvHhPrCKWOOLp+ysvMeA+DxnhuPpgIaRpxRxo5A9t5jw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0 + + '@babel/plugin-proposal-private-property-in-object@7.21.0-placeholder-for-preset-env.2': + resolution: {integrity: sha512-SOSkfJDddaM7mak6cPEpswyTRnuRltl429hMraQEglW+OkovnCzsiszTmsrlY//qLFjCpQDFRvjdm2wA5pPm9w==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-syntax-import-assertions@7.27.1': + resolution: {integrity: sha512-UT/Jrhw57xg4ILHLFnzFpPDlMbcdEicaAtjPQpbj9wa8T4r5KVWCimHcL/460g8Ht0DMxDyjsLgiWSkVjnwPFg==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-syntax-import-attributes@7.27.1': + resolution: {integrity: sha512-oFT0FrKHgF53f4vOsZGi2Hh3I35PfSmVs4IBFLFj4dnafP+hIWDLg3VyKmUHfLoLHlyxY4C7DGtmHuJgn+IGww==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-syntax-unicode-sets-regex@7.18.6': + resolution: {integrity: sha512-727YkEAPwSIQTv5im8QHz3upqp92JTWhidIC81Tdx4VJYIte/VndKf1qKrfnnhPLiPghStWfvC/iFaMCQu7Nqg==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0 + + '@babel/plugin-transform-arrow-functions@7.27.1': + resolution: {integrity: sha512-8Z4TGic6xW70FKThA5HYEKKyBpOOsucTOD1DjU3fZxDg+K3zBJcXMFnt/4yQiZnf5+MiOMSXQ9PaEK/Ilh1DeA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-async-generator-functions@7.28.0': + resolution: {integrity: sha512-BEOdvX4+M765icNPZeidyADIvQ1m1gmunXufXxvRESy/jNNyfovIqUyE7MVgGBjWktCoJlzvFA1To2O4ymIO3Q==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-async-to-generator@7.27.1': + resolution: {integrity: sha512-NREkZsZVJS4xmTr8qzE5y8AfIPqsdQfRuUiLRTEzb7Qii8iFWCyDKaUV2c0rCuh4ljDZ98ALHP/PetiBV2nddA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-block-scoped-functions@7.27.1': + resolution: {integrity: sha512-cnqkuOtZLapWYZUYM5rVIdv1nXYuFVIltZ6ZJ7nIj585QsjKM5dhL2Fu/lICXZ1OyIAFc7Qy+bvDAtTXqGrlhg==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-block-scoping@7.28.0': + resolution: {integrity: sha512-gKKnwjpdx5sER/wl0WN0efUBFzF/56YZO0RJrSYP4CljXnP31ByY7fol89AzomdlLNzI36AvOTmYHsnZTCkq8Q==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-class-properties@7.27.1': + resolution: {integrity: sha512-D0VcalChDMtuRvJIu3U/fwWjf8ZMykz5iZsg77Nuj821vCKI3zCyRLwRdWbsuJ/uRwZhZ002QtCqIkwC/ZkvbA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-class-static-block@7.27.1': + resolution: {integrity: sha512-s734HmYU78MVzZ++joYM+NkJusItbdRcbm+AGRgJCt3iA+yux0QpD9cBVdz3tKyrjVYWRl7j0mHSmv4lhV0aoA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.12.0 + + '@babel/plugin-transform-classes@7.28.0': + resolution: {integrity: sha512-IjM1IoJNw72AZFlj33Cu8X0q2XK/6AaVC3jQu+cgQ5lThWD5ajnuUAml80dqRmOhmPkTH8uAwnpMu9Rvj0LTRA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-computed-properties@7.27.1': + resolution: {integrity: sha512-lj9PGWvMTVksbWiDT2tW68zGS/cyo4AkZ/QTp0sQT0mjPopCmrSkzxeXkznjqBxzDI6TclZhOJbBmbBLjuOZUw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-destructuring@7.28.0': + resolution: {integrity: sha512-v1nrSMBiKcodhsyJ4Gf+Z0U/yawmJDBOTpEB3mcQY52r9RIyPneGyAS/yM6seP/8I+mWI3elOMtT5dB8GJVs+A==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-dotall-regex@7.27.1': + resolution: {integrity: sha512-gEbkDVGRvjj7+T1ivxrfgygpT7GUd4vmODtYpbs0gZATdkX8/iSnOtZSxiZnsgm1YjTgjI6VKBGSJJevkrclzw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-duplicate-keys@7.27.1': + resolution: {integrity: sha512-MTyJk98sHvSs+cvZ4nOauwTTG1JeonDjSGvGGUNHreGQns+Mpt6WX/dVzWBHgg+dYZhkC4X+zTDfkTU+Vy9y7Q==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-duplicate-named-capturing-groups-regex@7.27.1': + resolution: {integrity: sha512-hkGcueTEzuhB30B3eJCbCYeCaaEQOmQR0AdvzpD4LoN0GXMWzzGSuRrxR2xTnCrvNbVwK9N6/jQ92GSLfiZWoQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0 + + '@babel/plugin-transform-dynamic-import@7.27.1': + resolution: {integrity: sha512-MHzkWQcEmjzzVW9j2q8LGjwGWpG2mjwaaB0BNQwst3FIjqsg8Ct/mIZlvSPJvfi9y2AC8mi/ktxbFVL9pZ1I4A==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-explicit-resource-management@7.28.0': + resolution: {integrity: sha512-K8nhUcn3f6iB+P3gwCv/no7OdzOZQcKchW6N389V6PD8NUWKZHzndOd9sPDVbMoBsbmjMqlB4L9fm+fEFNVlwQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-exponentiation-operator@7.27.1': + resolution: {integrity: sha512-uspvXnhHvGKf2r4VVtBpeFnuDWsJLQ6MF6lGJLC89jBR1uoVeqM416AZtTuhTezOfgHicpJQmoD5YUakO/YmXQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-export-namespace-from@7.27.1': + resolution: {integrity: sha512-tQvHWSZ3/jH2xuq/vZDy0jNn+ZdXJeM8gHvX4lnJmsc3+50yPlWdZXIc5ay+umX+2/tJIqHqiEqcJvxlmIvRvQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-for-of@7.27.1': + resolution: {integrity: sha512-BfbWFFEJFQzLCQ5N8VocnCtA8J1CLkNTe2Ms2wocj75dd6VpiqS5Z5quTYcUoo4Yq+DN0rtikODccuv7RU81sw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-function-name@7.27.1': + resolution: {integrity: sha512-1bQeydJF9Nr1eBCMMbC+hdwmRlsv5XYOMu03YSWFwNs0HsAmtSxxF1fyuYPqemVldVyFmlCU7w8UE14LupUSZQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-json-strings@7.27.1': + resolution: {integrity: sha512-6WVLVJiTjqcQauBhn1LkICsR2H+zm62I3h9faTDKt1qP4jn2o72tSvqMwtGFKGTpojce0gJs+76eZ2uCHRZh0Q==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-literals@7.27.1': + resolution: {integrity: sha512-0HCFSepIpLTkLcsi86GG3mTUzxV5jpmbv97hTETW3yzrAij8aqlD36toB1D0daVFJM8NK6GvKO0gslVQmm+zZA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-logical-assignment-operators@7.27.1': + resolution: {integrity: sha512-SJvDs5dXxiae4FbSL1aBJlG4wvl594N6YEVVn9e3JGulwioy6z3oPjx/sQBO3Y4NwUu5HNix6KJ3wBZoewcdbw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-member-expression-literals@7.27.1': + resolution: {integrity: sha512-hqoBX4dcZ1I33jCSWcXrP+1Ku7kdqXf1oeah7ooKOIiAdKQ+uqftgCFNOSzA5AMS2XIHEYeGFg4cKRCdpxzVOQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-modules-amd@7.27.1': + resolution: {integrity: sha512-iCsytMg/N9/oFq6n+gFTvUYDZQOMK5kEdeYxmxt91fcJGycfxVP9CnrxoliM0oumFERba2i8ZtwRUCMhvP1LnA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-modules-commonjs@7.27.1': + resolution: {integrity: sha512-OJguuwlTYlN0gBZFRPqwOGNWssZjfIUdS7HMYtN8c1KmwpwHFBwTeFZrg9XZa+DFTitWOW5iTAG7tyCUPsCCyw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-modules-systemjs@7.27.1': + resolution: {integrity: sha512-w5N1XzsRbc0PQStASMksmUeqECuzKuTJer7kFagK8AXgpCMkeDMO5S+aaFb7A51ZYDF7XI34qsTX+fkHiIm5yA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-modules-umd@7.27.1': + resolution: {integrity: sha512-iQBE/xC5BV1OxJbp6WG7jq9IWiD+xxlZhLrdwpPkTX3ydmXdvoCpyfJN7acaIBZaOqTfr76pgzqBJflNbeRK+w==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-named-capturing-groups-regex@7.27.1': + resolution: {integrity: sha512-SstR5JYy8ddZvD6MhV0tM/j16Qds4mIpJTOd1Yu9J9pJjH93bxHECF7pgtc28XvkzTD6Pxcm/0Z73Hvk7kb3Ng==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0 + + '@babel/plugin-transform-new-target@7.27.1': + resolution: {integrity: sha512-f6PiYeqXQ05lYq3TIfIDu/MtliKUbNwkGApPUvyo6+tc7uaR4cPjPe7DFPr15Uyycg2lZU6btZ575CuQoYh7MQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-nullish-coalescing-operator@7.27.1': + resolution: {integrity: sha512-aGZh6xMo6q9vq1JGcw58lZ1Z0+i0xB2x0XaauNIUXd6O1xXc3RwoWEBlsTQrY4KQ9Jf0s5rgD6SiNkaUdJegTA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-numeric-separator@7.27.1': + resolution: {integrity: sha512-fdPKAcujuvEChxDBJ5c+0BTaS6revLV7CJL08e4m3de8qJfNIuCc2nc7XJYOjBoTMJeqSmwXJ0ypE14RCjLwaw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-object-rest-spread@7.28.0': + resolution: {integrity: sha512-9VNGikXxzu5eCiQjdE4IZn8sb9q7Xsk5EXLDBKUYg1e/Tve8/05+KJEtcxGxAgCY5t/BpKQM+JEL/yT4tvgiUA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-object-super@7.27.1': + resolution: {integrity: sha512-SFy8S9plRPbIcxlJ8A6mT/CxFdJx/c04JEctz4jf8YZaVS2px34j7NXRrlGlHkN/M2gnpL37ZpGRGVFLd3l8Ng==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-optional-catch-binding@7.27.1': + resolution: {integrity: sha512-txEAEKzYrHEX4xSZN4kJ+OfKXFVSWKB2ZxM9dpcE3wT7smwkNmXo5ORRlVzMVdJbD+Q8ILTgSD7959uj+3Dm3Q==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-optional-chaining@7.27.1': + resolution: {integrity: sha512-BQmKPPIuc8EkZgNKsv0X4bPmOoayeu4F1YCwx2/CfmDSXDbp7GnzlUH+/ul5VGfRg1AoFPsrIThlEBj2xb4CAg==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-parameters@7.27.7': + resolution: {integrity: sha512-qBkYTYCb76RRxUM6CcZA5KRu8K4SM8ajzVeUgVdMVO9NN9uI/GaVmBg/WKJJGnNokV9SY8FxNOVWGXzqzUidBg==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-private-methods@7.27.1': + resolution: {integrity: sha512-10FVt+X55AjRAYI9BrdISN9/AQWHqldOeZDUoLyif1Kn05a56xVBXb8ZouL8pZ9jem8QpXaOt8TS7RHUIS+GPA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-private-property-in-object@7.27.1': + resolution: {integrity: sha512-5J+IhqTi1XPa0DXF83jYOaARrX+41gOewWbkPyjMNRDqgOCqdffGh8L3f/Ek5utaEBZExjSAzcyjmV9SSAWObQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-property-literals@7.27.1': + resolution: {integrity: sha512-oThy3BCuCha8kDZ8ZkgOg2exvPYUlprMukKQXI1r1pJ47NCvxfkEy8vK+r/hT9nF0Aa4H1WUPZZjHTFtAhGfmQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + '@babel/plugin-transform-react-jsx-self@7.27.1': resolution: {integrity: sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==} engines: {node: '>=6.9.0'} @@ -183,6 +552,93 @@ packages: peerDependencies: '@babel/core': ^7.0.0-0 + '@babel/plugin-transform-regenerator@7.28.1': + resolution: {integrity: sha512-P0QiV/taaa3kXpLY+sXla5zec4E+4t4Aqc9ggHlfZ7a2cp8/x/Gv08jfwEtn9gnnYIMvHx6aoOZ8XJL8eU71Dg==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-regexp-modifiers@7.27.1': + resolution: {integrity: sha512-TtEciroaiODtXvLZv4rmfMhkCv8jx3wgKpL68PuiPh2M4fvz5jhsA7697N1gMvkvr/JTF13DrFYyEbY9U7cVPA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0 + + '@babel/plugin-transform-reserved-words@7.27.1': + resolution: {integrity: sha512-V2ABPHIJX4kC7HegLkYoDpfg9PVmuWy/i6vUM5eGK22bx4YVFD3M5F0QQnWQoDs6AGsUWTVOopBiMFQgHaSkVw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-shorthand-properties@7.27.1': + resolution: {integrity: sha512-N/wH1vcn4oYawbJ13Y/FxcQrWk63jhfNa7jef0ih7PHSIHX2LB7GWE1rkPrOnka9kwMxb6hMl19p7lidA+EHmQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-spread@7.27.1': + resolution: {integrity: sha512-kpb3HUqaILBJcRFVhFUs6Trdd4mkrzcGXss+6/mxUd273PfbWqSDHRzMT2234gIg2QYfAjvXLSquP1xECSg09Q==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-sticky-regex@7.27.1': + resolution: {integrity: sha512-lhInBO5bi/Kowe2/aLdBAawijx+q1pQzicSgnkB6dUPc1+RC8QmJHKf2OjvU+NZWitguJHEaEmbV6VWEouT58g==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-template-literals@7.27.1': + resolution: {integrity: sha512-fBJKiV7F2DxZUkg5EtHKXQdbsbURW3DZKQUWphDum0uRP6eHGGa/He9mc0mypL680pb+e/lDIthRohlv8NCHkg==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-typeof-symbol@7.27.1': + resolution: {integrity: sha512-RiSILC+nRJM7FY5srIyc4/fGIwUhyDuuBSdWn4y6yT6gm652DpCHZjIipgn6B7MQ1ITOUnAKWixEUjQRIBIcLw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-unicode-escapes@7.27.1': + resolution: {integrity: sha512-Ysg4v6AmF26k9vpfFuTZg8HRfVWzsh1kVfowA23y9j/Gu6dOuahdUVhkLqpObp3JIv27MLSii6noRnuKN8H0Mg==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-unicode-property-regex@7.27.1': + resolution: {integrity: sha512-uW20S39PnaTImxp39O5qFlHLS9LJEmANjMG7SxIhap8rCHqu0Ik+tLEPX5DKmHn6CsWQ7j3lix2tFOa5YtL12Q==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-unicode-regex@7.27.1': + resolution: {integrity: sha512-xvINq24TRojDuyt6JGtHmkVkrfVV3FPT16uytxImLeBZqW3/H52yN+kM1MGuyPkIQxrzKwPHs5U/MP3qKyzkGw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-unicode-sets-regex@7.27.1': + resolution: {integrity: sha512-EtkOujbc4cgvb0mlpQefi4NTPBzhSIevblFevACNLUspmrALgmEBdL/XfnyyITfd8fKBZrZys92zOWcik7j9Tw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0 + + '@babel/preset-env@7.28.0': + resolution: {integrity: sha512-VmaxeGOwuDqzLl5JUkIRM1X2Qu2uKGxHEQWh+cvvbl7JuJRgKGJSfsEF/bUaxFhJl/XAyxBe7q7qSuTbKFuCyg==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/preset-modules@0.1.6-no-external-plugins': + resolution: {integrity: sha512-HrcgcIESLm9aIR842yhJ5RWan/gebQUJ6E/E5+rf0y9o6oj7w0Br+sWuL6kEQ/o/AdfvR1Je9jG18/gnpwjEyA==} + peerDependencies: + '@babel/core': ^7.0.0-0 || ^8.0.0-0 <8.0.0 + + '@babel/runtime@7.28.2': + resolution: {integrity: sha512-KHp2IflsnGywDjBWDkR9iEqiWSpc8GIi0lgTT3mOElT0PP1tG26P4tmFI2YvAdzgq9RGyoHZQEIEdZy6Ec5xCA==} + engines: {node: '>=6.9.0'} + '@babel/template@7.27.2': resolution: {integrity: sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw==} engines: {node: '>=6.9.0'} @@ -191,10 +647,21 @@ packages: resolution: {integrity: sha512-oNcu2QbHqts9BtOWJosOVJapWjBDSxGCpFvikNR5TGDYDQf3JwpIoMzIKrvfoti93cLfPJEG4tH9SPVeyCGgdA==} engines: {node: '>=6.9.0'} + '@babel/traverse@7.28.0': + resolution: {integrity: sha512-mGe7UK5wWyh0bKRfupsUchrQGqvDbZDbKJw+kcRGSmdHVYrv+ltd0pnpDTVpiTqnaBru9iEvA8pz8W46v0Amwg==} + engines: {node: '>=6.9.0'} + '@babel/types@7.27.6': resolution: {integrity: sha512-ETyHEk2VHHvl9b9jZP5IHPavHYk57EhanlRRuae9XCpb/j5bDCbPPMOBfCWhnl/7EDJz0jEMCi/RhccCE8r1+Q==} engines: {node: '>=6.9.0'} + '@babel/types@7.28.2': + resolution: {integrity: sha512-ruv7Ae4J5dUYULmeXw1gmb7rYRz57OWCPM57pHojnLq/3Z1CK2lNSLTCVjxVk1F/TZHwOZZrOWi0ur95BbLxNQ==} + engines: {node: '>=6.9.0'} + + '@emnapi/runtime@1.4.5': + resolution: {integrity: sha512-++LApOtY0pEEz1zrd9vy1/zXVaVJJ/EbAF3u0fXIzPJEDtnITsBGbbK0EkM72amhl/R5b+5xx0Y/QhcVOpuulg==} + '@esbuild/aix-ppc64@0.25.5': resolution: {integrity: sha512-9o3TMmpmftaCMepOdA5k/yDw8SfInyzWWTjYTFCX3kPSDJMROQTb8jg+h9Cnwnmm1vOzvxN7gIfB5V2ewpjtGA==} engines: {node: '>=18'} @@ -403,10 +870,135 @@ packages: resolution: {integrity: sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==} engines: {node: '>=18.18'} + '@img/sharp-darwin-arm64@0.34.3': + resolution: {integrity: sha512-ryFMfvxxpQRsgZJqBd4wsttYQbCxsJksrv9Lw/v798JcQ8+w84mBWuXwl+TT0WJ/WrYOLaYpwQXi3sA9nTIaIg==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [arm64] + os: [darwin] + + '@img/sharp-darwin-x64@0.34.3': + resolution: {integrity: sha512-yHpJYynROAj12TA6qil58hmPmAwxKKC7reUqtGLzsOHfP7/rniNGTL8tjWX6L3CTV4+5P4ypcS7Pp+7OB+8ihA==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [x64] + os: [darwin] + + '@img/sharp-libvips-darwin-arm64@1.2.0': + resolution: {integrity: sha512-sBZmpwmxqwlqG9ueWFXtockhsxefaV6O84BMOrhtg/YqbTaRdqDE7hxraVE3y6gVM4eExmfzW4a8el9ArLeEiQ==} + cpu: [arm64] + os: [darwin] + + '@img/sharp-libvips-darwin-x64@1.2.0': + resolution: {integrity: sha512-M64XVuL94OgiNHa5/m2YvEQI5q2cl9d/wk0qFTDVXcYzi43lxuiFTftMR1tOnFQovVXNZJ5TURSDK2pNe9Yzqg==} + cpu: [x64] + os: [darwin] + + '@img/sharp-libvips-linux-arm64@1.2.0': + resolution: {integrity: sha512-RXwd0CgG+uPRX5YYrkzKyalt2OJYRiJQ8ED/fi1tq9WQW2jsQIn0tqrlR5l5dr/rjqq6AHAxURhj2DVjyQWSOA==} + cpu: [arm64] + os: [linux] + + '@img/sharp-libvips-linux-arm@1.2.0': + resolution: {integrity: sha512-mWd2uWvDtL/nvIzThLq3fr2nnGfyr/XMXlq8ZJ9WMR6PXijHlC3ksp0IpuhK6bougvQrchUAfzRLnbsen0Cqvw==} + cpu: [arm] + os: [linux] + + '@img/sharp-libvips-linux-ppc64@1.2.0': + resolution: {integrity: sha512-Xod/7KaDDHkYu2phxxfeEPXfVXFKx70EAFZ0qyUdOjCcxbjqyJOEUpDe6RIyaunGxT34Anf9ue/wuWOqBW2WcQ==} + cpu: [ppc64] + os: [linux] + + '@img/sharp-libvips-linux-s390x@1.2.0': + resolution: {integrity: sha512-eMKfzDxLGT8mnmPJTNMcjfO33fLiTDsrMlUVcp6b96ETbnJmd4uvZxVJSKPQfS+odwfVaGifhsB07J1LynFehw==} + cpu: [s390x] + os: [linux] + + '@img/sharp-libvips-linux-x64@1.2.0': + resolution: {integrity: sha512-ZW3FPWIc7K1sH9E3nxIGB3y3dZkpJlMnkk7z5tu1nSkBoCgw2nSRTFHI5pB/3CQaJM0pdzMF3paf9ckKMSE9Tg==} + cpu: [x64] + os: [linux] + + '@img/sharp-libvips-linuxmusl-arm64@1.2.0': + resolution: {integrity: sha512-UG+LqQJbf5VJ8NWJ5Z3tdIe/HXjuIdo4JeVNADXBFuG7z9zjoegpzzGIyV5zQKi4zaJjnAd2+g2nna8TZvuW9Q==} + cpu: [arm64] + os: [linux] + + '@img/sharp-libvips-linuxmusl-x64@1.2.0': + resolution: {integrity: sha512-SRYOLR7CXPgNze8akZwjoGBoN1ThNZoqpOgfnOxmWsklTGVfJiGJoC/Lod7aNMGA1jSsKWM1+HRX43OP6p9+6Q==} + cpu: [x64] + os: [linux] + + '@img/sharp-linux-arm64@0.34.3': + resolution: {integrity: sha512-QdrKe3EvQrqwkDrtuTIjI0bu6YEJHTgEeqdzI3uWJOH6G1O8Nl1iEeVYRGdj1h5I21CqxSvQp1Yv7xeU3ZewbA==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [arm64] + os: [linux] + + '@img/sharp-linux-arm@0.34.3': + resolution: {integrity: sha512-oBK9l+h6KBN0i3dC8rYntLiVfW8D8wH+NPNT3O/WBHeW0OQWCjfWksLUaPidsrDKpJgXp3G3/hkmhptAW0I3+A==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [arm] + os: [linux] + + '@img/sharp-linux-ppc64@0.34.3': + resolution: {integrity: sha512-GLtbLQMCNC5nxuImPR2+RgrviwKwVql28FWZIW1zWruy6zLgA5/x2ZXk3mxj58X/tszVF69KK0Is83V8YgWhLA==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [ppc64] + os: [linux] + + '@img/sharp-linux-s390x@0.34.3': + resolution: {integrity: sha512-3gahT+A6c4cdc2edhsLHmIOXMb17ltffJlxR0aC2VPZfwKoTGZec6u5GrFgdR7ciJSsHT27BD3TIuGcuRT0KmQ==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [s390x] + os: [linux] + + '@img/sharp-linux-x64@0.34.3': + resolution: {integrity: sha512-8kYso8d806ypnSq3/Ly0QEw90V5ZoHh10yH0HnrzOCr6DKAPI6QVHvwleqMkVQ0m+fc7EH8ah0BB0QPuWY6zJQ==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [x64] + os: [linux] + + '@img/sharp-linuxmusl-arm64@0.34.3': + resolution: {integrity: sha512-vAjbHDlr4izEiXM1OTggpCcPg9tn4YriK5vAjowJsHwdBIdx0fYRsURkxLG2RLm9gyBq66gwtWI8Gx0/ov+JKQ==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [arm64] + os: [linux] + + '@img/sharp-linuxmusl-x64@0.34.3': + resolution: {integrity: sha512-gCWUn9547K5bwvOn9l5XGAEjVTTRji4aPTqLzGXHvIr6bIDZKNTA34seMPgM0WmSf+RYBH411VavCejp3PkOeQ==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [x64] + os: [linux] + + '@img/sharp-wasm32@0.34.3': + resolution: {integrity: sha512-+CyRcpagHMGteySaWos8IbnXcHgfDn7pO2fiC2slJxvNq9gDipYBN42/RagzctVRKgxATmfqOSulgZv5e1RdMg==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [wasm32] + + '@img/sharp-win32-arm64@0.34.3': + resolution: {integrity: sha512-MjnHPnbqMXNC2UgeLJtX4XqoVHHlZNd+nPt1kRPmj63wURegwBhZlApELdtxM2OIZDRv/DFtLcNhVbd1z8GYXQ==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [arm64] + os: [win32] + + '@img/sharp-win32-ia32@0.34.3': + resolution: {integrity: sha512-xuCdhH44WxuXgOM714hn4amodJMZl3OEvf0GVTm0BEyMeA2to+8HEdRPShH0SLYptJY1uBw+SCFP9WVQi1Q/cw==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [ia32] + os: [win32] + + '@img/sharp-win32-x64@0.34.3': + resolution: {integrity: sha512-OWwz05d++TxzLEv4VnsTz5CmZ6mI6S05sfQGEMrNrQcOEERbX46332IvE7pO/EUiw7jUrrS40z/M7kPyjfl04g==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [x64] + os: [win32] + '@isaacs/fs-minipass@4.0.1': resolution: {integrity: sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w==} engines: {node: '>=18.0.0'} + '@jridgewell/gen-mapping@0.3.12': + resolution: {integrity: sha512-OuLGC46TjB5BbN1dH8JULVVZY4WTdkF7tV9Ys6wLL1rubZnCMstOhNHueU5bLCrnRuDhKPDM4g6sw4Bel5Gzqg==} + '@jridgewell/gen-mapping@0.3.8': resolution: {integrity: sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA==} engines: {node: '>=6.0.0'} @@ -419,12 +1011,18 @@ packages: resolution: {integrity: sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==} engines: {node: '>=6.0.0'} + '@jridgewell/source-map@0.3.10': + resolution: {integrity: sha512-0pPkgz9dY+bijgistcTTJ5mR+ocqRXLuhXHYdzoMmmoJ2C9S46RCm2GMUbatPEUK9Yjy26IrAy8D/M00lLkv+Q==} + '@jridgewell/sourcemap-codec@1.5.0': resolution: {integrity: sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==} '@jridgewell/trace-mapping@0.3.25': resolution: {integrity: sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==} + '@jridgewell/trace-mapping@0.3.29': + resolution: {integrity: sha512-uw6guiW/gcAGPDhLmd77/6lW8QLeiV5RUTsAX46Db6oLhGaVj4lhnPwb184s1bkc8kdVg/+h988dro8GRDpmYQ==} + '@nodelib/fs.scandir@2.1.5': resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==} engines: {node: '>= 8'} @@ -444,6 +1042,55 @@ packages: '@rolldown/pluginutils@1.0.0-beta.9': resolution: {integrity: sha512-e9MeMtVWo186sgvFFJOPGy7/d2j2mZhLJIdVW0C/xDluuOvymEATqz6zKsP0ZmXGzQtqlyjz5sC1sYQUoJG98w==} + '@rollup/plugin-babel@5.3.1': + 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 + + '@rollup/plugin-node-resolve@15.3.1': + resolution: {integrity: sha512-tgg6b91pAybXHJQMAAwW9VuWBO6Thi+q7BCNARLwSqlmsHz0XYURtGvh/AuwSADXSI4h/2uHbs7s4FzlZDGSGA==} + engines: {node: '>=14.0.0'} + peerDependencies: + rollup: ^2.78.0||^3.0.0||^4.0.0 + peerDependenciesMeta: + rollup: + optional: true + + '@rollup/plugin-replace@2.4.2': + resolution: {integrity: sha512-IGcu+cydlUMZ5En85jxHH4qj2hta/11BHq95iHEyb2sbgiN0eCdzvUcHw5gt9pBL5lTi4JDYJ1acCoMGpTvEZg==} + peerDependencies: + rollup: ^1.20.0 || ^2.0.0 + + '@rollup/plugin-terser@0.4.4': + resolution: {integrity: sha512-XHeJC5Bgvs8LfukDwWZp7yeqin6ns8RTl2B9avbejt6tZqsqvVoWI7ZTQrcNsfKEDWBTnTxM8nMDkO2IFFbd0A==} + engines: {node: '>=14.0.0'} + peerDependencies: + rollup: ^2.0.0||^3.0.0||^4.0.0 + peerDependenciesMeta: + rollup: + optional: true + + '@rollup/pluginutils@3.1.0': + resolution: {integrity: sha512-GksZ6pr6TpIjHm8h9lSQ8pi8BE9VeubNT0OMJ3B5uZJ8pz73NPiqOtCog/x2/QzM1ENChPKxMDhiQuRHsqc+lg==} + engines: {node: '>= 8.0.0'} + peerDependencies: + rollup: ^1.20.0||^2.0.0 + + '@rollup/pluginutils@5.2.0': + resolution: {integrity: sha512-qWJ2ZTbmumwiLFomfzTyt5Kng4hwPi9rwCYN4SHb6eaRU1KNO4ccxINHr/VhH4GgPlt1XfSTLX2LBTme8ne4Zw==} + engines: {node: '>=14.0.0'} + peerDependencies: + rollup: ^1.20.0||^2.0.0||^3.0.0||^4.0.0 + peerDependenciesMeta: + rollup: + optional: true + '@rollup/rollup-android-arm-eabi@4.42.0': resolution: {integrity: sha512-gldmAyS9hpj+H6LpRNlcjQWbuKUtb94lodB9uCz71Jm+7BxK1VIOo7y62tZZwxhA7j1ylv/yQz080L5WkS+LoQ==} cpu: [arm] @@ -544,6 +1191,9 @@ packages: cpu: [x64] os: [win32] + '@surma/rollup-plugin-off-main-thread@2.2.3': + resolution: {integrity: sha512-lR8q/9W7hZpMWweNiAKU7NQerBnzQQLvi8qnTDU/fxItPhtZVMbPV3lbCwjhIlNBe9Bbr5V+KHshvWmVSG9cxQ==} + '@tailwindcss/node@4.1.8': resolution: {integrity: sha512-OWwBsbC9BFAJelmnNcrKuf+bka2ZxCE2A4Ft53Tkg4uoiE67r/PMEYwCsourC26E+kmxfwE0hVzMdxqeW+xu7Q==} @@ -724,6 +1374,9 @@ packages: '@types/babel__traverse@7.20.7': resolution: {integrity: sha512-dkO5fhS7+/oos4ciWxyEyjWe48zmG6wbCheo/G2ZnHx4fs3EU6YC6UM8rk56gAjNJ9P3MTH2jo5jb92/K6wbng==} + '@types/estree@0.0.39': + resolution: {integrity: sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==} + '@types/estree@1.0.7': resolution: {integrity: sha512-w28IoSUCJpidD/TGviZwwMJckNESJZXFu7NBZ5YJ4mEUnNraUn9Pm8HSZm/jDF1pDWYKspWE7oVphigUPRakIQ==} @@ -744,6 +1397,12 @@ packages: '@types/react@19.1.6': resolution: {integrity: sha512-JeG0rEWak0N6Itr6QUx+X60uQmN+5t3j9r/OVDtWzFXKaj6kD1BwJzOksD0FF6iWxZlbE1kB0q9vtnU2ekqa1Q==} + '@types/resolve@1.20.2': + resolution: {integrity: sha512-60BCwRFOZCQhDncwQdxxeOEEkbc5dIMccYLwbxsS4TUNeVECQ/pBJ0j09mrHOl/JJvpRPGwO9SvE4nR2Nb/a4Q==} + + '@types/trusted-types@2.0.7': + resolution: {integrity: sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==} + '@types/uuid@10.0.0': resolution: {integrity: sha512-7gqG38EyHgyP1S+7+xomFtL+ZNHcKv6DwNaCZmJmo1vgMugyF3TCnXVg4t1uk89mLNwnLtnY3TpOpCOyp1/xHQ==} @@ -825,6 +1484,9 @@ packages: ajv@6.12.6: resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==} + ajv@8.17.1: + resolution: {integrity: sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==} + ansi-styles@4.3.0: resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==} engines: {node: '>=8'} @@ -832,15 +1494,82 @@ packages: argparse@2.0.1: resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==} + array-buffer-byte-length@1.0.2: + resolution: {integrity: sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw==} + engines: {node: '>= 0.4'} + + arraybuffer.prototype.slice@1.0.4: + resolution: {integrity: sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ==} + engines: {node: '>= 0.4'} + + arrify@1.0.1: + resolution: {integrity: sha512-3CYzex9M9FGQjCGMGyi6/31c8GJbgb0qGyrx5HWxPd0aCwh4cB2YjMb2Xf9UuoogrMrlO9cTqnB5rI5GHZTcUA==} + engines: {node: '>=0.10.0'} + + asn1@0.2.6: + resolution: {integrity: sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ==} + + assert-plus@1.0.0: + resolution: {integrity: sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw==} + engines: {node: '>=0.8'} + + async-function@1.0.0: + resolution: {integrity: sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA==} + engines: {node: '>= 0.4'} + + async@3.2.6: + resolution: {integrity: sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==} + asynckit@0.4.0: resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==} + at-least-node@1.0.0: + resolution: {integrity: sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==} + engines: {node: '>= 4.0.0'} + + available-typed-arrays@1.0.7: + resolution: {integrity: sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==} + engines: {node: '>= 0.4'} + + aws-sign2@0.7.0: + resolution: {integrity: sha512-08kcGqnYf/YmjoRhfxyu+CLxBjUtHLXLXX/vUfx9l2LYzG3c1m61nrpyFUZI6zeS+Li/wWMMidD9KgrqtGq3mA==} + + aws4@1.13.2: + resolution: {integrity: sha512-lHe62zvbTB5eEABUVi/AwVh0ZKY9rMMDhmm+eeyuuUQbQ3+J+fONVQOZyj+DdrvD4BY33uYniyRJ4UJIaSKAfw==} + axios@1.9.0: resolution: {integrity: sha512-re4CqKTJaURpzbLHtIi6XpDv20/CnpXOtjRY5/CU32L8gU8ek9UIivcfvSWvmKEngmVbrUtPpdDwWDWL7DNHvg==} + babel-plugin-polyfill-corejs2@0.4.14: + resolution: {integrity: sha512-Co2Y9wX854ts6U8gAAPXfn0GmAyctHuK8n0Yhfjd6t30g7yvKjspvvOo9yG+z52PZRgFErt7Ka2pYnXCjLKEpg==} + peerDependencies: + '@babel/core': ^7.4.0 || ^8.0.0-0 <8.0.0 + + babel-plugin-polyfill-corejs3@0.13.0: + resolution: {integrity: sha512-U+GNwMdSFgzVmfhNm8GJUX88AadB3uo9KpJqS3FaqNIPKgySuvMb+bHPsOmmuWyIcuqZj/pzt1RUIUZns4y2+A==} + peerDependencies: + '@babel/core': ^7.4.0 || ^8.0.0-0 <8.0.0 + + babel-plugin-polyfill-regenerator@0.6.5: + resolution: {integrity: sha512-ISqQ2frbiNU9vIJkzg7dlPpznPZ4jOiUQ1uSmB0fEHeowtN3COYRsXr/xexn64NpU13P06jc/L5TgiJXOgrbEg==} + peerDependencies: + '@babel/core': ^7.4.0 || ^8.0.0-0 <8.0.0 + balanced-match@1.0.2: resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==} + bcrypt-pbkdf@1.0.2: + resolution: {integrity: sha512-qeFIXtP4MSoi6NLqO12WfqARWWuCKi2Rn/9hJLEmtB5yTNr9DqFWkJRCf2qShWzPeAMRnOgCrq0sg/KLv5ES9w==} + + bignumber.js@2.4.0: + resolution: {integrity: sha512-uw4ra6Cv483Op/ebM0GBKKfxZlSmn6NgFRby5L3yGTlunLj53KQgndDlqy2WVFOwgvurocApYkSud0aO+mvrpQ==} + + bmp-js@0.0.1: + resolution: {integrity: sha512-OS74Rlt0Aynu2mTPmY9RZOUOXlqWecFIILFXr70vv16/xCZnFxvri9IKkF1IGxQ8r9dOE62qGNpKxXx8Lko8bg==} + + bmp-js@0.0.3: + resolution: {integrity: sha512-epsm3Z92j5xwek9p97pVw3KbsNc0F4QnbYh+N93SpbJYuHFQQ/UAh6K+bKFGyLePH3Hudtl/Sa95Quqp0gX8IQ==} + brace-expansion@1.1.11: resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==} @@ -856,10 +1585,39 @@ packages: engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7} hasBin: true + browserslist@4.25.1: + resolution: {integrity: sha512-KGj0KoOMXLpSNkkEI6Z6mShmQy0bc1I+T7K9N81k4WWMrfz+6fQ6es80B/YLAeRoKvjYE1YSHHOW1qe9xIVzHw==} + engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7} + hasBin: true + + buffer-alloc-unsafe@1.1.0: + resolution: {integrity: sha512-TEM2iMIEQdJ2yjPJoSIsldnleVaAk1oW3DBVUykyOLsEsFmEc9kn+SFFPz+gl54KQNxlDnAwCXosOS9Okx2xAg==} + + buffer-alloc@1.2.0: + resolution: {integrity: sha512-CFsHQgjtW1UChdXgbyJGtnm+O/uLQeZdtbDo8mfUgYXCHSM1wgrVxXm6bSyrUuErEb+4sYVGCzASBRot7zyrow==} + + buffer-equal@0.0.1: + resolution: {integrity: sha512-RgSV6InVQ9ODPdLWJ5UAqBqJBOg370Nz6ZQtRzpt6nUjc8v0St97uJ4PYC6NztqIScrAXafKM3mZPMygSe1ggA==} + engines: {node: '>=0.4.0'} + + buffer-fill@1.0.0: + resolution: {integrity: sha512-T7zexNBwiiaCOGDg9xNX9PBmjrubblRkENuptryuI64URkXDFum9il/JGL8Lm8wYfAXpredVXXZz7eMHilimiQ==} + + buffer-from@1.1.2: + resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==} + call-bind-apply-helpers@1.0.2: resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==} engines: {node: '>= 0.4'} + call-bind@1.0.8: + resolution: {integrity: sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==} + engines: {node: '>= 0.4'} + + call-bound@1.0.4: + resolution: {integrity: sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==} + engines: {node: '>= 0.4'} + callsites@3.1.0: resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==} engines: {node: '>=6'} @@ -867,6 +1625,15 @@ packages: caniuse-lite@1.0.30001721: resolution: {integrity: sha512-cOuvmUVtKrtEaoKiO0rSc29jcjwMwX5tOHDy4MgVFEWiUXj4uBMJkwI8MDySkgXidpMiHUcviogAvFi4pA2hDQ==} + caniuse-lite@1.0.30001727: + resolution: {integrity: sha512-pB68nIHmbN6L/4C6MH1DokyR3bYqFwjaSs/sWDHGj4CTcFtQUQMuJftVwWkXq7mNWOybD3KhUv3oWHoGxgP14Q==} + + caseless@0.12.0: + resolution: {integrity: sha512-4tYFyifaFfGacoiObjJegolkwSU4xQNGbVgUiNYVUxbQ2x2lUsFvY4hVgVzGiIe6WLOPqycWXA40l+PWsxthUw==} + + centra@2.7.0: + resolution: {integrity: sha512-PbFMgMSrmgx6uxCdm57RUos9Tc3fclMvhLSATYN39XsDV29B89zZ3KA89jmY0vwSGazyU+uerqwa6t+KaodPcg==} + chalk@4.1.2: resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==} engines: {node: '>=10'} @@ -886,23 +1653,63 @@ packages: color-name@1.1.4: resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==} + color-string@1.9.1: + resolution: {integrity: sha512-shrVawQFojnZv6xM40anx4CkoDP+fZsw/ZerEMsW/pyzsRbElpsL/DBVW7q3ExxwusdNXI3lXpuhEZkzs8p5Eg==} + + color@4.2.3: + resolution: {integrity: sha512-1rXeuUUiGGrykh+CeBdu5Ie7OJwinCgQY0bc7GCRxy5xVHy+moaqkpL/jqQq0MtQOeYcrqEz4abc5f0KtU7W4A==} + engines: {node: '>=12.5.0'} + combined-stream@1.0.8: resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==} engines: {node: '>= 0.8'} + 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'} + concat-map@0.0.1: resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==} convert-source-map@2.0.0: resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==} + core-js-compat@3.44.0: + resolution: {integrity: sha512-JepmAj2zfl6ogy34qfWtcE7nHKAJnKsQFRn++scjVS2bZFllwptzw61BZcZFYBPpUznLfAvh0LGhxKppk04ClA==} + + core-util-is@1.0.2: + resolution: {integrity: sha512-3lqz5YjWTYnW6dlDa5TLaTCcShfar1e40rmcJVwCBJC6mWlFuj0eCHIElmG1g5kyuJ/GD+8Wn4FFCcz4gJPfaQ==} + cross-spawn@7.0.6: resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==} engines: {node: '>= 8'} + crypto-random-string@2.0.0: + resolution: {integrity: sha512-v1plID3y9r/lPhviJ1wrXpLeyUIGAZ2SHNYTEapm7/8A9nLPoyvVp3RK/EPFqn5kEznyWgYZNsRtYYIWbuG8KA==} + engines: {node: '>=8'} + csstype@3.1.3: resolution: {integrity: sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==} + dashdash@1.14.1: + resolution: {integrity: sha512-jRFi8UDGo6j+odZiEpjazZaWqEal3w/basFjQHQEwVtZJGDpxbH1MeYluwCS8Xq5wmLJooDlMgvVarmWfGM44g==} + engines: {node: '>=0.10'} + + data-view-buffer@1.0.2: + resolution: {integrity: sha512-EmKO5V3OLXh1rtK2wgXRansaK1/mtVdTUEiEI0W8RkvgT05kfxaH29PliLnpLP73yYO6142Q72QNa8Wx/A5CqQ==} + engines: {node: '>= 0.4'} + + data-view-byte-length@1.0.2: + resolution: {integrity: sha512-tuhGbE6CfTM9+5ANGf+oQb72Ky/0+s3xKUpHvShfiz2RxMFgFPjsXuRLBVMtvMs15awe45SRb83D6wH4ew6wlQ==} + engines: {node: '>= 0.4'} + + data-view-byte-offset@1.0.1: + resolution: {integrity: sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ==} + engines: {node: '>= 0.4'} + debug@4.4.1: resolution: {integrity: sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==} engines: {node: '>=6.0'} @@ -915,6 +1722,18 @@ packages: deep-is@0.1.4: resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==} + deepmerge@4.3.1: + resolution: {integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==} + engines: {node: '>=0.10.0'} + + define-data-property@1.1.4: + resolution: {integrity: sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==} + engines: {node: '>= 0.4'} + + define-properties@1.2.1: + resolution: {integrity: sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==} + engines: {node: '>= 0.4'} + delayed-stream@1.0.0: resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==} engines: {node: '>=0.4.0'} @@ -923,17 +1742,35 @@ packages: resolution: {integrity: sha512-3UDv+G9CsCKO1WKMGw9fwq/SWJYbI0c5Y7LU1AXYoDdbhE2AHQ6N6Nb34sG8Fj7T5APy8qXDCKuuIHd1BR0tVA==} engines: {node: '>=8'} + dom-walk@0.1.2: + resolution: {integrity: sha512-6QvTW9mrGeIegrFXdtQi9pk7O/nSK6lSdXW2eqUspN5LWD7UTji2Fqw5V2YLjBpHEoU9Xl/eUWNpDeZvoyOv2w==} + dunder-proto@1.0.1: resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==} engines: {node: '>= 0.4'} + ecc-jsbn@0.1.2: + resolution: {integrity: sha512-eh9O+hwRHNbG4BLTjEl3nw044CkGm5X6LoaCf7LPp7UU8Qrt47JYNi6nPX8xjW97TKGKm1ouctg0QSpZe9qrnw==} + + ejs@3.1.10: + resolution: {integrity: sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA==} + engines: {node: '>=0.10.0'} + hasBin: true + electron-to-chromium@1.5.165: resolution: {integrity: sha512-naiMx1Z6Nb2TxPU6fiFrUrDTjyPMLdTtaOd2oLmG8zVSg2hCWGkhPyxwk+qRmZ1ytwVqUv0u7ZcDA5+ALhaUtw==} + electron-to-chromium@1.5.191: + resolution: {integrity: sha512-xcwe9ELcuxYLUFqZZxL19Z6HVKcvNkIwhbHUz7L3us6u12yR+7uY89dSl570f/IqNthx8dAw3tojG7i4Ni4tDA==} + enhanced-resolve@5.18.1: resolution: {integrity: sha512-ZSW3ma5GkcQBIpwZTSRAI8N71Uuwgs93IezB7mf7R60tC8ZbJideoDNKjHn2O9KIlx6rkGTTEk1xUCK2E1Y2Yg==} engines: {node: '>=10.13.0'} + es-abstract@1.24.0: + resolution: {integrity: sha512-WSzPgsdLtTcQwm4CROfS5ju2Wa1QQcVeT37jFjYzdFz1r9ahadC8B8/a4qxJxM+09F18iumCdRmlr96ZYkQvEg==} + engines: {node: '>= 0.4'} + es-define-property@1.0.1: resolution: {integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==} engines: {node: '>= 0.4'} @@ -950,6 +1787,13 @@ packages: resolution: {integrity: sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==} engines: {node: '>= 0.4'} + es-to-primitive@1.3.0: + resolution: {integrity: sha512-w+5mJ3GuFL+NjVtJlvydShqE1eN3h3PbI7/5LAsYJP/2qtuMXjfL2LpHSRqo4b4eSF5K/DH1JXKUAHSB2UW50g==} + engines: {node: '>= 0.4'} + + es6-promise@3.3.1: + resolution: {integrity: sha512-SOp9Phqvqn7jtEUxPWdWfWoLmyt2VaJ6MpvP9Comy1MceMXqE6bxvaTu4iaxpYYPzhny28Lc+M87/c2cPK6lDg==} + esbuild@0.25.5: resolution: {integrity: sha512-P8OtKZRv/5J5hhz0cUAdu/cLuPIKXpQl1R9pZtvmHWQvrAUVd0UNIPT4IB4W3rNOqVO0rlqHmCIbSwxh/c9yUQ==} engines: {node: '>=18'} @@ -1032,10 +1876,26 @@ packages: resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==} engines: {node: '>=4.0'} + estree-walker@1.0.1: + resolution: {integrity: sha512-1fMXF3YP4pZZVozF8j/ZLfvnR8NSIljt56UhbZ5PeeDmmGHpgpdwQt7ITlGvYaQukCvuBRMLEiKiYC+oeIg4cg==} + + 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'} + exif-parser@0.1.12: + resolution: {integrity: sha512-c2bQfLNbMzLPmzQuOr8fy0csy84WmwnER81W88DzTp9CYNPJ6yzOj2EZAh9pywYpqHnshVLHQJ8WzldAyfY+Iw==} + + extend@3.0.2: + resolution: {integrity: sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==} + + extsprintf@1.3.0: + resolution: {integrity: sha512-11Ndz7Nv+mvAC1j0ktTa7fAb0vLyGGX+rMHNBYQviQDGU0Hw7lhctJANqbPhu9nV9/izT/IntTgZ7Im/9LJs9g==} + engines: {'0': node >=0.6.0} + fast-deep-equal@3.1.3: resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==} @@ -1052,6 +1912,9 @@ packages: fast-levenshtein@2.0.6: resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==} + fast-uri@3.0.6: + resolution: {integrity: sha512-Atfo14OibSv5wAp4VWNsFYE1AchQRTv9cBGWET4pZWHzYshFSS9NQI6I57rdKn9croWVMbYFbLhJ+yJvmZIIHw==} + fastq@1.19.1: resolution: {integrity: sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==} @@ -1067,6 +1930,13 @@ packages: resolution: {integrity: sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==} engines: {node: '>=16.0.0'} + file-type@3.9.0: + resolution: {integrity: sha512-RLoqTXE8/vPmMuTI88DAzhMYC99I8BWv7zYP4A1puo5HIjEJ5EX48ighy4ZyKMG9EDXxBgW6e++cn7d1xuFghA==} + engines: {node: '>=0.10.0'} + + filelist@1.0.4: + resolution: {integrity: sha512-w1cEuf3S+DrLCQL7ET6kz+gmlJdbq9J7yXCSjK/OZCPA+qEN1WyF4ZAf0YYJa4/shHJra2t/d/r8SV4Ji+x+8Q==} + fill-range@7.1.1: resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==} engines: {node: '>=8'} @@ -1091,10 +1961,28 @@ packages: debug: optional: true + for-each@0.3.5: + resolution: {integrity: sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==} + engines: {node: '>= 0.4'} + + forever-agent@0.6.1: + resolution: {integrity: sha512-j0KLYPhm6zeac4lz3oJ3o65qvgQCcPubiyotZrXqEaG4hNagNYO8qdlUrX5vwqv9ohqeT/Z3j6+yW067yWWdUw==} + + form-data@2.3.3: + resolution: {integrity: sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ==} + engines: {node: '>= 0.12'} + form-data@4.0.3: resolution: {integrity: sha512-qsITQPfmvMOSAdeyZ+12I1c+CKSstAFAwu+97zrnWAbIr5u8wfsExUzCesVLC8NgHuRUqNN4Zy6UPWUTRGslcA==} engines: {node: '>= 6'} + fs-extra@9.1.0: + resolution: {integrity: sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==} + engines: {node: '>=10'} + + fs.realpath@1.0.0: + resolution: {integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==} + fsevents@2.3.3: resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==} engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0} @@ -1103,6 +1991,13 @@ packages: function-bind@1.1.2: resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==} + function.prototype.name@1.1.8: + resolution: {integrity: sha512-e5iwyodOHhbMr/yNrc7fDYG4qlbIvI5gajyzPnb5TCwyhjApznQh1BMFou9b30SevY43gCJKXycoCBjMbsuW0Q==} + engines: {node: '>= 0.4'} + + functions-have-names@1.2.3: + resolution: {integrity: sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==} + gensync@1.0.0-beta.2: resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==} engines: {node: '>=6.9.0'} @@ -1111,10 +2006,24 @@ packages: resolution: {integrity: sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==} engines: {node: '>= 0.4'} + get-own-enumerable-property-symbols@3.0.2: + resolution: {integrity: sha512-I0UBV/XOz1XkIJHEUDMZAbzCThU/H8DxmSfmdGcKPnVhu2VfFqr34jr9777IyaTYvxjedWhqVIilEDsCdP5G6g==} + get-proto@1.0.1: resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==} engines: {node: '>= 0.4'} + get-stream@2.3.1: + resolution: {integrity: sha512-AUGhbbemXxrZJRD5cDvKtQxLuYaIbNtDTK8YqupCI393Q2KSTreEsLUN3ZxAWFGiKTzL6nKuzfcIvieflUX9qA==} + engines: {node: '>=0.10.0'} + + get-symbol-description@1.1.0: + resolution: {integrity: sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg==} + engines: {node: '>= 0.4'} + + getpass@0.1.7: + resolution: {integrity: sha512-0fzj9JxOLfJ+XGLhR8ze3unN0KZCgZwiSSDz168VERjK8Wl8kVSdcu2kspd4s4wtAa1y/qrVRiAA0WclVsu0ng==} + glob-parent@5.1.2: resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==} engines: {node: '>= 6'} @@ -1123,6 +2032,13 @@ packages: resolution: {integrity: sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==} engines: {node: '>=10.13.0'} + glob@7.2.3: + resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==} + deprecated: Glob versions prior to v9 are no longer supported + + global@4.4.0: + resolution: {integrity: sha512-wv/LAoHdRE3BeTGz53FAamhGlPLhlssK45usmGFThIi4XqnBmjKQ16u+RNbP7WvigRZDxUsM0J3gcQ5yicaL0w==} + globals@11.12.0: resolution: {integrity: sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==} engines: {node: '>=4'} @@ -1135,6 +2051,10 @@ packages: resolution: {integrity: sha512-O+7l9tPdHCU320IigZZPj5zmRCFG9xHmx9cU8FqU2Rp+JN714seHV+2S9+JslCpY4gJwU2vOGox0wzgae/MCEg==} engines: {node: '>=18'} + globalthis@1.0.4: + resolution: {integrity: sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==} + engines: {node: '>= 0.4'} + goober@2.1.16: resolution: {integrity: sha512-erjk19y1U33+XAMe1VTvIONHYoSqE4iS7BYUZfHaqeohLmnC0FdxEh7rQU+6MZ4OajItzjZFSRtVANrQwNq6/g==} peerDependencies: @@ -1150,10 +2070,30 @@ packages: graphemer@1.4.0: resolution: {integrity: sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==} + har-schema@2.0.0: + resolution: {integrity: sha512-Oqluz6zhGX8cyRaTQlFMPw80bSJVG2x/cFb8ZPhUILGgHka9SsokCCOQgpveePerqidZOrT14ipqfJb7ILcW5Q==} + engines: {node: '>=4'} + + har-validator@5.1.5: + resolution: {integrity: sha512-nmT2T0lljbxdQZfspsno9hgrG3Uir6Ks5afism62poxqBM6sDnMEuPmzTq8XN0OEwqKLLdh1jQI3qyE66Nzb3w==} + engines: {node: '>=6'} + deprecated: this library is no longer supported + + has-bigints@1.1.0: + resolution: {integrity: sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg==} + engines: {node: '>= 0.4'} + has-flag@4.0.0: resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==} engines: {node: '>=8'} + has-property-descriptors@1.0.2: + resolution: {integrity: sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==} + + has-proto@1.2.0: + resolution: {integrity: sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ==} + engines: {node: '>= 0.4'} + has-symbols@1.1.0: resolution: {integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==} engines: {node: '>= 0.4'} @@ -1166,6 +2106,13 @@ packages: resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==} engines: {node: '>= 0.4'} + http-signature@1.2.0: + resolution: {integrity: sha512-CAbnr6Rz4CYQkLYUtSNXxQPUH2gK8f3iWexVlsnMeD+GjlsQ0Xsy1cOX+mN3dtxYomRy21CiOzU8Uhw6OwncEQ==} + engines: {node: '>=0.8', npm: '>=1.3.7'} + + idb@7.1.1: + resolution: {integrity: sha512-gchesWBzyvGHRO9W8tzUWFDycow5gwjvFKfyV9FF32Y7F50yZMp7mP+T2mJIWFx49zicqyC4uefHM17o6xKIVQ==} + ignore@5.3.2: resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==} engines: {node: '>= 4'} @@ -1174,6 +2121,11 @@ packages: resolution: {integrity: sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==} engines: {node: '>= 4'} + image-size@0.5.5: + resolution: {integrity: sha512-6TDAlDPZxUFCv+fuOkIoXT/V/f3Qbq8e37p+YOiYrUv3v9cc3/6x78VdfPgFVaB9dZYeLUfKgHRebpkm/oP2VQ==} + engines: {node: '>=0.10.0'} + hasBin: true + import-fresh@3.3.1: resolution: {integrity: sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==} engines: {node: '>=6'} @@ -1182,25 +2134,172 @@ packages: resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==} engines: {node: '>=0.8.19'} + inflight@1.0.6: + resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==} + deprecated: This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful. + + inherits@2.0.4: + resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==} + + internal-slot@1.1.0: + resolution: {integrity: sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw==} + engines: {node: '>= 0.4'} + + ip-regex@1.0.3: + resolution: {integrity: sha512-HjpCHTuxbR/6jWJroc/VN+npo5j0T4Vv2TAI5qdEHQx7hsL767MeccGFSsLtF694EiZKTSEqgoeU6DtGFCcuqQ==} + engines: {node: '>=0.10.0'} + + is-array-buffer@3.0.5: + resolution: {integrity: sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A==} + engines: {node: '>= 0.4'} + + is-arrayish@0.3.2: + resolution: {integrity: sha512-eVRqCvVlZbuw3GrM63ovNSNAeA1K16kaR/LRY/92w0zxQ5/1YzwblUX652i4Xs9RwAGjW9d9y6X88t8OaAJfWQ==} + + is-async-function@2.1.1: + resolution: {integrity: sha512-9dgM/cZBnNvjzaMYHVoxxfPj2QXt22Ev7SuuPrs+xav0ukGB0S6d4ydZdEiM48kLx5kDV+QBPrpVnFyefL8kkQ==} + engines: {node: '>= 0.4'} + + is-bigint@1.1.0: + resolution: {integrity: sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ==} + engines: {node: '>= 0.4'} + + is-boolean-object@1.2.2: + resolution: {integrity: sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A==} + engines: {node: '>= 0.4'} + + is-callable@1.2.7: + resolution: {integrity: sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==} + engines: {node: '>= 0.4'} + + is-core-module@2.16.1: + resolution: {integrity: sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==} + engines: {node: '>= 0.4'} + + is-data-view@1.0.2: + resolution: {integrity: sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw==} + engines: {node: '>= 0.4'} + + is-date-object@1.1.0: + resolution: {integrity: sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg==} + engines: {node: '>= 0.4'} + is-extglob@2.1.1: resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==} engines: {node: '>=0.10.0'} + is-finalizationregistry@1.1.1: + resolution: {integrity: sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg==} + engines: {node: '>= 0.4'} + + is-function@1.0.2: + resolution: {integrity: sha512-lw7DUp0aWXYg+CBCN+JKkcE0Q2RayZnSvnZBlwgxHBQhqt5pZNVy4Ri7H9GmmXkdu7LUthszM+Tor1u/2iBcpQ==} + + is-generator-function@1.1.0: + resolution: {integrity: sha512-nPUB5km40q9e8UfN/Zc24eLlzdSf9OfKByBw9CIdw4H1giPMeA0OIJvbchsCu4npfI2QcMVBsGEBHKZ7wLTWmQ==} + engines: {node: '>= 0.4'} + is-glob@4.0.3: resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==} engines: {node: '>=0.10.0'} + is-map@2.0.3: + resolution: {integrity: sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw==} + engines: {node: '>= 0.4'} + + is-module@1.0.0: + resolution: {integrity: sha512-51ypPSPCoTEIN9dy5Oy+h4pShgJmPCygKfyRCISBI+JoWT/2oJvK8QPxmwv7b/p239jXrm9M1mlQbyKJ5A152g==} + + is-negative-zero@2.0.3: + resolution: {integrity: sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==} + engines: {node: '>= 0.4'} + + is-number-object@1.1.1: + resolution: {integrity: sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw==} + engines: {node: '>= 0.4'} + 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'} + + is-regex@1.2.1: + resolution: {integrity: sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==} + engines: {node: '>= 0.4'} + + is-regexp@1.0.0: + resolution: {integrity: sha512-7zjFAPO4/gwyQAAgRRmqeEeyIICSdmCqa3tsVHMdBzaXXRiqopZL4Cyghg/XulGWrtABTpbnYYzzIRffLkP4oA==} + engines: {node: '>=0.10.0'} + + is-set@2.0.3: + resolution: {integrity: sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg==} + engines: {node: '>= 0.4'} + + is-shared-array-buffer@1.0.4: + resolution: {integrity: sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A==} + engines: {node: '>= 0.4'} + + is-stream@2.0.1: + resolution: {integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==} + engines: {node: '>=8'} + + is-string@1.1.1: + resolution: {integrity: sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA==} + engines: {node: '>= 0.4'} + + is-symbol@1.1.1: + resolution: {integrity: sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w==} + engines: {node: '>= 0.4'} + + is-typed-array@1.1.15: + resolution: {integrity: sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==} + engines: {node: '>= 0.4'} + + is-typedarray@1.0.0: + resolution: {integrity: sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==} + + is-weakmap@2.0.2: + resolution: {integrity: sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w==} + engines: {node: '>= 0.4'} + + is-weakref@1.1.1: + resolution: {integrity: sha512-6i9mGWSlqzNMEqpCp93KwRS1uUOodk2OJ6b+sq7ZPDSy2WuI5NFIxp/254TytR8ftefexkWn5xNiHUNpPOfSew==} + engines: {node: '>= 0.4'} + + is-weakset@2.0.4: + resolution: {integrity: sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ==} + engines: {node: '>= 0.4'} + + isarray@2.0.5: + resolution: {integrity: sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==} + isexe@2.0.0: resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==} + isstream@0.1.2: + resolution: {integrity: sha512-Yljz7ffyPbrLpLngrMtZ7NduUgVvi6wG9RJ9IUcyCd59YQ911PBJphODUcbOVbqYfxe1wuYf/LJ8PauMRwsM/g==} + + jake@10.9.2: + resolution: {integrity: sha512-2P4SQ0HrLQ+fw6llpLnOaGAvN2Zu6778SJMrCUwns4fOoG9ayrTiZk3VV8sCPkVZF8ab0zksVpS8FDY5pRCNBA==} + engines: {node: '>=10'} + hasBin: true + + jimp@0.2.28: + resolution: {integrity: sha512-9HT7DA279xkTlry2oG30s6AtOUglNiY2UdyYpj0yNI4/NBv8PmdNC0gcldgMU4HqvbUlrM3+v+6GaHnTkH23JQ==} + jiti@2.4.2: resolution: {integrity: sha512-rg9zJN+G4n2nfJl5MW3BMygZX56zKPNVEYYqq7adpmMh4Jn2QNEwhvQlFy6jPVdcod7txZtKHWnyZiA3a0zP7A==} hasBin: true + jpeg-js@0.1.2: + resolution: {integrity: sha512-CiRVjMKBUp6VYtGwzRjrdnro41yMwKGOWdP9ATXqmixdz2n7KHNwdqthTYSSbOKj/Ha79Gct1sA8ZQpse55TYA==} + + jpeg-js@0.2.0: + resolution: {integrity: sha512-Ni9PffhJtYtdD7VwxH6V2MnievekGfUefosGCHadog0/jAevRu6HPjYeMHbUemn0IPE8d4wGa8UsOGsX+iKy2g==} + js-tokens@4.0.0: resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==} @@ -1208,6 +2307,14 @@ packages: resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==} hasBin: true + jsbn@0.1.1: + resolution: {integrity: sha512-UVU9dibq2JcFWxQPA6KCqj5O42VOmAY3zQUfEKxU0KpTGXwNoCjkX1e13eHNvw/xPynt6pU0rZ1htjWTNTSXsg==} + + jsesc@3.0.2: + resolution: {integrity: sha512-xKqzzWXDttJuOcawBt4KnKHHIf5oQ/Cxax+0PWFG+DFDgHNAdi+TXECADI+RYiFUMmx8792xsMbbgXj4CwnP4g==} + engines: {node: '>=6'} + hasBin: true + jsesc@3.1.0: resolution: {integrity: sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==} engines: {node: '>=6'} @@ -1219,17 +2326,41 @@ packages: json-schema-traverse@0.4.1: resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==} + json-schema-traverse@1.0.0: + resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==} + + json-schema@0.4.0: + resolution: {integrity: sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==} + json-stable-stringify-without-jsonify@1.0.1: resolution: {integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==} + json-stringify-safe@5.0.1: + resolution: {integrity: sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==} + json5@2.2.3: resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==} engines: {node: '>=6'} hasBin: true + jsonfile@6.1.0: + resolution: {integrity: sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==} + + jsonpointer@5.0.1: + resolution: {integrity: sha512-p/nXbhSEcu3pZRdkW1OfJhpsVtW1gd4Wa1fnQc9YLiTfAjn0312eMKimbdIQzuZl9aa9xUGaRlP9T/CJE/ditQ==} + engines: {node: '>=0.10.0'} + + jsprim@1.4.2: + resolution: {integrity: sha512-P2bSOMAc/ciLz6DzgjVlGJP9+BrJWu5UDGK70C2iweC5QBIeFf0ZXRvGjEj2uYgrY2MkAAhsSWHDWlFtEroZWw==} + engines: {node: '>=0.6.0'} + keyv@4.5.4: resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==} + leven@3.1.0: + resolution: {integrity: sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==} + engines: {node: '>=6'} + levn@0.4.1: resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==} engines: {node: '>= 0.8.0'} @@ -1298,13 +2429,25 @@ packages: resolution: {integrity: sha512-xi6IyHML+c9+Q3W0S4fCQJOym42pyurFiJUHEcEyHS0CeKzia4yZDEsLlqOFykxOdHpNy0NmvVO31vcSqAxJCg==} engines: {node: '>= 12.0.0'} + load-bmfont@1.4.2: + resolution: {integrity: sha512-qElWkmjW9Oq1F9EI5Gt7aD9zcdHb9spJCW1L/dmPf7KzCCEJxq8nhHz5eCgI9aMf7vrG/wyaCqdsI+Iy9ZTlog==} + locate-path@6.0.0: resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==} engines: {node: '>=10'} + lodash.debounce@4.0.8: + resolution: {integrity: sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==} + lodash.merge@4.6.2: resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==} + lodash.sortby@4.7.0: + resolution: {integrity: sha512-HDWXG8isMntAyRF5vZ7xKuEvOhT4AhlRt/3czTSjvGUxjYCBVRQY48ViDHyfYz9VIoBkW4TMGQNapx+l3RUwdA==} + + lodash@4.17.21: + resolution: {integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==} + lru-cache@5.1.1: resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==} @@ -1313,6 +2456,9 @@ packages: peerDependencies: react: ^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0 + magic-string@0.25.9: + resolution: {integrity: sha512-RmF0AsMzgt25qzqqLc1+MbHmhdx0ojF2Fvs4XnOqz2ZOBXzzkEwc/dJQZCYHAn7v1jbVOjAZfK8msRn4BxO4VQ==} + magic-string@0.30.17: resolution: {integrity: sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA==} @@ -1336,13 +2482,28 @@ packages: resolution: {integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==} engines: {node: '>= 0.6'} + mime@1.6.0: + resolution: {integrity: sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==} + engines: {node: '>=4'} + hasBin: true + + min-document@2.19.0: + resolution: {integrity: sha512-9Wy1B3m3f66bPPmU5hdA4DR4PB2OfDU/+GS3yAB7IQozE3tqXaVv2zOjgla7MEGSRv95+ILmOuvhLkOK6wJtCQ==} + minimatch@3.1.2: resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==} + minimatch@5.1.6: + resolution: {integrity: sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==} + engines: {node: '>=10'} + minimatch@9.0.5: resolution: {integrity: sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==} engines: {node: '>=16 || 14 >=14.17'} + minimist@0.0.8: + resolution: {integrity: sha512-miQKw5Hv4NS1Psg2517mV4e4dYNaO3++hjAvLOAzKqZ61rH8NS1SK+vbfBWZ5PY/Me/bEWhUwqMghEW5Fb9T7Q==} + minipass@7.1.2: resolution: {integrity: sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==} engines: {node: '>=16 || 14 >=14.17'} @@ -1351,6 +2512,11 @@ packages: resolution: {integrity: sha512-oG62iEk+CYt5Xj2YqI5Xi9xWUeZhDI8jjQmC5oThVH5JGCTgIjr7ciJDzC7MBzYd//WvR1OTmP5Q38Q8ShQtVA==} engines: {node: '>= 18'} + mkdirp@0.5.1: + resolution: {integrity: sha512-SknJC52obPfGQPnjIkXbmA6+5H15E+fR+E4iR2oQ3zzCLbd7/ONua69R/Gw7AgkTLsRG+r5fzksYwWe1AgTyWA==} + deprecated: Legacy versions of mkdirp are no longer supported. Please update to mkdirp 1.x. (Note that the API surface has changed to use Promises in 1.x.) + hasBin: true + mkdirp@3.0.1: resolution: {integrity: sha512-+NsyUUAZDmo6YVHzL/stxSu3t9YS1iljliy3BSDrXJ/dkn1KYdmtZODGGjLcc9XLgVVpH4KshHB8XmZgMhaBXg==} engines: {node: '>=10'} @@ -1370,10 +2536,36 @@ packages: node-releases@2.0.19: resolution: {integrity: sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw==} + oauth-sign@0.9.0: + resolution: {integrity: sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==} + + object-assign@4.1.1: + resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==} + engines: {node: '>=0.10.0'} + + object-inspect@1.13.4: + resolution: {integrity: sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==} + engines: {node: '>= 0.4'} + + object-keys@1.1.1: + resolution: {integrity: sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==} + engines: {node: '>= 0.4'} + + object.assign@4.1.7: + resolution: {integrity: sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==} + engines: {node: '>= 0.4'} + + once@1.4.0: + resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==} + optionator@0.9.4: resolution: {integrity: sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==} engines: {node: '>= 0.8.0'} + own-keys@1.0.1: + resolution: {integrity: sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg==} + engines: {node: '>= 0.4'} + p-limit@3.1.0: resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==} engines: {node: '>=10'} @@ -1386,14 +2578,44 @@ packages: resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==} engines: {node: '>=6'} + parse-bmfont-ascii@1.0.6: + resolution: {integrity: sha512-U4RrVsUFCleIOBsIGYOMKjn9PavsGOXxbvYGtMOEfnId0SVNsgehXh1DxUdVPLoxd5mvcEtvmKs2Mmf0Mpa1ZA==} + + parse-bmfont-binary@1.0.6: + resolution: {integrity: sha512-GxmsRea0wdGdYthjuUeWTMWPqm2+FAd4GI8vCvhgJsFnoGhTrLhXDDupwTo7rXVAgaLIGoVHDZS9p/5XbSqeWA==} + + parse-bmfont-xml@1.1.6: + resolution: {integrity: sha512-0cEliVMZEhrFDwMh4SxIyVJpqYoOWDJ9P895tFuS+XuNzI5UBmBk5U5O4KuJdTnZpSBI4LFA2+ZiJaiwfSwlMA==} + + parse-headers@2.0.6: + resolution: {integrity: sha512-Tz11t3uKztEW5FEVZnj1ox8GKblWn+PvHY9TmJV5Mll2uHEwRdR/5Li1OlXoECjLYkApdhWy44ocONwXLiKO5A==} + + parse-png@1.1.2: + resolution: {integrity: sha512-Ge6gDV9T5zhkWHmjvnNiyhPTCIoY7W+FC7qWPtuL2lIGZAFxxqTRG/ouEXsH9qkw+HzYiPEU/tFcxOCEDTP1Yw==} + engines: {node: '>=4'} + path-exists@4.0.0: resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==} engines: {node: '>=8'} + path-is-absolute@1.0.1: + resolution: {integrity: sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==} + engines: {node: '>=0.10.0'} + path-key@3.1.1: resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==} engines: {node: '>=8'} + path-parse@1.0.7: + resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==} + + performance-now@2.1.0: + resolution: {integrity: sha512-7EAHlyLHI56VEIdK57uwHdHKIaAGbnXPiw0yWbarQZOKaKpvUIgW0jWRVLiatnM+XXlSwsanIBH/hzGMJulMow==} + + phin@3.7.1: + resolution: {integrity: sha512-GEazpTWwTZaEQ9RhL7Nyz0WwqilbqgLahDM3D0hxWwmVDI52nXEybHqiN6/elwpkJBhcuj+WbBu+QfT0uhPGfQ==} + engines: {node: '>= 8'} + picocolors@1.1.1: resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==} @@ -1405,6 +2627,26 @@ packages: resolution: {integrity: sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==} engines: {node: '>=12'} + pinkie-promise@2.0.1: + resolution: {integrity: sha512-0Gni6D4UcLTbv9c57DfxDGdr41XfgUjqWZu492f0cIGr16zDU06BWP/RAEvOuo7CQ0CNjHaLlM59YJJFm3NWlw==} + engines: {node: '>=0.10.0'} + + pinkie@2.0.4: + resolution: {integrity: sha512-MnUuEycAemtSaeFSjXKW/aroV7akBbY+Sv+RkyqFjgAe73F+MR0TBWKBRDkmfWq/HiFmdavfZ1G7h4SPZXaCSg==} + engines: {node: '>=0.10.0'} + + pixelmatch@4.0.2: + resolution: {integrity: sha512-J8B6xqiO37sU/gkcMglv6h5Jbd9xNER7aHzpfRdNmV4IbQBzBpe4l9XmbG+xPF/znacgu2jfEw+wHffaq/YkXA==} + hasBin: true + + pngjs@3.4.0: + resolution: {integrity: sha512-NCrCHhWmnQklfH4MtJMRjZ2a8c80qXeMlQMv2uVp9ISJMTt562SbGd6n2oq0PaPgKm7Z6pL9E2UlLIhC+SHL3w==} + engines: {node: '>=4.0.0'} + + possible-typed-array-names@1.1.0: + resolution: {integrity: sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==} + engines: {node: '>= 0.4'} + postcss@8.5.4: resolution: {integrity: sha512-QSa9EBe+uwlGTFmHsPKokv3B/oEMQZxfqW0QqNCyhpa6mB1afzulwn8hihglqAb2pOw+BJgNlmXQ8la2VeHB7w==} engines: {node: ^10 || ^12 || >=14} @@ -1422,16 +2664,38 @@ packages: engines: {node: '>=14'} hasBin: true + pretty-bytes@5.6.0: + resolution: {integrity: sha512-FFw039TmrBqFK8ma/7OL3sDz/VytdtJr044/QUJtH0wK9lb9jLq9tJyIxUwtQJHwar2BqtiA4iCWSwo9JLkzFg==} + engines: {node: '>=6'} + + pretty-bytes@6.1.1: + resolution: {integrity: sha512-mQUvGU6aUFQ+rNvTIAcZuWGRT9a6f6Yrg9bHs4ImKF+HZCEK+plBvnAZYSIQztknZF2qnzNtr6F8s0+IuptdlQ==} + engines: {node: ^14.13.1 || >=16.0.0} + + process@0.11.10: + resolution: {integrity: sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A==} + engines: {node: '>= 0.6.0'} + proxy-from-env@1.1.0: resolution: {integrity: sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==} + psl@1.15.0: + resolution: {integrity: sha512-JZd3gMVBAVQkSs6HdNZo9Sdo0LNcQeMNP3CozBJb3JYC/QUYZTnKxP+f8oWRX4rHP5EurWxqAHTSwUCjlNKa1w==} + punycode@2.3.1: resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==} engines: {node: '>=6'} + qs@6.5.3: + resolution: {integrity: sha512-qxXIEh4pCGfHICj1mAJQ2/2XVZkjCDTcEgfoSQxc/fYivUZxTkk7L3bDBJSoNrEzXI17oUO5Dp07ktqE5KzczA==} + engines: {node: '>=0.6'} + queue-microtask@1.2.3: resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==} + randombytes@2.1.0: + resolution: {integrity: sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==} + react-dom@19.1.0: resolution: {integrity: sha512-Xs1hdnE+DyKgeHJeJznQmYMIBG3TKIHJJT95Q58nHLSrElKlGQqDTR2HQ9fx5CN/Gk6Vh/kupBTDLU11/nDk/g==} peerDependencies: @@ -1456,14 +2720,67 @@ packages: resolution: {integrity: sha512-FS+XFBNvn3GTAWq26joslQgWNoFu08F4kl0J4CgdNKADkdSGXQyTCnKteIAJy96Br6YbpEU1LSzV5dYtjMkMDg==} engines: {node: '>=0.10.0'} + read-chunk@1.0.1: + resolution: {integrity: sha512-5NLTTdX45dKFtG8CX5pKmvS9V5u9wBE+gkklN7xhDuhq3pA2I4O7ALfKxosCMcLHOhkxj6GNacZhfXtp5nlCdg==} + engines: {node: '>=0.10.0'} + + reflect.getprototypeof@1.0.10: + resolution: {integrity: sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw==} + engines: {node: '>= 0.4'} + + regenerate-unicode-properties@10.2.0: + resolution: {integrity: sha512-DqHn3DwbmmPVzeKj9woBadqmXxLvQoQIwu7nopMc72ztvxVmVk2SBhSnx67zuye5TP+lJsb/TBQsjLKhnDf3MA==} + engines: {node: '>=4'} + + regenerate@1.4.2: + resolution: {integrity: sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==} + + regexp.prototype.flags@1.5.4: + resolution: {integrity: sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA==} + engines: {node: '>= 0.4'} + + regexpu-core@6.2.0: + resolution: {integrity: sha512-H66BPQMrv+V16t8xtmq+UC0CBpiTBA60V8ibS1QVReIp8T1z8hwFxqcGzm9K6lgsN7sB5edVH8a+ze6Fqm4weA==} + engines: {node: '>=4'} + + regjsgen@0.8.0: + resolution: {integrity: sha512-RvwtGe3d7LvWiDQXeQw8p5asZUmfU1G/l6WbUXeHta7Y2PEIvBTwH6E2EfmYUK8pxcxEdEmaomqyp0vZZ7C+3Q==} + + regjsparser@0.12.0: + resolution: {integrity: sha512-cnE+y8bz4NhMjISKbgeVJtqNbtf5QpjZP+Bslo+UqkIt9QPnX9q095eiRRASJG1/tz6dlNr6Z5NsBiWYokp6EQ==} + hasBin: true + + request@2.88.2: + resolution: {integrity: sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw==} + engines: {node: '>= 6'} + deprecated: request has been deprecated, see https://github.com/request/request/issues/3142 + + require-from-string@2.0.2: + resolution: {integrity: sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==} + engines: {node: '>=0.10.0'} + + resize-img@1.1.2: + resolution: {integrity: sha512-/4nKUmuNPuM6gYTWad136ica81baOVjpesgv8FGaIvP0KWcbCWahOWBKaM4tFoM+aVcSA+qQDg28pcnIzFRpJw==} + engines: {node: '>=4'} + resolve-from@4.0.0: resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==} engines: {node: '>=4'} + resolve@1.22.10: + resolution: {integrity: sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w==} + engines: {node: '>= 0.4'} + hasBin: true + reusify@1.1.0: resolution: {integrity: sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==} engines: {iojs: '>=1.0.0', node: '>=0.10.0'} + rollup@2.79.2: + resolution: {integrity: sha512-fS6iqSPZDs3dr/y7Od6y5nha8dW1YnbgtsyotCVvoFGKbERG++CVRFv1meyGDE1SNItQA8BrnCw7ScdAhRJ3XQ==} + engines: {node: '>=10.0.0'} + hasBin: true + rollup@4.42.0: resolution: {integrity: sha512-LW+Vse3BJPyGJGAJt1j8pWDKPd73QM8cRXYK1IxOBgL2AGLu7Xd2YOW0M2sLUBCkF5MshXXtMApyEAEzMVMsnw==} engines: {node: '>=18.0.0', npm: '>=8.0.0'} @@ -1472,6 +2789,27 @@ packages: run-parallel@1.2.0: resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==} + safe-array-concat@1.1.3: + resolution: {integrity: sha512-AURm5f0jYEOydBj7VQlVvDrjeFgthDdEF5H1dP+6mNpoXOMo1quQqJ4wvJDyRZ9+pO3kGWoOdmV08cSv2aJV6Q==} + engines: {node: '>=0.4'} + + safe-buffer@5.2.1: + resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==} + + safe-push-apply@1.0.0: + resolution: {integrity: sha512-iKE9w/Z7xCzUMIZqdBsp6pEQvwuEebH4vdpjcDWnyzaI6yl6O9FHvVpmGelvEHNsoY6wGblkxR6Zty/h00WiSA==} + engines: {node: '>= 0.4'} + + safe-regex-test@1.1.0: + resolution: {integrity: sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==} + engines: {node: '>= 0.4'} + + safer-buffer@2.1.2: + resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==} + + sax@1.4.1: + resolution: {integrity: sha512-+aWOz7yVScEGoKNd4PA10LZ8sk0A/z5+nXQG5giUO5rprX9jgYsTdov9qCchZiPIZezbZH+jRut8nPodFAX4Jg==} + scheduler@0.26.0: resolution: {integrity: sha512-NlHwttCI/l5gCPR3D1nNXtWABUmBwvZpEQiD4IXSbIDq8BzLIK/7Ir5gTFSGZDUu37K5cMNp0hFtzO38sC7gWA==} @@ -1484,6 +2822,9 @@ packages: engines: {node: '>=10'} hasBin: true + serialize-javascript@6.0.2: + resolution: {integrity: sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==} + seroval-plugins@1.3.2: resolution: {integrity: sha512-0QvCV2lM3aj/U3YozDiVwx9zpH0q8A60CTWIv4Jszj/givcudPb48B+rkU5D51NJ0pTpweGMttHjboPa9/zoIQ==} engines: {node: '>=10'} @@ -1494,6 +2835,22 @@ packages: resolution: {integrity: sha512-RbcPH1n5cfwKrru7v7+zrZvjLurgHhGyso3HTyGtRivGWgYjbOmGuivCQaORNELjNONoK35nj28EoWul9sb1zQ==} engines: {node: '>=10'} + set-function-length@1.2.2: + resolution: {integrity: sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==} + engines: {node: '>= 0.4'} + + set-function-name@2.0.2: + resolution: {integrity: sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==} + engines: {node: '>= 0.4'} + + set-proto@1.0.0: + resolution: {integrity: sha512-RJRdvCo6IAnPdsvP/7m6bsQqNnn1FCBX5ZNtFL98MmFF/4xAIJTIg1YbHW5DC2W5SKZanrC6i4HsJqlajw/dZw==} + engines: {node: '>= 0.4'} + + sharp@0.34.3: + resolution: {integrity: sha512-eX2IQ6nFohW4DbvHIOLRB3MHFpYqaqvXd3Tp5e/T/dSH83fxaNJQRvDMhASmkNTsNTVF2/OOopzRCt7xokgPfg==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + shebang-command@2.0.0: resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==} engines: {node: '>=8'} @@ -1502,6 +2859,28 @@ packages: resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==} engines: {node: '>=8'} + side-channel-list@1.0.0: + resolution: {integrity: sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==} + engines: {node: '>= 0.4'} + + side-channel-map@1.0.1: + resolution: {integrity: sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==} + engines: {node: '>= 0.4'} + + side-channel-weakmap@1.0.2: + resolution: {integrity: sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==} + engines: {node: '>= 0.4'} + + side-channel@1.1.0: + resolution: {integrity: sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==} + engines: {node: '>= 0.4'} + + simple-swizzle@0.2.2: + resolution: {integrity: sha512-JA//kQgZtbuY83m+xT+tXJkmJncGMTFT+C+g2h2R9uxkYIrE2yy9sgmcLhCnw57/WSD+Eh3J97FPEDFnbXnDUg==} + + smob@1.5.0: + resolution: {integrity: sha512-g6T+p7QO8npa+/hNx9ohv1E5pVCmWrVCUzUXJyLdMmftX6ER0oiWY/w9knEonLpnOp6b6FenKnMfR8gqwWdwig==} + solid-js@1.9.7: resolution: {integrity: sha512-/saTKi8iWEM233n5OSi1YHCCuh66ZIQ7aK2hsToPe4tqGm7qAejU1SwNuTPivbWAYq7SjuHVVYxxuZQNRbICiw==} @@ -1515,6 +2894,62 @@ packages: resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==} engines: {node: '>=0.10.0'} + source-map-support@0.5.21: + resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==} + + 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'} + + sourcemap-codec@1.4.8: + resolution: {integrity: sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==} + deprecated: Please use @jridgewell/sourcemap-codec instead + + sshpk@1.18.0: + resolution: {integrity: sha512-2p2KJZTSqQ/I3+HX42EpYOa2l3f8Erv8MWKsy2I9uf4wA7yFIkXRffYdsx86y6z4vHtV8u7g+pPlr8/4ouAxsQ==} + engines: {node: '>=0.10.0'} + hasBin: true + + stop-iteration-iterator@1.1.0: + resolution: {integrity: sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ==} + engines: {node: '>= 0.4'} + + stream-to-buffer@0.1.0: + resolution: {integrity: sha512-Da4WoKaZyu3nf+bIdIifh7IPkFjARBnBK+pYqn0EUJqksjV9afojjaCCHUemH30Jmu7T2qcKvlZm2ykN38uzaw==} + engines: {node: '>= 0.8'} + + stream-to@0.2.2: + resolution: {integrity: sha512-Kg1BSDTwgGiVMtTCJNlo7kk/xzL33ZuZveEBRt6rXw+f1WLK/8kmz2NVCT/Qnv0JkV85JOHcLhD82mnXsR3kPw==} + engines: {node: '>= 0.10.0'} + + string.prototype.matchall@4.0.12: + resolution: {integrity: sha512-6CC9uyBL+/48dYizRf7H7VAYCMCNTBeM78x/VTUe9bFEaxBepPJDa1Ow99LqI/1yF7kuy7Q3cQsYMrcjGUcskA==} + engines: {node: '>= 0.4'} + + string.prototype.trim@1.2.10: + resolution: {integrity: sha512-Rs66F0P/1kedk5lyYyH9uBzuiI/kNRmwJAR9quK6VOtIpZ2G+hMZd+HQbbv25MgCA6gEffoMZYxlTod4WcdrKA==} + engines: {node: '>= 0.4'} + + string.prototype.trimend@1.0.9: + resolution: {integrity: sha512-G7Ok5C6E/j4SGfyLCloXTrngQIQU3PWtXGst3yM7Bea9FRURf1S42ZHlZZtsNque2FN2PoUhfZXYLNWwEr4dLQ==} + engines: {node: '>= 0.4'} + + string.prototype.trimstart@1.0.8: + resolution: {integrity: sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==} + engines: {node: '>= 0.4'} + + stringify-object@3.3.0: + resolution: {integrity: sha512-rHqiFh1elqCQ9WPLIC8I0Q/g/wj5J1eMkyoiD6eoQApWHP0FtlK7rqnhmabL5VUY9JQCcqwwvlOaSuutekgyrw==} + engines: {node: '>=4'} + + strip-comments@2.0.1: + resolution: {integrity: sha512-ZprKx+bBLXv067WTCALv8SSz5l2+XhpYCsVtSqlMnkAXMWDq+/ekVbl1ghqP9rUHTzv6sm/DwCOiYutU/yp1fw==} + engines: {node: '>=10'} + strip-json-comments@3.1.1: resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==} engines: {node: '>=8'} @@ -1523,6 +2958,10 @@ packages: resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==} engines: {node: '>=8'} + supports-preserve-symlinks-flag@1.0.0: + resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==} + engines: {node: '>= 0.4'} + synckit@0.11.8: resolution: {integrity: sha512-+XZ+r1XGIJGeQk3VvXhT6xx/VpbHsRzsTkGgF6E5RX9TTXD0118l87puaEBZ566FhqblC6U0d4XnubznJDm30A==} engines: {node: ^14.18.0 || >=16.0.0} @@ -1538,30 +2977,86 @@ packages: resolution: {integrity: sha512-5S7Va8hKfV7W5U6g3aYxXmlPoZVAwUMy9AOKyF2fVuZa2UD3qZjg578OrLRt8PcNN1PleVaL/5/yYATNL0ICUw==} engines: {node: '>=18'} + temp-dir@2.0.0: + resolution: {integrity: sha512-aoBAniQmmwtcKp/7BzsH8Cxzv8OL736p7v1ihGb5e9DJ9kTwGWHrQrVB5+lfVDzfGrdRzXch+ig7LHaY1JTOrg==} + engines: {node: '>=8'} + + tempy@0.6.0: + resolution: {integrity: sha512-G13vtMYPT/J8A4X2SjdtBTphZlrp1gKv6hZiOjw14RCWg6GbHuQBGtjlx75xLbYV/wEc0D7G5K4rxKP/cXk8Bw==} + engines: {node: '>=10'} + + terser@5.43.1: + resolution: {integrity: sha512-+6erLbBm0+LROX2sPXlUYx/ux5PyE9K/a92Wrt6oA+WDAoFTdpHE5tCYCI5PNzq2y8df4rA+QgHLJuR4jNymsg==} + engines: {node: '>=10'} + hasBin: true + tiny-invariant@1.3.3: resolution: {integrity: sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==} tiny-warning@1.0.3: resolution: {integrity: sha512-lBN9zLN/oAf68o3zNXYrdCt1kP8WsiGW8Oo2ka41b2IM5JL/S1CTyX1rW0mb/zSuJun0ZUrDxx4sqvYS2FWzPA==} + tinycolor2@1.6.0: + resolution: {integrity: sha512-XPaBkWQJdsf3pLKJV9p4qN/S+fm2Oj8AIPo1BTUhg5oxkvm9+SVEGFdhyOz7tTdUTfvxMiAs4sp6/eZO2Ew+pw==} + tinyglobby@0.2.14: resolution: {integrity: sha512-tX5e7OM1HnYr2+a2C/4V0htOcSQcoSTH9KgJnVvNm5zm/cyEWKJ7j7YutsH9CxMdtOkkLFy2AHrMci9IM8IPZQ==} engines: {node: '>=12.0.0'} + to-ico@1.1.5: + resolution: {integrity: sha512-5kIh7m7bkIlqIESEZkL8gAMMzucXKfPe3hX2FoDY5HEAfD9OJU+Qh9b6Enp74w0qRcxVT5ejss66PHKqc3AVkg==} + engines: {node: '>=4'} + to-regex-range@5.0.1: resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==} engines: {node: '>=8.0'} + tough-cookie@2.5.0: + resolution: {integrity: sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==} + engines: {node: '>=0.8'} + + tr46@1.0.1: + resolution: {integrity: sha512-dTpowEjclQ7Kgx5SdBkqRzVhERQXov8/l9Ft9dVM9fmg0W0KQSVaXX9T4i6twCPNtYiZM53lpSSUAwJbFPOHxA==} + ts-api-utils@2.1.0: resolution: {integrity: sha512-CUgTZL1irw8u29bzrOD/nH85jqyc74D6SshFgujOIA7osm2Rz7dYH77agkx7H4FBNxDq7Cjf+IjaX/8zwFW+ZQ==} engines: {node: '>=18.12'} peerDependencies: typescript: '>=4.8.4' + tslib@2.8.1: + resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==} + + tunnel-agent@0.6.0: + resolution: {integrity: sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==} + + tweetnacl@0.14.5: + resolution: {integrity: sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA==} + type-check@0.4.0: resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==} engines: {node: '>= 0.8.0'} + type-fest@0.16.0: + resolution: {integrity: sha512-eaBzG6MxNzEn9kiwvtre90cXaNLkmadMWa1zQMs3XORCXNbsH/OewwbxC5ia9dCxIxnTAsSxXJaa/p5y8DlvJg==} + engines: {node: '>=10'} + + typed-array-buffer@1.0.3: + resolution: {integrity: sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==} + engines: {node: '>= 0.4'} + + typed-array-byte-length@1.0.3: + resolution: {integrity: sha512-BaXgOuIxz8n8pIq3e7Atg/7s+DpiYrxn4vdot3w9KbnBhcRQq6o3xemQdIfynqSeXeDrF32x+WvfzmOjPiY9lg==} + engines: {node: '>= 0.4'} + + typed-array-byte-offset@1.0.4: + resolution: {integrity: sha512-bTlAFB/FBYMcuX81gbL4OcpH5PmlFHqlCCpAl8AlEzMz5k53oNDvN8p1PNOWLEmI2x4orp3raOFB51tv9X+MFQ==} + engines: {node: '>= 0.4'} + + typed-array-length@1.0.7: + resolution: {integrity: sha512-3KS2b+kL7fsuk/eJZ7EQdnEmQoaho/r6KUef7hxvltNA5DR8NAUM+8wJMbJyZ4G9/7i3v5zPBIMN5aybAh2/Jg==} + engines: {node: '>= 0.4'} + typescript-eslint@8.33.1: resolution: {integrity: sha512-AgRnV4sKkWOiZ0Kjbnf5ytTJXMUZQ0qhSVdQtDNYLPLnjsATEYhaO94GlRQwi4t4gO8FfjM6NnikHeKjUm8D7A==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} @@ -1574,9 +3069,41 @@ packages: engines: {node: '>=14.17'} hasBin: true + unbox-primitive@1.1.0: + resolution: {integrity: sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw==} + engines: {node: '>= 0.4'} + undici-types@6.21.0: resolution: {integrity: sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==} + unicode-canonical-property-names-ecmascript@2.0.1: + resolution: {integrity: sha512-dA8WbNeb2a6oQzAQ55YlT5vQAWGV9WXOsi3SskE3bcCdM0P4SDd+24zS/OCacdRq5BkdsRj9q3Pg6YyQoxIGqg==} + engines: {node: '>=4'} + + unicode-match-property-ecmascript@2.0.0: + resolution: {integrity: sha512-5kaZCrbp5mmbz5ulBkDkbY0SsPOjKqVS35VpL9ulMPfSl0J0Xsm+9Evphv9CoIZFwre7aJoa94AY6seMKGVN5Q==} + engines: {node: '>=4'} + + unicode-match-property-value-ecmascript@2.2.0: + resolution: {integrity: sha512-4IehN3V/+kkr5YeSSDDQG8QLqO26XpL2XP3GQtqwlT/QYSECAwFztxVHjlbh0+gjJ3XmNLS0zDsbgs9jWKExLg==} + engines: {node: '>=4'} + + unicode-property-aliases-ecmascript@2.1.0: + resolution: {integrity: sha512-6t3foTQI9qne+OZoVQB/8x8rk2k1eVy1gRXhV3oFQ5T6R1dqQ1xtin3XqSlx3+ATBkliTaR/hHyJBm+LVPNM8w==} + engines: {node: '>=4'} + + unique-string@2.0.0: + resolution: {integrity: sha512-uNaeirEPvpZWSgzwsPGtU2zVSTrn/8L5q/IexZmH0eH6SA73CmAA5U4GwORTxQAZs95TAXLNqeLoPPNO5gZfWg==} + engines: {node: '>=8'} + + universalify@2.0.1: + resolution: {integrity: sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==} + engines: {node: '>= 10.0.0'} + + upath@1.2.0: + resolution: {integrity: sha512-aZwGpamFO61g3OlfT7OQCHqhGnW43ieH9WZeP7QxN/G/jS4jfqUkZxoryvJgVPEcrl5NL/ggHsSmLMHuH64Lhg==} + engines: {node: '>=4'} + update-browserslist-db@1.1.3: resolution: {integrity: sha512-UxhIZQ+QInVdunkDAaiazvvT/+fXL5Osr0JZlJulepYu6Jd7qJtDZjlur0emRlT71EN3ScPoE7gvsuIKKNavKw==} hasBin: true @@ -1586,6 +3113,10 @@ packages: uri-js@4.4.1: resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==} + url-regex@3.2.0: + resolution: {integrity: sha512-dQ9cJzMou5OKr6ZzfvwJkCq3rC72PNXhqz0v3EIhF4a3Np+ujr100AhUx2cKx5ei3iymoJpJrPB3sVSEMdqAeg==} + engines: {node: '>=0.10.0'} + use-debounce@10.0.5: resolution: {integrity: sha512-Q76E3lnIV+4YT9AHcrHEHYmAd9LKwUAbPXDm7FlqVGDHiSOhX3RDjT8dm0AxbJup6WgOb1YEcKyCr11kBJR5KQ==} engines: {node: '>= 16.0.0'} @@ -1601,6 +3132,27 @@ packages: resolution: {integrity: sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A==} hasBin: true + uuid@3.4.0: + resolution: {integrity: sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A==} + deprecated: Please upgrade to version 7 or higher. Older versions may use Math.random() in certain circumstances, which is known to be problematic. See https://v8.dev/blog/math-random for details. + hasBin: true + + verror@1.10.0: + resolution: {integrity: sha512-ZZKSmDAEFOijERBLkmYfJ+vmk3w+7hOLYDNkRCuRuMJGEmqYNCNLyBBFwWKVMhfwaEF3WOd0Zlw86U/WC/+nYw==} + engines: {'0': node >=0.6.0} + + vite-plugin-pwa@1.0.2: + resolution: {integrity: sha512-O3UwjsCnoDclgJANoOgzzqW7SFgwXE/th2OmUP/ILxHKwzWxxKDBu+B/Xa9Cv4IgSVSnj2HgRVIJ7F15+vQFkA==} + engines: {node: '>=16.0.0'} + peerDependencies: + '@vite-pwa/assets-generator': ^1.0.0 + vite: ^3.1.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 + workbox-build: ^7.3.0 + workbox-window: ^7.3.0 + peerDependenciesMeta: + '@vite-pwa/assets-generator': + optional: true + vite@6.3.5: resolution: {integrity: sha512-cZn6NDFE7wdTpINgs++ZJ4N49W2vRp8LCKrn3Ob1kYNtOo21vfDoaV5GzBfLU4MovSAB8uNRm4jgzVQZ+mBzPQ==} engines: {node: ^18.0.0 || ^20.0.0 || >=22.0.0} @@ -1641,6 +3193,28 @@ packages: yaml: optional: true + webidl-conversions@4.0.2: + resolution: {integrity: sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg==} + + whatwg-url@7.1.0: + resolution: {integrity: sha512-WUu7Rg1DroM7oQvGWfOiAK21n74Gg+T4elXEQYkOhtyLeWiJFoOGLXPKI/9gzIie9CtwVLm8wtw6YJdKyxSjeg==} + + which-boxed-primitive@1.1.1: + resolution: {integrity: sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA==} + engines: {node: '>= 0.4'} + + which-builtin-type@1.2.1: + resolution: {integrity: sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q==} + engines: {node: '>= 0.4'} + + which-collection@1.0.2: + resolution: {integrity: sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw==} + engines: {node: '>= 0.4'} + + which-typed-array@1.1.19: + resolution: {integrity: sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw==} + engines: {node: '>= 0.4'} + which@2.0.2: resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==} engines: {node: '>= 8'} @@ -1650,6 +3224,76 @@ packages: resolution: {integrity: sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==} engines: {node: '>=0.10.0'} + workbox-background-sync@7.3.0: + resolution: {integrity: sha512-PCSk3eK7Mxeuyatb22pcSx9dlgWNv3+M8PqPaYDokks8Y5/FX4soaOqj3yhAZr5k6Q5JWTOMYgaJBpbw11G9Eg==} + + workbox-broadcast-update@7.3.0: + resolution: {integrity: sha512-T9/F5VEdJVhwmrIAE+E/kq5at2OY6+OXXgOWQevnubal6sO92Gjo24v6dCVwQiclAF5NS3hlmsifRrpQzZCdUA==} + + workbox-build@7.3.0: + resolution: {integrity: sha512-JGL6vZTPlxnlqZRhR/K/msqg3wKP+m0wfEUVosK7gsYzSgeIxvZLi1ViJJzVL7CEeI8r7rGFV973RiEqkP3lWQ==} + engines: {node: '>=16.0.0'} + + workbox-cacheable-response@7.3.0: + resolution: {integrity: sha512-eAFERIg6J2LuyELhLlmeRcJFa5e16Mj8kL2yCDbhWE+HUun9skRQrGIFVUagqWj4DMaaPSMWfAolM7XZZxNmxA==} + + workbox-core@7.3.0: + resolution: {integrity: sha512-Z+mYrErfh4t3zi7NVTvOuACB0A/jA3bgxUN3PwtAVHvfEsZxV9Iju580VEETug3zYJRc0Dmii/aixI/Uxj8fmw==} + + workbox-expiration@7.3.0: + resolution: {integrity: sha512-lpnSSLp2BM+K6bgFCWc5bS1LR5pAwDWbcKt1iL87/eTSJRdLdAwGQznZE+1czLgn/X05YChsrEegTNxjM067vQ==} + + workbox-google-analytics@7.3.0: + resolution: {integrity: sha512-ii/tSfFdhjLHZ2BrYgFNTrb/yk04pw2hasgbM70jpZfLk0vdJAXgaiMAWsoE+wfJDNWoZmBYY0hMVI0v5wWDbg==} + + workbox-navigation-preload@7.3.0: + resolution: {integrity: sha512-fTJzogmFaTv4bShZ6aA7Bfj4Cewaq5rp30qcxl2iYM45YD79rKIhvzNHiFj1P+u5ZZldroqhASXwwoyusnr2cg==} + + workbox-precaching@7.3.0: + resolution: {integrity: sha512-ckp/3t0msgXclVAYaNndAGeAoWQUv7Rwc4fdhWL69CCAb2UHo3Cef0KIUctqfQj1p8h6aGyz3w8Cy3Ihq9OmIw==} + + workbox-range-requests@7.3.0: + resolution: {integrity: sha512-EyFmM1KpDzzAouNF3+EWa15yDEenwxoeXu9bgxOEYnFfCxns7eAxA9WSSaVd8kujFFt3eIbShNqa4hLQNFvmVQ==} + + workbox-recipes@7.3.0: + resolution: {integrity: sha512-BJro/MpuW35I/zjZQBcoxsctgeB+kyb2JAP5EB3EYzePg8wDGoQuUdyYQS+CheTb+GhqJeWmVs3QxLI8EBP1sg==} + + workbox-routing@7.3.0: + resolution: {integrity: sha512-ZUlysUVn5ZUzMOmQN3bqu+gK98vNfgX/gSTZ127izJg/pMMy4LryAthnYtjuqcjkN4HEAx1mdgxNiKJMZQM76A==} + + workbox-strategies@7.3.0: + resolution: {integrity: sha512-tmZydug+qzDFATwX7QiEL5Hdf7FrkhjaF9db1CbB39sDmEZJg3l9ayDvPxy8Y18C3Y66Nrr9kkN1f/RlkDgllg==} + + workbox-streams@7.3.0: + resolution: {integrity: sha512-SZnXucyg8x2Y61VGtDjKPO5EgPUG5NDn/v86WYHX+9ZqvAsGOytP0Jxp1bl663YUuMoXSAtsGLL+byHzEuMRpw==} + + workbox-sw@7.3.0: + resolution: {integrity: sha512-aCUyoAZU9IZtH05mn0ACUpyHzPs0lMeJimAYkQkBsOWiqaJLgusfDCR+yllkPkFRxWpZKF8vSvgHYeG7LwhlmA==} + + workbox-window@7.3.0: + resolution: {integrity: sha512-qW8PDy16OV1UBaUNGlTVcepzrlzyzNW/ZJvFQQs2j2TzGsg6IKjcpZC1RSquqQnTOafl5pCj5bGfAHlCjOOjdA==} + + wrappy@1.0.2: + resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==} + + xhr@2.6.0: + resolution: {integrity: sha512-/eCGLb5rxjx5e3mF1A7s+pLlR6CGyqWN91fv1JgER5mVWg1MZmlhBvy9kjcsOdRk8RrIujotWyJamfyrp+WIcA==} + + xml-parse-from-string@1.0.1: + resolution: {integrity: sha512-ErcKwJTF54uRzzNMXq2X5sMIy88zJvfN2DmdoQvy7PAFJ+tPRU6ydWuOKNMyfmOjdyBQTFREi60s0Y0SyI0G0g==} + + xml2js@0.5.0: + resolution: {integrity: sha512-drPFnkQJik/O+uPKpqSgr22mpuFHqKdbS835iAQrUC73L2F5WkboIRd63ai/2Yg6I1jzifPFKH2NTK+cfglkIA==} + engines: {node: '>=4.0.0'} + + xmlbuilder@11.0.1: + resolution: {integrity: sha512-fDlsI/kFEx7gLvbecc0/ohLG50fugQp8ryHzMTuW9vSa1GJ0XYWKnhsUx7oie3G98+r56aTQIUB4kht42R3JvA==} + engines: {node: '>=4.0'} + + xtend@4.0.2: + resolution: {integrity: sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==} + engines: {node: '>=0.4'} + yallist@3.1.1: resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==} @@ -1670,6 +3314,13 @@ snapshots: '@jridgewell/gen-mapping': 0.3.8 '@jridgewell/trace-mapping': 0.3.25 + '@apideck/better-ajv-errors@0.3.6(ajv@8.17.1)': + dependencies: + ajv: 8.17.1 + json-schema: 0.4.0 + jsonpointer: 5.0.1 + leven: 3.1.0 + '@babel/code-frame@7.27.1': dependencies: '@babel/helper-validator-identifier': 7.27.1 @@ -1678,6 +3329,8 @@ snapshots: '@babel/compat-data@7.27.5': {} + '@babel/compat-data@7.28.0': {} + '@babel/core@7.27.4': dependencies: '@ampproject/remapping': 2.3.0 @@ -1706,6 +3359,18 @@ snapshots: '@jridgewell/trace-mapping': 0.3.25 jsesc: 3.1.0 + '@babel/generator@7.28.0': + dependencies: + '@babel/parser': 7.28.0 + '@babel/types': 7.28.2 + '@jridgewell/gen-mapping': 0.3.12 + '@jridgewell/trace-mapping': 0.3.29 + jsesc: 3.1.0 + + '@babel/helper-annotate-as-pure@7.27.3': + dependencies: + '@babel/types': 7.28.2 + '@babel/helper-compilation-targets@7.27.2': dependencies: '@babel/compat-data': 7.27.5 @@ -1714,6 +3379,46 @@ snapshots: lru-cache: 5.1.1 semver: 6.3.1 + '@babel/helper-create-class-features-plugin@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-annotate-as-pure': 7.27.3 + '@babel/helper-member-expression-to-functions': 7.27.1 + '@babel/helper-optimise-call-expression': 7.27.1 + '@babel/helper-replace-supers': 7.27.1(@babel/core@7.27.4) + '@babel/helper-skip-transparent-expression-wrappers': 7.27.1 + '@babel/traverse': 7.28.0 + semver: 6.3.1 + transitivePeerDependencies: + - supports-color + + '@babel/helper-create-regexp-features-plugin@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-annotate-as-pure': 7.27.3 + regexpu-core: 6.2.0 + semver: 6.3.1 + + '@babel/helper-define-polyfill-provider@0.6.5(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-compilation-targets': 7.27.2 + '@babel/helper-plugin-utils': 7.27.1 + debug: 4.4.1 + lodash.debounce: 4.0.8 + resolve: 1.22.10 + transitivePeerDependencies: + - supports-color + + '@babel/helper-globals@7.28.0': {} + + '@babel/helper-member-expression-to-functions@7.27.1': + dependencies: + '@babel/traverse': 7.28.0 + '@babel/types': 7.28.2 + transitivePeerDependencies: + - supports-color + '@babel/helper-module-imports@7.27.1': dependencies: '@babel/traverse': 7.27.4 @@ -1730,14 +3435,51 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/helper-optimise-call-expression@7.27.1': + dependencies: + '@babel/types': 7.28.2 + '@babel/helper-plugin-utils@7.27.1': {} + '@babel/helper-remap-async-to-generator@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-annotate-as-pure': 7.27.3 + '@babel/helper-wrap-function': 7.27.1 + '@babel/traverse': 7.28.0 + transitivePeerDependencies: + - supports-color + + '@babel/helper-replace-supers@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-member-expression-to-functions': 7.27.1 + '@babel/helper-optimise-call-expression': 7.27.1 + '@babel/traverse': 7.28.0 + transitivePeerDependencies: + - supports-color + + '@babel/helper-skip-transparent-expression-wrappers@7.27.1': + dependencies: + '@babel/traverse': 7.28.0 + '@babel/types': 7.28.2 + transitivePeerDependencies: + - supports-color + '@babel/helper-string-parser@7.27.1': {} '@babel/helper-validator-identifier@7.27.1': {} '@babel/helper-validator-option@7.27.1': {} + '@babel/helper-wrap-function@7.27.1': + dependencies: + '@babel/template': 7.27.2 + '@babel/traverse': 7.28.0 + '@babel/types': 7.28.2 + transitivePeerDependencies: + - supports-color + '@babel/helpers@7.27.6': dependencies: '@babel/template': 7.27.2 @@ -1747,6 +3489,331 @@ snapshots: dependencies: '@babel/types': 7.27.6 + '@babel/parser@7.28.0': + dependencies: + '@babel/types': 7.28.2 + + '@babel/plugin-bugfix-firefox-class-in-computed-class-key@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + '@babel/traverse': 7.28.0 + transitivePeerDependencies: + - supports-color + + '@babel/plugin-bugfix-safari-class-field-initializer-scope@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + '@babel/helper-skip-transparent-expression-wrappers': 7.27.1 + '@babel/plugin-transform-optional-chaining': 7.27.1(@babel/core@7.27.4) + transitivePeerDependencies: + - supports-color + + '@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + '@babel/traverse': 7.28.0 + transitivePeerDependencies: + - supports-color + + '@babel/plugin-proposal-private-property-in-object@7.21.0-placeholder-for-preset-env.2(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + + '@babel/plugin-syntax-import-assertions@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-syntax-import-attributes@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-syntax-unicode-sets-regex@7.18.6(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-create-regexp-features-plugin': 7.27.1(@babel/core@7.27.4) + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-arrow-functions@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-async-generator-functions@7.28.0(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + '@babel/helper-remap-async-to-generator': 7.27.1(@babel/core@7.27.4) + '@babel/traverse': 7.28.0 + transitivePeerDependencies: + - supports-color + + '@babel/plugin-transform-async-to-generator@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-module-imports': 7.27.1 + '@babel/helper-plugin-utils': 7.27.1 + '@babel/helper-remap-async-to-generator': 7.27.1(@babel/core@7.27.4) + transitivePeerDependencies: + - supports-color + + '@babel/plugin-transform-block-scoped-functions@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-block-scoping@7.28.0(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-class-properties@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-create-class-features-plugin': 7.27.1(@babel/core@7.27.4) + '@babel/helper-plugin-utils': 7.27.1 + transitivePeerDependencies: + - supports-color + + '@babel/plugin-transform-class-static-block@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-create-class-features-plugin': 7.27.1(@babel/core@7.27.4) + '@babel/helper-plugin-utils': 7.27.1 + transitivePeerDependencies: + - supports-color + + '@babel/plugin-transform-classes@7.28.0(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-annotate-as-pure': 7.27.3 + '@babel/helper-compilation-targets': 7.27.2 + '@babel/helper-globals': 7.28.0 + '@babel/helper-plugin-utils': 7.27.1 + '@babel/helper-replace-supers': 7.27.1(@babel/core@7.27.4) + '@babel/traverse': 7.28.0 + transitivePeerDependencies: + - supports-color + + '@babel/plugin-transform-computed-properties@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + '@babel/template': 7.27.2 + + '@babel/plugin-transform-destructuring@7.28.0(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + '@babel/traverse': 7.28.0 + transitivePeerDependencies: + - supports-color + + '@babel/plugin-transform-dotall-regex@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-create-regexp-features-plugin': 7.27.1(@babel/core@7.27.4) + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-duplicate-keys@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-duplicate-named-capturing-groups-regex@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-create-regexp-features-plugin': 7.27.1(@babel/core@7.27.4) + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-dynamic-import@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-explicit-resource-management@7.28.0(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + '@babel/plugin-transform-destructuring': 7.28.0(@babel/core@7.27.4) + transitivePeerDependencies: + - supports-color + + '@babel/plugin-transform-exponentiation-operator@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-export-namespace-from@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-for-of@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + '@babel/helper-skip-transparent-expression-wrappers': 7.27.1 + transitivePeerDependencies: + - supports-color + + '@babel/plugin-transform-function-name@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-compilation-targets': 7.27.2 + '@babel/helper-plugin-utils': 7.27.1 + '@babel/traverse': 7.28.0 + transitivePeerDependencies: + - supports-color + + '@babel/plugin-transform-json-strings@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-literals@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-logical-assignment-operators@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-member-expression-literals@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-modules-amd@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-module-transforms': 7.27.3(@babel/core@7.27.4) + '@babel/helper-plugin-utils': 7.27.1 + transitivePeerDependencies: + - supports-color + + '@babel/plugin-transform-modules-commonjs@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-module-transforms': 7.27.3(@babel/core@7.27.4) + '@babel/helper-plugin-utils': 7.27.1 + transitivePeerDependencies: + - supports-color + + '@babel/plugin-transform-modules-systemjs@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-module-transforms': 7.27.3(@babel/core@7.27.4) + '@babel/helper-plugin-utils': 7.27.1 + '@babel/helper-validator-identifier': 7.27.1 + '@babel/traverse': 7.28.0 + transitivePeerDependencies: + - supports-color + + '@babel/plugin-transform-modules-umd@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-module-transforms': 7.27.3(@babel/core@7.27.4) + '@babel/helper-plugin-utils': 7.27.1 + transitivePeerDependencies: + - supports-color + + '@babel/plugin-transform-named-capturing-groups-regex@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-create-regexp-features-plugin': 7.27.1(@babel/core@7.27.4) + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-new-target@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-nullish-coalescing-operator@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-numeric-separator@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-object-rest-spread@7.28.0(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-compilation-targets': 7.27.2 + '@babel/helper-plugin-utils': 7.27.1 + '@babel/plugin-transform-destructuring': 7.28.0(@babel/core@7.27.4) + '@babel/plugin-transform-parameters': 7.27.7(@babel/core@7.27.4) + '@babel/traverse': 7.28.0 + transitivePeerDependencies: + - supports-color + + '@babel/plugin-transform-object-super@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + '@babel/helper-replace-supers': 7.27.1(@babel/core@7.27.4) + transitivePeerDependencies: + - supports-color + + '@babel/plugin-transform-optional-catch-binding@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-optional-chaining@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + '@babel/helper-skip-transparent-expression-wrappers': 7.27.1 + transitivePeerDependencies: + - supports-color + + '@babel/plugin-transform-parameters@7.27.7(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-private-methods@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-create-class-features-plugin': 7.27.1(@babel/core@7.27.4) + '@babel/helper-plugin-utils': 7.27.1 + transitivePeerDependencies: + - supports-color + + '@babel/plugin-transform-private-property-in-object@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-annotate-as-pure': 7.27.3 + '@babel/helper-create-class-features-plugin': 7.27.1(@babel/core@7.27.4) + '@babel/helper-plugin-utils': 7.27.1 + transitivePeerDependencies: + - supports-color + + '@babel/plugin-transform-property-literals@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + '@babel/plugin-transform-react-jsx-self@7.27.1(@babel/core@7.27.4)': dependencies: '@babel/core': 7.27.4 @@ -1757,6 +3824,158 @@ snapshots: '@babel/core': 7.27.4 '@babel/helper-plugin-utils': 7.27.1 + '@babel/plugin-transform-regenerator@7.28.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-regexp-modifiers@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-create-regexp-features-plugin': 7.27.1(@babel/core@7.27.4) + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-reserved-words@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-shorthand-properties@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-spread@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + '@babel/helper-skip-transparent-expression-wrappers': 7.27.1 + transitivePeerDependencies: + - supports-color + + '@babel/plugin-transform-sticky-regex@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-template-literals@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-typeof-symbol@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-unicode-escapes@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-unicode-property-regex@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-create-regexp-features-plugin': 7.27.1(@babel/core@7.27.4) + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-unicode-regex@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-create-regexp-features-plugin': 7.27.1(@babel/core@7.27.4) + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-transform-unicode-sets-regex@7.27.1(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-create-regexp-features-plugin': 7.27.1(@babel/core@7.27.4) + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/preset-env@7.28.0(@babel/core@7.27.4)': + dependencies: + '@babel/compat-data': 7.28.0 + '@babel/core': 7.27.4 + '@babel/helper-compilation-targets': 7.27.2 + '@babel/helper-plugin-utils': 7.27.1 + '@babel/helper-validator-option': 7.27.1 + '@babel/plugin-bugfix-firefox-class-in-computed-class-key': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-bugfix-safari-class-field-initializer-scope': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-proposal-private-property-in-object': 7.21.0-placeholder-for-preset-env.2(@babel/core@7.27.4) + '@babel/plugin-syntax-import-assertions': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-syntax-import-attributes': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-syntax-unicode-sets-regex': 7.18.6(@babel/core@7.27.4) + '@babel/plugin-transform-arrow-functions': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-async-generator-functions': 7.28.0(@babel/core@7.27.4) + '@babel/plugin-transform-async-to-generator': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-block-scoped-functions': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-block-scoping': 7.28.0(@babel/core@7.27.4) + '@babel/plugin-transform-class-properties': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-class-static-block': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-classes': 7.28.0(@babel/core@7.27.4) + '@babel/plugin-transform-computed-properties': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-destructuring': 7.28.0(@babel/core@7.27.4) + '@babel/plugin-transform-dotall-regex': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-duplicate-keys': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-duplicate-named-capturing-groups-regex': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-dynamic-import': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-explicit-resource-management': 7.28.0(@babel/core@7.27.4) + '@babel/plugin-transform-exponentiation-operator': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-export-namespace-from': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-for-of': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-function-name': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-json-strings': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-literals': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-logical-assignment-operators': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-member-expression-literals': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-modules-amd': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-modules-commonjs': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-modules-systemjs': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-modules-umd': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-named-capturing-groups-regex': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-new-target': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-nullish-coalescing-operator': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-numeric-separator': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-object-rest-spread': 7.28.0(@babel/core@7.27.4) + '@babel/plugin-transform-object-super': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-optional-catch-binding': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-optional-chaining': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-parameters': 7.27.7(@babel/core@7.27.4) + '@babel/plugin-transform-private-methods': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-private-property-in-object': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-property-literals': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-regenerator': 7.28.1(@babel/core@7.27.4) + '@babel/plugin-transform-regexp-modifiers': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-reserved-words': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-shorthand-properties': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-spread': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-sticky-regex': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-template-literals': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-typeof-symbol': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-unicode-escapes': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-unicode-property-regex': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-unicode-regex': 7.27.1(@babel/core@7.27.4) + '@babel/plugin-transform-unicode-sets-regex': 7.27.1(@babel/core@7.27.4) + '@babel/preset-modules': 0.1.6-no-external-plugins(@babel/core@7.27.4) + babel-plugin-polyfill-corejs2: 0.4.14(@babel/core@7.27.4) + babel-plugin-polyfill-corejs3: 0.13.0(@babel/core@7.27.4) + babel-plugin-polyfill-regenerator: 0.6.5(@babel/core@7.27.4) + core-js-compat: 3.44.0 + semver: 6.3.1 + transitivePeerDependencies: + - supports-color + + '@babel/preset-modules@0.1.6-no-external-plugins(@babel/core@7.27.4)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-plugin-utils': 7.27.1 + '@babel/types': 7.28.2 + esutils: 2.0.3 + + '@babel/runtime@7.28.2': {} + '@babel/template@7.27.2': dependencies: '@babel/code-frame': 7.27.1 @@ -1775,11 +3994,33 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/traverse@7.28.0': + dependencies: + '@babel/code-frame': 7.27.1 + '@babel/generator': 7.28.0 + '@babel/helper-globals': 7.28.0 + '@babel/parser': 7.28.0 + '@babel/template': 7.27.2 + '@babel/types': 7.28.2 + debug: 4.4.1 + transitivePeerDependencies: + - supports-color + '@babel/types@7.27.6': dependencies: '@babel/helper-string-parser': 7.27.1 '@babel/helper-validator-identifier': 7.27.1 + '@babel/types@7.28.2': + dependencies: + '@babel/helper-string-parser': 7.27.1 + '@babel/helper-validator-identifier': 7.27.1 + + '@emnapi/runtime@1.4.5': + dependencies: + tslib: 2.8.1 + optional: true + '@esbuild/aix-ppc64@0.25.5': optional: true @@ -1912,10 +4153,101 @@ snapshots: '@humanwhocodes/retry@0.4.3': {} + '@img/sharp-darwin-arm64@0.34.3': + optionalDependencies: + '@img/sharp-libvips-darwin-arm64': 1.2.0 + optional: true + + '@img/sharp-darwin-x64@0.34.3': + optionalDependencies: + '@img/sharp-libvips-darwin-x64': 1.2.0 + optional: true + + '@img/sharp-libvips-darwin-arm64@1.2.0': + optional: true + + '@img/sharp-libvips-darwin-x64@1.2.0': + optional: true + + '@img/sharp-libvips-linux-arm64@1.2.0': + optional: true + + '@img/sharp-libvips-linux-arm@1.2.0': + optional: true + + '@img/sharp-libvips-linux-ppc64@1.2.0': + optional: true + + '@img/sharp-libvips-linux-s390x@1.2.0': + optional: true + + '@img/sharp-libvips-linux-x64@1.2.0': + optional: true + + '@img/sharp-libvips-linuxmusl-arm64@1.2.0': + optional: true + + '@img/sharp-libvips-linuxmusl-x64@1.2.0': + optional: true + + '@img/sharp-linux-arm64@0.34.3': + optionalDependencies: + '@img/sharp-libvips-linux-arm64': 1.2.0 + optional: true + + '@img/sharp-linux-arm@0.34.3': + optionalDependencies: + '@img/sharp-libvips-linux-arm': 1.2.0 + optional: true + + '@img/sharp-linux-ppc64@0.34.3': + optionalDependencies: + '@img/sharp-libvips-linux-ppc64': 1.2.0 + optional: true + + '@img/sharp-linux-s390x@0.34.3': + optionalDependencies: + '@img/sharp-libvips-linux-s390x': 1.2.0 + optional: true + + '@img/sharp-linux-x64@0.34.3': + optionalDependencies: + '@img/sharp-libvips-linux-x64': 1.2.0 + optional: true + + '@img/sharp-linuxmusl-arm64@0.34.3': + optionalDependencies: + '@img/sharp-libvips-linuxmusl-arm64': 1.2.0 + optional: true + + '@img/sharp-linuxmusl-x64@0.34.3': + optionalDependencies: + '@img/sharp-libvips-linuxmusl-x64': 1.2.0 + optional: true + + '@img/sharp-wasm32@0.34.3': + dependencies: + '@emnapi/runtime': 1.4.5 + optional: true + + '@img/sharp-win32-arm64@0.34.3': + optional: true + + '@img/sharp-win32-ia32@0.34.3': + optional: true + + '@img/sharp-win32-x64@0.34.3': + optional: true + '@isaacs/fs-minipass@4.0.1': dependencies: minipass: 7.1.2 + '@jridgewell/gen-mapping@0.3.12': + dependencies: + '@jridgewell/sourcemap-codec': 1.5.0 + '@jridgewell/trace-mapping': 0.3.29 + '@jridgewell/gen-mapping@0.3.8': dependencies: '@jridgewell/set-array': 1.2.1 @@ -1926,6 +4258,11 @@ snapshots: '@jridgewell/set-array@1.2.1': {} + '@jridgewell/source-map@0.3.10': + dependencies: + '@jridgewell/gen-mapping': 0.3.12 + '@jridgewell/trace-mapping': 0.3.29 + '@jridgewell/sourcemap-codec@1.5.0': {} '@jridgewell/trace-mapping@0.3.25': @@ -1933,6 +4270,11 @@ snapshots: '@jridgewell/resolve-uri': 3.1.2 '@jridgewell/sourcemap-codec': 1.5.0 + '@jridgewell/trace-mapping@0.3.29': + dependencies: + '@jridgewell/resolve-uri': 3.1.2 + '@jridgewell/sourcemap-codec': 1.5.0 + '@nodelib/fs.scandir@2.1.5': dependencies: '@nodelib/fs.stat': 2.0.5 @@ -1949,6 +4291,56 @@ snapshots: '@rolldown/pluginutils@1.0.0-beta.9': {} + '@rollup/plugin-babel@5.3.1(@babel/core@7.27.4)(@types/babel__core@7.20.5)(rollup@2.79.2)': + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-module-imports': 7.27.1 + '@rollup/pluginutils': 3.1.0(rollup@2.79.2) + rollup: 2.79.2 + optionalDependencies: + '@types/babel__core': 7.20.5 + transitivePeerDependencies: + - supports-color + + '@rollup/plugin-node-resolve@15.3.1(rollup@2.79.2)': + dependencies: + '@rollup/pluginutils': 5.2.0(rollup@2.79.2) + '@types/resolve': 1.20.2 + deepmerge: 4.3.1 + is-module: 1.0.0 + resolve: 1.22.10 + optionalDependencies: + rollup: 2.79.2 + + '@rollup/plugin-replace@2.4.2(rollup@2.79.2)': + dependencies: + '@rollup/pluginutils': 3.1.0(rollup@2.79.2) + magic-string: 0.25.9 + rollup: 2.79.2 + + '@rollup/plugin-terser@0.4.4(rollup@2.79.2)': + dependencies: + serialize-javascript: 6.0.2 + smob: 1.5.0 + terser: 5.43.1 + optionalDependencies: + rollup: 2.79.2 + + '@rollup/pluginutils@3.1.0(rollup@2.79.2)': + dependencies: + '@types/estree': 0.0.39 + estree-walker: 1.0.1 + picomatch: 2.3.1 + rollup: 2.79.2 + + '@rollup/pluginutils@5.2.0(rollup@2.79.2)': + dependencies: + '@types/estree': 1.0.8 + estree-walker: 2.0.2 + picomatch: 4.0.2 + optionalDependencies: + rollup: 2.79.2 + '@rollup/rollup-android-arm-eabi@4.42.0': optional: true @@ -2009,6 +4401,13 @@ snapshots: '@rollup/rollup-win32-x64-msvc@4.42.0': optional: true + '@surma/rollup-plugin-off-main-thread@2.2.3': + dependencies: + ejs: 3.1.10 + json5: 2.2.3 + magic-string: 0.25.9 + string.prototype.matchall: 4.0.12 + '@tailwindcss/node@4.1.8': dependencies: '@ampproject/remapping': 2.3.0 @@ -2081,12 +4480,12 @@ snapshots: postcss: 8.5.4 tailwindcss: 4.1.8 - '@tailwindcss/vite@4.1.8(vite@6.3.5(@types/node@22.15.30)(jiti@2.4.2)(lightningcss@1.30.1))': + '@tailwindcss/vite@4.1.8(vite@6.3.5(@types/node@22.15.30)(jiti@2.4.2)(lightningcss@1.30.1)(terser@5.43.1))': dependencies: '@tailwindcss/node': 4.1.8 '@tailwindcss/oxide': 4.1.8 tailwindcss: 4.1.8 - vite: 6.3.5(@types/node@22.15.30)(jiti@2.4.2)(lightningcss@1.30.1) + vite: 6.3.5(@types/node@22.15.30)(jiti@2.4.2)(lightningcss@1.30.1)(terser@5.43.1) '@tanstack/history@1.120.17': {} @@ -2188,6 +4587,8 @@ snapshots: dependencies: '@babel/types': 7.27.6 + '@types/estree@0.0.39': {} + '@types/estree@1.0.7': {} '@types/estree@1.0.8': {} @@ -2206,6 +4607,10 @@ snapshots: dependencies: csstype: 3.1.3 + '@types/resolve@1.20.2': {} + + '@types/trusted-types@2.0.7': {} + '@types/uuid@10.0.0': {} '@typescript-eslint/eslint-plugin@8.33.1(@typescript-eslint/parser@8.33.1(eslint@9.28.0(jiti@2.4.2))(typescript@5.8.3))(eslint@9.28.0(jiti@2.4.2))(typescript@5.8.3)': @@ -2300,7 +4705,7 @@ snapshots: '@typescript-eslint/types': 8.33.1 eslint-visitor-keys: 4.2.0 - '@vitejs/plugin-react@4.5.1(vite@6.3.5(@types/node@22.15.30)(jiti@2.4.2)(lightningcss@1.30.1))': + '@vitejs/plugin-react@4.5.1(vite@6.3.5(@types/node@22.15.30)(jiti@2.4.2)(lightningcss@1.30.1)(terser@5.43.1))': dependencies: '@babel/core': 7.27.4 '@babel/plugin-transform-react-jsx-self': 7.27.1(@babel/core@7.27.4) @@ -2308,7 +4713,7 @@ snapshots: '@rolldown/pluginutils': 1.0.0-beta.9 '@types/babel__core': 7.20.5 react-refresh: 0.17.0 - vite: 6.3.5(@types/node@22.15.30)(jiti@2.4.2)(lightningcss@1.30.1) + vite: 6.3.5(@types/node@22.15.30)(jiti@2.4.2)(lightningcss@1.30.1)(terser@5.43.1) transitivePeerDependencies: - supports-color @@ -2325,14 +4730,58 @@ snapshots: json-schema-traverse: 0.4.1 uri-js: 4.4.1 + ajv@8.17.1: + dependencies: + fast-deep-equal: 3.1.3 + fast-uri: 3.0.6 + json-schema-traverse: 1.0.0 + require-from-string: 2.0.2 + ansi-styles@4.3.0: dependencies: color-convert: 2.0.1 argparse@2.0.1: {} + array-buffer-byte-length@1.0.2: + dependencies: + call-bound: 1.0.4 + is-array-buffer: 3.0.5 + + arraybuffer.prototype.slice@1.0.4: + dependencies: + array-buffer-byte-length: 1.0.2 + call-bind: 1.0.8 + define-properties: 1.2.1 + es-abstract: 1.24.0 + es-errors: 1.3.0 + get-intrinsic: 1.3.0 + is-array-buffer: 3.0.5 + + arrify@1.0.1: {} + + asn1@0.2.6: + dependencies: + safer-buffer: 2.1.2 + + assert-plus@1.0.0: {} + + async-function@1.0.0: {} + + async@3.2.6: {} + asynckit@0.4.0: {} + at-least-node@1.0.0: {} + + available-typed-arrays@1.0.7: + dependencies: + possible-typed-array-names: 1.1.0 + + aws-sign2@0.7.0: {} + + aws4@1.13.2: {} + axios@1.9.0: dependencies: follow-redirects: 1.15.9 @@ -2341,8 +4790,42 @@ snapshots: transitivePeerDependencies: - debug + babel-plugin-polyfill-corejs2@0.4.14(@babel/core@7.27.4): + dependencies: + '@babel/compat-data': 7.28.0 + '@babel/core': 7.27.4 + '@babel/helper-define-polyfill-provider': 0.6.5(@babel/core@7.27.4) + semver: 6.3.1 + transitivePeerDependencies: + - supports-color + + babel-plugin-polyfill-corejs3@0.13.0(@babel/core@7.27.4): + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-define-polyfill-provider': 0.6.5(@babel/core@7.27.4) + core-js-compat: 3.44.0 + transitivePeerDependencies: + - supports-color + + babel-plugin-polyfill-regenerator@0.6.5(@babel/core@7.27.4): + dependencies: + '@babel/core': 7.27.4 + '@babel/helper-define-polyfill-provider': 0.6.5(@babel/core@7.27.4) + transitivePeerDependencies: + - supports-color + balanced-match@1.0.2: {} + bcrypt-pbkdf@1.0.2: + dependencies: + tweetnacl: 0.14.5 + + bignumber.js@2.4.0: {} + + bmp-js@0.0.1: {} + + bmp-js@0.0.3: {} + brace-expansion@1.1.11: dependencies: balanced-match: 1.0.2 @@ -2363,15 +4846,57 @@ snapshots: node-releases: 2.0.19 update-browserslist-db: 1.1.3(browserslist@4.25.0) + browserslist@4.25.1: + dependencies: + caniuse-lite: 1.0.30001727 + electron-to-chromium: 1.5.191 + node-releases: 2.0.19 + update-browserslist-db: 1.1.3(browserslist@4.25.1) + + buffer-alloc-unsafe@1.1.0: {} + + buffer-alloc@1.2.0: + dependencies: + buffer-alloc-unsafe: 1.1.0 + buffer-fill: 1.0.0 + + buffer-equal@0.0.1: {} + + buffer-fill@1.0.0: {} + + buffer-from@1.1.2: {} + call-bind-apply-helpers@1.0.2: dependencies: es-errors: 1.3.0 function-bind: 1.1.2 + call-bind@1.0.8: + dependencies: + call-bind-apply-helpers: 1.0.2 + es-define-property: 1.0.1 + get-intrinsic: 1.3.0 + set-function-length: 1.2.2 + + call-bound@1.0.4: + dependencies: + call-bind-apply-helpers: 1.0.2 + get-intrinsic: 1.3.0 + callsites@3.1.0: {} caniuse-lite@1.0.30001721: {} + caniuse-lite@1.0.30001727: {} + + caseless@0.12.0: {} + + centra@2.7.0: + dependencies: + follow-redirects: 1.15.9 + transitivePeerDependencies: + - debug + chalk@4.1.2: dependencies: ansi-styles: 4.3.0 @@ -2387,45 +4912,173 @@ snapshots: color-name@1.1.4: {} + color-string@1.9.1: + dependencies: + color-name: 1.1.4 + simple-swizzle: 0.2.2 + + color@4.2.3: + dependencies: + color-convert: 2.0.1 + color-string: 1.9.1 + combined-stream@1.0.8: dependencies: delayed-stream: 1.0.0 + commander@2.20.3: {} + + common-tags@1.8.2: {} + concat-map@0.0.1: {} convert-source-map@2.0.0: {} + core-js-compat@3.44.0: + dependencies: + browserslist: 4.25.1 + + core-util-is@1.0.2: {} + cross-spawn@7.0.6: dependencies: path-key: 3.1.1 shebang-command: 2.0.0 which: 2.0.2 + crypto-random-string@2.0.0: {} + csstype@3.1.3: {} + dashdash@1.14.1: + dependencies: + assert-plus: 1.0.0 + + data-view-buffer@1.0.2: + dependencies: + call-bound: 1.0.4 + es-errors: 1.3.0 + is-data-view: 1.0.2 + + data-view-byte-length@1.0.2: + dependencies: + call-bound: 1.0.4 + es-errors: 1.3.0 + is-data-view: 1.0.2 + + data-view-byte-offset@1.0.1: + dependencies: + call-bound: 1.0.4 + es-errors: 1.3.0 + is-data-view: 1.0.2 + debug@4.4.1: dependencies: ms: 2.1.3 deep-is@0.1.4: {} + deepmerge@4.3.1: {} + + define-data-property@1.1.4: + dependencies: + es-define-property: 1.0.1 + es-errors: 1.3.0 + gopd: 1.2.0 + + define-properties@1.2.1: + dependencies: + define-data-property: 1.1.4 + has-property-descriptors: 1.0.2 + object-keys: 1.1.1 + delayed-stream@1.0.0: {} detect-libc@2.0.4: {} + dom-walk@0.1.2: {} + dunder-proto@1.0.1: dependencies: call-bind-apply-helpers: 1.0.2 es-errors: 1.3.0 gopd: 1.2.0 + ecc-jsbn@0.1.2: + dependencies: + jsbn: 0.1.1 + safer-buffer: 2.1.2 + + ejs@3.1.10: + dependencies: + jake: 10.9.2 + electron-to-chromium@1.5.165: {} + electron-to-chromium@1.5.191: {} + enhanced-resolve@5.18.1: dependencies: graceful-fs: 4.2.11 tapable: 2.2.2 + es-abstract@1.24.0: + dependencies: + array-buffer-byte-length: 1.0.2 + arraybuffer.prototype.slice: 1.0.4 + available-typed-arrays: 1.0.7 + call-bind: 1.0.8 + call-bound: 1.0.4 + data-view-buffer: 1.0.2 + data-view-byte-length: 1.0.2 + data-view-byte-offset: 1.0.1 + es-define-property: 1.0.1 + es-errors: 1.3.0 + es-object-atoms: 1.1.1 + es-set-tostringtag: 2.1.0 + es-to-primitive: 1.3.0 + function.prototype.name: 1.1.8 + get-intrinsic: 1.3.0 + get-proto: 1.0.1 + get-symbol-description: 1.1.0 + globalthis: 1.0.4 + gopd: 1.2.0 + has-property-descriptors: 1.0.2 + has-proto: 1.2.0 + has-symbols: 1.1.0 + hasown: 2.0.2 + internal-slot: 1.1.0 + is-array-buffer: 3.0.5 + is-callable: 1.2.7 + is-data-view: 1.0.2 + is-negative-zero: 2.0.3 + is-regex: 1.2.1 + is-set: 2.0.3 + is-shared-array-buffer: 1.0.4 + is-string: 1.1.1 + is-typed-array: 1.1.15 + is-weakref: 1.1.1 + math-intrinsics: 1.1.0 + object-inspect: 1.13.4 + object-keys: 1.1.1 + object.assign: 4.1.7 + own-keys: 1.0.1 + regexp.prototype.flags: 1.5.4 + safe-array-concat: 1.1.3 + safe-push-apply: 1.0.0 + safe-regex-test: 1.1.0 + set-proto: 1.0.0 + stop-iteration-iterator: 1.1.0 + string.prototype.trim: 1.2.10 + string.prototype.trimend: 1.0.9 + string.prototype.trimstart: 1.0.8 + typed-array-buffer: 1.0.3 + typed-array-byte-length: 1.0.3 + typed-array-byte-offset: 1.0.4 + typed-array-length: 1.0.7 + unbox-primitive: 1.1.0 + which-typed-array: 1.1.19 + es-define-property@1.0.1: {} es-errors@1.3.0: {} @@ -2441,6 +5094,14 @@ snapshots: has-tostringtag: 1.0.2 hasown: 2.0.2 + es-to-primitive@1.3.0: + dependencies: + is-callable: 1.2.7 + is-date-object: 1.1.0 + is-symbol: 1.1.1 + + es6-promise@3.3.1: {} + esbuild@0.25.5: optionalDependencies: '@esbuild/aix-ppc64': 0.25.5 @@ -2561,8 +5222,18 @@ snapshots: estraverse@5.3.0: {} + estree-walker@1.0.1: {} + + estree-walker@2.0.2: {} + esutils@2.0.3: {} + exif-parser@0.1.12: {} + + extend@3.0.2: {} + + extsprintf@1.3.0: {} + fast-deep-equal@3.1.3: {} fast-diff@1.3.0: {} @@ -2579,6 +5250,8 @@ snapshots: fast-levenshtein@2.0.6: {} + fast-uri@3.0.6: {} + fastq@1.19.1: dependencies: reusify: 1.1.0 @@ -2591,6 +5264,12 @@ snapshots: dependencies: flat-cache: 4.0.1 + file-type@3.9.0: {} + + filelist@1.0.4: + dependencies: + minimatch: 5.1.6 + fill-range@7.1.1: dependencies: to-regex-range: 5.0.1 @@ -2609,6 +5288,18 @@ snapshots: follow-redirects@1.15.9: {} + for-each@0.3.5: + dependencies: + is-callable: 1.2.7 + + forever-agent@0.6.1: {} + + form-data@2.3.3: + dependencies: + asynckit: 0.4.0 + combined-stream: 1.0.8 + mime-types: 2.1.35 + form-data@4.0.3: dependencies: asynckit: 0.4.0 @@ -2617,11 +5308,31 @@ snapshots: hasown: 2.0.2 mime-types: 2.1.35 + fs-extra@9.1.0: + dependencies: + at-least-node: 1.0.0 + graceful-fs: 4.2.11 + jsonfile: 6.1.0 + universalify: 2.0.1 + + fs.realpath@1.0.0: {} + fsevents@2.3.3: optional: true function-bind@1.1.2: {} + function.prototype.name@1.1.8: + dependencies: + call-bind: 1.0.8 + call-bound: 1.0.4 + define-properties: 1.2.1 + functions-have-names: 1.2.3 + hasown: 2.0.2 + is-callable: 1.2.7 + + functions-have-names@1.2.3: {} + gensync@1.0.0-beta.2: {} get-intrinsic@1.3.0: @@ -2637,11 +5348,28 @@ snapshots: hasown: 2.0.2 math-intrinsics: 1.1.0 + get-own-enumerable-property-symbols@3.0.2: {} + get-proto@1.0.1: dependencies: dunder-proto: 1.0.1 es-object-atoms: 1.1.1 + get-stream@2.3.1: + dependencies: + object-assign: 4.1.1 + pinkie-promise: 2.0.1 + + get-symbol-description@1.1.0: + dependencies: + call-bound: 1.0.4 + es-errors: 1.3.0 + get-intrinsic: 1.3.0 + + getpass@0.1.7: + dependencies: + assert-plus: 1.0.0 + glob-parent@5.1.2: dependencies: is-glob: 4.0.3 @@ -2650,12 +5378,31 @@ snapshots: dependencies: is-glob: 4.0.3 + glob@7.2.3: + 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 + + global@4.4.0: + dependencies: + min-document: 2.19.0 + process: 0.11.10 + globals@11.12.0: {} globals@14.0.0: {} globals@16.2.0: {} + globalthis@1.0.4: + dependencies: + define-properties: 1.2.1 + gopd: 1.2.0 + goober@2.1.16(csstype@3.1.3): dependencies: csstype: 3.1.3 @@ -2666,8 +5413,25 @@ snapshots: graphemer@1.4.0: {} + har-schema@2.0.0: {} + + har-validator@5.1.5: + dependencies: + ajv: 6.12.6 + har-schema: 2.0.0 + + has-bigints@1.1.0: {} + has-flag@4.0.0: {} + has-property-descriptors@1.0.2: + dependencies: + es-define-property: 1.0.1 + + has-proto@1.2.0: + dependencies: + dunder-proto: 1.0.1 + has-symbols@1.1.0: {} has-tostringtag@1.0.2: @@ -2678,10 +5442,20 @@ snapshots: dependencies: function-bind: 1.1.2 + http-signature@1.2.0: + dependencies: + assert-plus: 1.0.0 + jsprim: 1.4.2 + sshpk: 1.18.0 + + idb@7.1.1: {} + ignore@5.3.2: {} ignore@7.0.5: {} + image-size@0.5.5: {} + import-fresh@3.3.1: dependencies: parent-module: 1.0.1 @@ -2689,38 +5463,229 @@ snapshots: imurmurhash@0.1.4: {} + inflight@1.0.6: + dependencies: + once: 1.4.0 + wrappy: 1.0.2 + + inherits@2.0.4: {} + + internal-slot@1.1.0: + dependencies: + es-errors: 1.3.0 + hasown: 2.0.2 + side-channel: 1.1.0 + + ip-regex@1.0.3: {} + + is-array-buffer@3.0.5: + dependencies: + call-bind: 1.0.8 + call-bound: 1.0.4 + get-intrinsic: 1.3.0 + + is-arrayish@0.3.2: {} + + is-async-function@2.1.1: + dependencies: + async-function: 1.0.0 + call-bound: 1.0.4 + get-proto: 1.0.1 + has-tostringtag: 1.0.2 + safe-regex-test: 1.1.0 + + is-bigint@1.1.0: + dependencies: + has-bigints: 1.1.0 + + is-boolean-object@1.2.2: + dependencies: + call-bound: 1.0.4 + has-tostringtag: 1.0.2 + + is-callable@1.2.7: {} + + is-core-module@2.16.1: + dependencies: + hasown: 2.0.2 + + is-data-view@1.0.2: + dependencies: + call-bound: 1.0.4 + get-intrinsic: 1.3.0 + is-typed-array: 1.1.15 + + is-date-object@1.1.0: + dependencies: + call-bound: 1.0.4 + has-tostringtag: 1.0.2 + is-extglob@2.1.1: {} + is-finalizationregistry@1.1.1: + dependencies: + call-bound: 1.0.4 + + is-function@1.0.2: {} + + is-generator-function@1.1.0: + dependencies: + call-bound: 1.0.4 + get-proto: 1.0.1 + has-tostringtag: 1.0.2 + safe-regex-test: 1.1.0 + is-glob@4.0.3: dependencies: is-extglob: 2.1.1 + is-map@2.0.3: {} + + is-module@1.0.0: {} + + is-negative-zero@2.0.3: {} + + is-number-object@1.1.1: + dependencies: + call-bound: 1.0.4 + has-tostringtag: 1.0.2 + is-number@7.0.0: {} + is-obj@1.0.1: {} + + is-regex@1.2.1: + dependencies: + call-bound: 1.0.4 + gopd: 1.2.0 + has-tostringtag: 1.0.2 + hasown: 2.0.2 + + is-regexp@1.0.0: {} + + is-set@2.0.3: {} + + is-shared-array-buffer@1.0.4: + dependencies: + call-bound: 1.0.4 + + is-stream@2.0.1: {} + + is-string@1.1.1: + dependencies: + call-bound: 1.0.4 + has-tostringtag: 1.0.2 + + is-symbol@1.1.1: + dependencies: + call-bound: 1.0.4 + has-symbols: 1.1.0 + safe-regex-test: 1.1.0 + + is-typed-array@1.1.15: + dependencies: + which-typed-array: 1.1.19 + + is-typedarray@1.0.0: {} + + is-weakmap@2.0.2: {} + + is-weakref@1.1.1: + dependencies: + call-bound: 1.0.4 + + is-weakset@2.0.4: + dependencies: + call-bound: 1.0.4 + get-intrinsic: 1.3.0 + + isarray@2.0.5: {} + isexe@2.0.0: {} + isstream@0.1.2: {} + + jake@10.9.2: + dependencies: + async: 3.2.6 + chalk: 4.1.2 + filelist: 1.0.4 + minimatch: 3.1.2 + + jimp@0.2.28: + dependencies: + bignumber.js: 2.4.0 + bmp-js: 0.0.3 + es6-promise: 3.3.1 + exif-parser: 0.1.12 + file-type: 3.9.0 + jpeg-js: 0.2.0 + load-bmfont: 1.4.2 + mime: 1.6.0 + mkdirp: 0.5.1 + pixelmatch: 4.0.2 + pngjs: 3.4.0 + read-chunk: 1.0.1 + request: 2.88.2 + stream-to-buffer: 0.1.0 + tinycolor2: 1.6.0 + url-regex: 3.2.0 + transitivePeerDependencies: + - debug + jiti@2.4.2: {} + jpeg-js@0.1.2: {} + + jpeg-js@0.2.0: {} + js-tokens@4.0.0: {} js-yaml@4.1.0: dependencies: argparse: 2.0.1 + jsbn@0.1.1: {} + + jsesc@3.0.2: {} + jsesc@3.1.0: {} json-buffer@3.0.1: {} json-schema-traverse@0.4.1: {} + json-schema-traverse@1.0.0: {} + + json-schema@0.4.0: {} + json-stable-stringify-without-jsonify@1.0.1: {} + json-stringify-safe@5.0.1: {} + json5@2.2.3: {} + jsonfile@6.1.0: + dependencies: + universalify: 2.0.1 + optionalDependencies: + graceful-fs: 4.2.11 + + jsonpointer@5.0.1: {} + + jsprim@1.4.2: + dependencies: + assert-plus: 1.0.0 + extsprintf: 1.3.0 + json-schema: 0.4.0 + verror: 1.10.0 + keyv@4.5.4: dependencies: json-buffer: 3.0.1 + leven@3.1.0: {} + levn@0.4.1: dependencies: prelude-ls: 1.2.1 @@ -2771,12 +5736,31 @@ snapshots: lightningcss-win32-arm64-msvc: 1.30.1 lightningcss-win32-x64-msvc: 1.30.1 + load-bmfont@1.4.2: + dependencies: + buffer-equal: 0.0.1 + mime: 1.6.0 + parse-bmfont-ascii: 1.0.6 + parse-bmfont-binary: 1.0.6 + parse-bmfont-xml: 1.1.6 + phin: 3.7.1 + xhr: 2.6.0 + xtend: 4.0.2 + transitivePeerDependencies: + - debug + locate-path@6.0.0: dependencies: p-locate: 5.0.0 + lodash.debounce@4.0.8: {} + lodash.merge@4.6.2: {} + lodash.sortby@4.7.0: {} + + lodash@4.17.21: {} + lru-cache@5.1.1: dependencies: yallist: 3.1.1 @@ -2785,6 +5769,10 @@ snapshots: dependencies: react: 19.1.0 + magic-string@0.25.9: + dependencies: + sourcemap-codec: 1.4.8 + magic-string@0.30.17: dependencies: '@jridgewell/sourcemap-codec': 1.5.0 @@ -2804,20 +5792,36 @@ snapshots: dependencies: mime-db: 1.52.0 + mime@1.6.0: {} + + min-document@2.19.0: + dependencies: + dom-walk: 0.1.2 + minimatch@3.1.2: dependencies: brace-expansion: 1.1.11 + minimatch@5.1.6: + dependencies: + brace-expansion: 2.0.1 + minimatch@9.0.5: dependencies: brace-expansion: 2.0.1 + minimist@0.0.8: {} + minipass@7.1.2: {} minizlib@3.0.2: dependencies: minipass: 7.1.2 + mkdirp@0.5.1: + dependencies: + minimist: 0.0.8 + mkdirp@3.0.1: {} ms@2.1.3: {} @@ -2828,6 +5832,27 @@ snapshots: node-releases@2.0.19: {} + oauth-sign@0.9.0: {} + + object-assign@4.1.1: {} + + object-inspect@1.13.4: {} + + object-keys@1.1.1: {} + + object.assign@4.1.7: + dependencies: + call-bind: 1.0.8 + call-bound: 1.0.4 + define-properties: 1.2.1 + es-object-atoms: 1.1.1 + has-symbols: 1.1.0 + object-keys: 1.1.1 + + once@1.4.0: + dependencies: + wrappy: 1.0.2 + optionator@0.9.4: dependencies: deep-is: 0.1.4 @@ -2837,6 +5862,12 @@ snapshots: type-check: 0.4.0 word-wrap: 1.2.5 + own-keys@1.0.1: + dependencies: + get-intrinsic: 1.3.0 + object-keys: 1.1.1 + safe-push-apply: 1.0.0 + p-limit@3.1.0: dependencies: yocto-queue: 0.1.0 @@ -2849,16 +5880,57 @@ snapshots: dependencies: callsites: 3.1.0 + parse-bmfont-ascii@1.0.6: {} + + parse-bmfont-binary@1.0.6: {} + + parse-bmfont-xml@1.1.6: + dependencies: + xml-parse-from-string: 1.0.1 + xml2js: 0.5.0 + + parse-headers@2.0.6: {} + + parse-png@1.1.2: + dependencies: + pngjs: 3.4.0 + path-exists@4.0.0: {} + path-is-absolute@1.0.1: {} + path-key@3.1.1: {} + path-parse@1.0.7: {} + + performance-now@2.1.0: {} + + phin@3.7.1: + dependencies: + centra: 2.7.0 + transitivePeerDependencies: + - debug + picocolors@1.1.1: {} picomatch@2.3.1: {} picomatch@4.0.2: {} + pinkie-promise@2.0.1: + dependencies: + pinkie: 2.0.4 + + pinkie@2.0.4: {} + + pixelmatch@4.0.2: + dependencies: + pngjs: 3.4.0 + + pngjs@3.4.0: {} + + possible-typed-array-names@1.1.0: {} + postcss@8.5.4: dependencies: nanoid: 3.3.11 @@ -2873,12 +5945,28 @@ snapshots: prettier@3.5.3: {} + pretty-bytes@5.6.0: {} + + pretty-bytes@6.1.1: {} + + process@0.11.10: {} + proxy-from-env@1.1.0: {} + psl@1.15.0: + dependencies: + punycode: 2.3.1 + punycode@2.3.1: {} + qs@6.5.3: {} + queue-microtask@1.2.3: {} + randombytes@2.1.0: + dependencies: + safe-buffer: 5.2.1 + react-dom@19.1.0(react@19.1.0): dependencies: react: 19.1.0 @@ -2896,10 +5984,99 @@ snapshots: react@19.1.0: {} + read-chunk@1.0.1: {} + + reflect.getprototypeof@1.0.10: + dependencies: + call-bind: 1.0.8 + define-properties: 1.2.1 + es-abstract: 1.24.0 + es-errors: 1.3.0 + es-object-atoms: 1.1.1 + get-intrinsic: 1.3.0 + get-proto: 1.0.1 + which-builtin-type: 1.2.1 + + regenerate-unicode-properties@10.2.0: + dependencies: + regenerate: 1.4.2 + + regenerate@1.4.2: {} + + regexp.prototype.flags@1.5.4: + dependencies: + call-bind: 1.0.8 + define-properties: 1.2.1 + es-errors: 1.3.0 + get-proto: 1.0.1 + gopd: 1.2.0 + set-function-name: 2.0.2 + + regexpu-core@6.2.0: + dependencies: + regenerate: 1.4.2 + regenerate-unicode-properties: 10.2.0 + regjsgen: 0.8.0 + regjsparser: 0.12.0 + unicode-match-property-ecmascript: 2.0.0 + unicode-match-property-value-ecmascript: 2.2.0 + + regjsgen@0.8.0: {} + + regjsparser@0.12.0: + dependencies: + jsesc: 3.0.2 + + request@2.88.2: + dependencies: + aws-sign2: 0.7.0 + aws4: 1.13.2 + caseless: 0.12.0 + combined-stream: 1.0.8 + extend: 3.0.2 + forever-agent: 0.6.1 + form-data: 2.3.3 + har-validator: 5.1.5 + http-signature: 1.2.0 + is-typedarray: 1.0.0 + isstream: 0.1.2 + json-stringify-safe: 5.0.1 + mime-types: 2.1.35 + oauth-sign: 0.9.0 + performance-now: 2.1.0 + qs: 6.5.3 + safe-buffer: 5.2.1 + tough-cookie: 2.5.0 + tunnel-agent: 0.6.0 + uuid: 3.4.0 + + require-from-string@2.0.2: {} + + resize-img@1.1.2: + dependencies: + bmp-js: 0.0.1 + file-type: 3.9.0 + get-stream: 2.3.1 + jimp: 0.2.28 + jpeg-js: 0.1.2 + parse-png: 1.1.2 + transitivePeerDependencies: + - debug + resolve-from@4.0.0: {} + resolve@1.22.10: + dependencies: + is-core-module: 2.16.1 + path-parse: 1.0.7 + supports-preserve-symlinks-flag: 1.0.0 + reusify@1.1.0: {} + rollup@2.79.2: + optionalDependencies: + fsevents: 2.3.3 + rollup@4.42.0: dependencies: '@types/estree': 1.0.7 @@ -2930,24 +6107,138 @@ snapshots: dependencies: queue-microtask: 1.2.3 + safe-array-concat@1.1.3: + dependencies: + call-bind: 1.0.8 + call-bound: 1.0.4 + get-intrinsic: 1.3.0 + has-symbols: 1.1.0 + isarray: 2.0.5 + + safe-buffer@5.2.1: {} + + safe-push-apply@1.0.0: + dependencies: + es-errors: 1.3.0 + isarray: 2.0.5 + + safe-regex-test@1.1.0: + dependencies: + call-bound: 1.0.4 + es-errors: 1.3.0 + is-regex: 1.2.1 + + safer-buffer@2.1.2: {} + + sax@1.4.1: {} + scheduler@0.26.0: {} semver@6.3.1: {} semver@7.7.2: {} + serialize-javascript@6.0.2: + dependencies: + randombytes: 2.1.0 + seroval-plugins@1.3.2(seroval@1.3.2): dependencies: seroval: 1.3.2 seroval@1.3.2: {} + set-function-length@1.2.2: + dependencies: + define-data-property: 1.1.4 + es-errors: 1.3.0 + function-bind: 1.1.2 + get-intrinsic: 1.3.0 + gopd: 1.2.0 + has-property-descriptors: 1.0.2 + + set-function-name@2.0.2: + dependencies: + define-data-property: 1.1.4 + es-errors: 1.3.0 + functions-have-names: 1.2.3 + has-property-descriptors: 1.0.2 + + set-proto@1.0.0: + dependencies: + dunder-proto: 1.0.1 + es-errors: 1.3.0 + es-object-atoms: 1.1.1 + + sharp@0.34.3: + dependencies: + color: 4.2.3 + detect-libc: 2.0.4 + semver: 7.7.2 + optionalDependencies: + '@img/sharp-darwin-arm64': 0.34.3 + '@img/sharp-darwin-x64': 0.34.3 + '@img/sharp-libvips-darwin-arm64': 1.2.0 + '@img/sharp-libvips-darwin-x64': 1.2.0 + '@img/sharp-libvips-linux-arm': 1.2.0 + '@img/sharp-libvips-linux-arm64': 1.2.0 + '@img/sharp-libvips-linux-ppc64': 1.2.0 + '@img/sharp-libvips-linux-s390x': 1.2.0 + '@img/sharp-libvips-linux-x64': 1.2.0 + '@img/sharp-libvips-linuxmusl-arm64': 1.2.0 + '@img/sharp-libvips-linuxmusl-x64': 1.2.0 + '@img/sharp-linux-arm': 0.34.3 + '@img/sharp-linux-arm64': 0.34.3 + '@img/sharp-linux-ppc64': 0.34.3 + '@img/sharp-linux-s390x': 0.34.3 + '@img/sharp-linux-x64': 0.34.3 + '@img/sharp-linuxmusl-arm64': 0.34.3 + '@img/sharp-linuxmusl-x64': 0.34.3 + '@img/sharp-wasm32': 0.34.3 + '@img/sharp-win32-arm64': 0.34.3 + '@img/sharp-win32-ia32': 0.34.3 + '@img/sharp-win32-x64': 0.34.3 + shebang-command@2.0.0: dependencies: shebang-regex: 3.0.0 shebang-regex@3.0.0: {} + side-channel-list@1.0.0: + dependencies: + es-errors: 1.3.0 + object-inspect: 1.13.4 + + side-channel-map@1.0.1: + dependencies: + call-bound: 1.0.4 + es-errors: 1.3.0 + get-intrinsic: 1.3.0 + object-inspect: 1.13.4 + + side-channel-weakmap@1.0.2: + dependencies: + call-bound: 1.0.4 + es-errors: 1.3.0 + get-intrinsic: 1.3.0 + object-inspect: 1.13.4 + side-channel-map: 1.0.1 + + side-channel@1.1.0: + dependencies: + es-errors: 1.3.0 + object-inspect: 1.13.4 + side-channel-list: 1.0.0 + side-channel-map: 1.0.1 + side-channel-weakmap: 1.0.2 + + simple-swizzle@0.2.2: + dependencies: + is-arrayish: 0.3.2 + + smob@1.5.0: {} + solid-js@1.9.7: dependencies: csstype: 3.1.3 @@ -2961,12 +6252,97 @@ snapshots: source-map-js@1.2.1: {} + source-map-support@0.5.21: + dependencies: + buffer-from: 1.1.2 + source-map: 0.6.1 + + source-map@0.6.1: {} + + source-map@0.8.0-beta.0: + dependencies: + whatwg-url: 7.1.0 + + sourcemap-codec@1.4.8: {} + + sshpk@1.18.0: + dependencies: + asn1: 0.2.6 + assert-plus: 1.0.0 + bcrypt-pbkdf: 1.0.2 + dashdash: 1.14.1 + ecc-jsbn: 0.1.2 + getpass: 0.1.7 + jsbn: 0.1.1 + safer-buffer: 2.1.2 + tweetnacl: 0.14.5 + + stop-iteration-iterator@1.1.0: + dependencies: + es-errors: 1.3.0 + internal-slot: 1.1.0 + + stream-to-buffer@0.1.0: + dependencies: + stream-to: 0.2.2 + + stream-to@0.2.2: {} + + string.prototype.matchall@4.0.12: + dependencies: + call-bind: 1.0.8 + call-bound: 1.0.4 + define-properties: 1.2.1 + es-abstract: 1.24.0 + es-errors: 1.3.0 + es-object-atoms: 1.1.1 + get-intrinsic: 1.3.0 + gopd: 1.2.0 + has-symbols: 1.1.0 + internal-slot: 1.1.0 + regexp.prototype.flags: 1.5.4 + set-function-name: 2.0.2 + side-channel: 1.1.0 + + string.prototype.trim@1.2.10: + dependencies: + call-bind: 1.0.8 + call-bound: 1.0.4 + define-data-property: 1.1.4 + define-properties: 1.2.1 + es-abstract: 1.24.0 + es-object-atoms: 1.1.1 + has-property-descriptors: 1.0.2 + + string.prototype.trimend@1.0.9: + dependencies: + call-bind: 1.0.8 + call-bound: 1.0.4 + define-properties: 1.2.1 + es-object-atoms: 1.1.1 + + string.prototype.trimstart@1.0.8: + dependencies: + call-bind: 1.0.8 + define-properties: 1.2.1 + es-object-atoms: 1.1.1 + + stringify-object@3.3.0: + dependencies: + get-own-enumerable-property-symbols: 3.0.2 + is-obj: 1.0.1 + is-regexp: 1.0.0 + + strip-comments@2.0.1: {} + strip-json-comments@3.1.1: {} supports-color@7.2.0: dependencies: has-flag: 4.0.0 + supports-preserve-symlinks-flag@1.0.0: {} + synckit@0.11.8: dependencies: '@pkgr/core': 0.2.7 @@ -2984,27 +6360,108 @@ snapshots: mkdirp: 3.0.1 yallist: 5.0.0 + temp-dir@2.0.0: {} + + tempy@0.6.0: + dependencies: + is-stream: 2.0.1 + temp-dir: 2.0.0 + type-fest: 0.16.0 + unique-string: 2.0.0 + + terser@5.43.1: + dependencies: + '@jridgewell/source-map': 0.3.10 + acorn: 8.14.1 + commander: 2.20.3 + source-map-support: 0.5.21 + tiny-invariant@1.3.3: {} tiny-warning@1.0.3: {} + tinycolor2@1.6.0: {} + tinyglobby@0.2.14: dependencies: fdir: 6.4.5(picomatch@4.0.2) picomatch: 4.0.2 + to-ico@1.1.5: + dependencies: + arrify: 1.0.1 + buffer-alloc: 1.2.0 + image-size: 0.5.5 + parse-png: 1.1.2 + resize-img: 1.1.2 + transitivePeerDependencies: + - debug + to-regex-range@5.0.1: dependencies: is-number: 7.0.0 + tough-cookie@2.5.0: + dependencies: + psl: 1.15.0 + punycode: 2.3.1 + + tr46@1.0.1: + dependencies: + punycode: 2.3.1 + ts-api-utils@2.1.0(typescript@5.8.3): dependencies: typescript: 5.8.3 + tslib@2.8.1: + optional: true + + tunnel-agent@0.6.0: + dependencies: + safe-buffer: 5.2.1 + + tweetnacl@0.14.5: {} + type-check@0.4.0: dependencies: prelude-ls: 1.2.1 + type-fest@0.16.0: {} + + typed-array-buffer@1.0.3: + dependencies: + call-bound: 1.0.4 + es-errors: 1.3.0 + is-typed-array: 1.1.15 + + typed-array-byte-length@1.0.3: + dependencies: + call-bind: 1.0.8 + for-each: 0.3.5 + gopd: 1.2.0 + has-proto: 1.2.0 + is-typed-array: 1.1.15 + + typed-array-byte-offset@1.0.4: + dependencies: + available-typed-arrays: 1.0.7 + call-bind: 1.0.8 + for-each: 0.3.5 + gopd: 1.2.0 + has-proto: 1.2.0 + is-typed-array: 1.1.15 + reflect.getprototypeof: 1.0.10 + + typed-array-length@1.0.7: + dependencies: + call-bind: 1.0.8 + for-each: 0.3.5 + gopd: 1.2.0 + is-typed-array: 1.1.15 + possible-typed-array-names: 1.1.0 + reflect.getprototypeof: 1.0.10 + typescript-eslint@8.33.1(eslint@9.28.0(jiti@2.4.2))(typescript@5.8.3): dependencies: '@typescript-eslint/eslint-plugin': 8.33.1(@typescript-eslint/parser@8.33.1(eslint@9.28.0(jiti@2.4.2))(typescript@5.8.3))(eslint@9.28.0(jiti@2.4.2))(typescript@5.8.3) @@ -3017,18 +6474,54 @@ snapshots: typescript@5.8.3: {} + unbox-primitive@1.1.0: + dependencies: + call-bound: 1.0.4 + has-bigints: 1.1.0 + has-symbols: 1.1.0 + which-boxed-primitive: 1.1.1 + undici-types@6.21.0: {} + unicode-canonical-property-names-ecmascript@2.0.1: {} + + unicode-match-property-ecmascript@2.0.0: + dependencies: + unicode-canonical-property-names-ecmascript: 2.0.1 + unicode-property-aliases-ecmascript: 2.1.0 + + unicode-match-property-value-ecmascript@2.2.0: {} + + unicode-property-aliases-ecmascript@2.1.0: {} + + unique-string@2.0.0: + dependencies: + crypto-random-string: 2.0.0 + + universalify@2.0.1: {} + + upath@1.2.0: {} + update-browserslist-db@1.1.3(browserslist@4.25.0): dependencies: browserslist: 4.25.0 escalade: 3.2.0 picocolors: 1.1.1 + update-browserslist-db@1.1.3(browserslist@4.25.1): + dependencies: + browserslist: 4.25.1 + escalade: 3.2.0 + picocolors: 1.1.1 + uri-js@4.4.1: dependencies: punycode: 2.3.1 + url-regex@3.2.0: + dependencies: + ip-regex: 1.0.3 + use-debounce@10.0.5(react@19.1.0): dependencies: react: 19.1.0 @@ -3039,7 +6532,26 @@ snapshots: uuid@11.1.0: {} - vite@6.3.5(@types/node@22.15.30)(jiti@2.4.2)(lightningcss@1.30.1): + uuid@3.4.0: {} + + verror@1.10.0: + dependencies: + assert-plus: 1.0.0 + core-util-is: 1.0.2 + extsprintf: 1.3.0 + + vite-plugin-pwa@1.0.2(vite@6.3.5(@types/node@22.15.30)(jiti@2.4.2)(lightningcss@1.30.1)(terser@5.43.1))(workbox-build@7.3.0(@types/babel__core@7.20.5))(workbox-window@7.3.0): + dependencies: + debug: 4.4.1 + pretty-bytes: 6.1.1 + tinyglobby: 0.2.14 + vite: 6.3.5(@types/node@22.15.30)(jiti@2.4.2)(lightningcss@1.30.1)(terser@5.43.1) + workbox-build: 7.3.0(@types/babel__core@7.20.5) + workbox-window: 7.3.0 + transitivePeerDependencies: + - supports-color + + vite@6.3.5(@types/node@22.15.30)(jiti@2.4.2)(lightningcss@1.30.1)(terser@5.43.1): dependencies: esbuild: 0.25.5 fdir: 6.4.5(picomatch@4.0.2) @@ -3052,6 +6564,56 @@ snapshots: fsevents: 2.3.3 jiti: 2.4.2 lightningcss: 1.30.1 + terser: 5.43.1 + + webidl-conversions@4.0.2: {} + + whatwg-url@7.1.0: + dependencies: + lodash.sortby: 4.7.0 + tr46: 1.0.1 + webidl-conversions: 4.0.2 + + which-boxed-primitive@1.1.1: + dependencies: + is-bigint: 1.1.0 + is-boolean-object: 1.2.2 + is-number-object: 1.1.1 + is-string: 1.1.1 + is-symbol: 1.1.1 + + which-builtin-type@1.2.1: + dependencies: + call-bound: 1.0.4 + function.prototype.name: 1.1.8 + has-tostringtag: 1.0.2 + is-async-function: 2.1.1 + is-date-object: 1.1.0 + is-finalizationregistry: 1.1.1 + is-generator-function: 1.1.0 + is-regex: 1.2.1 + is-weakref: 1.1.1 + isarray: 2.0.5 + which-boxed-primitive: 1.1.1 + which-collection: 1.0.2 + which-typed-array: 1.1.19 + + which-collection@1.0.2: + dependencies: + is-map: 2.0.3 + is-set: 2.0.3 + is-weakmap: 2.0.2 + is-weakset: 2.0.4 + + which-typed-array@1.1.19: + dependencies: + available-typed-arrays: 1.0.7 + call-bind: 1.0.8 + call-bound: 1.0.4 + for-each: 0.3.5 + get-proto: 1.0.1 + gopd: 1.2.0 + has-tostringtag: 1.0.2 which@2.0.2: dependencies: @@ -3059,6 +6621,139 @@ snapshots: word-wrap@1.2.5: {} + workbox-background-sync@7.3.0: + dependencies: + idb: 7.1.1 + workbox-core: 7.3.0 + + workbox-broadcast-update@7.3.0: + dependencies: + workbox-core: 7.3.0 + + workbox-build@7.3.0(@types/babel__core@7.20.5): + dependencies: + '@apideck/better-ajv-errors': 0.3.6(ajv@8.17.1) + '@babel/core': 7.27.4 + '@babel/preset-env': 7.28.0(@babel/core@7.27.4) + '@babel/runtime': 7.28.2 + '@rollup/plugin-babel': 5.3.1(@babel/core@7.27.4)(@types/babel__core@7.20.5)(rollup@2.79.2) + '@rollup/plugin-node-resolve': 15.3.1(rollup@2.79.2) + '@rollup/plugin-replace': 2.4.2(rollup@2.79.2) + '@rollup/plugin-terser': 0.4.4(rollup@2.79.2) + '@surma/rollup-plugin-off-main-thread': 2.2.3 + ajv: 8.17.1 + 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.2 + 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: 7.3.0 + workbox-broadcast-update: 7.3.0 + workbox-cacheable-response: 7.3.0 + workbox-core: 7.3.0 + workbox-expiration: 7.3.0 + workbox-google-analytics: 7.3.0 + workbox-navigation-preload: 7.3.0 + workbox-precaching: 7.3.0 + workbox-range-requests: 7.3.0 + workbox-recipes: 7.3.0 + workbox-routing: 7.3.0 + workbox-strategies: 7.3.0 + workbox-streams: 7.3.0 + workbox-sw: 7.3.0 + workbox-window: 7.3.0 + transitivePeerDependencies: + - '@types/babel__core' + - supports-color + + workbox-cacheable-response@7.3.0: + dependencies: + workbox-core: 7.3.0 + + workbox-core@7.3.0: {} + + workbox-expiration@7.3.0: + dependencies: + idb: 7.1.1 + workbox-core: 7.3.0 + + workbox-google-analytics@7.3.0: + dependencies: + workbox-background-sync: 7.3.0 + workbox-core: 7.3.0 + workbox-routing: 7.3.0 + workbox-strategies: 7.3.0 + + workbox-navigation-preload@7.3.0: + dependencies: + workbox-core: 7.3.0 + + workbox-precaching@7.3.0: + dependencies: + workbox-core: 7.3.0 + workbox-routing: 7.3.0 + workbox-strategies: 7.3.0 + + workbox-range-requests@7.3.0: + dependencies: + workbox-core: 7.3.0 + + workbox-recipes@7.3.0: + dependencies: + workbox-cacheable-response: 7.3.0 + workbox-core: 7.3.0 + workbox-expiration: 7.3.0 + workbox-precaching: 7.3.0 + workbox-routing: 7.3.0 + workbox-strategies: 7.3.0 + + workbox-routing@7.3.0: + dependencies: + workbox-core: 7.3.0 + + workbox-strategies@7.3.0: + dependencies: + workbox-core: 7.3.0 + + workbox-streams@7.3.0: + dependencies: + workbox-core: 7.3.0 + workbox-routing: 7.3.0 + + workbox-sw@7.3.0: {} + + workbox-window@7.3.0: + dependencies: + '@types/trusted-types': 2.0.7 + workbox-core: 7.3.0 + + wrappy@1.0.2: {} + + xhr@2.6.0: + dependencies: + global: 4.4.0 + is-function: 1.0.2 + parse-headers: 2.0.6 + xtend: 4.0.2 + + xml-parse-from-string@1.0.1: {} + + xml2js@0.5.0: + dependencies: + sax: 1.4.1 + xmlbuilder: 11.0.1 + + xmlbuilder@11.0.1: {} + + xtend@4.0.2: {} + yallist@3.1.1: {} yallist@5.0.0: {} diff --git a/spotizerr-ui/pnpm-workspace.yaml b/spotizerr-ui/pnpm-workspace.yaml new file mode 100644 index 0000000..fc3aeab --- /dev/null +++ b/spotizerr-ui/pnpm-workspace.yaml @@ -0,0 +1,2 @@ +ignoredBuiltDependencies: + - sharp diff --git a/spotizerr-ui/public/apple-touch-icon-180x180.png b/spotizerr-ui/public/apple-touch-icon-180x180.png new file mode 100644 index 0000000000000000000000000000000000000000..1a80da12ec74d63e303d846ef4d80b574edddaa5 GIT binary patch literal 4980 zcmds5=RX`w*WOiD&nnTQB%(ZeU7cMKEkuo8m#|nh2v#R*1PLOdmvF1mg0Ol^)abqU z5`<-Cm3Qy2@9+5wo)2f{e3>(6=FBvo5w#g zg@8h48nk2Y-#q@`Qi`kzeNdS2)}-^dK~>$?0S z40Kfa?)qZN#D>|x#Kh$MpUI}lsi~Lk*MAapGDJIt+pzG3z=KM+s^;zZ17f{K{#i6= zcT@={$bWcuiyQr-o4c%28pSN(SpPO7x1!b0&rj`A%x%721B+TxKqe77<;#~ds^ zoFyyqS2f1_YU|@dS$S3FZjHt8{XKf#-JDM8ZAwxo7NfaPR z2{UP^537ZK!s76DmMb5g*JsQ$Oq&lX-JDM_32)Pc+4!%$`Sy3ee5S!9vV|(Q<@a~j z#e_$0jZ1z~oe)XD2buBGG3@j&XI4;QLag#$qsYc7!nq#A^n{S>syIMiSm- zzf3oS=ep>U&Gap|KkZYNsW`zsGxhP2*Yub3Ji% z8wbCLn%Cn6XfZr_&!9J}kzfWXc~Yr%)bHk<0$4%J$Ym6U){aHq4@uxi31>7%EHx9Rhh@KJgODN+JUQaCQSH3~WV73JUJpT=QT%kNqp=_ScPBM83@>aa%L z@*fSulIIQiPh$MajXXYfoq6Jp8W(tTgWh`{=fgU*VH>?Sfld3wJ{CZO+4Gb7pc~AL z*QZA!9&J~So5c^$&2*(#L`M}b7qPcy7a6`t&?K4wvC`dkKK_gw<;?Tk{VT8|>E@&x ztd8#grOv@NH{U>RcJ>(xk6#RMCHY8vPF7#hySf<^X@AhX ztktPc_V1N;O{lCWRc+}&ta0fU?s22p#0}Cqw#qm)D%Q`s138k)fy85N2CH@4fGr-r z6GbN))=$@lKt z%_Ui;81)*F-ARoa|EzksjPmF@RIx9*EGYrSp+N|nQt6eTS4OrW@!uYJ7Jn&lrDvt& z3Wf)mF^d;$p79CW zj^D*pTILU6xK;4`Zow&M{i0#SOizd0Qmhs%cq`3>CvdNBL{8uo9VTqxY2n`dQbAxw zu#}9Lh0*pQvf>(_yF58jrQCdRJOJADr$Mqt1n0ER1XEDjo#Mf(;UwO`VYO&i(Rajq z_)xvgDcg(Y%S%vLH}zK(0|*-LF#&37TdOZJ?B8iVFiCRt`cpug_o)$IzI$u70#Lip zM9`96*$NnyY7*35Bv?u2UpMsq@uphQw|@`3iZ36}R-7-mw+QL)9S&1B^aV|2`s-%Y z|Kq4Pps@6MB{;5?@!8NBWC8hsRn6Ky?S*mNHgFb^=-khkM zcv;8d2{dt&sk5gU`fNo0*ChsFt3blz9+YRejF9hwAZNesG9A00$I>z!3>t(0|C_2D_2uRb1?} zzMp1#?&bqY6Nn;lW&){A^^%1px0BZ9<4NUEuO_M3d^h8!!vJx=OO*n*34{wfjJ- zOkKXmlbQ`XhZ9gPP&j~^Agq_UI?$4k#>KKJAxee@3|6kjS0N&YhQ|={*)K{WtqghR zm*_?BLGD!{kZ=2=OS5N`pfgCwHCE=1BlOyqX*7QV_KI!bgr=aie6^t5ML;cSTRMiEV3Y(uWl z-W1k9Ew3Fek-bYwl@` zwK{Uv)n7SdOrk(qd&Twc5$p!TP~ACZu*u=x>T>i)iCB^X4EwW3tpOg#lMV*9ex{8; zA&SC;K``Zw7rr#w6r{ZPATuV92T{76ZC(Y^Tb9u4)0p6sPLhjx*XlX8*Nb*B?16~Q z8pNx__7uD9A;v$0a!^@2V0f4?7lF@u9IxYic@(Q6)6s54BH3Ad8qnsXaV6xlsC-j0 zr($UrG}YF4pNn@0&u)UGSyOX$m988Jb}Mk|n~T`f4K9h;#P9lp6GT2#@U_K&o$RLq zX=urBjHa)beCb3dy@wB~T7-dY#%eh7Evc`Q@i~mg2SRDPB0Gn9N%W^P9gh|zTlbn= z2BeGP=y=thRr!lxqRpW*oW^|eW#zJP8nBSdGxhv1W))QTQf& zcJ=2%a%S~3blk%4ipiBAmb8VK!ITq7FdD~8WpbKY_bXUihE}O2qGYn{K5(fET4#&S zPE3)G_$*3hn0V4o6g7ihi)Mw-2Cs?wD*8naNN%8v?q;GPa{%*s$vx+-tNXra1lT5TIbv}lE4d#ldbYzeNQ~Cab+I~ox z$#dRq8alP9`SIHy>s++VO7j}T#PuTD3iC8|Z&Mp2^y_+p)6P2fOg7MTexx!f=ByBjJ2 z+y83#rTxa!63@`$wCuL>KXzSaeJYm(eW!tMIRcNmp?fMD1dFX=3wxJeI&@^*7n^GJ zoGPt`_A*!q)&zoBA%Ekzf!TD9f;th-DWHfnRng4TvM7Tqwbc*?hdoSk$kTx0 zbwx0fXrAEYb&E}L_RjZKkZ}iYnHlY?n}(u>PV~vIh7oE-gddfTqwNI%!)(!7l@Qs@ z%4sBitsiTS6V?4IpTYT7^kQ?3Z$$2xitZAfJP$FkPv9??>3V5_d;LX(QJLHj zRb;pxIl_JTseJ0yXp72Hf27a-s%AV2bF*kOjLkC4-08BfD6e1#mz%9Sp9hm882I3E z3E^vZ@61$Hw=t?oDJ2iRl@kp-F5!`?)y*Sv2S!uRaM{Ija&iSauWPFYSJac(tr!p- z8;QY1ibJN`Zxl&_*~oUudxHP-hthwHB44^Q9zpqdtzh5T4y>dg#-p8~SKoN9Cvlun z+A&Rj&$|J{~~*qLBA^#H%E6E>71T|95ENBA2UKs9)8p5cpX@2 zK@ZP=XdFiTxuoDGe%G;Vyf3Yxpd|yFZW5u0|LyJivh!8bn^=m)H=L~2NkETth>JM% zxV-P_GN;R;oZ4Pli7Zzb)SqGrh5~zFQK_>4(#6St3=8KBhLpb8eC&krIU4DI2{Gu$ z)ti{wy_q%Y3J7pVVh8SA`%^UOSFl{j5drp0$9BLx0T(2|>r!|WPos(fvfrszO- z`8>5i#Af5*OG&Fb+j}6yo&VWImVw_sze48;#1gqb(Ebqkye)MgGLGq0MP}!3J%yZQ z%2X-oWF*fJ3^=UPL(6fv*B4>DpX11oV?BHMPJ|jRg8I8x(r*j5e{d*H42}*>6o)#_ zJmzg&O(cZ;!}ClpnB%Ccr+ z6D*}4fC;qIE8Q1tx*8{obklzG3XJSpMA8-N0*1S`%coAfA0Qighs{#8cqIdyE~vdJ zMu~I$ENwD!9wMcPDJ1hR!ZrNqSuP^G1sSYmqoq8?2Q<_lc&Tpoc6_cAJ&kxFvbWqg z>ndcf2_rlbD41eTM8n*eTcjJl|0Nnr&E-p;e^%BASS$%o@A?>)F8G)X@k8bP|CVB~ o6qa5Tj#mAzO{o9ZpSmObqRaHQGwZ+!-$nyyK7FoQrD7ZLe+d?If&c&j literal 0 HcmV?d00001 diff --git a/spotizerr-ui/public/favicon-128x128.png b/spotizerr-ui/public/favicon-128x128.png new file mode 100644 index 0000000000000000000000000000000000000000..61bb429135f25bd335d3a2a8f2c38e3d95f69893 GIT binary patch literal 3150 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 I(f5e|A2FlK761SM literal 0 HcmV?d00001 diff --git a/spotizerr-ui/public/favicon-16x16.png b/spotizerr-ui/public/favicon-16x16.png new file mode 100644 index 0000000000000000000000000000000000000000..97c1d8dfdcd8e8eb4ff8d38640abf023bd68e792 GIT binary patch literal 387 zcmV-}0et?6P)T=E9u0%>9N)$_M@fd7FR`@@H-e z7>2pauLR@?*P@<)Wmyac14xpD$z(#APN$Tw+GsR-ESSw^D9aL-Wl?kk2a9tO+ zZ9~(vOD8`B%(poVL!8fNY`0qkL4dC7=wZikuwJiW7zVwl*8#_Iw76QWa5x;0rYUy2 z9g-wLp656okC0^&CqA1d-2!cTO!{P99(Ze8-S99f8Vj`gJ0^9%q002ovPDHLkV1jU_r(6I4 literal 0 HcmV?d00001 diff --git a/spotizerr-ui/public/favicon-256x256.png b/spotizerr-ui/public/favicon-256x256.png new file mode 100644 index 0000000000000000000000000000000000000000..f28e458be7c08e4c66abdd3a05cdc5672a86dd10 GIT binary patch literal 6815 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 literal 0 HcmV?d00001 diff --git a/spotizerr-ui/public/favicon.ico b/spotizerr-ui/public/favicon.ico old mode 100755 new mode 100644 index fa67ed9b119d65aa0890d28eab48190734d78dfa..940c2eb7005bae70a6cdf9808fc5ac1b8c7536f9 GIT binary patch literal 14510 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 Gr+)*8fT7j^ diff --git a/spotizerr-ui/public/pwa-192x192.png b/spotizerr-ui/public/pwa-192x192.png new file mode 100644 index 0000000000000000000000000000000000000000..db1a7a7a73bd07ebfb9e8a1e08d294aa729093ee GIT binary patch literal 4892 zcmdT|X*ApGxBdkoDKXbn(@|3!LnxA(5;3c}ic&-PQ%X_MikgC$r}m&YHMgd=W=ah; zmHL-sC?##pb4!J$H6^$?_v^hM?ppWDy&v|w*Lv6f@b0zu^X&aT$<~&}uyZ2k004lQ zni$wJe9u1yVP%}Qv;J%h2Msd0i3b4Y&3_Ek5^n1U0KB8726}dcf**z8SE8Q;2i?H% z;JsyT1#5ZhS=(5a&|DTS`;s=+&`Z53S|lbIXK$>2y=3nfHkkEn4ZjcV^+9o9<3iBw zcGV`W4%#t#!6NE&B<;cNoe`ad9Q;_<)_VX>+nN(+A|z)l(t^OxPU%-rArYP$;zhA6hO+ zeFcCu20x;bDF5iQ_tU?}P%CLSD9Cr?zWPXIK%nmfyl%VuX#K)jKNtFt@|HFleRgtC zX8QK{JN#@ZQR4V^apd$u1oiKz!`-E*boJ?7W>$_Q3fhS|sdSPx&=ru+D=HGtRJ;Fu zYV$_*A;a69{add1@MUfLhq|Uw&4#^aq7Sd9x?2K_n-|4uzP5HI<+hhDSE+T$lvCsB zmiej!Rz=!xWR4WR>t>skSN*x9vU@PB+`Zkp5Jhu@5PrZsS@2Ab-uYg15|nS5iHjWu z1;@+MnMn~f9JoQ;qFi3xk#sUpNWeJO1Y;J z^{7~O#i>W*(nQupi?`d2!@PqxOj%}J!|(e0{E!zd@@$=ZkV>PyQjv(*?KOD$u9jJ@ zWVdKAZ|2Ok226gqRdYqyo3Nv+7xfVjN>zNF*L|}8b;Xay$m1C`?E+GX*R9gP-4>{t zyW9f!@|5&=7v7&X&}%JoHn@1}Zp$aSL^Pczl<$$!+r#CD=8OtbUI4-L9-wA6F5v)jhTFU2O7B%VR3Jx1b8~nPH9mq=}1euuFIANbGnEw z6}b>`Wk*)hC8!tNU^9Ur1i13G8!(zDV)f3g(7F33DezjMbUc>%m6u&QgxIY&pX(fO zwfppVi}uOEZEo!9M!`Mt$z}JK#Di-J4W#Ik-!ptths&wT^pDq+=N|Cn@nRfH5Vd#a zN}3_N$Bb4v77Lx77`rm24OQXKDW0@K>)^O|feE3Hef{A=voPfBBKqXl^|LYb*}Jd= zg1dR>LS*YgP(KWwQXvdNC~Ixk>q|Qpb=X}#s_Q=0ywf00GTT_)vxe&Yp1Pjw_fK*j zd#{HhwTPF9`$1^&0Y$CmGjcU}JP{ZQ=NQKa`{+A#9Xrq`irbX$jKpo8DFRG|2 zo8)2s3Y`z*J6eOMZ4F)sEHG;O7NLrx*Kd}k+N-U1GL_gYw}&l|D~p|?3?FV3hSH@{ z6>L8}3Nt5J_b7^_EFN#w)m;{cmMq#6TLNnAiQvNhe!)U4^L*sN9N*D%6@`{5Tbo=C zXjo}@HtSGluvE%Syzah}U(Jn)`o?p_I@*s`w}>&!ac9NV*gc4ACIGdg zw`FTl&x--oV-P)&j5yD@7r7q?Z>X8nb^iRIHYeUWiaw*;bi!ceU&u0rZX)Mrs}Mh% zA&n4XSP#l;o7`}pGPC;gYUmf=%D)mu#*k$9xGM1C87koAIk5Xg zKrpz&iCKid6F$O~?%fL(OruVjle|%mHT-Gz*MQQkoUp$?g4=(7fInNX!Q5PKMoAhy z+#3*dcHQU2n6c!MdokJZq7OBla(oaF$!EO?^wWTL--29kYA;oCT0Rr#qy1v^`X|v; zbH&yY)F=bvxu47P#n};r3>Fv*4w3tK~6EvW)Ix6ihdTp&hrqRA@-=m@tAQcNzc2Ty?Lv)!{`j|p^XKJ zGI)Lx;{Lb#jCsNBEDMcl9|B!>IZUbRm+je32gPV+lEK!n=~l8w>a7HcKKxwpu;RU< zhD|m<4iTLSmT`AD(P5UCq%eq5!14 z_K6_01l)plWlW%Tl;#zVxFOXyS-(Y5tlm2L*3@zsM~g)Fq&Xb3M?YN2On$>EBG!+6 zG`{>dgZJ*`KL04fJbIl}eBc+H?75lFUMHv(W&+%m`jJ(!L5km-52p;cWP3lbSqU@B z6c@W7e*9K#XjjV-e__4+aduH5OmJ$E@?IiZ`&7w(q0Pz-rY<d6h)2!;Fz)`3zoygU0~9NqB-G65+l+G62~&%}r<`At5hp)~m2Jp)AMS_&4e1g6 zuKYXge!f$V-P}c2(t4M+;hFCju&9uuk3ti+?&2}*4k`S4ZqSk@CinCt(|RX$DHu4_ zbCj_$RizUD;)xs9UPL0EpByZpHO2kz_$%ir1&Oc?%KE7IR24*&HB_$r+7o7NQ#&3H zk8{}8v#ZGKY^9wS!EWc%8b zvslIl?EyYCNBm|p#BsRKC5*wGMhylyS3egvj|}dAy&pJR+DkEeRV`;(K(-?@!6G_- zyiTR2Jhx8L;4?C*h+EQpyt(td6jveeHTR<31yDGDyyXlRs?CK+Dqs{$#|}pVa0syF*JXaXs9Rthp6t8H=vk z&sQYuw-8-Q*TFmqlt95vErn8vH8U!#ef!ck4XiJ-bJKFy-yoOlbC%W}A*O-9b+Q3l z(lwr=h?hZ4uM#DqP{+|)5`}iKT4!(g4O3vY;KgHl!sBP}Me!qQk4rzXAOdFFZso8H zB>!-Fgkneglj{=(;2Zh?JS;JM;iC38HQszk0axIFJfu8%6b*eDu=W z$8>3SHEU$Lr+XT#;!8u^y)JsNaiSBRNwi@3s5@QT4HY3TA)%UAEBWxl#vAIW7T?j! zoX}UH>pi)AgpTdTYjX<>(jv|=zxz6+S`}oS#%ATto$_9E>7MZqmQ2T3_>*gw{la`U zdqGL8UB9QDSB%weF#E+L8SL4Hwu&=|7E}5dBBN67-_xJSRp;A77iISHFBN|fSzit~#Q4Y=w|G?U76wVmIPu(l>2!SK*u((x-9zXB#0Kd_Y27qWo8DmTyTIIi@wn%4O{ zU$bzGkHH}DDeW?c*d|LD^K7GdE{>;@%SwCCKy(8?VJIlWVtuX%ZG9JcRRlea^(^2P zK^JfmUPNg5F?N;&K}b{AO~c)@0wLNvFwF{m65^3~?se?-57@>1j8`XtH0p9#JUQX|OFR!&jh_HM;lG?PC;J4|^o%KU&~kI1>Pp?Guw_=TNTj#;@6 zQ7d?LXsAYX2mj@plN-~}C8lYoJf1nfx~{Ty@uupajiqFj=@_o=jt(s+BtQ|?HrQMb zQVcxS-ItXn7D!1}4M;-#vjW6OYQL&K7DD^0!!Pn;n6aA{7KFeut2@_gEjQ%Y8Po(; zN(s}p&1FHHKr!ZL|KGHY|5l2*6?mS=9iXZIztMpHtCDmiQ6{$bI%;wQ$&kAMQ$tIG JTC98Qe*lzH>>dCB literal 0 HcmV?d00001 diff --git a/spotizerr-ui/public/pwa-512x512-maskable.png b/spotizerr-ui/public/pwa-512x512-maskable.png new file mode 100644 index 0000000000000000000000000000000000000000..a42d6331ed901cfef58eb13ee2f1fe20eb23f6cb GIT binary patch literal 16762 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 Wma*Rqe7gb!Jy6kBF1v5}`o95G;C1i- literal 0 HcmV?d00001 diff --git a/spotizerr-ui/public/pwa-512x512.png b/spotizerr-ui/public/pwa-512x512.png new file mode 100644 index 0000000000000000000000000000000000000000..e15944572456fe644848b80eaf5d3db0b295be72 GIT binary patch literal 17208 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 literal 0 HcmV?d00001 diff --git a/spotizerr-ui/public/spotizerr.png b/spotizerr-ui/public/spotizerr.png new file mode 100644 index 0000000000000000000000000000000000000000..c8a5679e6af616d74be2623fe8f4e9a16c4ca92b GIT binary patch literal 67022 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 literal 0 HcmV?d00001 diff --git a/spotizerr-ui/public/spotizerr.svg b/spotizerr-ui/public/spotizerr.svg new file mode 100644 index 0000000..1f62136 --- /dev/null +++ b/spotizerr-ui/public/spotizerr.svg @@ -0,0 +1,7 @@ + + + + + + + diff --git a/spotizerr-ui/scripts/generate-icons.js b/spotizerr-ui/scripts/generate-icons.js new file mode 100644 index 0000000..1d8dbe3 --- /dev/null +++ b/spotizerr-ui/scripts/generate-icons.js @@ -0,0 +1,199 @@ +import sharp from 'sharp'; +import { existsSync, writeFileSync } from 'fs'; +import { join, dirname } from 'path'; +import { fileURLToPath } from 'url'; +import toIco from 'to-ico'; + +const __filename = fileURLToPath(import.meta.url); +const __dirname = dirname(__filename); + +const publicDir = join(__dirname, '../public'); +const pngPath = join(publicDir, 'spotizerr.png'); + +async function generateIcons() { + try { + // Check if the PNG file exists + if (!existsSync(pngPath)) { + throw new Error(`PNG file not found at ${pngPath}. Please ensure spotizerr.png exists in the public directory.`); + } + + console.log('🎨 Generating PWA icons from PNG...'); + + // Since the source is already 1667x1667 (square), we don't need to worry about aspect ratio + const sourceSize = 1667; + + // Define icon configurations + const iconConfigs = [ + { + size: 16, + name: 'favicon-16x16.png', + padding: 0.1, // 10% padding for small icons + }, + { + size: 32, + name: 'favicon-32x32.png', + padding: 0.1, + }, + { + size: 180, + name: 'apple-touch-icon-180x180.png', + padding: 0.05, // 5% padding for Apple (they prefer less padding) + }, + { + size: 192, + name: 'pwa-192x192.png', + padding: 0.1, + }, + { + size: 512, + name: 'pwa-512x512.png', + padding: 0.1, + } + ]; + + // Load the source PNG + const sourceImage = sharp(pngPath); + + for (const config of iconConfigs) { + const { size, name, padding } = config; + + if (padding > 0) { + // Create icon with padding by compositing on a background + const paddedSize = Math.round(size * (1 - padding * 2)); + const offset = Math.round((size - paddedSize) / 2); + + // Create a black background and composite the resized logo on top + await sharp({ + create: { + width: size, + height: size, + channels: 4, + background: { r: 15, g: 23, b: 42, alpha: 1 } // #0f172a in RGB + } + }) + .composite([{ + input: await sourceImage.resize(paddedSize, paddedSize).png().toBuffer(), + top: offset, + left: offset + }]) + .png() + .toFile(join(publicDir, name)); + } else { + // Direct resize without padding + await sourceImage + .resize(size, size) + .png() + .toFile(join(publicDir, name)); + } + + console.log(`✅ Generated ${name} (${size}x${size}) - padding: ${padding * 100}%`); + } + + // Create maskable icon (less padding, solid background) + const maskableSize = 512; + const maskablePadding = 0.05; // 5% padding for maskable icons + const maskablePaddedSize = Math.round(maskableSize * (1 - maskablePadding * 2)); + const maskableOffset = Math.round((maskableSize - maskablePaddedSize) / 2); + + await sharp({ + create: { + width: maskableSize, + height: maskableSize, + channels: 4, + background: { r: 15, g: 23, b: 42, alpha: 1 } // Solid background for maskable + } + }) + .composite([{ + input: await sourceImage.resize(maskablePaddedSize, maskablePaddedSize).png().toBuffer(), + top: maskableOffset, + left: maskableOffset + }]) + .png() + .toFile(join(publicDir, 'pwa-512x512-maskable.png')); + + console.log(`✅ Generated pwa-512x512-maskable.png (${maskableSize}x${maskableSize}) - maskable`); + + // Generate additional favicon sizes for ICO compatibility + const additionalSizes = [48, 64, 96, 128, 256]; + for (const size of additionalSizes) { + const padding = size <= 48 ? 0.05 : 0.1; + const paddedSize = Math.round(size * (1 - padding * 2)); + const offset = Math.round((size - paddedSize) / 2); + + await sharp({ + create: { + width: size, + height: size, + channels: 4, + background: { r: 15, g: 23, b: 42, alpha: 1 } + } + }) + .composite([{ + input: await sourceImage.resize(paddedSize, paddedSize).png().toBuffer(), + top: offset, + left: offset + }]) + .png() + .toFile(join(publicDir, `favicon-${size}x${size}.png`)); + + console.log(`✅ Generated favicon-${size}x${size}.png (${size}x${size}) - padding: ${padding * 100}%`); + } + + // Generate favicon.ico with multiple sizes + console.log('🎯 Generating favicon.ico...'); + const icoSizes = [16, 32, 48]; + const icoBuffers = []; + + for (const size of icoSizes) { + const padding = 0.1; // 10% padding for ICO + const paddedSize = Math.round(size * (1 - padding * 2)); + const offset = Math.round((size - paddedSize) / 2); + + const buffer = await sharp({ + create: { + width: size, + height: size, + channels: 4, + background: { r: 15, g: 23, b: 42, alpha: 1 } + } + }) + .composite([{ + input: await sourceImage.resize(paddedSize, paddedSize).png().toBuffer(), + top: offset, + left: offset + }]) + .png() + .toBuffer(); + + icoBuffers.push(buffer); + } + + // Create the ICO file + const icoBuffer = await toIco(icoBuffers); + writeFileSync(join(publicDir, 'favicon.ico'), icoBuffer); + + console.log(`✅ Generated favicon.ico (${icoSizes.join('x, ')}x sizes) - multi-size ICO`); + + console.log('🎉 All PWA icons generated successfully!'); + console.log(''); + console.log('📋 Generated files:'); + iconConfigs.forEach(config => { + console.log(` • ${config.name} (${config.size}x${config.size})`); + }); + console.log(' • pwa-512x512-maskable.png (512x512)'); + additionalSizes.forEach(size => { + console.log(` • favicon-${size}x${size}.png (${size}x${size})`); + }); + console.log(' • favicon.ico (multi-size: 16x16, 32x32, 48x48)'); + console.log(''); + console.log('💡 The icons are generated with appropriate padding and the dark theme background.'); + console.log('💡 The source PNG already has the perfect background, so no additional styling needed.'); + console.log('💡 favicon.ico contains multiple sizes for optimal browser compatibility.'); + + } catch (error) { + console.error('❌ Error generating PWA icons:', error); + process.exit(1); + } +} + +generateIcons(); \ No newline at end of file diff --git a/spotizerr-ui/src/index.css b/spotizerr-ui/src/index.css index 8fd78e1..098f919 100644 --- a/spotizerr-ui/src/index.css +++ b/spotizerr-ui/src/index.css @@ -100,57 +100,57 @@ --color-icon-button-hover-dark: #334155; /* Icon Colors */ - --color-icon-primary: #475569; - --color-icon-primary-hover: #334155; - --color-icon-primary-active: #1e293b; - --color-icon-primary-dark: #cbd5e1; - --color-icon-primary-hover-dark: #e2e8f0; - --color-icon-primary-active-dark: #f8fafc; + --color-icon-primary: #000000; + --color-icon-primary-hover: #000000; + --color-icon-primary-active: #000000; + --color-icon-primary-dark: #ffffff; + --color-icon-primary-hover-dark: #ffffff; + --color-icon-primary-active-dark: #ffffff; - --color-icon-secondary: #64748b; - --color-icon-secondary-hover: #475569; - --color-icon-secondary-active: #334155; - --color-icon-secondary-dark: #94a3b8; - --color-icon-secondary-hover-dark: #cbd5e1; - --color-icon-secondary-active-dark: #e2e8f0; + --color-icon-secondary: #000000; + --color-icon-secondary-hover: #000000; + --color-icon-secondary-active: #000000; + --color-icon-secondary-dark: #ffffff; + --color-icon-secondary-hover-dark: #ffffff; + --color-icon-secondary-active-dark: #ffffff; - --color-icon-muted: #94a3b8; - --color-icon-muted-hover: #64748b; - --color-icon-muted-active: #475569; - --color-icon-muted-dark: #64748b; - --color-icon-muted-hover-dark: #94a3b8; - --color-icon-muted-active-dark: #cbd5e1; + --color-icon-muted: #000000; + --color-icon-muted-hover: #000000; + --color-icon-muted-active: #000000; + --color-icon-muted-dark: #ffffff; + --color-icon-muted-hover-dark: #ffffff; + --color-icon-muted-active-dark: #ffffff; - --color-icon-accent: #3b82f6; - --color-icon-accent-hover: #2563eb; - --color-icon-accent-active: #1d4ed8; - --color-icon-accent-dark: #60a5fa; - --color-icon-accent-hover-dark: #93c5fd; - --color-icon-accent-active-dark: #bfdbfe; + --color-icon-accent: #000000; + --color-icon-accent-hover: #000000; + --color-icon-accent-active: #000000; + --color-icon-accent-dark: #ffffff; + --color-icon-accent-hover-dark: #ffffff; + --color-icon-accent-active-dark: #ffffff; - --color-icon-success: #22c55e; - --color-icon-success-hover: #16a34a; - --color-icon-success-active: #15803d; - --color-icon-success-dark: #4ade80; - --color-icon-success-hover-dark: #86efac; - --color-icon-success-active-dark: #bbf7d0; + --color-icon-success: #000000; + --color-icon-success-hover: #000000; + --color-icon-success-active: #000000; + --color-icon-success-dark: #ffffff; + --color-icon-success-hover-dark: #ffffff; + --color-icon-success-active-dark: #ffffff; - --color-icon-error: #ef4444; - --color-icon-error-hover: #dc2626; - --color-icon-error-active: #b91c1c; - --color-icon-error-dark: #f87171; - --color-icon-error-hover-dark: #fca5a5; - --color-icon-error-active-dark: #fecaca; + --color-icon-error: #000000; + --color-icon-error-hover: #000000; + --color-icon-error-active: #000000; + --color-icon-error-dark: #ffffff; + --color-icon-error-hover-dark: #ffffff; + --color-icon-error-active-dark: #ffffff; - --color-icon-warning: #f59e0b; - --color-icon-warning-hover: #d97706; - --color-icon-warning-active: #b45309; - --color-icon-warning-dark: #fbbf24; - --color-icon-warning-hover-dark: #fcd34d; - --color-icon-warning-active-dark: #fde68a; + --color-icon-warning: #000000; + --color-icon-warning-hover: #000000; + --color-icon-warning-active: #000000; + --color-icon-warning-dark: #ffffff; + --color-icon-warning-hover-dark: #ffffff; + --color-icon-warning-active-dark: #ffffff; --color-icon-inverse: #ffffff; - --color-icon-inverse-dark: #0f172a; + --color-icon-inverse-dark: #000000; } @layer base { @@ -162,158 +162,158 @@ .icon-primary { fill: var(--color-icon-primary); color: var(--color-icon-primary); - filter: brightness(0) saturate(100%) invert(27%) sepia(8%) saturate(1363%) hue-rotate(183deg) brightness(96%) contrast(89%); + filter: brightness(0); } .dark .icon-primary { fill: var(--color-icon-primary-dark); color: var(--color-icon-primary-dark); - filter: brightness(0) saturate(100%) invert(83%) sepia(8%) saturate(1018%) hue-rotate(183deg) brightness(96%) contrast(91%); + filter: brightness(0) invert(100%); } .icon-primary:hover { fill: var(--color-icon-primary-hover); color: var(--color-icon-primary-hover); - filter: brightness(0) saturate(100%) invert(21%) sepia(12%) saturate(1190%) hue-rotate(183deg) brightness(96%) contrast(92%); + filter: brightness(0); } .dark .icon-primary:hover { fill: var(--color-icon-primary-hover-dark); color: var(--color-icon-primary-hover-dark); - filter: brightness(0) saturate(100%) invert(90%) sepia(6%) saturate(668%) hue-rotate(183deg) brightness(97%) contrast(91%); + filter: brightness(0) invert(100%); } .icon-secondary { fill: var(--color-icon-secondary); color: var(--color-icon-secondary); - filter: brightness(0) saturate(100%) invert(48%) sepia(14%) saturate(725%) hue-rotate(183deg) brightness(94%) contrast(88%); + filter: brightness(0); } .dark .icon-secondary { fill: var(--color-icon-secondary-dark); color: var(--color-icon-secondary-dark); - filter: brightness(0) saturate(100%) invert(69%) sepia(11%) saturate(763%) hue-rotate(183deg) brightness(93%) contrast(89%); + filter: brightness(0) invert(100%); } .icon-secondary:hover { fill: var(--color-icon-secondary-hover); color: var(--color-icon-secondary-hover); - filter: brightness(0) saturate(100%) invert(27%) sepia(8%) saturate(1363%) hue-rotate(183deg) brightness(96%) contrast(89%); + filter: brightness(0); } .dark .icon-secondary:hover { fill: var(--color-icon-secondary-hover-dark); color: var(--color-icon-secondary-hover-dark); - filter: brightness(0) saturate(100%) invert(83%) sepia(8%) saturate(1018%) hue-rotate(183deg) brightness(96%) contrast(91%); + filter: brightness(0) invert(100%); } .icon-muted { fill: var(--color-icon-muted); color: var(--color-icon-muted); - filter: brightness(0) saturate(100%) invert(69%) sepia(11%) saturate(763%) hue-rotate(183deg) brightness(93%) contrast(89%); + filter: brightness(0); } .dark .icon-muted { fill: var(--color-icon-muted-dark); color: var(--color-icon-muted-dark); - filter: brightness(0) saturate(100%) invert(48%) sepia(14%) saturate(725%) hue-rotate(183deg) brightness(94%) contrast(88%); + filter: brightness(0) invert(100%); } .icon-muted:hover { fill: var(--color-icon-muted-hover); color: var(--color-icon-muted-hover); - filter: brightness(0) saturate(100%) invert(48%) sepia(14%) saturate(725%) hue-rotate(183deg) brightness(94%) contrast(88%); + filter: brightness(0); } .dark .icon-muted:hover { fill: var(--color-icon-muted-hover-dark); color: var(--color-icon-muted-hover-dark); - filter: brightness(0) saturate(100%) invert(69%) sepia(11%) saturate(763%) hue-rotate(183deg) brightness(93%) contrast(89%); + filter: brightness(0) invert(100%); } .icon-accent { fill: var(--color-icon-accent); color: var(--color-icon-accent); - filter: brightness(0) saturate(100%) invert(41%) sepia(96%) saturate(1347%) hue-rotate(215deg) brightness(99%) contrast(86%); + filter: brightness(0); } .dark .icon-accent { fill: var(--color-icon-accent-dark); color: var(--color-icon-accent-dark); - filter: brightness(0) saturate(100%) invert(67%) sepia(25%) saturate(2334%) hue-rotate(215deg) brightness(102%) contrast(96%); + filter: brightness(0) invert(100%); } .icon-accent:hover { fill: var(--color-icon-accent-hover); color: var(--color-icon-accent-hover); - filter: brightness(0) saturate(100%) invert(29%) sepia(81%) saturate(2476%) hue-rotate(215deg) brightness(98%) contrast(86%); + filter: brightness(0); } .dark .icon-accent:hover { fill: var(--color-icon-accent-hover-dark); color: var(--color-icon-accent-hover-dark); - filter: brightness(0) saturate(100%) invert(75%) sepia(28%) saturate(1388%) hue-rotate(215deg) brightness(104%) contrast(96%); + filter: brightness(0) invert(100%); } .icon-success { fill: var(--color-icon-success); color: var(--color-icon-success); - filter: brightness(0) saturate(100%) invert(47%) sepia(95%) saturate(450%) hue-rotate(92deg) brightness(98%) contrast(91%); + filter: brightness(0); } .dark .icon-success { fill: var(--color-icon-success-dark); color: var(--color-icon-success-dark); - filter: brightness(0) saturate(100%) invert(64%) sepia(78%) saturate(394%) hue-rotate(92deg) brightness(101%) contrast(89%); + filter: brightness(0) invert(100%); } .icon-success:hover { fill: var(--color-icon-success-hover); color: var(--color-icon-success-hover); - filter: brightness(0) saturate(100%) invert(42%) sepia(78%) saturate(440%) hue-rotate(92deg) brightness(96%) contrast(89%); + filter: brightness(0); } .dark .icon-success:hover { fill: var(--color-icon-success-hover-dark); color: var(--color-icon-success-hover-dark); - filter: brightness(0) saturate(100%) invert(75%) sepia(64%) saturate(295%) hue-rotate(92deg) brightness(103%) contrast(87%); + filter: brightness(0) invert(100%); } .icon-error { fill: var(--color-icon-error); color: var(--color-icon-error); - filter: brightness(0) saturate(100%) invert(30%) sepia(93%) saturate(1742%) hue-rotate(339deg) brightness(98%) contrast(94%); + filter: brightness(0); } .dark .icon-error { fill: var(--color-icon-error-dark); color: var(--color-icon-error-dark); - filter: brightness(0) saturate(100%) invert(62%) sepia(93%) saturate(1360%) hue-rotate(339deg) brightness(99%) contrast(96%); + filter: brightness(0) invert(100%); } .icon-error:hover { fill: var(--color-icon-error-hover); color: var(--color-icon-error-hover); - filter: brightness(0) saturate(100%) invert(17%) sepia(95%) saturate(2341%) hue-rotate(339deg) brightness(96%) contrast(94%); + filter: brightness(0); } .dark .icon-error:hover { fill: var(--color-icon-error-hover-dark); color: var(--color-icon-error-hover-dark); - filter: brightness(0) saturate(100%) invert(74%) sepia(29%) saturate(1214%) hue-rotate(339deg) brightness(99%) contrast(94%); + filter: brightness(0) invert(100%); } .icon-warning { fill: var(--color-icon-warning); color: var(--color-icon-warning); - filter: brightness(0) saturate(100%) invert(67%) sepia(98%) saturate(1284%) hue-rotate(12deg) brightness(95%) contrast(92%); + filter: brightness(0); } .dark .icon-warning { fill: var(--color-icon-warning-dark); color: var(--color-icon-warning-dark); - filter: brightness(0) saturate(100%) invert(84%) sepia(36%) saturate(1043%) hue-rotate(12deg) brightness(97%) contrast(91%); + filter: brightness(0) invert(100%); } .icon-warning:hover { fill: var(--color-icon-warning-hover); color: var(--color-icon-warning-hover); - filter: brightness(0) saturate(100%) invert(58%) sepia(89%) saturate(1619%) hue-rotate(12deg) brightness(94%) contrast(96%); + filter: brightness(0); } .dark .icon-warning:hover { fill: var(--color-icon-warning-hover-dark); color: var(--color-icon-warning-hover-dark); - filter: brightness(0) saturate(100%) invert(89%) sepia(21%) saturate(789%) hue-rotate(12deg) brightness(98%) contrast(88%); + filter: brightness(0) invert(100%); } .icon-inverse { fill: var(--color-icon-inverse); color: var(--color-icon-inverse); - filter: brightness(0) saturate(100%) invert(100%); + filter: brightness(0) invert(100%); } .dark .icon-inverse { fill: var(--color-icon-inverse-dark); color: var(--color-icon-inverse-dark); - filter: brightness(0) saturate(100%) invert(5%) sepia(8%) saturate(7470%) hue-rotate(183deg) brightness(97%) contrast(108%); + filter: brightness(0); } } diff --git a/spotizerr-ui/src/main.tsx b/spotizerr-ui/src/main.tsx index 6ace0a2..8f8ca28 100644 --- a/spotizerr-ui/src/main.tsx +++ b/spotizerr-ui/src/main.tsx @@ -1,11 +1,51 @@ import React from "react"; import ReactDOM from "react-dom/client"; import { RouterProvider } from "@tanstack/react-router"; +import { QueryClient, QueryClientProvider } from "@tanstack/react-query"; import { router } from "./router"; import "./index.css"; +// Dark mode detection and setup +function setupDarkMode() { + // Check for saved theme preference or default to system preference + const savedTheme = localStorage.getItem('theme'); + const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches; + + if (savedTheme === 'dark' || (!savedTheme && prefersDark)) { + document.documentElement.classList.add('dark'); + } else { + document.documentElement.classList.remove('dark'); + } + + // Listen for system theme changes + window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', (e) => { + if (!localStorage.getItem('theme')) { + if (e.matches) { + document.documentElement.classList.add('dark'); + } else { + document.documentElement.classList.remove('dark'); + } + } + }); +} + +// Initialize dark mode +setupDarkMode(); + +// Create a QueryClient instance +const queryClient = new QueryClient({ + defaultOptions: { + queries: { + staleTime: 1000 * 60 * 5, // 5 minutes + refetchOnWindowFocus: false, + }, + }, +}); + ReactDOM.createRoot(document.getElementById("root")!).render( - + + + , ); diff --git a/spotizerr-ui/src/router.tsx b/spotizerr-ui/src/router.tsx index 929a351..4050e3c 100644 --- a/spotizerr-ui/src/router.tsx +++ b/spotizerr-ui/src/router.tsx @@ -1,5 +1,5 @@ import { createRouter, createRootRoute, createRoute } from "@tanstack/react-router"; -import { Root } from "./routes/root"; +import Root from "./routes/root"; import { Album } from "./routes/album"; import { Artist } from "./routes/artist"; import { Track } from "./routes/track"; diff --git a/spotizerr-ui/src/routes/playlist.tsx b/spotizerr-ui/src/routes/playlist.tsx index 8c55aa5..442e1fe 100644 --- a/spotizerr-ui/src/routes/playlist.tsx +++ b/spotizerr-ui/src/routes/playlist.tsx @@ -3,7 +3,7 @@ import { useEffect, useState, useContext, useRef, useCallback } from "react"; import apiClient from "../lib/api-client"; import { useSettings } from "../contexts/settings-context"; import { toast } from "sonner"; -import type { PlaylistType, TrackType, PlaylistMetadataType, PlaylistTracksResponseType, PlaylistItemType } from "../types/spotify"; +import type { TrackType, PlaylistMetadataType, PlaylistTracksResponseType, PlaylistItemType } from "../types/spotify"; import { QueueContext } from "../contexts/queue-context"; import { FaArrowLeft } from "react-icons/fa"; import { FaDownload } from "react-icons/fa6"; diff --git a/spotizerr-ui/src/routes/root.tsx b/spotizerr-ui/src/routes/root.tsx index c2656da..a4b9159 100644 --- a/spotizerr-ui/src/routes/root.tsx +++ b/spotizerr-ui/src/routes/root.tsx @@ -1,61 +1,53 @@ -import { Outlet } from "@tanstack/react-router"; -import { QueueProvider } from "../contexts/QueueProvider"; -import { useQueue } from "../contexts/queue-context"; -import { Queue } from "../components/Queue"; -import { Link } from "@tanstack/react-router"; -import { SettingsProvider } from "../contexts/SettingsProvider"; -import { Toaster } from "sonner"; -import { QueryClient, QueryClientProvider } from "@tanstack/react-query"; - -// Create a client -const queryClient = new QueryClient(); +import { Outlet, Link } from "@tanstack/react-router"; +import { QueueProvider } from "@/contexts/QueueProvider"; +import { SettingsProvider } from "@/contexts/SettingsProvider"; +import { QueueContext } from "@/contexts/queue-context"; +import { Queue } from "@/components/Queue"; +import { useContext } from "react"; function AppLayout() { - const { toggleVisibility } = useQueue(); + const { toggleVisibility } = useContext(QueueContext) || {}; return ( - <> -
-
-
- - Logo -

Spotizerr

+
+
+
+ + Logo +

Spotizerr

+ +
+ + Watchlist -
- - Watchlist - - - History - - - Settings - - -
+ + History + + + Settings + +
-
-
- -
-
+
+
+ +
+ +
+ - - +
); } -export const Root = () => { +export default function Root() { return ( - - - - - - - + + + + + ); -}; +} diff --git a/spotizerr-ui/vite.config.ts b/spotizerr-ui/vite.config.ts index a96df9a..0759fbf 100644 --- a/spotizerr-ui/vite.config.ts +++ b/spotizerr-ui/vite.config.ts @@ -3,13 +3,97 @@ import react from "@vitejs/plugin-react"; import { fileURLToPath } from "url"; import { dirname, resolve } from "path"; import tailwindcss from "@tailwindcss/vite"; +import { VitePWA } from "vite-plugin-pwa"; const __filename = fileURLToPath(import.meta.url); const __dirname = dirname(__filename); // https://vite.dev/config/ export default defineConfig({ - plugins: [react(), tailwindcss()], + plugins: [ + react(), + tailwindcss(), + VitePWA({ + registerType: 'autoUpdate', + includeAssets: ['favicon.ico', 'spotizerr.svg', '*.svg'], + injectRegister: 'auto', + manifest: { + name: 'Spotizerr', + short_name: 'Spotizerr', + description: 'Music downloader and manager for Spotify content', + theme_color: '#1e293b', + background_color: '#0f172a', + display: 'standalone', + scope: '/', + start_url: '/', + lang: 'en', + orientation: 'portrait-primary', + categories: ['music', 'entertainment', 'utilities'], + icons: [ + { + src: 'pwa-192x192.png', + sizes: '192x192', + type: 'image/png' + }, + { + src: 'pwa-512x512.png', + sizes: '512x512', + type: 'image/png' + }, + { + src: 'pwa-192x192.png', + sizes: '192x192', + type: 'image/png', + purpose: 'maskable' + }, + { + src: 'pwa-512x512.png', + sizes: '512x512', + type: 'image/png', + purpose: 'maskable' + }, + { + src: 'apple-touch-icon-180x180.png', + sizes: '180x180', + type: 'image/png' + } + ] + }, + workbox: { + globPatterns: ['**/*.{js,css,html,ico,png,svg,woff2}'], + navigateFallback: 'index.html', + navigateFallbackDenylist: [/^\/_/, /\/[^/?]+\.[^/]+$/], + runtimeCaching: [ + { + urlPattern: /^https:\/\/api\./i, + handler: 'NetworkFirst', + options: { + cacheName: 'api-cache', + expiration: { + maxEntries: 100, + maxAgeSeconds: 60 * 60 * 24 // 24 hours + } + } + }, + { + urlPattern: /\.(?:png|jpg|jpeg|svg|gif|webp)$/, + handler: 'CacheFirst', + options: { + cacheName: 'images-cache', + expiration: { + maxEntries: 500, + maxAgeSeconds: 60 * 60 * 24 * 30 // 30 days + } + } + } + ] + }, + devOptions: { + enabled: true, + type: 'module' + } + }) + ], resolve: { alias: { "@": resolve(__dirname, "./src"),