From 0350b80cdabc4b53795c66cfc8edce90780b2d61 Mon Sep 17 00:00:00 2001 From: Jonas Gerg Date: Tue, 21 Jul 2026 13:41:18 +0200 Subject: [PATCH] feat: make miniplan a PWA --- public/dev-dist/sw.js | 88 + public/dev-dist/workbox-7e5eb42b.js | 3395 +++++++++++ public/index.html | 7 +- public/package-lock.json | 5996 ++++++++++++++++++-- public/package.json | 5 +- public/public/apple-touch-icon-180x180.png | Bin 0 -> 2769 bytes public/public/favicon.ico | Bin 4286 -> 931 bytes public/public/logo.svg | 5 + public/public/maskable-icon-512x512.png | Bin 0 -> 9691 bytes public/public/minis_logo.png | Bin 0 -> 23066 bytes public/public/pwa-192x192.png | Bin 0 -> 4124 bytes public/public/pwa-512x512.png | Bin 0 -> 12070 bytes public/public/pwa-64x64.png | Bin 0 -> 891 bytes public/public/screenshot1.png | Bin 0 -> 60444 bytes public/public/screenshot2.png | Bin 0 -> 43665 bytes public/public/screenshot3.png | Bin 0 -> 65093 bytes public/src/assets/logo.svg | 6 +- public/src/main.ts | 13 + public/vite.config.ts | 65 +- 19 files changed, 9212 insertions(+), 368 deletions(-) create mode 100644 public/dev-dist/sw.js create mode 100644 public/dev-dist/workbox-7e5eb42b.js create mode 100644 public/public/apple-touch-icon-180x180.png create mode 100644 public/public/logo.svg create mode 100644 public/public/maskable-icon-512x512.png create mode 100644 public/public/minis_logo.png create mode 100644 public/public/pwa-192x192.png create mode 100644 public/public/pwa-512x512.png create mode 100644 public/public/pwa-64x64.png create mode 100644 public/public/screenshot1.png create mode 100644 public/public/screenshot2.png create mode 100644 public/public/screenshot3.png diff --git a/public/dev-dist/sw.js b/public/dev-dist/sw.js new file mode 100644 index 0000000..dd86a08 --- /dev/null +++ b/public/dev-dist/sw.js @@ -0,0 +1,88 @@ +/** + * 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-7e5eb42b'], (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": "index.html", + "revision": "0.dgdlb6t7e8s" + }], {}); + workbox.cleanupOutdatedCaches(); + workbox.registerRoute(new workbox.NavigationRoute(workbox.createHandlerBoundToURL("index.html"), { + allowlist: [/^\/$/] + })); + +})); diff --git a/public/dev-dist/workbox-7e5eb42b.js b/public/dev-dist/workbox-7e5eb42b.js new file mode 100644 index 0000000..5414d9f --- /dev/null +++ b/public/dev-dist/workbox-7e5eb42b.js @@ -0,0 +1,3395 @@ +define(['exports'], (function (exports) { 'use strict'; + + // @ts-ignore + try { + self['workbox:core:7.4.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. + */ + /** + * 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 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 = { + '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[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.4.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 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.4.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 = 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. + */ + function stripParams(fullURL, ignoreParams) { + const strippedURL = new URL(fullURL); + for (const param of ignoreParams) { + strippedURL.searchParams.delete(param); + } + return strippedURL.href; + } + /** + * Matches an item in the cache, ignoring specific URL params. This is similar + * to the `ignoreSearch` option, but it allows you to ignore just specific + * params (while continuing to match on the others). + * + * @private + * @param {Cache} cache + * @param {Request} request + * @param {Object} matchOptions + * @param {Array} ignoreParams + * @return {Promise} + */ + async function cacheMatchIgnoreParams(cache, request, ignoreParams, matchOptions) { + const strippedRequestURL = stripParams(request.url, ignoreParams); + // If the request doesn't include any ignored params, match as normal. + if (request.url === strippedRequestURL) { + return cache.match(request, matchOptions); + } + // Otherwise, match by comparing keys + const keysOptions = Object.assign(Object.assign({}, matchOptions), { + ignoreSearch: true + }); + const cacheKeys = await cache.keys(request, keysOptions); + for (const cacheKey of cacheKeys) { + const strippedCacheKeyURL = stripParams(cacheKey.url, ignoreParams); + if (strippedRequestURL === strippedCacheKeyURL) { + return cache.match(cacheKey, matchOptions); + } + } + return; + } + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * The Deferred class composes Promises in a way that allows for them to be + * resolved or rejected from outside the constructor. In most cases promises + * should be used directly, but Deferreds can be necessary when the logic to + * resolve a promise must be separate. + * + * @private + */ + class Deferred { + /** + * Creates a promise and exposes its resolve and reject functions as methods. + */ + constructor() { + this.promise = new Promise((resolve, reject) => { + this.resolve = resolve; + this.reject = reject; + }); + } + } + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + // Callbacks to be executed whenever there's a quota error. + // Can't change Function type right now. + // eslint-disable-next-line @typescript-eslint/ban-types + const quotaErrorCallbacks = new Set(); + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * Runs all of the callback functions, one at a time sequentially, in the order + * in which they were registered. + * + * @memberof workbox-core + * @private + */ + async function executeQuotaErrorCallbacks() { + { + logger.log(`About to run ${quotaErrorCallbacks.size} ` + `callbacks to clean up caches.`); + } + for (const callback of quotaErrorCallbacks) { + await callback(); + { + logger.log(callback, 'is complete.'); + } + } + { + logger.log('Finished running callbacks.'); + } + } + + /* + Copyright 2019 Google LLC + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * Returns a promise that resolves and the passed number of milliseconds. + * This utility is an async/await-friendly version of `setTimeout`. + * + * @param {number} ms + * @return {Promise} + * @private + */ + function timeout(ms) { + return new Promise(resolve => setTimeout(resolve, ms)); + } + + // @ts-ignore + try { + self['workbox:strategies:7.4.0'] && _(); + } catch (e) {} + + /* + Copyright 2020 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + function toRequest(input) { + return typeof input === 'string' ? new Request(input) : input; + } + /** + * A class created every time a Strategy instance 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 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 may be killed + * prior to your work completing. + */ + async doneWaiting() { + while (this._extendLifetimePromises.length) { + const promises = this._extendLifetimePromises.splice(0); + const result = await Promise.allSettled(promises); + const firstRejection = result.find(i => i.status === 'rejected'); + if (firstRejection) { + throw firstRejection.reason; + } + } + } + /** + * 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 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.NavigationRoute = NavigationRoute; + exports.cleanupOutdatedCaches = cleanupOutdatedCaches; + exports.clientsClaim = clientsClaim; + exports.createHandlerBoundToURL = createHandlerBoundToURL; + exports.precacheAndRoute = precacheAndRoute; + exports.registerRoute = registerRoute; + +})); diff --git a/public/index.html b/public/index.html index b212dc9..1244085 100644 --- a/public/index.html +++ b/public/index.html @@ -3,9 +3,14 @@ + + + + + Miniplan App - + diff --git a/public/package-lock.json b/public/package-lock.json index 27e3e77..7ffd550 100644 --- a/public/package-lock.json +++ b/public/package-lock.json @@ -17,19 +17,482 @@ "devDependencies": { "@tsconfig/node18": "^18.2.0", "@types/node": "^18.17.0", + "@vite-pwa/assets-generator": "^1.0.2", "@vitejs/plugin-vue": "^4.2.3", "@vue/tsconfig": "^0.4.0", "less": "^4.2.0", "npm-run-all": "^4.1.5", "typescript": "~5.1.6", "vite": "^4.4.6", - "vue-tsc": "^1.8.6" + "vite-plugin-pwa": "^1.3.0", + "vue-tsc": "^1.8.6", + "workbox-window": "^7.4.1" + } + }, + "node_modules/@apideck/better-ajv-errors": { + "version": "0.3.7", + "resolved": "https://registry.npmjs.org/@apideck/better-ajv-errors/-/better-ajv-errors-0.3.7.tgz", + "integrity": "sha512-TajUJwGWbDwkCx/CZi7tRE8PVB7simCvKJfHUsSdvps+aTM/PDPP4gkLmKnc+x3CE//y9i/nj74GqdL/hwk7Iw==", + "dev": true, + "license": "MIT", + "dependencies": { + "jsonpointer": "^5.0.1", + "leven": "^3.1.0" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "ajv": ">=8" + } + }, + "node_modules/@babel/code-frame": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.7.tgz", + "integrity": "sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-validator-identifier": "^7.29.7", + "js-tokens": "^4.0.0", + "picocolors": "^1.1.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/compat-data": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.7.tgz", + "integrity": "sha512-locTkQyKvwIEgBzVrn8693ebc97F2U8ZHjbXwDXJ5Fn2TCpNwTlKcaKLkdHop5c/icOFE7qt7Q9JC5hnKNa6Gg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/core": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.7.tgz", + "integrity": "sha512-RgHBCvtjbOK2gXSNBNIkNoEc9qoVEtau3hj8gEqKQuL3HZAibKarWFEI3Lfm6EYKkLalOh8eSrj9b+ch9H/VBA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.7", + "@babel/generator": "^7.29.7", + "@babel/helper-compilation-targets": "^7.29.7", + "@babel/helper-module-transforms": "^7.29.7", + "@babel/helpers": "^7.29.7", + "@babel/parser": "^7.29.7", + "@babel/template": "^7.29.7", + "@babel/traverse": "^7.29.7", + "@babel/types": "^7.29.7", + "@jridgewell/remapping": "^2.3.5", + "convert-source-map": "^2.0.0", + "debug": "^4.1.0", + "gensync": "^1.0.0-beta.2", + "json5": "^2.2.3", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/babel" + } + }, + "node_modules/@babel/core/node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/@babel/core/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/generator": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.7.tgz", + "integrity": "sha512-DkXD5OJQaAQIdZ1bt3UZdEnHAn9Imd3IVBdX03UFe+ony9Ojw5pzr9YVKGDY1jt+Gcn/FnGkNf8r+Vj5NOJWtQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.29.7", + "@babel/types": "^7.29.7", + "@jridgewell/gen-mapping": "^0.3.12", + "@jridgewell/trace-mapping": "^0.3.28", + "jsesc": "^3.0.2" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-annotate-as-pure": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.29.7.tgz", + "integrity": "sha512-OoK6239jHPuSQOoS0kfTVKn0b/rVTk0seKq4Gd2UMLtmOVLjDC0ki3e+c90Trqv2gMfvJFqkiljrr568+qddiw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-compilation-targets": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.29.7.tgz", + "integrity": "sha512-wem6WaBj4NaVYVdNhLPPVacES6ZJ+KBBfSkTMD3YZxbP3rm3Di85tJU5ljaUNhaOynt+Aj0xruhYuzQBt8n71g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.29.7", + "@babel/helper-validator-option": "^7.29.7", + "browserslist": "^4.24.0", + "lru-cache": "^5.1.1", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-compilation-targets/node_modules/lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", + "dev": true, + "license": "ISC", + "dependencies": { + "yallist": "^3.0.2" + } + }, + "node_modules/@babel/helper-compilation-targets/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/helper-compilation-targets/node_modules/yallist": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", + "dev": true, + "license": "ISC" + }, + "node_modules/@babel/helper-create-class-features-plugin": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.29.7.tgz", + "integrity": "sha512-IY3ZD9Tmooqr3TUhc3DUWxiuo8xx1DWLhd5M7hQ+ZWJamqM2BbalrBJb2MisSLoYorOj75U03qULCxQTY9r3hg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.29.7", + "@babel/helper-member-expression-to-functions": "^7.29.7", + "@babel/helper-optimise-call-expression": "^7.29.7", + "@babel/helper-replace-supers": "^7.29.7", + "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7", + "@babel/traverse": "^7.29.7", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-create-class-features-plugin/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/helper-create-regexp-features-plugin": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.29.7.tgz", + "integrity": "sha512-907Uymvqgg1dwUA+7IGwFAOSYzQOuzPXKNJ1yxzwPffzkYFg2q2eHi1fIOs6sXkG9NbIUMunnUlkYsfRFNvomg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.29.7", + "regexpu-core": "^6.3.1", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-create-regexp-features-plugin/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/helper-define-polyfill-provider": { + "version": "0.6.8", + "resolved": "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.6.8.tgz", + "integrity": "sha512-47UwBLPpQi1NoWzLuHNjRoHlYXMwIJoBf7MFou6viC/sIHWYygpvr0B6IAyh5sBdA2nr2LPIRww8lfaUVQINBA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-compilation-targets": "^7.28.6", + "@babel/helper-plugin-utils": "^7.28.6", + "debug": "^4.4.3", + "lodash.debounce": "^4.0.8", + "resolve": "^1.22.11" + }, + "peerDependencies": { + "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" + } + }, + "node_modules/@babel/helper-define-polyfill-provider/node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/@babel/helper-globals": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.29.7.tgz", + "integrity": "sha512-3nQVUAtvkKH9zahfWgw96Jc/uFOmjACE1kQz82E2lqWmHBgjzbNlsC22nuQTfahmWeQtTq5nQ/4Nnd2A1wj4zA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-member-expression-to-functions": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.29.7.tgz", + "integrity": "sha512-j+7JYmk1JYDtACIGj0QJqqWZjoUpMoEikQGADMaHgCMCSDqd2+P32rfcibUNrGOMWrlzK1WJBdxrB3JJQZwWtg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/traverse": "^7.29.7", + "@babel/types": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-imports": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.29.7.tgz", + "integrity": "sha512-ejHwrQQYcm9xnTivShn2IDOlIzInN34AXskvq9QicvCtEzq1Vzclu/tKF8Jq1Cg8JG2GL6/EmjgsCT7lXepE3g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/traverse": "^7.29.7", + "@babel/types": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-transforms": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.29.7.tgz", + "integrity": "sha512-UPUVSyXbOh627KiCIGQSgwWzGeBKLkaJ9PJEdrngIwMSzxLR4jS4+f1f1jb7VzBbg8nFLaYotvVPFCTqdrmTAg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-imports": "^7.29.7", + "@babel/helper-validator-identifier": "^7.29.7", + "@babel/traverse": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-optimise-call-expression": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.29.7.tgz", + "integrity": "sha512-+kmGVjcT9RGYzoDwdwEqEvGgKe3BYq+O1iGzjFubaNgZHwYHP6lsF2Yghf4kEuv9BV7tYDZ913aBW9am6YKong==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-plugin-utils": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.29.7.tgz", + "integrity": "sha512-G7sHYigPY17oO5SYWnfD/0MTBwVR781S/JI643e/JhUYgVgWE/61SoW3NH9KWUKyKq5LVh3npif99Wkt6j86Jw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-remap-async-to-generator": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.29.7.tgz", + "integrity": "sha512-16AMiW26DbXWBbr3B8wNozKM0ydMLB892vaOaJW/fPJdnT8vJk5sdkQcU/isqUxyCE0cEoa8wZOcbgDuC4b6Og==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.29.7", + "@babel/helper-wrap-function": "^7.29.7", + "@babel/traverse": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-replace-supers": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.29.7.tgz", + "integrity": "sha512-atfGXWSeCiF4DnKZIfmJfQRkSw9b9gNNXR1kqKjbhG4pGYCOnkp8OcTB8E3NXjBu8NpheSnOeNKz8KT7UNFTmQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-member-expression-to-functions": "^7.29.7", + "@babel/helper-optimise-call-expression": "^7.29.7", + "@babel/traverse": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-skip-transparent-expression-wrappers": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.29.7.tgz", + "integrity": "sha512-brcMGQaVzIeUb+6/bs1Av0f8YuNNjKY2JyvfRCsFuFsdKccEQ5Ges2y74D74NZ1Rz8lKJ9ksJkfqwQFJ/iNEyQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/traverse": "^7.29.7", + "@babel/types": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz", + "integrity": "sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz", + "integrity": "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-option": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.29.7.tgz", + "integrity": "sha512-N9ZErrD+yW5geCDtBqnOoxmR8+tNKiGuxKlDpuJxfsqpa2dFcexaziGAE/qoHLiDDreVNMupxGmSoNlyvsA3gw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-wrap-function": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.29.7.tgz", + "integrity": "sha512-iES0Skag9ERIF68aXadpO6dbXa03mNWK3sEqJaMnLNs/eC3l0lkImdfoy6Y09/SfkpawdAB4RjQ7PVA7TcVGdw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/template": "^7.29.7", + "@babel/traverse": "^7.29.7", + "@babel/types": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helpers": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.7.tgz", + "integrity": "sha512-1k2lAGRMfHTcwuNYcCNUmaUffmQv8KWMfh2iJUUeRlwlwH4FdNG7mfPI10NPfLHJFThE4Tyr4mv7kTNZOiPuBg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/template": "^7.29.7", + "@babel/types": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" } }, "node_modules/@babel/parser": { - "version": "7.22.10", - "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.22.10.tgz", - "integrity": "sha512-lNbdGsQb9ekfsnjFGhEiF4hfFqGgfOP3H3d27re3n+CGhNuTSUEQdfWk556sTLNTloczcdM5TYF2LhzmDQKyvQ==", + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.7.tgz", + "integrity": "sha512-hnORnjP/1P/zFEndoeX+n+t1RwWRJiJpM/jO7FW32Kn9r5+sJB2JWOdYo4L6k78j15eCwY3Gm/7364B1EMwtNg==", + "license": "MIT", + "dependencies": { + "@babel/types": "^7.29.7" + }, "bin": { "parser": "bin/babel-parser.js" }, @@ -37,6 +500,1229 @@ "node": ">=6.0.0" } }, + "node_modules/@babel/plugin-bugfix-firefox-class-in-computed-class-key": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-firefox-class-in-computed-class-key/-/plugin-bugfix-firefox-class-in-computed-class-key-7.29.7.tgz", + "integrity": "sha512-j8SrR0zLZrRsC09DlszEx8FpMiwukKffYXMK0d5LmOglO7vGG6sz/BR/20yHqWH+Lnn31JTt2PE3hIWNgM2J6w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/traverse": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-bugfix-safari-class-field-initializer-scope": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-class-field-initializer-scope/-/plugin-bugfix-safari-class-field-initializer-scope-7.29.7.tgz", + "integrity": "sha512-r8j8escF+U2FUHo0KOhPUdMzUO+jp9fInva6+ACVAF3Y97Ev+5iNZwiqTghmzNeWwDkOPlYuTcfb1vDaoZKmAQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.29.7.tgz", + "integrity": "sha512-GE1TFSiuFeGsCxmYXZl8HwoPrVlwe4rHPFE8weieGKZqnDORK+Ar3vgWMgW+AOxQ6/2TgLSKx9p6W7O4rC6qgQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-bugfix-safari-rest-destructuring-rhs-array": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-rest-destructuring-rhs-array/-/plugin-bugfix-safari-rest-destructuring-rhs-array-7.29.7.tgz", + "integrity": "sha512-oBNVCvnO5tND+xSopWvV8WNGfpTfgP4Zr/YXXSj8zfmcPktp5Ku/aZlsIowgSD4fjmgHn6sGmB9APVsU5zOdhA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.29.7.tgz", + "integrity": "sha512-QQt9qKHZ2sg/kivaLr7lnQr8HVrQDdBNSfCsTjiDxRuX/K5ORyKq+Bu8Xr0cDE3Dfkv0cw28Ve0EKyKMvulkOw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7", + "@babel/plugin-transform-optional-chaining": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.13.0" + } + }, + "node_modules/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly/-/plugin-bugfix-v8-static-class-fields-redefine-readonly-7.29.7.tgz", + "integrity": "sha512-pn6QacGLgvCcwc+syUhKE/qSjV2D1IHDB84RNxWYSt1mW3K/SCtjinZ2p0cETJxAWBjPy3K/1lHwG5BjjPxNlw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/traverse": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-proposal-private-property-in-object": { + "version": "7.21.0-placeholder-for-preset-env.2", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.21.0-placeholder-for-preset-env.2.tgz", + "integrity": "sha512-SOSkfJDddaM7mak6cPEpswyTRnuRltl429hMraQEglW+OkovnCzsiszTmsrlY//qLFjCpQDFRvjdm2wA5pPm9w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-import-assertions": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.29.7.tgz", + "integrity": "sha512-/An1OCBN93thpBAGyfsK2pcf0jvju1SAtKkL2Ny++B5Sy6sqgzXDQH1cZxWbF96Wuk+bn41MDA9bLd4VVAw6rw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-import-attributes": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.29.7.tgz", + "integrity": "sha512-zGYcYfq/WmZ4V+kBIXQon9dSSc8ircGZqw9ZaNhhGj9nZkeBu1jHLBDQqYYi5WA9uawvA2sIMbry2nCFhf5Djg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-unicode-sets-regex": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-unicode-sets-regex/-/plugin-syntax-unicode-sets-regex-7.18.6.tgz", + "integrity": "sha512-727YkEAPwSIQTv5im8QHz3upqp92JTWhidIC81Tdx4VJYIte/VndKf1qKrfnnhPLiPghStWfvC/iFaMCQu7Nqg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.18.6", + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-transform-arrow-functions": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.29.7.tgz", + "integrity": "sha512-N7zArUXWzAMzm+/N0uPBeVB3Fam5lMxtUwMmDK5f/IBBS7a7p1qeUoxd/6CckXoxUdgsntq1Dh8xNW06maZbDQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-async-generator-functions": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.29.7.tgz", + "integrity": "sha512-d98gXZkgswvkyohMBABkhm3GeXhYj8psWfwQ2C7gtfrKGTykQa/iOIi+JJhwMjPlZ6Vm2XN+DCf3Es1EoG4ZLA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/helper-remap-async-to-generator": "^7.29.7", + "@babel/traverse": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-async-to-generator": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.29.7.tgz", + "integrity": "sha512-pcUb2SS+RMo9TWVBwKGI5ShtoG7R+zBsFmCKDa6fe8c+hPr3XJlZgoE5j6i8W7gDjhyvy+85vmYexanvXh3d1w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-imports": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/helper-remap-async-to-generator": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-block-scoped-functions": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.29.7.tgz", + "integrity": "sha512-cUSmjh72N+rN4PrkFlN1dJwNCwjVp5d38/CQrEsFggkD10UiFlBFgdH3tv5dNsLuHY+3S8db2xCHjhZcv5WgvA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-block-scoping": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.29.7.tgz", + "integrity": "sha512-ONyr4+AZhKh8yKWInVxU9AXA9EbsyeLcL6V0dJy6M2/62vuvpGm29zzuymbTpdc451GEpDIdAyPLP3r+P61yKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-class-properties": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.29.7.tgz", + "integrity": "sha512-GtcpjFvanPfzNQi3eTitsCqtRRmmqzpy/A+yhTR1HaZo1Ly3EA8ZXxlPyHdR8/IuRMYc3E4wdGBewB2QKQjAaA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-class-features-plugin": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-class-static-block": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-static-block/-/plugin-transform-class-static-block-7.29.7.tgz", + "integrity": "sha512-kibJgmEdX2iMwsHY2tSZNDgj8PwIlCQz7FK9KuGKO8zsuoUwSEhoNnNVp/emKWrbY4HeO6kkXfdMqRKKKXBm2A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-class-features-plugin": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.12.0" + } + }, + "node_modules/@babel/plugin-transform-classes": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.29.7.tgz", + "integrity": "sha512-qV0OGGBVacduzQHE649JyCneOFI/maT+YKsO+K4Yi3xv2wTPNjM/W2o2gdzMwEAZz7fXNTHAe0NcSg30bIN69g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.29.7", + "@babel/helper-compilation-targets": "^7.29.7", + "@babel/helper-globals": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/helper-replace-supers": "^7.29.7", + "@babel/traverse": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-computed-properties": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.29.7.tgz", + "integrity": "sha512-RK7/IyU5phpuCdBAuig5VkzG/EnbDaui5SQGdU9BFrHdV+mV4cUjLMQ9lJDjLNtWHsqtiefpGZUXQP2BiTYMsA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/template": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-destructuring": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.29.7.tgz", + "integrity": "sha512-iPX8aD6H9zV5s7ZsqTdNocPN/MGQ5sSMnElKrktxjJRMnB2jN/1p2+R7GkfD6CAYoVFqy5A4XnSIUeGgJzIWpg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/traverse": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-dotall-regex": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.29.7.tgz", + "integrity": "sha512-3qc18hsD2RdZiyJNDNc7HQpv6xbncwh8FYtxNFFzclSyh/trPD9KkVR9BDECUjDLvb7yJVF15GfYUuC+LMkkiQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-duplicate-keys": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.29.7.tgz", + "integrity": "sha512-6IvRRriEMqnBwD6chtxdLpMYCHWEzN+oL5cyQtjykya19UgzbmKhxmhZgKC/LHxS2nYr9Q/qYPZ5Lr6jOL9+yQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-duplicate-named-capturing-groups-regex": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-named-capturing-groups-regex/-/plugin-transform-duplicate-named-capturing-groups-regex-7.29.7.tgz", + "integrity": "sha512-2wiIyo2BjtgU7HufSeDnL9L2O7zr8jmhFKuSr65VpRkUiRKRNpb0mdlk56+XPPKoIrfHqzbMuglDvZun0RISsA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-transform-dynamic-import": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dynamic-import/-/plugin-transform-dynamic-import-7.29.7.tgz", + "integrity": "sha512-giOlEm/EFjfjr+te9NsdjkUo2v4f8rS/SXPumRVHAtbNcyNlvtREkU1dZzaIDclNpnaVhlCqRdFKhJBjBikzLg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-explicit-resource-management": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-explicit-resource-management/-/plugin-transform-explicit-resource-management-7.29.7.tgz", + "integrity": "sha512-Rstj7coNz8sE+7Ju7ihpHLI564lsK5pUpNNlvptCIC/16E/S5hbl6n3kESPKdNRmqEWlpn5xpS5Q2dvXBsySLw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/plugin-transform-destructuring": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-exponentiation-operator": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.29.7.tgz", + "integrity": "sha512-zFpMOTLZBdW5LfObqcSbL6kefg4R4eLdmvS0wbN9M6D5Mym/sKm9toOoWyVOa+xDjvCnuWcHls2YonXwHvH3CQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-export-namespace-from": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-export-namespace-from/-/plugin-transform-export-namespace-from-7.29.7.tgz", + "integrity": "sha512-24B2nOy2TeJSMheqwPD4DDQOV/elLSIlKxjZt4i05H5AgdPdWR3n18HnNrcJ+j76WJd9gbwb9jPjNYUy6RautA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-for-of": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.29.7.tgz", + "integrity": "sha512-zeSIHh0+E1Um1WJRXCFlHQYu2ieJNdivLLjlBEp+dIBu3S51n+SZZmIXjxnItw6pz56Cn+KvK68BIBVsxq2JiQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-function-name": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.29.7.tgz", + "integrity": "sha512-otRWaHXE6fbAGkePvaj/kvs3HsqXfPhlnzwSOlnFgbqCPMd975dW+4wZ00WFBt+/YlBGcJwNrARQTOJOb4ZrIg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-compilation-targets": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/traverse": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-json-strings": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-json-strings/-/plugin-transform-json-strings-7.29.7.tgz", + "integrity": "sha512-RRnE2+eon1rJAq8MnoF1b5kTpY1vU88twHcvcKMrsqP/jxIRqDVs9iJB5fqPuqyeFAW0wJo4MlUIPpQCq/aRsg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-literals": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-literals/-/plugin-transform-literals-7.29.7.tgz", + "integrity": "sha512-DZ/oLP21ZuWx1vKqnoNv6/tvEK48AQOBRai40CX9dTjGluvT/YZCyY3rryDtyUqCEoyNroy5KKPwX2iQCiRvyw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-logical-assignment-operators": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.29.7.tgz", + "integrity": "sha512-A0H91hh6W8MFRkp5TqJmMr39jzGD1A1E1Ysiv2O06Sfbhkapm+XyIzxWCEh5kqwOZ1/8QZ0dY3SeQ7XBqfJd5Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-member-expression-literals": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.29.7.tgz", + "integrity": "sha512-hl1kwFZCCiDyfH25Xmco9jTrkPgnS9pmOzSG7W5I4SaGbLeqKv417hcU2RKmaxoPEgsoJh7ZPOrnPGq99bHoUg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-modules-amd": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.29.7.tgz", + "integrity": "sha512-fxtQoH3m5ywUSIfaH0FGCzWu4McsYon5bD3K4XnskC7f+OyQMj7rsOMi4NvvmJ83WwBAg4UCe+ov4VZlqEvyew==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-transforms": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-modules-commonjs": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.29.7.tgz", + "integrity": "sha512-j0vCldybPC5b5dwCQOJ21uKtHzt7hxLygJTg9eF1ScfaikEDNfzn94XoW5Fi+seBR0nCyL23xaBFFkq7dTM8XQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-transforms": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-modules-systemjs": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.29.7.tgz", + "integrity": "sha512-TM2ZcQLoG2/y4HODiStCo10DibYhWhGWAwVv+EQKmG/7GFl0N+AAmUiXOMKM+aiJ9XBJ9AHVZBvTzMnJ2sM3cQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-transforms": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/helper-validator-identifier": "^7.29.7", + "@babel/traverse": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-modules-umd": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.29.7.tgz", + "integrity": "sha512-B4UkaTK3QpgCwJnrxKfMPKdo92CN7OKXAlpAAnM3UPu0Q0lCCk57ylA9AJbRy2v8dDKOPAAWcoR6CMyeoHwRCA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-transforms": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-named-capturing-groups-regex": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.29.7.tgz", + "integrity": "sha512-vuFoLwr4qnv2xbZ16SQd6uPcH5FNrLHhk/Jzo++0XJFcaDsr4gjJVg6j398oMHiC+83k/GiBzviwF5KBJkPUtQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-transform-new-target": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.29.7.tgz", + "integrity": "sha512-fEo41GmsOUhOBlw8ioo6zvjX5Xc2Lqkzlyfqbpsk3eB6TReV18uhxZ0esfEokVbY2+PVJAQHNKxER6lGrzNd3A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-nullish-coalescing-operator": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-nullish-coalescing-operator/-/plugin-transform-nullish-coalescing-operator-7.29.7.tgz", + "integrity": "sha512-idmp1dFaekP9GbcMvG24Kvw2BfhFZjHnNJCkV4WuIY4PskJzwI3f1N5OdgYke38T7rftO6ERulFRn2cFeZwRkg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-numeric-separator": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-numeric-separator/-/plugin-transform-numeric-separator-7.29.7.tgz", + "integrity": "sha512-zR7fv/z14OjgHl4AgRtkDBvBMhIzCxqV/qN/2BCRC7LjFwvuzjYe7gDWxC4Wl/SNsLM6SE1IWvRPYMgSJaUvNw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-object-rest-spread": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.29.7.tgz", + "integrity": "sha512-Ld98jn4c0smUywL57m7SgsHq3OpThOa6LqZJif3G6jYOovPleoFhVrBJ1WegRApSFB2wu4+RelAj9AC9G08Z4A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-compilation-targets": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/plugin-transform-destructuring": "^7.29.7", + "@babel/plugin-transform-parameters": "^7.29.7", + "@babel/traverse": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-object-super": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.29.7.tgz", + "integrity": "sha512-Ea/diGcw0twB5IlZPO5sgET6fJsLJqPABqTuFWIR+iMPGPZJkATEIWx0wa+aEQ5UY1CBQyP/gkAiLEqn1vBiQA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/helper-replace-supers": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-optional-catch-binding": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.29.7.tgz", + "integrity": "sha512-sLsyndxK2VwX6yNUOakMb7Sh553ZTe/vVM1XJ+9Z5aW1ytsc8xOIwmyk05NNjN60vkc5/KqoTH6hB4V41LJhng==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-optional-chaining": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-chaining/-/plugin-transform-optional-chaining-7.29.7.tgz", + "integrity": "sha512-6GM1dhvK3gNODkXcEcMCOLEDCLSoZ/sBbro2Ax8HURyasQ4NshagQixkRFdh5niI6E4gmA/jYI/4aT7rRos3ZQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-parameters": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.29.7.tgz", + "integrity": "sha512-ZDOBqV/qLYJI0YElr8DcENEyARsFQeESqWXH6gZlghYXuPPjvweuDhP4VyEi4BlUBlLRFZVjxoZDMjxhLW766g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-private-methods": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.29.7.tgz", + "integrity": "sha512-/6Rz4DK1ETDEM/bWHsPHcaEe7ZaT1EqSXjtSP/L0DijOYuaUhiRiOKcwpZ8P7zR4xXEHc2ITdiCgBm9Tpyv9ug==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-class-features-plugin": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-private-property-in-object": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-property-in-object/-/plugin-transform-private-property-in-object-7.29.7.tgz", + "integrity": "sha512-+BNo06dnrzdNNqCm1X6YUaVv0DKk8Q+JYcoZfOkLhYWNCXzlwTSRq8zGWayT1csjcpNXV9CQTBRRbmTLZac5cA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.29.7", + "@babel/helper-create-class-features-plugin": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-property-literals": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.29.7.tgz", + "integrity": "sha512-bOMRLQuI0A5ZqHq3OWJ89/rXpJ/NJrbVhXiP4zwPGMs6kpcVsuTUNjwoE30K0Qm3mf48a/TnRYYD6vPNqcg6jA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-regenerator": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.29.7.tgz", + "integrity": "sha512-rNNFV0DBAJp988xW2DOntfDoYn1eR8GGF5AT5vYc+rjyfaQkM242c9tZUHHPe7KYaiJizXPWhQTzzdbXySyhBw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-regexp-modifiers": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regexp-modifiers/-/plugin-transform-regexp-modifiers-7.29.7.tgz", + "integrity": "sha512-mB5Fs0VWrJ42ZCmc8114v60qetdaUVNkj9PmSZRmanCZM3S9hm0CFRLjRmYIsuXav14l2jvZ+4T8iiCGnhj3nQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-transform-reserved-words": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.29.7.tgz", + "integrity": "sha512-5+YhdpVgmfSmwZyLMftfaiffLRMHjzIRHFHHLdibcSyJm2pasMrKHrO3Ptrt2DRshjvpgjEJJ1zVW14WPq/6QA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-shorthand-properties": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.29.7.tgz", + "integrity": "sha512-I+WYbGBAiCn7nA6xBrlgPH+MB7HWb4u8pv5S0Pv7OtwNvIFvCCb24YlttKEeUFVurfBCEaOTnuhlqsb7f0Z5Dg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-spread": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-spread/-/plugin-transform-spread-7.29.7.tgz", + "integrity": "sha512-/u5K1QWada7tbYNqTjMh96718g9NTwh9tfPJMsSmVsQwGT447FskV+KcfeXkXq2GWki4EM/MuTdmBec+hOuVTQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-sticky-regex": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.29.7.tgz", + "integrity": "sha512-BCHzNYJGe9l7EpwwDBN/ztlL2NYFFq8hp9ddjtUEM9f2O7S7kKV/lL6Fwo7IF7NSkYhPK2vO+86nIGltA90MsA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-template-literals": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.29.7.tgz", + "integrity": "sha512-NCSEJ4sLFU2gqAub45HYh4fus2yQ36rr6ei6vpU7NdoJqCpxvEG8E6eJpscGyXP3VHD2Ny+fSXr04k1hoUrFqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-typeof-symbol": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.29.7.tgz", + "integrity": "sha512-223mNGoTkBiTEWFoK+Q6Go3tueMRclO8vxxxxquNCYuNI4jWOofFKJRRDu6SDrB8Sgo1UEGW9T4GAQ8ZyRso1A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-unicode-escapes": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.29.7.tgz", + "integrity": "sha512-jCfXxSjf94lf4E0hKE0AByxF6F3/pVFqRdUUNkDJhsY0m1ZKjnN6ZYyMeHNpzflxb/0q5b7t3p+BE+SLF1WOtA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-unicode-property-regex": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-property-regex/-/plugin-transform-unicode-property-regex-7.29.7.tgz", + "integrity": "sha512-OgZ+zoAJgZLUCunsTRQ5LAjOywDv5zzZ2/hQ5aMw1pGXyY2rtE8/chXYUmu3AlVHKpm10KEdG9aMwbI/K76ZGw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-unicode-regex": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.29.7.tgz", + "integrity": "sha512-7D/x/23/d/3VqZ0QA+LGbZMlGwZjztBygSWWWsfTPoQ1oQ6Q1P6Mr3d0kk42XabyUVw+fha3LqdRsFqeKqvCyA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-unicode-sets-regex": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.29.7.tgz", + "integrity": "sha512-BLOhLht9DOJwIxlmp91wHvkXv1lguuHS3/FwUO8HL1H0u8s4hR1gASVFyilu9iGtcTRYqjTZmlsFFeQletntEg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/preset-env": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.29.7.tgz", + "integrity": "sha512-GYzX36n1nsciIb0uyH0GHwxwtNwPQIcpxSeiVLDtG/B7jB5xXgchnmL1f/jCX5o+pwnaDBtO60ONSJhEBJfxYA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.29.7", + "@babel/helper-compilation-targets": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/helper-validator-option": "^7.29.7", + "@babel/plugin-bugfix-firefox-class-in-computed-class-key": "^7.29.7", + "@babel/plugin-bugfix-safari-class-field-initializer-scope": "^7.29.7", + "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": "^7.29.7", + "@babel/plugin-bugfix-safari-rest-destructuring-rhs-array": "^7.29.7", + "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": "^7.29.7", + "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": "^7.29.7", + "@babel/plugin-proposal-private-property-in-object": "7.21.0-placeholder-for-preset-env.2", + "@babel/plugin-syntax-import-assertions": "^7.29.7", + "@babel/plugin-syntax-import-attributes": "^7.29.7", + "@babel/plugin-syntax-unicode-sets-regex": "^7.18.6", + "@babel/plugin-transform-arrow-functions": "^7.29.7", + "@babel/plugin-transform-async-generator-functions": "^7.29.7", + "@babel/plugin-transform-async-to-generator": "^7.29.7", + "@babel/plugin-transform-block-scoped-functions": "^7.29.7", + "@babel/plugin-transform-block-scoping": "^7.29.7", + "@babel/plugin-transform-class-properties": "^7.29.7", + "@babel/plugin-transform-class-static-block": "^7.29.7", + "@babel/plugin-transform-classes": "^7.29.7", + "@babel/plugin-transform-computed-properties": "^7.29.7", + "@babel/plugin-transform-destructuring": "^7.29.7", + "@babel/plugin-transform-dotall-regex": "^7.29.7", + "@babel/plugin-transform-duplicate-keys": "^7.29.7", + "@babel/plugin-transform-duplicate-named-capturing-groups-regex": "^7.29.7", + "@babel/plugin-transform-dynamic-import": "^7.29.7", + "@babel/plugin-transform-explicit-resource-management": "^7.29.7", + "@babel/plugin-transform-exponentiation-operator": "^7.29.7", + "@babel/plugin-transform-export-namespace-from": "^7.29.7", + "@babel/plugin-transform-for-of": "^7.29.7", + "@babel/plugin-transform-function-name": "^7.29.7", + "@babel/plugin-transform-json-strings": "^7.29.7", + "@babel/plugin-transform-literals": "^7.29.7", + "@babel/plugin-transform-logical-assignment-operators": "^7.29.7", + "@babel/plugin-transform-member-expression-literals": "^7.29.7", + "@babel/plugin-transform-modules-amd": "^7.29.7", + "@babel/plugin-transform-modules-commonjs": "^7.29.7", + "@babel/plugin-transform-modules-systemjs": "^7.29.7", + "@babel/plugin-transform-modules-umd": "^7.29.7", + "@babel/plugin-transform-named-capturing-groups-regex": "^7.29.7", + "@babel/plugin-transform-new-target": "^7.29.7", + "@babel/plugin-transform-nullish-coalescing-operator": "^7.29.7", + "@babel/plugin-transform-numeric-separator": "^7.29.7", + "@babel/plugin-transform-object-rest-spread": "^7.29.7", + "@babel/plugin-transform-object-super": "^7.29.7", + "@babel/plugin-transform-optional-catch-binding": "^7.29.7", + "@babel/plugin-transform-optional-chaining": "^7.29.7", + "@babel/plugin-transform-parameters": "^7.29.7", + "@babel/plugin-transform-private-methods": "^7.29.7", + "@babel/plugin-transform-private-property-in-object": "^7.29.7", + "@babel/plugin-transform-property-literals": "^7.29.7", + "@babel/plugin-transform-regenerator": "^7.29.7", + "@babel/plugin-transform-regexp-modifiers": "^7.29.7", + "@babel/plugin-transform-reserved-words": "^7.29.7", + "@babel/plugin-transform-shorthand-properties": "^7.29.7", + "@babel/plugin-transform-spread": "^7.29.7", + "@babel/plugin-transform-sticky-regex": "^7.29.7", + "@babel/plugin-transform-template-literals": "^7.29.7", + "@babel/plugin-transform-typeof-symbol": "^7.29.7", + "@babel/plugin-transform-unicode-escapes": "^7.29.7", + "@babel/plugin-transform-unicode-property-regex": "^7.29.7", + "@babel/plugin-transform-unicode-regex": "^7.29.7", + "@babel/plugin-transform-unicode-sets-regex": "^7.29.7", + "@babel/preset-modules": "0.1.6-no-external-plugins", + "babel-plugin-polyfill-corejs2": "^0.4.15", + "babel-plugin-polyfill-corejs3": "^0.14.0", + "babel-plugin-polyfill-regenerator": "^0.6.6", + "core-js-compat": "^3.48.0", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/preset-env/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/preset-modules": { + "version": "0.1.6-no-external-plugins", + "resolved": "https://registry.npmjs.org/@babel/preset-modules/-/preset-modules-0.1.6-no-external-plugins.tgz", + "integrity": "sha512-HrcgcIESLm9aIR842yhJ5RWan/gebQUJ6E/E5+rf0y9o6oj7w0Br+sWuL6kEQ/o/AdfvR1Je9jG18/gnpwjEyA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.0.0", + "@babel/types": "^7.4.4", + "esutils": "^2.0.2" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0 || ^8.0.0-0 <8.0.0" + } + }, + "node_modules/@babel/runtime": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.7.tgz", + "integrity": "sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/template": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.29.7.tgz", + "integrity": "sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.7", + "@babel/parser": "^7.29.7", + "@babel/types": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/traverse": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.7.tgz", + "integrity": "sha512-EhlfNQtZ+NK22w5BM61ciuiq1m58ed33Wr1Xan//ZRTy6hgjnwyCffRYwzsGXdASJSUJ1guZILsErh1eQcl+zw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.7", + "@babel/generator": "^7.29.7", + "@babel/helper-globals": "^7.29.7", + "@babel/parser": "^7.29.7", + "@babel/template": "^7.29.7", + "@babel/types": "^7.29.7", + "debug": "^4.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/traverse/node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/@babel/types": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.7.tgz", + "integrity": "sha512-4zBIxpPzowiZpusoFkyGVwakdRJUyuH5PxQ/PrqghfdFWWasvnCdPfQXHrenDai+gyLARulZjZowCOj6fjT4pA==", + "license": "MIT", + "dependencies": { + "@babel/helper-string-parser": "^7.29.7", + "@babel/helper-validator-identifier": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@canvas/image-data": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@canvas/image-data/-/image-data-1.1.0.tgz", + "integrity": "sha512-QdObRRjRbcXGmM1tmJ+MrHcaz1MftF2+W7YI+MsphnsCrmtyfS0d5qJbk0MeSbUeyM/jCb0hmnkXPsy026L7dA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@emnapi/runtime": { + "version": "1.11.2", + "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.11.2.tgz", + "integrity": "sha512-kyOl3X0DuTiT1h2ft8r2fYO8JYtU9a9Xis/zBSiGArNaagCOWx90N1k2wxp18czFDH+OgcWGb5ZP/XMt3dcyPA==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "tslib": "^2.4.0" + } + }, "node_modules/@esbuild/android-arm": { "version": "0.18.20", "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.18.20.tgz", @@ -389,10 +2075,1013 @@ "node": ">=12" } }, + "node_modules/@img/sharp-darwin-arm64": { + "version": "0.33.5", + "resolved": "https://registry.npmjs.org/@img/sharp-darwin-arm64/-/sharp-darwin-arm64-0.33.5.tgz", + "integrity": "sha512-UT4p+iz/2H4twwAoLCqfA9UH5pI6DggwKEGuaPy7nCVQ8ZsiY5PIcrRvD1DzuY3qYL07NtIQcWnBSY/heikIFQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^18.17.0 || ^20.3.0 || >=21.0.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-darwin-arm64": "1.0.4" + } + }, + "node_modules/@img/sharp-darwin-x64": { + "version": "0.33.5", + "resolved": "https://registry.npmjs.org/@img/sharp-darwin-x64/-/sharp-darwin-x64-0.33.5.tgz", + "integrity": "sha512-fyHac4jIc1ANYGRDxtiqelIbdWkIuQaI84Mv45KvGRRxSAa7o7d1ZKAOBaYbnepLC1WqxfpimdeWfvqqSGwR2Q==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^18.17.0 || ^20.3.0 || >=21.0.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-darwin-x64": "1.0.4" + } + }, + "node_modules/@img/sharp-libvips-darwin-arm64": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-arm64/-/sharp-libvips-darwin-arm64-1.0.4.tgz", + "integrity": "sha512-XblONe153h0O2zuFfTAbQYAX2JhYmDHeWikp1LM9Hul9gVPjFY427k6dFEcOL72O01QxQsWi761svJ/ev9xEDg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "darwin" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-libvips-darwin-x64": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-x64/-/sharp-libvips-darwin-x64-1.0.4.tgz", + "integrity": "sha512-xnGR8YuZYfJGmWPvmlunFaWJsb9T/AO2ykoP3Fz/0X5XV2aoYBPkX6xqCQvUTKKiLddarLaxpzNe+b1hjeWHAQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "darwin" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-libvips-linux-arm": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm/-/sharp-libvips-linux-arm-1.0.5.tgz", + "integrity": "sha512-gvcC4ACAOPRNATg/ov8/MnbxFDJqf/pDePbBnuBDcjsI8PssmjoKMAz4LtLaVi+OnSb5FK/yIOamqDwGmXW32g==", + "cpu": [ + "arm" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "linux" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-libvips-linux-arm64": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm64/-/sharp-libvips-linux-arm64-1.0.4.tgz", + "integrity": "sha512-9B+taZ8DlyyqzZQnoeIvDVR/2F4EbMepXMc/NdVbkzsJbzkUjhXv/70GQJ7tdLA4YJgNP25zukcxpX2/SueNrA==", + "cpu": [ + "arm64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "linux" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-libvips-linux-s390x": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-s390x/-/sharp-libvips-linux-s390x-1.0.4.tgz", + "integrity": "sha512-u7Wz6ntiSSgGSGcjZ55im6uvTrOxSIS8/dgoVMoiGE9I6JAfU50yH5BoDlYA1tcuGS7g/QNtetJnxA6QEsCVTA==", + "cpu": [ + "s390x" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "linux" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-libvips-linux-x64": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-x64/-/sharp-libvips-linux-x64-1.0.4.tgz", + "integrity": "sha512-MmWmQ3iPFZr0Iev+BAgVMb3ZyC4KeFc3jFxnNbEPas60e1cIfevbtuyf9nDGIzOaW9PdnDciJm+wFFaTlj5xYw==", + "cpu": [ + "x64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "linux" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-libvips-linuxmusl-arm64": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-arm64/-/sharp-libvips-linuxmusl-arm64-1.0.4.tgz", + "integrity": "sha512-9Ti+BbTYDcsbp4wfYib8Ctm1ilkugkA/uscUn6UXK1ldpC1JjiXbLfFZtRlBhjPZ5o1NCLiDbg8fhUPKStHoTA==", + "cpu": [ + "arm64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "linux" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-libvips-linuxmusl-x64": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-x64/-/sharp-libvips-linuxmusl-x64-1.0.4.tgz", + "integrity": "sha512-viYN1KX9m+/hGkJtvYYp+CCLgnJXwiQB39damAO7WMdKWlIhmYTfHjwSbQeUK/20vY154mwezd9HflVFM1wVSw==", + "cpu": [ + "x64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "linux" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-linux-arm": { + "version": "0.33.5", + "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm/-/sharp-linux-arm-0.33.5.tgz", + "integrity": "sha512-JTS1eldqZbJxjvKaAkxhZmBqPRGmxgu+qFKSInv8moZ2AmT5Yib3EQ1c6gp493HvrvV8QgdOXdyaIBrhvFhBMQ==", + "cpu": [ + "arm" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^18.17.0 || ^20.3.0 || >=21.0.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-linux-arm": "1.0.5" + } + }, + "node_modules/@img/sharp-linux-arm64": { + "version": "0.33.5", + "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm64/-/sharp-linux-arm64-0.33.5.tgz", + "integrity": "sha512-JMVv+AMRyGOHtO1RFBiJy/MBsgz0x4AWrT6QoEVVTyh1E39TrCUpTRI7mx9VksGX4awWASxqCYLCV4wBZHAYxA==", + "cpu": [ + "arm64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^18.17.0 || ^20.3.0 || >=21.0.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-linux-arm64": "1.0.4" + } + }, + "node_modules/@img/sharp-linux-s390x": { + "version": "0.33.5", + "resolved": "https://registry.npmjs.org/@img/sharp-linux-s390x/-/sharp-linux-s390x-0.33.5.tgz", + "integrity": "sha512-y/5PCd+mP4CA/sPDKl2961b+C9d+vPAveS33s6Z3zfASk2j5upL6fXVPZi7ztePZ5CuH+1kW8JtvxgbuXHRa4Q==", + "cpu": [ + "s390x" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^18.17.0 || ^20.3.0 || >=21.0.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-linux-s390x": "1.0.4" + } + }, + "node_modules/@img/sharp-linux-x64": { + "version": "0.33.5", + "resolved": "https://registry.npmjs.org/@img/sharp-linux-x64/-/sharp-linux-x64-0.33.5.tgz", + "integrity": "sha512-opC+Ok5pRNAzuvq1AG0ar+1owsu842/Ab+4qvU879ippJBHvyY5n2mxF1izXqkPYlGuP/M556uh53jRLJmzTWA==", + "cpu": [ + "x64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^18.17.0 || ^20.3.0 || >=21.0.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-linux-x64": "1.0.4" + } + }, + "node_modules/@img/sharp-linuxmusl-arm64": { + "version": "0.33.5", + "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-arm64/-/sharp-linuxmusl-arm64-0.33.5.tgz", + "integrity": "sha512-XrHMZwGQGvJg2V/oRSUfSAfjfPxO+4DkiRh6p2AFjLQztWUuY/o8Mq0eMQVIY7HJ1CDQUJlxGGZRw1a5bqmd1g==", + "cpu": [ + "arm64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^18.17.0 || ^20.3.0 || >=21.0.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-linuxmusl-arm64": "1.0.4" + } + }, + "node_modules/@img/sharp-linuxmusl-x64": { + "version": "0.33.5", + "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-x64/-/sharp-linuxmusl-x64-0.33.5.tgz", + "integrity": "sha512-WT+d/cgqKkkKySYmqoZ8y3pxx7lx9vVejxW/W4DOFMYVSkErR+w7mf2u8m/y4+xHe7yY9DAXQMWQhpnMuFfScw==", + "cpu": [ + "x64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^18.17.0 || ^20.3.0 || >=21.0.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-linuxmusl-x64": "1.0.4" + } + }, + "node_modules/@img/sharp-wasm32": { + "version": "0.33.5", + "resolved": "https://registry.npmjs.org/@img/sharp-wasm32/-/sharp-wasm32-0.33.5.tgz", + "integrity": "sha512-ykUW4LVGaMcU9lu9thv85CbRMAwfeadCJHRsg2GmeRa/cJxsVY9Rbd57JcMxBkKHag5U/x7TSBpScF4U8ElVzg==", + "cpu": [ + "wasm32" + ], + "dev": true, + "license": "Apache-2.0 AND LGPL-3.0-or-later AND MIT", + "optional": true, + "dependencies": { + "@emnapi/runtime": "^1.2.0" + }, + "engines": { + "node": "^18.17.0 || ^20.3.0 || >=21.0.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-win32-ia32": { + "version": "0.33.5", + "resolved": "https://registry.npmjs.org/@img/sharp-win32-ia32/-/sharp-win32-ia32-0.33.5.tgz", + "integrity": "sha512-T36PblLaTwuVJ/zw/LaH0PdZkRz5rd3SmMHX8GSmR7vtNSP5Z6bQkExdSK7xGWyxLw4sUknBuugTelgw2faBbQ==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "Apache-2.0 AND LGPL-3.0-or-later", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": "^18.17.0 || ^20.3.0 || >=21.0.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-win32-x64": { + "version": "0.33.5", + "resolved": "https://registry.npmjs.org/@img/sharp-win32-x64/-/sharp-win32-x64-0.33.5.tgz", + "integrity": "sha512-MpY/o8/8kj+EcnxwvrP4aTJSWw/aZ7JIGR4aBeZkZw5B7/Jn+tY9/VNwtcoGmdT7GfggGIU4kygOMSbYnOrAbg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "Apache-2.0 AND LGPL-3.0-or-later", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": "^18.17.0 || ^20.3.0 || >=21.0.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@isaacs/cliui": { + "version": "9.0.0", + "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-9.0.0.tgz", + "integrity": "sha512-AokJm4tuBHillT+FpMtxQ60n8ObyXBatq7jD2/JA9dxbDDokKQm8KMht5ibGzLVU9IJDIKK4TPKgMHEYMn3lMg==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": ">=18" + } + }, + "node_modules/@jridgewell/gen-mapping": { + "version": "0.3.13", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz", + "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.0", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/remapping": { + "version": "2.3.5", + "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz", + "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/source-map": { + "version": "0.3.11", + "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.11.tgz", + "integrity": "sha512-ZMp1V8ZFcPG5dIWnQLr3NSI1MiCU7UETdS/A0G8V/XWHvJv3ZsFqutJn1Y5RPmAPX6F3BiE397OqveU/9NCuIA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.25" + } + }, "node_modules/@jridgewell/sourcemap-codec": { - "version": "1.4.15", - "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz", - "integrity": "sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==" + "version": "1.5.5", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", + "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", + "license": "MIT" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.31", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", + "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "node_modules/@quansync/fs": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@quansync/fs/-/fs-1.0.0.tgz", + "integrity": "sha512-4TJ3DFtlf1L5LDMaM6CanJ/0lckGNtJcMjQ1NAV6zDmA0tEHKZtxNKin8EgPaVX1YzljbxckyT2tJrpQKAtngQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "quansync": "^1.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sxzz" + } + }, + "node_modules/@rollup/plugin-babel": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/@rollup/plugin-babel/-/plugin-babel-6.1.0.tgz", + "integrity": "sha512-dFZNuFD2YRcoomP4oYf+DvQNSUA9ih+A3vUqopQx5EdtPGo3WBnQcI/S8pwpz91UsGfL0HsMSOlaMld8HrbubA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-imports": "^7.18.6", + "@rollup/pluginutils": "^5.0.1" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0", + "@types/babel__core": "^7.1.9", + "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0" + }, + "peerDependenciesMeta": { + "@types/babel__core": { + "optional": true + }, + "rollup": { + "optional": true + } + } + }, + "node_modules/@rollup/plugin-node-resolve": { + "version": "16.0.3", + "resolved": "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-16.0.3.tgz", + "integrity": "sha512-lUYM3UBGuM93CnMPG1YocWu7X802BrNF3jW2zny5gQyLQgRFJhV1Sq0Zi74+dh/6NBx1DxFC4b4GXg9wUCG5Qg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@rollup/pluginutils": "^5.0.1", + "@types/resolve": "1.20.2", + "deepmerge": "^4.2.2", + "is-module": "^1.0.0", + "resolve": "^1.22.1" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "rollup": "^2.78.0||^3.0.0||^4.0.0" + }, + "peerDependenciesMeta": { + "rollup": { + "optional": true + } + } + }, + "node_modules/@rollup/plugin-replace": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/@rollup/plugin-replace/-/plugin-replace-6.0.3.tgz", + "integrity": "sha512-J4RZarRvQAm5IF0/LwUUg+obsm+xZhYnbMXmXROyoSE1ATJe3oXSb9L5MMppdxP2ylNSjv6zFBwKYjcKMucVfA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@rollup/pluginutils": "^5.0.1", + "magic-string": "^0.30.3" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0" + }, + "peerDependenciesMeta": { + "rollup": { + "optional": true + } + } + }, + "node_modules/@rollup/plugin-terser": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@rollup/plugin-terser/-/plugin-terser-1.0.0.tgz", + "integrity": "sha512-FnCxhTBx6bMOYQrar6C8h3scPt8/JwIzw3+AJ2K++6guogH5fYaIFia+zZuhqv0eo1RN7W1Pz630SyvLbDjhtQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "serialize-javascript": "^7.0.3", + "smob": "^1.0.0", + "terser": "^5.17.4" + }, + "engines": { + "node": ">=20.0.0" + }, + "peerDependencies": { + "rollup": "^2.0.0||^3.0.0||^4.0.0" + }, + "peerDependenciesMeta": { + "rollup": { + "optional": true + } + } + }, + "node_modules/@rollup/pluginutils": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.4.0.tgz", + "integrity": "sha512-MfPp06CjRLfXQ3wY0R8vJDYBy/MvVcc9OulEfR0B8Iv9ko+GCNaRZ+EpJYFl27LhKsZK0o420sYCRHCjfCgeUg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.0", + "estree-walker": "^2.0.2", + "picomatch": "^4.0.2" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0" + }, + "peerDependenciesMeta": { + "rollup": { + "optional": true + } + } + }, + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.62.2.tgz", + "integrity": "sha512-6o7ZLZK+BeenkZCFNDXqpbjw9bD6nuWonvS/lwQJp7NoVVxm6p3qE7qQ5jGuBjiFsgvqjD8mZAU5oWxTmbOeOg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-android-arm64": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.62.2.tgz", + "integrity": "sha512-BaH7BllCACHoH1LguOU56UItGfUWjujlO65kS9LAodViaN4bwIKd7oeW/ZHJ/4ljr/7MIiENnNy3HJ0zXv8Zkw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.62.2.tgz", + "integrity": "sha512-v39RCCvj4He82I9sFmk+M1VZ0PLM9sfsLVikjfx2hYBNALhrrOR2D3JjQA6AhlaSOgcR+RzrKY7e1+bT6SUO/A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.62.2.tgz", + "integrity": "sha512-yl0y2vq3S3lHeuXhEdss6TWfKW8vkujImO12tn4ZkG/4oghr09LvdYm2RElVjokTQiUvDUGXLGsYeLqUMCKpGA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-freebsd-arm64": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.62.2.tgz", + "integrity": "sha512-tT4pvt4qXD+vEoezupCWi+a1F0vvDiksiHc+PxRlYTOH1I6/X4id9jPxTP+Fg+545euaFT1jJVs4CEdHZAU1vw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-freebsd-x64": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.62.2.tgz", + "integrity": "sha512-6nU5F2wCW+qvCBhTn1pdIU3bzsIoF7EUwsCDRxilWGprQR6yd508YnH9+OKFCwpfS8pjZqDUmnCAr7exax0XCg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.62.2.tgz", + "integrity": "sha512-n1GJHPOvpIfhi3TmrCeh6S6URt9BFCt0KQE3qvexyGCTAKpR4Lg+eWvNZEqu7epxwus/8ElT3hacYEucm49SZg==", + "cpu": [ + "arm" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm-musleabihf": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.62.2.tgz", + "integrity": "sha512-JqgflS8wEB+UXV/vS1RpRbifGBeN4D5lz8D8oOFbFZw4vedvdOgCFAjfBmIMdW3yL10XpQQ0Ambepw6MXrhOnA==", + "cpu": [ + "arm" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.62.2.tgz", + "integrity": "sha512-wnFJkogWvN4jm/hQRF2UBaeUmk20j5+DmHvoyWii2b8HJDyvz1MF2OU/6ynXt2KR63rbZLWkFpoytpdc/yBuSA==", + "cpu": [ + "arm64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.62.2.tgz", + "integrity": "sha512-HVu2bp0zhvJ8xHEV9+UUs7S90VadmBSY3LcIMvozbPo4AuMGDWlz3ymHLHZPX4hR67TKTt8Qp5PJ5RBg/i+RMQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-gnu": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.62.2.tgz", + "integrity": "sha512-mQqqAV8QaoSgr9I2fKDLY2BAVvmKjWoGiu/cSYQonsLvtqwEn1E4QYfnCOcp5zoEqNhsDYin1s6jx/VJmrxlZg==", + "cpu": [ + "loong64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-musl": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.62.2.tgz", + "integrity": "sha512-IxKLoxCQ2IWi6bT2akyDUBGsOImDKB+sPp4EsTmwFQ/fMwpCKm8uLSSgP/Kx/QYUgKis6SEZ5/Nlhup0DIA0PQ==", + "cpu": [ + "loong64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-gnu": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.62.2.tgz", + "integrity": "sha512-Mk5ha2RQSgyFfmYYLkBpPnUk8D8FriBxesO1u9O75X0mHgXL1UQcH5Itl2lurWL2tj0RxV9b9tJgipac0hRY9A==", + "cpu": [ + "ppc64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-musl": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.62.2.tgz", + "integrity": "sha512-CjvEnqJL/0/TQ3TXX3OPIJ/kmBellrWd4heXUmHeJlTnmwjKpSJzoehLaL6Xk0ZnMHBu9dZuFADNOrtjF4v+2w==", + "cpu": [ + "ppc64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.62.2.tgz", + "integrity": "sha512-1SiZbzwdkaDURsew/tSOrooKiYy7EQGT6m8ufavAi9NEyQb/6VuIxFXAL1fqa4iZe3g4NbNk4P7J32z2tw5Mgg==", + "cpu": [ + "riscv64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-musl": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.62.2.tgz", + "integrity": "sha512-nQts12zJ3NQRoE6uYljOH89v7szzLDvG2JD/vsX+vGXU8w/At1GowTZ5/7qeFQ8m7L55rpR8Okugnuo5bgjy2Q==", + "cpu": [ + "riscv64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.62.2.tgz", + "integrity": "sha512-E9/ll019jhPIJgpzfZoIkBGhcz+kKNgVWYRY0zr9srBdPPFVpvOKW8VaJKUbeK+eZXyQF9ltME+Kk6affeaPgg==", + "cpu": [ + "s390x" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.62.2.tgz", + "integrity": "sha512-5BqxR/pshjey51iliyzTD5Xi3EN0aLmQ2lZ3lvefVV9c82BvrLo2/6OT55iifpWBufs6kdwWbuOKS841DrmK9A==", + "cpu": [ + "x64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.62.2.tgz", + "integrity": "sha512-uNN83XxQrRAh/w0/pmAfibcwyb6YWt4gP+dpnQKPVJshAloQ785ii8CT8ZCIxkGg9opVsvAlGhFitSm6D1Jjpg==", + "cpu": [ + "x64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-openbsd-x64": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.62.2.tgz", + "integrity": "sha512-srjEIxSH3LRnJN6THczDHWQplqEMFiAJrTab0msUryh9kwNpkICf3Ea6q6MN/2cZwRFUNx5w+h6Hpi4QuHS6Zg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ] + }, + "node_modules/@rollup/rollup-openharmony-arm64": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.62.2.tgz", + "integrity": "sha512-8hOJnxgbyObnCm5AlRA3A931xX19xq80RjVTKgJOvEKWqJruP/Uf12IbAOaDjjEXYRewwHLfmF0YRIdK3OwKWA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.62.2.tgz", + "integrity": "sha512-mmF4AY1i0hG/bLWUctUq59gtmgaSIRa3cu/A3JFRp/sCNEme2bgDEiDS22P9FbnJB8NJNF4jPJiSP5RHQpUTDg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.62.2.tgz", + "integrity": "sha512-DZgkknc6jhHrk46V25vbAM0zZkyP0nSDkJB8/dRkLTxv470dOmWDqGoEJl/9A0dFfS7yE3REOwNDxpHwSLSt0Q==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-gnu": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.62.2.tgz", + "integrity": "sha512-T6xr6ucWSFto+VGajA8YH26LdpHRuP4YLHEKAtCWvJDOlnmWcDZVCI2Jmjr+IFHDlt2zRaTAKE4tfjTaWLgJBg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.62.2.tgz", + "integrity": "sha512-BfzEnDJOt9T8M989/lA37EcJgat01wLRnoi5dQf3QzOH7jzpqTAzdDbVfRljVr5r+jzKqpbHeyOfAaXxAd0PAA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] }, "node_modules/@swc/helpers": { "version": "0.2.14", @@ -400,18 +3089,79 @@ "integrity": "sha512-wpCQMhf5p5GhNg2MmGKXzUNwxe7zRiCsmqYsamez2beP7mKPCSiu+BjZcdN95yYSzO857kr0VfQewmGpS77nqA==", "license": "MIT" }, + "node_modules/@trickfilm400/rollup-plugin-off-main-thread": { + "version": "3.0.0-pre1", + "resolved": "https://registry.npmjs.org/@trickfilm400/rollup-plugin-off-main-thread/-/rollup-plugin-off-main-thread-3.0.0-pre1.tgz", + "integrity": "sha512-/67zpWDBLV+oYAEL682s1ktXL0HgqX76f6gaVGkGnVZlBbm1zd0v4Bz8MFF2GGhoX9rvfq3KSQHubFHwa6w6/Q==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "ejs": "^3.1.10", + "json5": "^2.2.3", + "magic-string": "^0.30.21", + "string.prototype.matchall": "^4.0.12" + }, + "engines": { + "node": ">=12" + } + }, "node_modules/@tsconfig/node18": { "version": "18.2.0", "resolved": "https://registry.npmjs.org/@tsconfig/node18/-/node18-18.2.0.tgz", "integrity": "sha512-yhxwIlFVSVcMym3O31HoMnRXpoenmpIxcj4Yoes2DUpe+xCJnA7ECQP1Vw889V0jTt/2nzvpLQ/UuMYCd3JPIg==", "dev": true }, + "node_modules/@types/estree": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz", + "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==", + "dev": true, + "license": "MIT" + }, "node_modules/@types/node": { "version": "18.17.5", "resolved": "https://registry.npmjs.org/@types/node/-/node-18.17.5.tgz", "integrity": "sha512-xNbS75FxH6P4UXTPUJp/zNPq6/xsfdJKussCWNOnz4aULWIRwMgP1LgaB5RiBnMX1DPCYenuqGZfnIAx5mbFLA==", "dev": true }, + "node_modules/@types/resolve": { + "version": "1.20.2", + "resolved": "https://registry.npmjs.org/@types/resolve/-/resolve-1.20.2.tgz", + "integrity": "sha512-60BCwRFOZCQhDncwQdxxeOEEkbc5dIMccYLwbxsS4TUNeVECQ/pBJ0j09mrHOl/JJvpRPGwO9SvE4nR2Nb/a4Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/trusted-types": { + "version": "2.0.7", + "resolved": "https://registry.npmjs.org/@types/trusted-types/-/trusted-types-2.0.7.tgz", + "integrity": "sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@vite-pwa/assets-generator": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@vite-pwa/assets-generator/-/assets-generator-1.0.2.tgz", + "integrity": "sha512-MCbrb508JZHqe7bUibmZj/lyojdhLRnfkmyXnkrCM2zVrjTgL89U8UEfInpKTvPeTnxsw2hmyZxnhsdNR6yhwg==", + "dev": true, + "license": "MIT", + "dependencies": { + "cac": "^6.7.14", + "colorette": "^2.0.20", + "consola": "^3.4.2", + "sharp": "^0.33.5", + "sharp-ico": "^0.1.5", + "unconfig": "^7.3.1" + }, + "bin": { + "pwa-assets-generator": "bin/pwa-assets-generator.mjs" + }, + "engines": { + "node": ">=16.14.0" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, "node_modules/@vitejs/plugin-vue": { "version": "4.2.3", "resolved": "https://registry.npmjs.org/@vitejs/plugin-vue/-/plugin-vue-4.2.3.tgz", @@ -623,6 +3373,36 @@ "@vue/language-core": "1.8.8" } }, + "node_modules/acorn": { + "version": "8.17.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.17.0.tgz", + "integrity": "sha512-xRQbDb9BnwDafYNn6Vwl839DYVjqXYb1XVGtWAZ1kcDc6iwAL4hg3B1dZlRiuENFeO2H53gFG3in621AdERVAg==", + "dev": true, + "license": "MIT", + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/ajv": { + "version": "8.20.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.20.0.tgz", + "integrity": "sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==", + "dev": true, + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.3", + "fast-uri": "^3.0.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, "node_modules/ansi-styles": { "version": "3.2.1", "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", @@ -636,30 +3416,36 @@ } }, "node_modules/array-buffer-byte-length": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.0.tgz", - "integrity": "sha512-LPuwb2P+NrQw3XhxGc36+XSvuBPopovXYTR9Ew++Du9Yb/bx5AzBfrIsBoj0EZUifjQU+sHL21sseZ3jerWO/A==", + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.2.tgz", + "integrity": "sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "is-array-buffer": "^3.0.1" + "call-bound": "^1.0.3", + "is-array-buffer": "^3.0.5" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/arraybuffer.prototype.slice": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.1.tgz", - "integrity": "sha512-09x0ZWFEjj4WD8PDbykUwo3t9arLn8NIzmmYEJFpYekOAQjpkGSyrQhNoRTcwwcFRu+ycWF78QZ63oWTqSjBcw==", + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.4.tgz", + "integrity": "sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ==", "dev": true, + "license": "MIT", "dependencies": { - "array-buffer-byte-length": "^1.0.0", - "call-bind": "^1.0.2", - "define-properties": "^1.2.0", - "get-intrinsic": "^1.2.1", - "is-array-buffer": "^3.0.2", - "is-shared-array-buffer": "^1.0.2" + "array-buffer-byte-length": "^1.0.1", + "call-bind": "^1.0.8", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.5", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.6", + "is-array-buffer": "^3.0.4" }, "engines": { "node": ">= 0.4" @@ -668,11 +3454,42 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/available-typed-arrays": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.5.tgz", - "integrity": "sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw==", + "node_modules/async": { + "version": "3.2.6", + "resolved": "https://registry.npmjs.org/async/-/async-3.2.6.tgz", + "integrity": "sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==", "dev": true, + "license": "MIT" + }, + "node_modules/async-function": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/async-function/-/async-function-1.0.0.tgz", + "integrity": "sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/at-least-node": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/at-least-node/-/at-least-node-1.0.0.tgz", + "integrity": "sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">= 4.0.0" + } + }, + "node_modules/available-typed-arrays": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz", + "integrity": "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "possible-typed-array-names": "^1.0.0" + }, "engines": { "node": ">= 0.4" }, @@ -680,12 +3497,77 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/babel-plugin-polyfill-corejs2": { + "version": "0.4.17", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.4.17.tgz", + "integrity": "sha512-aTyf30K/rqAsNwN76zYrdtx8obu0E4KoUME29B1xj+B3WxgvWkp943vYQ+z8Mv3lw9xHXMHpvSPOBxzAkIa94w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.28.6", + "@babel/helper-define-polyfill-provider": "^0.6.8", + "semver": "^6.3.1" + }, + "peerDependencies": { + "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" + } + }, + "node_modules/babel-plugin-polyfill-corejs2/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/babel-plugin-polyfill-corejs3": { + "version": "0.14.2", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.14.2.tgz", + "integrity": "sha512-coWpDLJ410R781Npmn/SIBZEsAetR4xVi0SxLMXPaMO4lSf1MwnkGYMtkFxew0Dn8B3/CpbpYxN0JCgg8mn67g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-define-polyfill-provider": "^0.6.8", + "core-js-compat": "^3.48.0" + }, + "peerDependencies": { + "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" + } + }, + "node_modules/babel-plugin-polyfill-regenerator": { + "version": "0.6.8", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.6.8.tgz", + "integrity": "sha512-M762rNHfSF1EV3SLtnCJXFoQbbIIz0OyRwnCmV0KPC7qosSfCO0QLTSuJX3ayAebubhE6oYBAYPrBA5ljowaZg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-define-polyfill-provider": "^0.6.8" + }, + "peerDependencies": { + "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" + } + }, "node_modules/balanced-match": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", "dev": true }, + "node_modules/baseline-browser-mapping": { + "version": "2.10.44", + "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.44.tgz", + "integrity": "sha512-T3ghW+sl/ZJ8w1v/yQx3qvJ9040DWoLBz8JT/CILbAKcFyG9b2MRe75v6W5uXjv6uH1lumK2Kv46y2zSkcej0Q==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "baseline-browser-mapping": "dist/cli.cjs" + }, + "engines": { + "node": ">=6.0.0" + } + }, "node_modules/brace-expansion": { "version": "1.1.11", "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", @@ -696,19 +3578,128 @@ "concat-map": "0.0.1" } }, - "node_modules/call-bind": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz", - "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==", + "node_modules/browserslist": { + "version": "4.28.6", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.6.tgz", + "integrity": "sha512-FQBYNK15VMslhLHpA7+n+n1GOlF1kId2xcCg7/j95f24AOF6VDYMNH4mFxF7KuaTdv627faazpOAjFzMrfJOUw==", "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", "dependencies": { - "function-bind": "^1.1.1", - "get-intrinsic": "^1.0.2" + "baseline-browser-mapping": "^2.10.42", + "caniuse-lite": "^1.0.30001803", + "electron-to-chromium": "^1.5.389", + "node-releases": "^2.0.51", + "update-browserslist-db": "^1.2.3" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "node_modules/buffer-from": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz", + "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/cac": { + "version": "6.7.14", + "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz", + "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/call-bind": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.9.tgz", + "integrity": "sha512-a/hy+pNsFUTR+Iz8TCJvXudKVLAnz/DyeSUo10I5yvFDQJBFU2s9uqQpoSrJlroHUKoKqzg+epxyP9lqFdzfBQ==", + "dev": true, + "license": "MIT", + "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" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/call-bind-apply-helpers": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz", + "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/call-bound": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz", + "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "get-intrinsic": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/caniuse-lite": { + "version": "1.0.30001806", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001806.tgz", + "integrity": "sha512-72Cuvd95zbSYPKq6Fhg8eDJRlzgWDf7/mtoZv6Qe/DYNCEBdNxoA3+rZAU2ZhGCpZlns3EssFavaZomckT5Uuw==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/caniuse-lite" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "CC-BY-4.0" + }, "node_modules/chalk": { "version": "2.4.2", "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", @@ -723,6 +3714,20 @@ "node": ">=4" } }, + "node_modules/color": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/color/-/color-4.2.3.tgz", + "integrity": "sha512-1rXeuUUiGGrykh+CeBdu5Ie7OJwinCgQY0bc7GCRxy5xVHy+moaqkpL/jqQq0MtQOeYcrqEz4abc5f0KtU7W4A==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1", + "color-string": "^1.9.0" + }, + "engines": { + "node": ">=12.5.0" + } + }, "node_modules/color-convert": { "version": "1.9.3", "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", @@ -738,12 +3743,84 @@ "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==", "dev": true }, + "node_modules/color-string": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/color-string/-/color-string-1.9.1.tgz", + "integrity": "sha512-shrVawQFojnZv6xM40anx4CkoDP+fZsw/ZerEMsW/pyzsRbElpsL/DBVW7q3ExxwusdNXI3lXpuhEZkzs8p5Eg==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-name": "^1.0.0", + "simple-swizzle": "^0.2.2" + } + }, + "node_modules/color/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/color/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true, + "license": "MIT" + }, + "node_modules/colorette": { + "version": "2.0.20", + "resolved": "https://registry.npmjs.org/colorette/-/colorette-2.0.20.tgz", + "integrity": "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==", + "dev": true, + "license": "MIT" + }, + "node_modules/commander": { + "version": "2.20.3", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", + "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/common-tags": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/common-tags/-/common-tags-1.8.2.tgz", + "integrity": "sha512-gk/Z852D2Wtb//0I+kRFNKKE9dIIVirjoqPoA1wJU+XePVXZfGeBpk45+A1rKO4Q43prqWBNY/MiIeRLbPWUaA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4.0.0" + } + }, "node_modules/concat-map": { "version": "0.0.1", "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", "dev": true }, + "node_modules/consola": { + "version": "3.4.2", + "resolved": "https://registry.npmjs.org/consola/-/consola-3.4.2.tgz", + "integrity": "sha512-5IKcdX0nnYavi6G7TtOhwkYzyjfJlatbjMjuLSfE2kYT5pMDOilZ4OvMhi637CcDICTmz3wARPoyhqyX1Y+XvA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^14.18.0 || >=16.10.0" + } + }, + "node_modules/convert-source-map": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", + "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==", + "dev": true, + "license": "MIT" + }, "node_modules/copy-anything": { "version": "2.0.6", "resolved": "https://registry.npmjs.org/copy-anything/-/copy-anything-2.0.6.tgz", @@ -768,6 +3845,20 @@ "url": "https://opencollective.com/core-js" } }, + "node_modules/core-js-compat": { + "version": "3.49.0", + "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.49.0.tgz", + "integrity": "sha512-VQXt1jr9cBz03b331DFDCCP90b3fanciLkgiOoy8SBHy06gNf+vQ1A3WFLqG7I8TipYIKeYK9wxd0tUrvHcOZA==", + "dev": true, + "license": "MIT", + "dependencies": { + "browserslist": "^4.28.1" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/core-js" + } + }, "node_modules/cross-spawn": { "version": "6.0.5", "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-6.0.5.tgz", @@ -784,11 +3875,75 @@ "node": ">=4.8" } }, + "node_modules/crypto-random-string": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/crypto-random-string/-/crypto-random-string-2.0.0.tgz", + "integrity": "sha512-v1plID3y9r/lPhviJ1wrXpLeyUIGAZ2SHNYTEapm7/8A9nLPoyvVp3RK/EPFqn5kEznyWgYZNsRtYYIWbuG8KA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, "node_modules/csstype": { "version": "3.1.2", "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.2.tgz", "integrity": "sha512-I7K1Uu0MBPzaFKg4nI5Q7Vs2t+3gWWW648spaF+Rg7pI9ds18Ugn+lvg4SHczUdKlHI5LWBXyqfS8+DufyBsgQ==" }, + "node_modules/data-view-buffer": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/data-view-buffer/-/data-view-buffer-1.0.2.tgz", + "integrity": "sha512-EmKO5V3OLXh1rtK2wgXRansaK1/mtVdTUEiEI0W8RkvgT05kfxaH29PliLnpLP73yYO6142Q72QNa8Wx/A5CqQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3", + "es-errors": "^1.3.0", + "is-data-view": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/data-view-byte-length": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/data-view-byte-length/-/data-view-byte-length-1.0.2.tgz", + "integrity": "sha512-tuhGbE6CfTM9+5ANGf+oQb72Ky/0+s3xKUpHvShfiz2RxMFgFPjsXuRLBVMtvMs15awe45SRb83D6wH4ew6wlQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3", + "es-errors": "^1.3.0", + "is-data-view": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/inspect-js" + } + }, + "node_modules/data-view-byte-offset": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/data-view-byte-offset/-/data-view-byte-offset-1.0.1.tgz", + "integrity": "sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "is-data-view": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/de-indent": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/de-indent/-/de-indent-1.0.2.tgz", @@ -805,12 +3960,71 @@ "ms": "^2.1.1" } }, - "node_modules/define-properties": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.0.tgz", - "integrity": "sha512-xvqAVKGfT1+UAvPwKTVw/njhdQ8ZhXK4lI0bCIuCMrp2up9nPnaDftrLtmpTazqd1o+UY4zgzU+avtMbDP+ldA==", + "node_modules/decode-bmp": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/decode-bmp/-/decode-bmp-0.2.1.tgz", + "integrity": "sha512-NiOaGe+GN0KJqi2STf24hfMkFitDUaIoUU3eKvP/wAbLe8o6FuW5n/x7MHPR0HKvBokp6MQY/j7w8lewEeVCIA==", "dev": true, + "license": "MIT", "dependencies": { + "@canvas/image-data": "^1.0.0", + "to-data-view": "^1.1.0" + }, + "engines": { + "node": ">=8.6.0" + } + }, + "node_modules/decode-ico": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/decode-ico/-/decode-ico-0.4.1.tgz", + "integrity": "sha512-69NZfbKIzux1vBOd31al3XnMnH+2mqDhEgLdpygErm4d60N+UwA5Sq5WFjmEDQzumgB9fElojGwWG0vybVfFmA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@canvas/image-data": "^1.0.0", + "decode-bmp": "^0.2.0", + "to-data-view": "^1.1.0" + }, + "engines": { + "node": ">=8.6" + } + }, + "node_modules/deepmerge": { + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz", + "integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/define-data-property": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz", + "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-define-property": "^1.0.0", + "es-errors": "^1.3.0", + "gopd": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/define-properties": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz", + "integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==", + "dev": true, + "license": "MIT", + "dependencies": { + "define-data-property": "^1.0.1", "has-property-descriptors": "^1.0.0", "object-keys": "^1.1.1" }, @@ -821,6 +4035,23 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/defu": { + "version": "6.1.7", + "resolved": "https://registry.npmjs.org/defu/-/defu-6.1.7.tgz", + "integrity": "sha512-7z22QmUWiQ/2d0KkdYmANbRUVABpZ9SNYyH5vx6PZ+nE5bcC0l7uFvEfHlyld/HcGBFTL536ClDt3DEcSlEJAQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/detect-libc": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz", + "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=8" + } + }, "node_modules/dropzone": { "version": "6.0.0-beta.2", "resolved": "https://registry.npmjs.org/dropzone/-/dropzone-6.0.0-beta.2.tgz", @@ -847,6 +4078,44 @@ "vue": ">=3.0.0" } }, + "node_modules/dunder-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz", + "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.1", + "es-errors": "^1.3.0", + "gopd": "^1.2.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/ejs": { + "version": "3.1.10", + "resolved": "https://registry.npmjs.org/ejs/-/ejs-3.1.10.tgz", + "integrity": "sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "jake": "^10.8.5" + }, + "bin": { + "ejs": "bin/cli.js" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/electron-to-chromium": { + "version": "1.5.394", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.394.tgz", + "integrity": "sha512-Wmt2Gm0o8JWBuGgmc4XZ0u9s1RaCRqhxP47phplmfg04+qypTUurpeJGP45A7Fhv7jdrrVH44PLlR9qXo37cVQ==", + "dev": true, + "license": "ISC" + }, "node_modules/errno": { "version": "0.1.8", "resolved": "https://registry.npmjs.org/errno/-/errno-0.1.8.tgz", @@ -870,50 +4139,66 @@ } }, "node_modules/es-abstract": { - "version": "1.22.1", - "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.22.1.tgz", - "integrity": "sha512-ioRRcXMO6OFyRpyzV3kE1IIBd4WG5/kltnzdxSCqoP8CMGs/Li+M1uF5o7lOkZVFjDs+NLesthnF66Pg/0q0Lw==", + "version": "1.24.2", + "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.24.2.tgz", + "integrity": "sha512-2FpH9Q5i2RRwyEP1AylXe6nYLR5OhaJTZwmlcP0dL/+JCbgg7yyEo/sEK6HeGZRf3dFpWwThaRHVApXSkW3xeg==", "dev": true, + "license": "MIT", "dependencies": { - "array-buffer-byte-length": "^1.0.0", - "arraybuffer.prototype.slice": "^1.0.1", - "available-typed-arrays": "^1.0.5", - "call-bind": "^1.0.2", - "es-set-tostringtag": "^2.0.1", - "es-to-primitive": "^1.2.1", - "function.prototype.name": "^1.1.5", - "get-intrinsic": "^1.2.1", - "get-symbol-description": "^1.0.0", - "globalthis": "^1.0.3", - "gopd": "^1.0.1", - "has": "^1.0.3", - "has-property-descriptors": "^1.0.0", - "has-proto": "^1.0.1", - "has-symbols": "^1.0.3", - "internal-slot": "^1.0.5", - "is-array-buffer": "^3.0.2", + "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-negative-zero": "^2.0.2", - "is-regex": "^1.1.4", - "is-shared-array-buffer": "^1.0.2", - "is-string": "^1.0.7", - "is-typed-array": "^1.1.10", - "is-weakref": "^1.0.2", - "object-inspect": "^1.12.3", + "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.4", - "regexp.prototype.flags": "^1.5.0", - "safe-array-concat": "^1.0.0", - "safe-regex-test": "^1.0.0", - "string.prototype.trim": "^1.2.7", - "string.prototype.trimend": "^1.0.6", - "string.prototype.trimstart": "^1.0.6", - "typed-array-buffer": "^1.0.0", - "typed-array-byte-length": "^1.0.0", - "typed-array-byte-offset": "^1.0.0", - "typed-array-length": "^1.0.4", - "unbox-primitive": "^1.0.2", - "which-typed-array": "^1.1.10" + "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" }, "engines": { "node": ">= 0.4" @@ -922,29 +4207,87 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/es-set-tostringtag": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.0.1.tgz", - "integrity": "sha512-g3OMbtlwY3QewlqAiMLI47KywjWZoEytKr8pf6iTC8uJq5bIAH52Z9pnQ8pVL6whrCto53JZDuUIsifGeLorTg==", + "node_modules/es-abstract-get": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/es-abstract-get/-/es-abstract-get-1.0.0.tgz", + "integrity": "sha512-6PMWXpdhshVvFp+FoWYs1EvG1Nj0tvk0dZM+XcK0xMEM1czRVcP6ohqPWHy6qPagSpC8j4+p89WXlT+xXJs/fg==", "dev": true, + "license": "MIT", "dependencies": { - "get-intrinsic": "^1.1.3", - "has": "^1.0.3", - "has-tostringtag": "^1.0.0" + "es-errors": "^1.3.0", + "es-object-atoms": "^1.1.2", + "is-callable": "^1.2.7", + "object-inspect": "^1.13.4" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/es-define-property": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz", + "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-errors": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz", + "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-object-atoms": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.2.tgz", + "integrity": "sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-set-tostringtag": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz", + "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.6", + "has-tostringtag": "^1.0.2", + "hasown": "^2.0.2" }, "engines": { "node": ">= 0.4" } }, "node_modules/es-to-primitive": { - "version": "1.2.1", - "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz", - "integrity": "sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==", + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.3.4.tgz", + "integrity": "sha512-yPDz7wqpg1/mmHLmS3tcfTfbw5f1eryXvyghYBffGdERwe+mV7ZcWzTR8LR17Kvqt3qfPurjlonmnq3MKXIOXw==", "dev": true, + "license": "MIT", "dependencies": { - "is-callable": "^1.1.4", - "is-date-object": "^1.0.1", - "is-symbol": "^1.0.2" + "es-abstract-get": "^1.0.0", + "es-define-property": "^1.0.1", + "es-errors": "^1.3.0", + "is-callable": "^1.2.7", + "is-date-object": "^1.1.0", + "is-symbol": "^1.1.1" }, "engines": { "node": ">= 0.4" @@ -990,6 +4333,16 @@ "@esbuild/win32-x64": "0.18.20" } }, + "node_modules/escalade": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", + "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, "node_modules/escape-string-regexp": { "version": "1.0.5", "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", @@ -1004,13 +4357,222 @@ "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz", "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==" }, - "node_modules/for-each": { - "version": "0.3.3", - "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz", - "integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==", + "node_modules/esutils": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", + "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/eta": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/eta/-/eta-4.6.0.tgz", + "integrity": "sha512-lW6is4T1NFOYnmqGZIfvixqj7A7sSvScF+DN8EK6K58xI5MZ5UvYe0GjopxOXQtZvUn4eDdVuZ8XSoYWTMEKwA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=20" + }, + "funding": { + "url": "https://github.com/bgub/eta?sponsor=1" + } + }, + "node_modules/fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/fast-json-stable-stringify": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", + "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", + "dev": true, + "license": "MIT" + }, + "node_modules/fast-uri": { + "version": "3.1.4", + "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.4.tgz", + "integrity": "sha512-8JnbkQ4juDyvYs4mgFGQqg4yCYtFDtUtmp2QIQq11ZZe5CFQ5wcqm1rqDgAh/QdMySuBnPzMUiJUNZG5N/AiQw==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/fastify" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/fastify" + } + ], + "license": "BSD-3-Clause" + }, + "node_modules/fdir": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", + "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, + "node_modules/filelist": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/filelist/-/filelist-1.0.6.tgz", + "integrity": "sha512-5giy2PkLYY1cP39p17Ech+2xlpTRL9HLspOfEgm0L6CwBXBTgsK5ou0JtzYuepxkaQ/tvhCFIJ5uXo0OrM2DxA==", + "dev": true, + "license": "Apache-2.0", "dependencies": { - "is-callable": "^1.1.3" + "minimatch": "^5.0.1" + } + }, + "node_modules/filelist/node_modules/brace-expansion": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.2.tgz", + "integrity": "sha512-w5JZcKgdhDOgOwm8H+KgbosopHMuGcl6qbulwjtz3SM7I7P3yW1eAjzMPLrIE+NQ9vjgANKHWeMHnrT0OXW1oA==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/filelist/node_modules/minimatch": { + "version": "5.1.9", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.9.tgz", + "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/for-each": { + "version": "0.3.5", + "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.5.tgz", + "integrity": "sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-callable": "^1.2.7" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/foreground-child": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz", + "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==", + "dev": true, + "license": "ISC", + "dependencies": { + "cross-spawn": "^7.0.6", + "signal-exit": "^4.0.1" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/foreground-child/node_modules/cross-spawn": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", + "dev": true, + "license": "MIT", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/foreground-child/node_modules/path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/foreground-child/node_modules/shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "dev": true, + "license": "MIT", + "dependencies": { + "shebang-regex": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/foreground-child/node_modules/shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/foreground-child/node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/fs-extra": { + "version": "9.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz", + "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "at-least-node": "^1.0.0", + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=10" } }, "node_modules/fsevents": { @@ -1028,21 +4590,31 @@ } }, "node_modules/function-bind": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", - "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==", - "dev": true + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } }, "node_modules/function.prototype.name": { - "version": "1.1.5", - "resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.5.tgz", - "integrity": "sha512-uN7m/BzVKQnCUF/iW8jYea67v++2u7m5UgENbHRtdDVclOUP+FMPlCNdmk0h/ysGyo2tavMJEDqJAkJdRa1vMA==", + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.2.0.tgz", + "integrity": "sha512-jObKIik1P2QjPHP5nz5BaOtUlfgS0fWo8IUByNXkM+o+02sJOi94em77GwJKQSJ3gfPHdgzLNrHc1uokV4P/ew==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "define-properties": "^1.1.3", - "es-abstract": "^1.19.0", - "functions-have-names": "^1.2.2" + "call-bind": "^1.0.9", + "call-bound": "^1.0.4", + "es-define-property": "^1.0.1", + "es-errors": "^1.3.0", + "functions-have-names": "^1.2.3", + "has-property-descriptors": "^1.0.2", + "hasown": "^2.0.4", + "is-callable": "^1.2.7", + "is-document.all": "^1.0.0" }, "engines": { "node": ">= 0.4" @@ -1056,33 +4628,48 @@ "resolved": "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz", "integrity": "sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==", "dev": true, + "license": "MIT", "funding": { "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/generator-function": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/generator-function/-/generator-function-2.0.1.tgz", + "integrity": "sha512-SFdFmIJi+ybC0vjlHN0ZGVGHc3lgE0DxPAT0djjVg+kjOnSqclqmj0KQ7ykTOLP6YxoqOvuAODGdcHJn+43q3g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/gensync": { + "version": "1.0.0-beta.2", + "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", + "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, "node_modules/get-intrinsic": { - "version": "1.2.1", - "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.1.tgz", - "integrity": "sha512-2DcsyfABl+gVHEfCOaTrWgyt+tb6MSEGmKq+kI5HwLbIYgjgmMcV8KQ41uaKz1xxUcn9tJtgFbQUEVcEbd0FYw==", + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz", + "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==", "dev": true, + "license": "MIT", "dependencies": { - "function-bind": "^1.1.1", - "has": "^1.0.3", - "has-proto": "^1.0.1", - "has-symbols": "^1.0.3" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/get-symbol-description": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.0.0.tgz", - "integrity": "sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw==", - "dev": true, - "dependencies": { - "call-bind": "^1.0.2", - "get-intrinsic": "^1.1.1" + "call-bind-apply-helpers": "^1.0.2", + "es-define-property": "^1.0.1", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.1.1", + "function-bind": "^1.1.2", + "get-proto": "^1.0.1", + "gopd": "^1.2.0", + "has-symbols": "^1.1.0", + "hasown": "^2.0.2", + "math-intrinsics": "^1.1.0" }, "engines": { "node": ">= 0.4" @@ -1091,13 +4678,118 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/globalthis": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.3.tgz", - "integrity": "sha512-sFdI5LyBiNTHjRd7cGPWapiHWMOXKyuBNX/cWJ3NfzrZQVa8GI/8cofCl74AOVqq9W5kNmguTIzJ/1s2gyI9wA==", + "node_modules/get-own-enumerable-property-symbols": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/get-own-enumerable-property-symbols/-/get-own-enumerable-property-symbols-3.0.2.tgz", + "integrity": "sha512-I0UBV/XOz1XkIJHEUDMZAbzCThU/H8DxmSfmdGcKPnVhu2VfFqr34jr9777IyaTYvxjedWhqVIilEDsCdP5G6g==", "dev": true, + "license": "ISC" + }, + "node_modules/get-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz", + "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==", + "dev": true, + "license": "MIT", "dependencies": { - "define-properties": "^1.1.3" + "dunder-proto": "^1.0.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/get-symbol-description": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.1.0.tgz", + "integrity": "sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.6" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/glob": { + "version": "11.1.0", + "resolved": "https://registry.npmjs.org/glob/-/glob-11.1.0.tgz", + "integrity": "sha512-vuNwKSaKiqm7g0THUBu2x7ckSs3XJLXE+2ssL7/MfTGPLLcrJQ/4Uq1CjPTtO5cCIiRxqvN6Twy1qOwhL0Xjcw==", + "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "foreground-child": "^3.3.1", + "jackspeak": "^4.1.1", + "minimatch": "^10.1.1", + "minipass": "^7.1.2", + "package-json-from-dist": "^1.0.0", + "path-scurry": "^2.0.0" + }, + "bin": { + "glob": "dist/esm/bin.mjs" + }, + "engines": { + "node": "20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/glob/node_modules/balanced-match": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz", + "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "18 || 20 || >=22" + } + }, + "node_modules/glob/node_modules/brace-expansion": { + "version": "5.0.7", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.7.tgz", + "integrity": "sha512-7oFy703dxfY3/NLxC1fh2SUCQ0H9rmAY+5EpDVfXjUTTs+HEwR2nYaqLv+GWcTsumwxPfiz6CzCNkwXwBUwqCA==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^4.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + } + }, + "node_modules/glob/node_modules/minimatch": { + "version": "10.2.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.5.tgz", + "integrity": "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "brace-expansion": "^5.0.5" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/globalthis": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.4.tgz", + "integrity": "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "define-properties": "^1.2.1", + "gopd": "^1.0.1" }, "engines": { "node": ">= 0.4" @@ -1107,12 +4799,13 @@ } }, "node_modules/gopd": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz", - "integrity": "sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==", + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz", + "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==", "dev": true, - "dependencies": { - "get-intrinsic": "^1.1.3" + "license": "MIT", + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -1124,23 +4817,15 @@ "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==", "dev": true }, - "node_modules/has": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz", - "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==", - "dev": true, - "dependencies": { - "function-bind": "^1.1.1" - }, - "engines": { - "node": ">= 0.4.0" - } - }, "node_modules/has-bigints": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.0.2.tgz", - "integrity": "sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==", + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.1.0.tgz", + "integrity": "sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg==", "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, "funding": { "url": "https://github.com/sponsors/ljharb" } @@ -1155,22 +4840,27 @@ } }, "node_modules/has-property-descriptors": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz", - "integrity": "sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ==", + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz", + "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==", "dev": true, + "license": "MIT", "dependencies": { - "get-intrinsic": "^1.1.1" + "es-define-property": "^1.0.0" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/has-proto": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.1.tgz", - "integrity": "sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg==", + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.2.0.tgz", + "integrity": "sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ==", "dev": true, + "license": "MIT", + "dependencies": { + "dunder-proto": "^1.0.0" + }, "engines": { "node": ">= 0.4" }, @@ -1179,10 +4869,11 @@ } }, "node_modules/has-symbols": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz", - "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==", + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz", + "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==", "dev": true, + "license": "MIT", "engines": { "node": ">= 0.4" }, @@ -1191,12 +4882,13 @@ } }, "node_modules/has-tostringtag": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.0.tgz", - "integrity": "sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==", + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz", + "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==", "dev": true, + "license": "MIT", "dependencies": { - "has-symbols": "^1.0.2" + "has-symbols": "^1.0.3" }, "engines": { "node": ">= 0.4" @@ -1205,6 +4897,19 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/hasown": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz", + "integrity": "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==", + "dev": true, + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, "node_modules/he": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz", @@ -1220,6 +4925,13 @@ "integrity": "sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==", "dev": true }, + "node_modules/ico-endec": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/ico-endec/-/ico-endec-0.1.6.tgz", + "integrity": "sha512-ZdLU38ZoED3g1j3iEyzcQj+wAkY2xfWNkymszfJPoxucIUhK7NayQ+/C4Kv0nDFMIsbtbEHldv3V8PU494/ueQ==", + "dev": true, + "license": "MPL-2.0" + }, "node_modules/iconv-lite": { "version": "0.6.3", "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz", @@ -1233,6 +4945,13 @@ "node": ">=0.10.0" } }, + "node_modules/idb": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/idb/-/idb-7.1.1.tgz", + "integrity": "sha512-gchesWBzyvGHRO9W8tzUWFDycow5gwjvFKfyV9FF32Y7F50yZMp7mP+T2mJIWFx49zicqyC4uefHM17o6xKIVQ==", + "dev": true, + "license": "ISC" + }, "node_modules/image-size": { "version": "0.5.5", "resolved": "https://registry.npmjs.org/image-size/-/image-size-0.5.5.tgz", @@ -1247,28 +4966,33 @@ } }, "node_modules/internal-slot": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.5.tgz", - "integrity": "sha512-Y+R5hJrzs52QCG2laLn4udYVnxsfny9CpOhNhUvk/SSSVyF6T27FzRbF0sroPidSu3X8oEAkOn2K804mjpt6UQ==", + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.1.0.tgz", + "integrity": "sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw==", "dev": true, + "license": "MIT", "dependencies": { - "get-intrinsic": "^1.2.0", - "has": "^1.0.3", - "side-channel": "^1.0.4" + "es-errors": "^1.3.0", + "hasown": "^2.0.2", + "side-channel": "^1.1.0" }, "engines": { "node": ">= 0.4" } }, "node_modules/is-array-buffer": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.2.tgz", - "integrity": "sha512-y+FyyR/w8vfIRq4eQcM1EYgSTnmHXPqaF+IgzgraytCFq5Xh8lllDVmAZolPJiZttZLeFSINPYMaEJ7/vWUa1w==", + "version": "3.0.5", + "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.5.tgz", + "integrity": "sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "get-intrinsic": "^1.2.0", - "is-typed-array": "^1.1.10" + "call-bind": "^1.0.8", + "call-bound": "^1.0.3", + "get-intrinsic": "^1.2.6" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -1280,26 +5004,51 @@ "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==", "dev": true }, - "node_modules/is-bigint": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.0.4.tgz", - "integrity": "sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==", + "node_modules/is-async-function": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-async-function/-/is-async-function-2.1.1.tgz", + "integrity": "sha512-9dgM/cZBnNvjzaMYHVoxxfPj2QXt22Ev7SuuPrs+xav0ukGB0S6d4ydZdEiM48kLx5kDV+QBPrpVnFyefL8kkQ==", "dev": true, + "license": "MIT", "dependencies": { - "has-bigints": "^1.0.1" + "async-function": "^1.0.0", + "call-bound": "^1.0.3", + "get-proto": "^1.0.1", + "has-tostringtag": "^1.0.2", + "safe-regex-test": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-bigint": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.1.0.tgz", + "integrity": "sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-bigints": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/is-boolean-object": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.1.2.tgz", - "integrity": "sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==", + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.2.2.tgz", + "integrity": "sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "has-tostringtag": "^1.0.0" + "call-bound": "^1.0.3", + "has-tostringtag": "^1.0.2" }, "engines": { "node": ">= 0.4" @@ -1313,6 +5062,7 @@ "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz", "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==", "dev": true, + "license": "MIT", "engines": { "node": ">= 0.4" }, @@ -1321,24 +5071,13 @@ } }, "node_modules/is-core-module": { - "version": "2.13.0", - "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.13.0.tgz", - "integrity": "sha512-Z7dk6Qo8pOCp3l4tsX2C5ZVas4V+UxwQodwZhLopL91TX8UyyHEXafPcyoeeWuLrwzHcr3igO78wNLwHJHsMCQ==", + "version": "2.16.2", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.2.tgz", + "integrity": "sha512-evOr8xfXKxE6qSR0hSXL2r3sd7ALj8+7jQEUvPYcm5sgZFdJ+AYzT6yNmJenvIYQBgIGwfwz08sL8zoL7yq2BA==", "dev": true, + "license": "MIT", "dependencies": { - "has": "^1.0.3" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/is-date-object": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.5.tgz", - "integrity": "sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==", - "dev": true, - "dependencies": { - "has-tostringtag": "^1.0.0" + "hasown": "^2.0.3" }, "engines": { "node": ">= 0.4" @@ -1347,11 +5086,119 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/is-negative-zero": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.2.tgz", - "integrity": "sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA==", + "node_modules/is-data-view": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-data-view/-/is-data-view-1.0.2.tgz", + "integrity": "sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw==", "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "get-intrinsic": "^1.2.6", + "is-typed-array": "^1.1.13" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-date-object": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.1.0.tgz", + "integrity": "sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "has-tostringtag": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-document.all": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-document.all/-/is-document.all-1.0.0.tgz", + "integrity": "sha512-+XSoyS05OdBbhFuELhgTCpFNHkpBOJqtsZfUFFpe5QTw+9Sjbh8zitxhQkYAo6wV7e1Vb8cAPvpCk9jGam/82g==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.4" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-finalizationregistry": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-finalizationregistry/-/is-finalizationregistry-1.1.1.tgz", + "integrity": "sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-generator-function": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.1.2.tgz", + "integrity": "sha512-upqt1SkGkODW9tsGNG5mtXTXtECizwtS2kA161M+gJPc1xdb/Ax629af6YrTwcOeQHbewrPNlE5Dx7kzvXTizA==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.4", + "generator-function": "^2.0.0", + "get-proto": "^1.0.1", + "has-tostringtag": "^1.0.2", + "safe-regex-test": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-map": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/is-map/-/is-map-2.0.3.tgz", + "integrity": "sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-module": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-module/-/is-module-1.0.0.tgz", + "integrity": "sha512-51ypPSPCoTEIN9dy5Oy+h4pShgJmPCygKfyRCISBI+JoWT/2oJvK8QPxmwv7b/p239jXrm9M1mlQbyKJ5A152g==", + "dev": true, + "license": "MIT" + }, + "node_modules/is-negative-zero": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.3.tgz", + "integrity": "sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==", + "dev": true, + "license": "MIT", "engines": { "node": ">= 0.4" }, @@ -1360,12 +5207,14 @@ } }, "node_modules/is-number-object": { - "version": "1.0.7", - "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.0.7.tgz", - "integrity": "sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==", + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.1.1.tgz", + "integrity": "sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw==", "dev": true, + "license": "MIT", "dependencies": { - "has-tostringtag": "^1.0.0" + "call-bound": "^1.0.3", + "has-tostringtag": "^1.0.2" }, "engines": { "node": ">= 0.4" @@ -1374,14 +5223,27 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/is-regex": { - "version": "1.1.4", - "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.1.4.tgz", - "integrity": "sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==", + "node_modules/is-obj": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-obj/-/is-obj-1.0.1.tgz", + "integrity": "sha512-l4RyHgRqGN4Y3+9JHVrNqO+tN0rV5My76uW5/nuO4K1b6vw5G8d/cmFjP9tRfEsdhZNt0IFdZuK/c2Vr4Nb+Qg==", "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-regex": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.2.1.tgz", + "integrity": "sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==", + "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "has-tostringtag": "^1.0.0" + "call-bound": "^1.0.2", + "gopd": "^1.2.0", + "has-tostringtag": "^1.0.2", + "hasown": "^2.0.2" }, "engines": { "node": ">= 0.4" @@ -1390,25 +5252,67 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/is-regexp": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-regexp/-/is-regexp-1.0.0.tgz", + "integrity": "sha512-7zjFAPO4/gwyQAAgRRmqeEeyIICSdmCqa3tsVHMdBzaXXRiqopZL4Cyghg/XulGWrtABTpbnYYzzIRffLkP4oA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-set": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/is-set/-/is-set-2.0.3.tgz", + "integrity": "sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/is-shared-array-buffer": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.2.tgz", - "integrity": "sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA==", + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.4.tgz", + "integrity": "sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2" + "call-bound": "^1.0.3" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/is-string": { - "version": "1.0.7", - "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.0.7.tgz", - "integrity": "sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==", + "node_modules/is-stream": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz", + "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==", "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-string": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.1.1.tgz", + "integrity": "sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA==", + "dev": true, + "license": "MIT", "dependencies": { - "has-tostringtag": "^1.0.0" + "call-bound": "^1.0.3", + "has-tostringtag": "^1.0.2" }, "engines": { "node": ">= 0.4" @@ -1418,12 +5322,15 @@ } }, "node_modules/is-symbol": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.4.tgz", - "integrity": "sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==", + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.1.1.tgz", + "integrity": "sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w==", "dev": true, + "license": "MIT", "dependencies": { - "has-symbols": "^1.0.2" + "call-bound": "^1.0.2", + "has-symbols": "^1.1.0", + "safe-regex-test": "^1.1.0" }, "engines": { "node": ">= 0.4" @@ -1433,12 +5340,13 @@ } }, "node_modules/is-typed-array": { - "version": "1.1.12", - "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.12.tgz", - "integrity": "sha512-Z14TF2JNG8Lss5/HMqt0//T9JeHXttXy5pH/DBU4vi98ozO2btxzq9MwYDZYnKwU8nRsz/+GVFVRDq3DkVuSPg==", + "version": "1.1.15", + "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.15.tgz", + "integrity": "sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==", "dev": true, + "license": "MIT", "dependencies": { - "which-typed-array": "^1.1.11" + "which-typed-array": "^1.1.16" }, "engines": { "node": ">= 0.4" @@ -1447,13 +5355,47 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/is-weakref": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.0.2.tgz", - "integrity": "sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==", + "node_modules/is-weakmap": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/is-weakmap/-/is-weakmap-2.0.2.tgz", + "integrity": "sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w==", "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-weakref": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.1.1.tgz", + "integrity": "sha512-6i9mGWSlqzNMEqpCp93KwRS1uUOodk2OJ6b+sq7ZPDSy2WuI5NFIxp/254TytR8ftefexkWn5xNiHUNpPOfSew==", + "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2" + "call-bound": "^1.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-weakset": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/is-weakset/-/is-weakset-2.0.4.tgz", + "integrity": "sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3", + "get-intrinsic": "^1.2.6" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -1469,7 +5411,8 @@ "version": "2.0.5", "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz", "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/isexe": { "version": "2.0.0", @@ -1477,12 +5420,119 @@ "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", "dev": true }, + "node_modules/jackspeak": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-4.2.3.tgz", + "integrity": "sha512-ykkVRwrYvFm1nb2AJfKKYPr0emF6IiXDYUaFx4Zn9ZuIH7MrzEZ3sD5RlqGXNRpHtvUHJyOnCEFxOlNDtGo7wg==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "@isaacs/cliui": "^9.0.0" + }, + "engines": { + "node": "20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/jake": { + "version": "10.9.4", + "resolved": "https://registry.npmjs.org/jake/-/jake-10.9.4.tgz", + "integrity": "sha512-wpHYzhxiVQL+IV05BLE2Xn34zW1S223hvjtqk0+gsPrwd/8JNLXJgZZM/iPFsYc1xyphF+6M6EvdE5E9MBGkDA==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "async": "^3.2.6", + "filelist": "^1.0.4", + "picocolors": "^1.1.1" + }, + "bin": { + "jake": "bin/cli.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/jiti": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/jiti/-/jiti-2.7.0.tgz", + "integrity": "sha512-AC/7JofJvZGrrneWNaEnJeOLUx+JlGt7tNa0wZiRPT4MY1wmfKjt2+6O2p2uz2+skll8OZZmJMNqeke7kKbNgQ==", + "dev": true, + "license": "MIT", + "bin": { + "jiti": "lib/jiti-cli.mjs" + } + }, + "node_modules/js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/jsesc": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz", + "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==", + "dev": true, + "license": "MIT", + "bin": { + "jsesc": "bin/jsesc" + }, + "engines": { + "node": ">=6" + } + }, "node_modules/json-parse-better-errors": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/json-parse-better-errors/-/json-parse-better-errors-1.0.2.tgz", "integrity": "sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw==", "dev": true }, + "node_modules/json-schema-traverse": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==", + "dev": true, + "license": "MIT" + }, + "node_modules/json5": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", + "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", + "dev": true, + "license": "MIT", + "bin": { + "json5": "lib/cli.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/jsonfile": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz", + "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "universalify": "^2.0.0" + }, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/jsonpointer": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/jsonpointer/-/jsonpointer-5.0.1.tgz", + "integrity": "sha512-p/nXbhSEcu3pZRdkW1OfJhpsVtW1gd4Wa1fnQc9YLiTfAjn0312eMKimbdIQzuZl9aa9xUGaRlP9T/CJE/ditQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, "node_modules/just-extend": { "version": "5.1.1", "resolved": "https://registry.npmjs.org/just-extend/-/just-extend-5.1.1.tgz", @@ -1515,6 +5565,16 @@ "source-map": "~0.6.0" } }, + "node_modules/leven": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/leven/-/leven-3.1.0.tgz", + "integrity": "sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, "node_modules/load-json-file": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-4.0.0.tgz", @@ -1530,6 +5590,13 @@ "node": ">=4" } }, + "node_modules/lodash.debounce": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/lodash.debounce/-/lodash.debounce-4.0.8.tgz", + "integrity": "sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==", + "dev": true, + "license": "MIT" + }, "node_modules/lru-cache": { "version": "6.0.0", "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", @@ -1543,14 +5610,12 @@ } }, "node_modules/magic-string": { - "version": "0.30.2", - "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.2.tgz", - "integrity": "sha512-lNZdu7pewtq/ZvWUp9Wpf/x7WzMTsR26TWV03BRZrXFsv+BI6dy8RAiKgm1uM/kyR0rCfUcqvOlXKG66KhIGug==", + "version": "0.30.21", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz", + "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==", + "license": "MIT", "dependencies": { - "@jridgewell/sourcemap-codec": "^1.4.15" - }, - "engines": { - "node": ">=12" + "@jridgewell/sourcemap-codec": "^1.5.5" } }, "node_modules/make-dir": { @@ -1577,6 +5642,16 @@ "node": ">=6" } }, + "node_modules/math-intrinsics": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz", + "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, "node_modules/memorystream": { "version": "0.3.1", "resolved": "https://registry.npmjs.org/memorystream/-/memorystream-0.3.1.tgz", @@ -1611,12 +5686,21 @@ "node": "*" } }, + "node_modules/minipass": { + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz", + "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, "node_modules/ms": { "version": "2.1.3", "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", - "dev": true, - "optional": true + "dev": true }, "node_modules/muggle-string": { "version": "0.3.1", @@ -1665,6 +5749,16 @@ "integrity": "sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ==", "dev": true }, + "node_modules/node-releases": { + "version": "2.0.51", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.51.tgz", + "integrity": "sha512-wRNIrw4DmVLKQlbgOMdkMx27Wrpzes2hh5Jtbi2bjPd+4wJstWIqP5A+lscnqbm0xxmT5Bpg8Lec5ItEBwx6BQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + } + }, "node_modules/normalize-package-data": { "version": "2.5.0", "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.5.0.tgz", @@ -1703,10 +5797,14 @@ } }, "node_modules/object-inspect": { - "version": "1.12.3", - "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.3.tgz", - "integrity": "sha512-geUvdk7c+eizMNUDkRpW1wJwgfOiOeHbxBR/hLXK1aT6zmVSO0jsQcs7fj6MGw89jC/cjGfLcNOrtMYtGqm81g==", + "version": "1.13.4", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz", + "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==", "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, "funding": { "url": "https://github.com/sponsors/ljharb" } @@ -1721,14 +5819,17 @@ } }, "node_modules/object.assign": { - "version": "4.1.4", - "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.4.tgz", - "integrity": "sha512-1mxKf0e58bvyjSCtKYY4sRe9itRk3PJpquJOjeIkz885CczcI4IvJJDLPS72oowuSh+pBxUFROpX+TU++hxhZQ==", + "version": "4.1.7", + "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.7.tgz", + "integrity": "sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "define-properties": "^1.1.4", - "has-symbols": "^1.0.3", + "call-bind": "^1.0.8", + "call-bound": "^1.0.3", + "define-properties": "^1.2.1", + "es-object-atoms": "^1.0.0", + "has-symbols": "^1.1.0", "object-keys": "^1.1.1" }, "engines": { @@ -1738,6 +5839,31 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/own-keys": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/own-keys/-/own-keys-1.0.1.tgz", + "integrity": "sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg==", + "dev": true, + "license": "MIT", + "dependencies": { + "get-intrinsic": "^1.2.6", + "object-keys": "^1.1.1", + "safe-push-apply": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/package-json-from-dist": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz", + "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==", + "dev": true, + "license": "BlueOak-1.0.0" + }, "node_modules/parse-json": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-4.0.0.tgz", @@ -1775,6 +5901,33 @@ "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", "dev": true }, + "node_modules/path-scurry": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.2.tgz", + "integrity": "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "lru-cache": "^11.0.0", + "minipass": "^7.1.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/path-scurry/node_modules/lru-cache": { + "version": "11.5.2", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.2.tgz", + "integrity": "sha512-4pfM1Ff0x50o0tQwb5ucw/RzNyD0/YJME6IVcStalZuMWxdt3sR3huStTtxz4PUmvZfRguvDejasvQ2kifR11g==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": "20 || >=22" + } + }, "node_modules/path-type": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/path-type/-/path-type-3.0.0.tgz", @@ -1788,9 +5941,23 @@ } }, "node_modules/picocolors": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz", - "integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==" + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.5.tgz", + "integrity": "sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } }, "node_modules/pidtree": { "version": "0.3.1", @@ -1813,6 +5980,16 @@ "node": ">=4" } }, + "node_modules/possible-typed-array-names": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz", + "integrity": "sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, "node_modules/postcss": { "version": "8.4.27", "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.27.tgz", @@ -1840,6 +6017,19 @@ "node": "^10 || ^12 || >=14" } }, + "node_modules/pretty-bytes": { + "version": "6.1.1", + "resolved": "https://registry.npmjs.org/pretty-bytes/-/pretty-bytes-6.1.1.tgz", + "integrity": "sha512-mQUvGU6aUFQ+rNvTIAcZuWGRT9a6f6Yrg9bHs4ImKF+HZCEK+plBvnAZYSIQztknZF2qnzNtr6F8s0+IuptdlQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/prr": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/prr/-/prr-1.0.1.tgz", @@ -1847,6 +6037,23 @@ "dev": true, "optional": true }, + "node_modules/quansync": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/quansync/-/quansync-1.0.0.tgz", + "integrity": "sha512-5xZacEEufv3HSTPQuchrvV6soaiACMFnq1H8wkVioctoH3TRha9Sz66lOxRwPK/qZj7HPiSveih9yAyh98gvqA==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/antfu" + }, + { + "type": "individual", + "url": "https://github.com/sponsors/sxzz" + } + ], + "license": "MIT" + }, "node_modules/read-pkg": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-3.0.0.tgz", @@ -1861,15 +6068,21 @@ "node": ">=4" } }, - "node_modules/regexp.prototype.flags": { - "version": "1.5.0", - "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.0.tgz", - "integrity": "sha512-0SutC3pNudRKgquxGoRGIz946MZVHqbNfPjBdxeOhBrdgDKlRoXmYLQN9xRbrR09ZXWeGAdPuif7egofn6v5LA==", + "node_modules/reflect.getprototypeof": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz", + "integrity": "sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "define-properties": "^1.2.0", - "functions-have-names": "^1.2.3" + "call-bind": "^1.0.8", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.9", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.0.0", + "get-intrinsic": "^1.2.7", + "get-proto": "^1.0.1", + "which-builtin-type": "^1.2.1" }, "engines": { "node": ">= 0.4" @@ -1878,19 +6091,113 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/resolve": { - "version": "1.22.4", - "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.4.tgz", - "integrity": "sha512-PXNdCiPqDqeUou+w1C2eTQbNfxKSuMxqTCuvlmmMsk1NWHL5fRrhY6Pl0qEYYc6+QqGClco1Qj8XnjPego4wfg==", + "node_modules/regenerate": { + "version": "1.4.2", + "resolved": "https://registry.npmjs.org/regenerate/-/regenerate-1.4.2.tgz", + "integrity": "sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==", "dev": true, + "license": "MIT" + }, + "node_modules/regenerate-unicode-properties": { + "version": "10.2.2", + "resolved": "https://registry.npmjs.org/regenerate-unicode-properties/-/regenerate-unicode-properties-10.2.2.tgz", + "integrity": "sha512-m03P+zhBeQd1RGnYxrGyDAPpWX/epKirLrp8e3qevZdVkKtnCrjjWczIbYc8+xd6vcTStVlqfycTx1KR4LOr0g==", + "dev": true, + "license": "MIT", "dependencies": { - "is-core-module": "^2.13.0", + "regenerate": "^1.4.2" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/regexp.prototype.flags": { + "version": "1.5.4", + "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.4.tgz", + "integrity": "sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA==", + "dev": true, + "license": "MIT", + "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" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/regexpu-core": { + "version": "6.4.0", + "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-6.4.0.tgz", + "integrity": "sha512-0ghuzq67LI9bLXpOX/ISfve/Mq33a4aFRzoQYhnnok1JOFpmE/A2TBGkNVenOGEeSBCjIiWcc6MVOG5HEQv0sA==", + "dev": true, + "license": "MIT", + "dependencies": { + "regenerate": "^1.4.2", + "regenerate-unicode-properties": "^10.2.2", + "regjsgen": "^0.8.0", + "regjsparser": "^0.13.0", + "unicode-match-property-ecmascript": "^2.0.0", + "unicode-match-property-value-ecmascript": "^2.2.1" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/regjsgen": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.8.0.tgz", + "integrity": "sha512-RvwtGe3d7LvWiDQXeQw8p5asZUmfU1G/l6WbUXeHta7Y2PEIvBTwH6E2EfmYUK8pxcxEdEmaomqyp0vZZ7C+3Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/regjsparser": { + "version": "0.13.2", + "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.13.2.tgz", + "integrity": "sha512-NgRBy2Nx/bE+9F27nVHnqcN5HjyLmecqsqx2PJHu3/IEtADD4WuxuXIVExD5PoSDFVrl78dOonfcOe5O+5nbzQ==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "jsesc": "~3.1.0" + }, + "bin": { + "regjsparser": "bin/parser" + } + }, + "node_modules/require-from-string": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz", + "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/resolve": { + "version": "1.22.12", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.12.tgz", + "integrity": "sha512-TyeJ1zif53BPfHootBGwPRYT1RUt6oGWsaQr8UyZW/eAm9bKoijtvruSDEmZHm92CwS9nj7/fWttqPCgzep8CA==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "is-core-module": "^2.16.1", "path-parse": "^1.0.7", "supports-preserve-symlinks-flag": "^1.0.0" }, "bin": { "resolve": "bin/resolve" }, + "engines": { + "node": ">= 0.4" + }, "funding": { "url": "https://github.com/sponsors/ljharb" } @@ -1920,14 +6227,16 @@ } }, "node_modules/safe-array-concat": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/safe-array-concat/-/safe-array-concat-1.0.0.tgz", - "integrity": "sha512-9dVEFruWIsnie89yym+xWTAYASdpw3CJV7Li/6zBewGf9z2i1j31rP6jnY0pHEO4QZh6N0K11bFjWmdR8UGdPQ==", + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/safe-array-concat/-/safe-array-concat-1.1.4.tgz", + "integrity": "sha512-wtZlHyOje6OZTGqAoaDKxFkgRtkF9CnHAVnCHKfuj200wAgL+bSJhdsCD2l0Qx/2ekEXjPWcyKkfGb5CPboslg==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "get-intrinsic": "^1.2.0", - "has-symbols": "^1.0.3", + "call-bind": "^1.0.9", + "call-bound": "^1.0.4", + "get-intrinsic": "^1.3.0", + "has-symbols": "^1.1.0", "isarray": "^2.0.5" }, "engines": { @@ -1937,15 +6246,36 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/safe-regex-test": { + "node_modules/safe-push-apply": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.0.0.tgz", - "integrity": "sha512-JBUUzyOgEwXQY1NuPtvcj/qcBDbDmEvWufhlnXZIm75DEHp+afM1r1ujJpJsV/gSM4t59tpDyPi1sd6ZaPFfsA==", + "resolved": "https://registry.npmjs.org/safe-push-apply/-/safe-push-apply-1.0.0.tgz", + "integrity": "sha512-iKE9w/Z7xCzUMIZqdBsp6pEQvwuEebH4vdpjcDWnyzaI6yl6O9FHvVpmGelvEHNsoY6wGblkxR6Zty/h00WiSA==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "get-intrinsic": "^1.1.3", - "is-regex": "^1.1.4" + "es-errors": "^1.3.0", + "isarray": "^2.0.5" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/safe-regex-test": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.1.0.tgz", + "integrity": "sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "is-regex": "^1.2.1" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -1974,6 +6304,130 @@ "semver": "bin/semver" } }, + "node_modules/serialize-javascript": { + "version": "7.0.7", + "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-7.0.7.tgz", + "integrity": "sha512-YAy8Od6KV+uuwUuU50np8fGB/Aues6Y0nAhA9y/hId74PlKUcme4pXcBD46NWKr1Q4osN/iseZ17YqO1XfmI8g==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/set-function-length": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz", + "integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==", + "dev": true, + "license": "MIT", + "dependencies": { + "define-data-property": "^1.1.4", + "es-errors": "^1.3.0", + "function-bind": "^1.1.2", + "get-intrinsic": "^1.2.4", + "gopd": "^1.0.1", + "has-property-descriptors": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/set-function-name": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/set-function-name/-/set-function-name-2.0.2.tgz", + "integrity": "sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "define-data-property": "^1.1.4", + "es-errors": "^1.3.0", + "functions-have-names": "^1.2.3", + "has-property-descriptors": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/set-proto": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/set-proto/-/set-proto-1.0.0.tgz", + "integrity": "sha512-RJRdvCo6IAnPdsvP/7m6bsQqNnn1FCBX5ZNtFL98MmFF/4xAIJTIg1YbHW5DC2W5SKZanrC6i4HsJqlajw/dZw==", + "dev": true, + "license": "MIT", + "dependencies": { + "dunder-proto": "^1.0.1", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/sharp": { + "version": "0.33.5", + "resolved": "https://registry.npmjs.org/sharp/-/sharp-0.33.5.tgz", + "integrity": "sha512-haPVm1EkS9pgvHrQ/F3Xy+hgcuMV0Wm9vfIBSiwZ05k+xgb0PkBQpGsAA/oWdDobNaZTH5ppvHtzCFbnSEwHVw==", + "dev": true, + "hasInstallScript": true, + "license": "Apache-2.0", + "dependencies": { + "color": "^4.2.3", + "detect-libc": "^2.0.3", + "semver": "^7.6.3" + }, + "engines": { + "node": "^18.17.0 || ^20.3.0 || >=21.0.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-darwin-arm64": "0.33.5", + "@img/sharp-darwin-x64": "0.33.5", + "@img/sharp-libvips-darwin-arm64": "1.0.4", + "@img/sharp-libvips-darwin-x64": "1.0.4", + "@img/sharp-libvips-linux-arm": "1.0.5", + "@img/sharp-libvips-linux-arm64": "1.0.4", + "@img/sharp-libvips-linux-s390x": "1.0.4", + "@img/sharp-libvips-linux-x64": "1.0.4", + "@img/sharp-libvips-linuxmusl-arm64": "1.0.4", + "@img/sharp-libvips-linuxmusl-x64": "1.0.4", + "@img/sharp-linux-arm": "0.33.5", + "@img/sharp-linux-arm64": "0.33.5", + "@img/sharp-linux-s390x": "0.33.5", + "@img/sharp-linux-x64": "0.33.5", + "@img/sharp-linuxmusl-arm64": "0.33.5", + "@img/sharp-linuxmusl-x64": "0.33.5", + "@img/sharp-wasm32": "0.33.5", + "@img/sharp-win32-ia32": "0.33.5", + "@img/sharp-win32-x64": "0.33.5" + } + }, + "node_modules/sharp-ico": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/sharp-ico/-/sharp-ico-0.1.5.tgz", + "integrity": "sha512-a3jODQl82NPp1d5OYb0wY+oFaPk7AvyxipIowCHk7pBsZCWgbe0yAkU2OOXdoH0ENyANhyOQbs9xkAiRHcF02Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "decode-ico": "*", + "ico-endec": "*", + "sharp": "*" + } + }, + "node_modules/sharp/node_modules/semver": { + "version": "7.8.5", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.5.tgz", + "integrity": "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, "node_modules/shebang-command": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz", @@ -2005,25 +6459,126 @@ } }, "node_modules/side-channel": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz", - "integrity": "sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==", + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.1.tgz", + "integrity": "sha512-6x6dK6zJdpTzF4sQeNYxwtvBzf6Eg4GtlesS94HOvTudUeyK2WXAaIfmDgsyslYrRBeFIlsi54AYsFGUuhmvrQ==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.0", - "get-intrinsic": "^1.0.2", - "object-inspect": "^1.9.0" + "es-errors": "^1.3.0", + "object-inspect": "^1.13.4", + "side-channel-list": "^1.0.1", + "side-channel-map": "^1.0.1", + "side-channel-weakmap": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/side-channel-list": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.1.tgz", + "integrity": "sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.4" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-map": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz", + "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-weakmap": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz", + "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3", + "side-channel-map": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/signal-exit": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", + "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/simple-swizzle": { + "version": "0.2.4", + "resolved": "https://registry.npmjs.org/simple-swizzle/-/simple-swizzle-0.2.4.tgz", + "integrity": "sha512-nAu1WFPQSMNr2Zn9PGSZK9AGn4t/y97lEm+MXTtUDwfP0ksAIX4nO+6ruD9Jwut4C49SB1Ws+fbXsm/yScWOHw==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-arrayish": "^0.3.1" + } + }, + "node_modules/simple-swizzle/node_modules/is-arrayish": { + "version": "0.3.4", + "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.3.4.tgz", + "integrity": "sha512-m6UrgzFVUYawGBh1dUsWR5M2Clqic9RVXC/9f8ceNlv2IcO9j9J/z8UoCLPqtsPBFNzEpfR3xftohbfqDx8EQA==", + "dev": true, + "license": "MIT" + }, + "node_modules/smob": { + "version": "1.6.2", + "resolved": "https://registry.npmjs.org/smob/-/smob-1.6.2.tgz", + "integrity": "sha512-RQsvleCbF8cVHEv+xuDGaA4pOizFqJ0GgjtMSRo6oP8pnN7WsigHgVGey6aILRBKv4W2YOMHLqbKdnB6hpB9fw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=20.0.0" + } + }, "node_modules/source-map": { "version": "0.6.1", "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", "dev": true, - "optional": true, "engines": { "node": ">=0.10.0" } @@ -2036,6 +6591,17 @@ "node": ">=0.10.0" } }, + "node_modules/source-map-support": { + "version": "0.5.21", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz", + "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==", + "dev": true, + "license": "MIT", + "dependencies": { + "buffer-from": "^1.0.0", + "source-map": "^0.6.0" + } + }, "node_modules/spdx-correct": { "version": "3.2.0", "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.2.0.tgz", @@ -2068,6 +6634,48 @@ "integrity": "sha512-XkD+zwiqXHikFZm4AX/7JSCXA98U5Db4AFd5XUg/+9UNtnH75+Z9KxtpYiJZx36mUDVOwH83pl7yvCer6ewM3w==", "dev": true }, + "node_modules/stop-iteration-iterator": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/stop-iteration-iterator/-/stop-iteration-iterator-1.1.0.tgz", + "integrity": "sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "internal-slot": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/string.prototype.matchall": { + "version": "4.0.12", + "resolved": "https://registry.npmjs.org/string.prototype.matchall/-/string.prototype.matchall-4.0.12.tgz", + "integrity": "sha512-6CC9uyBL+/48dYizRf7H7VAYCMCNTBeM78x/VTUe9bFEaxBepPJDa1Ow99LqI/1yF7kuy7Q3cQsYMrcjGUcskA==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "call-bound": "^1.0.3", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.6", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.0.0", + "get-intrinsic": "^1.2.6", + "gopd": "^1.2.0", + "has-symbols": "^1.1.0", + "internal-slot": "^1.1.0", + "regexp.prototype.flags": "^1.5.3", + "set-function-name": "^2.0.2", + "side-channel": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/string.prototype.padend": { "version": "3.1.4", "resolved": "https://registry.npmjs.org/string.prototype.padend/-/string.prototype.padend-3.1.4.tgz", @@ -2086,14 +6694,20 @@ } }, "node_modules/string.prototype.trim": { - "version": "1.2.7", - "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.7.tgz", - "integrity": "sha512-p6TmeT1T3411M8Cgg9wBTMRtY2q9+PNy9EV1i2lIXUN/btt763oIfxwN3RR8VU6wHX8j/1CFy0L+YuThm6bgOg==", + "version": "1.2.11", + "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.11.tgz", + "integrity": "sha512-PwvK7BU+CMTJGYQCTZb5RWXIML92lftJLhQz1tBzgKiqGxJaMlBAa48POXaNAC2s4y8jr3EFqrkF9+44neS46w==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "define-properties": "^1.1.4", - "es-abstract": "^1.20.4" + "call-bind": "^1.0.9", + "call-bound": "^1.0.4", + "define-data-property": "^1.1.4", + "define-properties": "^1.2.1", + "es-abstract": "^1.24.2", + "es-object-atoms": "^1.1.2", + "has-property-descriptors": "^1.0.2", + "safe-regex-test": "^1.1.0" }, "engines": { "node": ">= 0.4" @@ -2103,33 +6717,57 @@ } }, "node_modules/string.prototype.trimend": { - "version": "1.0.6", - "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.6.tgz", - "integrity": "sha512-JySq+4mrPf9EsDBEDYMOb/lM7XQLulwg5R/m1r0PXEFqrV0qHvl58sdTilSXtKOflCsK2E8jxf+GKC0T07RWwQ==", + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.10.tgz", + "integrity": "sha512-2+3aDAOmPTmuFwjDnmJG2ctEkQKVki7vOSqaxkv42Mowj1V6PnvuwFCRrR5lChUux1TBskPjfkeTOhqczDMxTw==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "define-properties": "^1.1.4", - "es-abstract": "^1.20.4" + "call-bind": "^1.0.9", + "call-bound": "^1.0.4", + "define-properties": "^1.2.1", + "es-object-atoms": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/string.prototype.trimstart": { - "version": "1.0.6", - "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.6.tgz", - "integrity": "sha512-omqjMDaY92pbn5HOX7f9IccLA+U1tA9GvtU4JrodiXFfYB7jPzzHpRzpglLAjtUV6bB557zwClJezTqnAiYnQA==", + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.8.tgz", + "integrity": "sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "define-properties": "^1.1.4", - "es-abstract": "^1.20.4" + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/stringify-object": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/stringify-object/-/stringify-object-3.3.0.tgz", + "integrity": "sha512-rHqiFh1elqCQ9WPLIC8I0Q/g/wj5J1eMkyoiD6eoQApWHP0FtlK7rqnhmabL5VUY9JQCcqwwvlOaSuutekgyrw==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "get-own-enumerable-property-symbols": "^3.0.0", + "is-obj": "^1.0.1", + "is-regexp": "^1.0.0" + }, + "engines": { + "node": ">=4" + } + }, "node_modules/strip-bom": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", @@ -2139,6 +6777,16 @@ "node": ">=4" } }, + "node_modules/strip-comments": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/strip-comments/-/strip-comments-2.0.1.tgz", + "integrity": "sha512-ZprKx+bBLXv067WTCALv8SSz5l2+XhpYCsVtSqlMnkAXMWDq+/ekVbl1ghqP9rUHTzv6sm/DwCOiYutU/yp1fw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + } + }, "node_modules/supports-color": { "version": "5.5.0", "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", @@ -2163,35 +6811,123 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/temp-dir": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/temp-dir/-/temp-dir-2.0.0.tgz", + "integrity": "sha512-aoBAniQmmwtcKp/7BzsH8Cxzv8OL736p7v1ihGb5e9DJ9kTwGWHrQrVB5+lfVDzfGrdRzXch+ig7LHaY1JTOrg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/tempy": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/tempy/-/tempy-0.6.0.tgz", + "integrity": "sha512-G13vtMYPT/J8A4X2SjdtBTphZlrp1gKv6hZiOjw14RCWg6GbHuQBGtjlx75xLbYV/wEc0D7G5K4rxKP/cXk8Bw==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-stream": "^2.0.0", + "temp-dir": "^2.0.0", + "type-fest": "^0.16.0", + "unique-string": "^2.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/terser": { + "version": "5.49.0", + "resolved": "https://registry.npmjs.org/terser/-/terser-5.49.0.tgz", + "integrity": "sha512-SNiDnXyHSrxVcIOtVbULzcTmniUiwcV7Nwdyj1twVubeTmbjoa8p69KKDpfkdoOavuM4/GRm1+ykI8qqnavHoA==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "@jridgewell/source-map": "^0.3.3", + "acorn": "^8.15.0", + "commander": "^2.20.0", + "source-map-support": "~0.5.20" + }, + "bin": { + "terser": "bin/terser" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/tinyglobby": { + "version": "0.2.17", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz", + "integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==", + "dev": true, + "license": "MIT", + "dependencies": { + "fdir": "^6.5.0", + "picomatch": "^4.0.4" + }, + "engines": { + "node": ">=12.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/SuperchupuDev" + } + }, + "node_modules/to-data-view": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/to-data-view/-/to-data-view-1.1.0.tgz", + "integrity": "sha512-1eAdufMg6mwgmlojAx3QeMnzB/BTVp7Tbndi3U7ftcT2zCZadjxkkmLmd97zmaxWi+sgGcgWrokmpEoy0Dn0vQ==", + "dev": true, + "license": "MIT" + }, "node_modules/tslib": { "version": "2.6.1", "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.6.1.tgz", "integrity": "sha512-t0hLfiEKfMUoqhG+U1oid7Pva4bbDPHYfJNiB7BiIjRkj1pyC++4N3huJfqY6aRH6VTB0rvtzQwjM4K6qpfOig==" }, - "node_modules/typed-array-buffer": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.0.tgz", - "integrity": "sha512-Y8KTSIglk9OZEr8zywiIHG/kmQ7KWyjseXs1CbSo8vC42w7hg2HgYTxSWwP0+is7bWDc1H+Fo026CpHFwm8tkw==", + "node_modules/type-fest": { + "version": "0.16.0", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.16.0.tgz", + "integrity": "sha512-eaBzG6MxNzEn9kiwvtre90cXaNLkmadMWa1zQMs3XORCXNbsH/OewwbxC5ia9dCxIxnTAsSxXJaa/p5y8DlvJg==", "dev": true, + "license": "(MIT OR CC0-1.0)", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/typed-array-buffer": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.3.tgz", + "integrity": "sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==", + "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "get-intrinsic": "^1.2.1", - "is-typed-array": "^1.1.10" + "call-bound": "^1.0.3", + "es-errors": "^1.3.0", + "is-typed-array": "^1.1.14" }, "engines": { "node": ">= 0.4" } }, "node_modules/typed-array-byte-length": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/typed-array-byte-length/-/typed-array-byte-length-1.0.0.tgz", - "integrity": "sha512-Or/+kvLxNpeQ9DtSydonMxCx+9ZXOswtwJn17SNLvhptaXYDJvkFFP5zbfU/uLmvnBJlI4yrnXRxpdWH/M5tNA==", + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/typed-array-byte-length/-/typed-array-byte-length-1.0.3.tgz", + "integrity": "sha512-BaXgOuIxz8n8pIq3e7Atg/7s+DpiYrxn4vdot3w9KbnBhcRQq6o3xemQdIfynqSeXeDrF32x+WvfzmOjPiY9lg==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", + "call-bind": "^1.0.8", "for-each": "^0.3.3", - "has-proto": "^1.0.1", - "is-typed-array": "^1.1.10" + "gopd": "^1.2.0", + "has-proto": "^1.2.0", + "is-typed-array": "^1.1.14" }, "engines": { "node": ">= 0.4" @@ -2201,16 +6937,19 @@ } }, "node_modules/typed-array-byte-offset": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/typed-array-byte-offset/-/typed-array-byte-offset-1.0.0.tgz", - "integrity": "sha512-RD97prjEt9EL8YgAgpOkf3O4IF9lhJFr9g0htQkm0rchFp/Vx7LW5Q8fSXXub7BXAODyUQohRMyOc3faCPd0hg==", + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/typed-array-byte-offset/-/typed-array-byte-offset-1.0.4.tgz", + "integrity": "sha512-bTlAFB/FBYMcuX81gbL4OcpH5PmlFHqlCCpAl8AlEzMz5k53oNDvN8p1PNOWLEmI2x4orp3raOFB51tv9X+MFQ==", "dev": true, + "license": "MIT", "dependencies": { - "available-typed-arrays": "^1.0.5", - "call-bind": "^1.0.2", + "available-typed-arrays": "^1.0.7", + "call-bind": "^1.0.8", "for-each": "^0.3.3", - "has-proto": "^1.0.1", - "is-typed-array": "^1.1.10" + "gopd": "^1.2.0", + "has-proto": "^1.2.0", + "is-typed-array": "^1.1.15", + "reflect.getprototypeof": "^1.0.9" }, "engines": { "node": ">= 0.4" @@ -2220,14 +6959,21 @@ } }, "node_modules/typed-array-length": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.4.tgz", - "integrity": "sha512-KjZypGq+I/H7HI5HlOoGHkWUUGq+Q0TPhQurLbyrVrvnKTBgzLhIJ7j6J/XTQOi0d1RjyZ0wdas8bKs2p0x3Ng==", + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.8.tgz", + "integrity": "sha512-phPGCwqr2+Qo0fwniCE8e4pKnGu/yFb5nD5Y8bf0EEeiI5GklnACYA9GFy/DrAeRrKHXvHn+1SUsOWgJp6RO+g==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "for-each": "^0.3.3", - "is-typed-array": "^1.1.9" + "call-bind": "^1.0.9", + "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" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -2247,25 +6993,169 @@ } }, "node_modules/unbox-primitive": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.2.tgz", - "integrity": "sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==", + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.1.0.tgz", + "integrity": "sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", + "call-bound": "^1.0.3", "has-bigints": "^1.0.2", - "has-symbols": "^1.0.3", - "which-boxed-primitive": "^1.0.2" + "has-symbols": "^1.1.0", + "which-boxed-primitive": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/unconfig": { + "version": "7.5.0", + "resolved": "https://registry.npmjs.org/unconfig/-/unconfig-7.5.0.tgz", + "integrity": "sha512-oi8Qy2JV4D3UQ0PsopR28CzdQ3S/5A1zwsUwp/rosSbfhJ5z7b90bIyTwi/F7hCLD4SGcZVjDzd4XoUQcEanvA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@quansync/fs": "^1.0.0", + "defu": "^6.1.4", + "jiti": "^2.6.1", + "quansync": "^1.0.0", + "unconfig-core": "7.5.0" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/unconfig-core": { + "version": "7.5.0", + "resolved": "https://registry.npmjs.org/unconfig-core/-/unconfig-core-7.5.0.tgz", + "integrity": "sha512-Su3FauozOGP44ZmKdHy2oE6LPjk51M/TRRjHv2HNCWiDvfvCoxC2lno6jevMA91MYAdCdwP05QnWdWpSbncX/w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@quansync/fs": "^1.0.0", + "quansync": "^1.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, "node_modules/underscore": { "version": "1.13.7", "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.13.7.tgz", "integrity": "sha512-GMXzWtsc57XAtguZgaQViUOzs0KTkk8ojr3/xAxXLITqf/3EMwxC0inyETfDFjH/Krbhuep0HNbbjI9i/q3F3g==" }, + "node_modules/unicode-canonical-property-names-ecmascript": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-2.0.1.tgz", + "integrity": "sha512-dA8WbNeb2a6oQzAQ55YlT5vQAWGV9WXOsi3SskE3bcCdM0P4SDd+24zS/OCacdRq5BkdsRj9q3Pg6YyQoxIGqg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/unicode-match-property-ecmascript": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-2.0.0.tgz", + "integrity": "sha512-5kaZCrbp5mmbz5ulBkDkbY0SsPOjKqVS35VpL9ulMPfSl0J0Xsm+9Evphv9CoIZFwre7aJoa94AY6seMKGVN5Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "unicode-canonical-property-names-ecmascript": "^2.0.0", + "unicode-property-aliases-ecmascript": "^2.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/unicode-match-property-value-ecmascript": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.2.1.tgz", + "integrity": "sha512-JQ84qTuMg4nVkx8ga4A16a1epI9H6uTXAknqxkGF/aFfRLw1xC/Bp24HNLaZhHSkWd3+84t8iXnp1J0kYcZHhg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/unicode-property-aliases-ecmascript": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-2.2.0.tgz", + "integrity": "sha512-hpbDzxUY9BFwX+UeBnxv3Sh1q7HFxj48DTmXchNgRa46lO8uj3/1iEn3MiNUYTg1g9ctIqXCCERn8gYZhHC5lQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/unique-string": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/unique-string/-/unique-string-2.0.0.tgz", + "integrity": "sha512-uNaeirEPvpZWSgzwsPGtU2zVSTrn/8L5q/IexZmH0eH6SA73CmAA5U4GwORTxQAZs95TAXLNqeLoPPNO5gZfWg==", + "dev": true, + "license": "MIT", + "dependencies": { + "crypto-random-string": "^2.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/universalify": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/upath": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/upath/-/upath-1.2.0.tgz", + "integrity": "sha512-aZwGpamFO61g3OlfT7OQCHqhGnW43ieH9WZeP7QxN/G/jS4jfqUkZxoryvJgVPEcrl5NL/ggHsSmLMHuH64Lhg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4", + "yarn": "*" + } + }, + "node_modules/update-browserslist-db": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz", + "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "escalade": "^3.2.0", + "picocolors": "^1.1.1" + }, + "bin": { + "update-browserslist-db": "cli.js" + }, + "peerDependencies": { + "browserslist": ">= 4.21.0" + } + }, "node_modules/validate-npm-package-license": { "version": "3.0.4", "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz", @@ -2331,6 +7221,55 @@ } } }, + "node_modules/vite-plugin-pwa": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/vite-plugin-pwa/-/vite-plugin-pwa-1.3.0.tgz", + "integrity": "sha512-c5kMgN+ITrOtHXp8PAtk2uOIEea6XjP/unCGxOWWBzQ6qa65qj/awHg0wf+QF9E/2u9vh86LqxPwzEPNbM2r5A==", + "dev": true, + "license": "MIT", + "dependencies": { + "debug": "^4.3.6", + "pretty-bytes": "^6.1.1", + "tinyglobby": "^0.2.10", + "workbox-build": "^7.4.1", + "workbox-window": "^7.4.1" + }, + "engines": { + "node": ">=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + }, + "peerDependencies": { + "@vite-pwa/assets-generator": "^1.0.0", + "vite": "^3.1.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0", + "workbox-build": "^7.4.1", + "workbox-window": "^7.4.1" + }, + "peerDependenciesMeta": { + "@vite-pwa/assets-generator": { + "optional": true + } + } + }, + "node_modules/vite-plugin-pwa/node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, "node_modules/vue": { "version": "3.3.4", "resolved": "https://registry.npmjs.org/vue/-/vue-3.3.4.tgz", @@ -2412,32 +7351,17 @@ } }, "node_modules/which-boxed-primitive": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz", - "integrity": "sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==", + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.1.1.tgz", + "integrity": "sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA==", "dev": true, + "license": "MIT", "dependencies": { - "is-bigint": "^1.0.1", - "is-boolean-object": "^1.1.0", - "is-number-object": "^1.0.4", - "is-string": "^1.0.5", - "is-symbol": "^1.0.3" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/which-typed-array": { - "version": "1.1.11", - "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.11.tgz", - "integrity": "sha512-qe9UWWpkeG5yzZ0tNYxDmd7vo58HDBc39mZ0xWWpolAGADdFOzkfamWLDxkOWcvHQKVmdTyQdLD4NOfjLWTKew==", - "dev": true, - "dependencies": { - "available-typed-arrays": "^1.0.5", - "call-bind": "^1.0.2", - "for-each": "^0.3.3", - "gopd": "^1.0.1", - "has-tostringtag": "^1.0.0" + "is-bigint": "^1.1.0", + "is-boolean-object": "^1.2.1", + "is-number-object": "^1.1.1", + "is-string": "^1.1.1", + "is-symbol": "^1.1.1" }, "engines": { "node": ">= 0.4" @@ -2446,6 +7370,350 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/which-builtin-type": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/which-builtin-type/-/which-builtin-type-1.2.1.tgz", + "integrity": "sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "function.prototype.name": "^1.1.6", + "has-tostringtag": "^1.0.2", + "is-async-function": "^2.0.0", + "is-date-object": "^1.1.0", + "is-finalizationregistry": "^1.1.0", + "is-generator-function": "^1.0.10", + "is-regex": "^1.2.1", + "is-weakref": "^1.0.2", + "isarray": "^2.0.5", + "which-boxed-primitive": "^1.1.0", + "which-collection": "^1.0.2", + "which-typed-array": "^1.1.16" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/which-collection": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/which-collection/-/which-collection-1.0.2.tgz", + "integrity": "sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-map": "^2.0.3", + "is-set": "^2.0.3", + "is-weakmap": "^2.0.2", + "is-weakset": "^2.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/which-typed-array": { + "version": "1.1.22", + "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.22.tgz", + "integrity": "sha512-fvO4ExWMFsqyhG3AiPAObMuY1lxaqgYcxbc49CNdWDDECOJNgQyvsOWVwbZc+qf3rzRtxojBK+CMEv0Ld5CYpw==", + "dev": true, + "license": "MIT", + "dependencies": { + "available-typed-arrays": "^1.0.7", + "call-bind": "^1.0.9", + "call-bound": "^1.0.4", + "for-each": "^0.3.5", + "get-proto": "^1.0.1", + "gopd": "^1.2.0", + "has-tostringtag": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/workbox-background-sync": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-background-sync/-/workbox-background-sync-7.4.1.tgz", + "integrity": "sha512-HhT7KE8tOWDm02wRNshXUnUPofMlhenF2DBdUnDPOubhizzPeItkYTmAB6td1Z2cjYPa98vzEiPLEuzn5hN66g==", + "dev": true, + "license": "MIT", + "dependencies": { + "idb": "^7.0.1", + "workbox-core": "7.4.1" + } + }, + "node_modules/workbox-broadcast-update": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-broadcast-update/-/workbox-broadcast-update-7.4.1.tgz", + "integrity": "sha512-uAlgslKLvbQY+suirIdnBCSYrcgBhjp81Nj4l1lj/Jmj0MJO2CJERnCJjT0GFVwmReV0N+zs78K6gqd5gr9/+A==", + "dev": true, + "license": "MIT", + "dependencies": { + "workbox-core": "7.4.1" + } + }, + "node_modules/workbox-build": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-build/-/workbox-build-7.4.1.tgz", + "integrity": "sha512-SDhxIvEAde9Gy/5w4Yo1Jh/M49Z0qE3q0oteyE8zGq0DScxFqVBcCtIXFuLtmtxRQZCMbf0prco4VyEu3KBQuw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@apideck/better-ajv-errors": "^0.3.1", + "@babel/core": "^7.24.4", + "@babel/preset-env": "^7.11.0", + "@babel/runtime": "^7.11.2", + "@rollup/plugin-babel": "^6.1.0", + "@rollup/plugin-node-resolve": "^16.0.3", + "@rollup/plugin-replace": "^6.0.3", + "@rollup/plugin-terser": "^1.0.0", + "@trickfilm400/rollup-plugin-off-main-thread": "^3.0.0-pre1", + "ajv": "^8.6.0", + "common-tags": "^1.8.0", + "eta": "^4.5.1", + "fast-json-stable-stringify": "^2.1.0", + "fs-extra": "^9.0.1", + "glob": "^11.0.1", + "pretty-bytes": "^5.3.0", + "rollup": "^4.53.3", + "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.4.1", + "workbox-broadcast-update": "7.4.1", + "workbox-cacheable-response": "7.4.1", + "workbox-core": "7.4.1", + "workbox-expiration": "7.4.1", + "workbox-google-analytics": "7.4.1", + "workbox-navigation-preload": "7.4.1", + "workbox-precaching": "7.4.1", + "workbox-range-requests": "7.4.1", + "workbox-recipes": "7.4.1", + "workbox-routing": "7.4.1", + "workbox-strategies": "7.4.1", + "workbox-streams": "7.4.1", + "workbox-sw": "7.4.1", + "workbox-window": "7.4.1" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/workbox-build/node_modules/pretty-bytes": { + "version": "5.6.0", + "resolved": "https://registry.npmjs.org/pretty-bytes/-/pretty-bytes-5.6.0.tgz", + "integrity": "sha512-FFw039TmrBqFK8ma/7OL3sDz/VytdtJr044/QUJtH0wK9lb9jLq9tJyIxUwtQJHwar2BqtiA4iCWSwo9JLkzFg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/workbox-build/node_modules/rollup": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.62.2.tgz", + "integrity": "sha512-RFnrW4lhXA3s3eqHDZvN654g8OTjzRfqpIRJYczCGB6HzphckVAi/Qh4tbPUbRuDi7s1Llv8g/NspLkttY3gTA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "1.0.9" + }, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@rollup/rollup-android-arm-eabi": "4.62.2", + "@rollup/rollup-android-arm64": "4.62.2", + "@rollup/rollup-darwin-arm64": "4.62.2", + "@rollup/rollup-darwin-x64": "4.62.2", + "@rollup/rollup-freebsd-arm64": "4.62.2", + "@rollup/rollup-freebsd-x64": "4.62.2", + "@rollup/rollup-linux-arm-gnueabihf": "4.62.2", + "@rollup/rollup-linux-arm-musleabihf": "4.62.2", + "@rollup/rollup-linux-arm64-gnu": "4.62.2", + "@rollup/rollup-linux-arm64-musl": "4.62.2", + "@rollup/rollup-linux-loong64-gnu": "4.62.2", + "@rollup/rollup-linux-loong64-musl": "4.62.2", + "@rollup/rollup-linux-ppc64-gnu": "4.62.2", + "@rollup/rollup-linux-ppc64-musl": "4.62.2", + "@rollup/rollup-linux-riscv64-gnu": "4.62.2", + "@rollup/rollup-linux-riscv64-musl": "4.62.2", + "@rollup/rollup-linux-s390x-gnu": "4.62.2", + "@rollup/rollup-linux-x64-gnu": "4.62.2", + "@rollup/rollup-linux-x64-musl": "4.62.2", + "@rollup/rollup-openbsd-x64": "4.62.2", + "@rollup/rollup-openharmony-arm64": "4.62.2", + "@rollup/rollup-win32-arm64-msvc": "4.62.2", + "@rollup/rollup-win32-ia32-msvc": "4.62.2", + "@rollup/rollup-win32-x64-gnu": "4.62.2", + "@rollup/rollup-win32-x64-msvc": "4.62.2", + "fsevents": "~2.3.2" + } + }, + "node_modules/workbox-build/node_modules/source-map": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.8.0.tgz", + "integrity": "sha512-d8EqvL+k/SOXCreS/SUzg2ciyHqBBLcN/yuRjFsbvVhHTE2pgei7oAhmPM7kWFbkX6OSMQfUq4KbkF3au9lhYQ==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">= 12" + } + }, + "node_modules/workbox-cacheable-response": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-cacheable-response/-/workbox-cacheable-response-7.4.1.tgz", + "integrity": "sha512-8xaFoJdDc2OjrlbbL3gEeBO1WKcMwRqwLRupgqahYXu75yXajPLuwrbXMrIGZuWYXrQwk0xDjOxZ/ujCy/oJYw==", + "dev": true, + "license": "MIT", + "dependencies": { + "workbox-core": "7.4.1" + } + }, + "node_modules/workbox-core": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-core/-/workbox-core-7.4.1.tgz", + "integrity": "sha512-DT+vu46eh/2vRsSHTY4Xmc32Z1rr9PRlQUXr1Dx30ZuXRWwOsvZgGgcwxcasubQLQmbTNYZjv44LkBAQ4tT5tQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/workbox-expiration": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-expiration/-/workbox-expiration-7.4.1.tgz", + "integrity": "sha512-lRKUF7b+OGbeXkQk1s6MHXOa3d7Xxf7Of31W6c6hCfipfIyrtdWZ89stq21AHZMaoG7VNFoHply4Ox+rU31TWg==", + "dev": true, + "license": "MIT", + "dependencies": { + "idb": "^7.0.1", + "workbox-core": "7.4.1" + } + }, + "node_modules/workbox-google-analytics": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-google-analytics/-/workbox-google-analytics-7.4.1.tgz", + "integrity": "sha512-Mks1JwLEt++ZAkF6sS1OpSh9RtAMIsiDgRpK+codiHGIPXeaUOgi4cPc3GFadUl8V5QPeypEk8Oxgl3HlwVzHw==", + "dev": true, + "license": "MIT", + "dependencies": { + "workbox-background-sync": "7.4.1", + "workbox-core": "7.4.1", + "workbox-routing": "7.4.1", + "workbox-strategies": "7.4.1" + } + }, + "node_modules/workbox-navigation-preload": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-navigation-preload/-/workbox-navigation-preload-7.4.1.tgz", + "integrity": "sha512-C4KVsjPcYKJOhr631AxR9XoG2rLF3QiTk5aMv36MXOjtWvm8axwNFAtKUPGsWUwLXXAMgYM1En7fsvndaXeXRQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "workbox-core": "7.4.1" + } + }, + "node_modules/workbox-precaching": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-precaching/-/workbox-precaching-7.4.1.tgz", + "integrity": "sha512-cdr/9qByww7yzEp7zg/qI4ukUrrNjQLgN+ONQRpjy/VqGQXwkgHwr00KksGJK8v0VifwDXBb8a4cWNZH71jn3Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "workbox-core": "7.4.1", + "workbox-routing": "7.4.1", + "workbox-strategies": "7.4.1" + } + }, + "node_modules/workbox-range-requests": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-range-requests/-/workbox-range-requests-7.4.1.tgz", + "integrity": "sha512-7i2oxAUE82gHdAJBCAQ04JzNOdRPqzuOzGfoUyJpFSmeqBNYGPrAH8GPoPjUQTfp+NycwrD2H68VtuF8qxv0vQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "workbox-core": "7.4.1" + } + }, + "node_modules/workbox-recipes": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-recipes/-/workbox-recipes-7.4.1.tgz", + "integrity": "sha512-gnbVfmV4/TtmQaM4x9AtuXhcdstJsep3XMVeztOrQVPT+R6+6DeBjGTCQ7fFCXm+4GEHUA5VEBTyi5+4gWGeog==", + "dev": true, + "license": "MIT", + "dependencies": { + "workbox-cacheable-response": "7.4.1", + "workbox-core": "7.4.1", + "workbox-expiration": "7.4.1", + "workbox-precaching": "7.4.1", + "workbox-routing": "7.4.1", + "workbox-strategies": "7.4.1" + } + }, + "node_modules/workbox-routing": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-routing/-/workbox-routing-7.4.1.tgz", + "integrity": "sha512-yubJGErZOusuidAenaL5ypfhQOa7urxP/f8E0ws7FPb4039RiWXUWBAyUkmUoOL/BcQGen3h0J8872d51IYxtA==", + "dev": true, + "license": "MIT", + "dependencies": { + "workbox-core": "7.4.1" + } + }, + "node_modules/workbox-strategies": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-strategies/-/workbox-strategies-7.4.1.tgz", + "integrity": "sha512-GZxpaw9NbmOelj7667uZ2kpk5BFpOGbO4X0qjwh5ls8XQ8C+Lha5LQchTiUzsTFSS+NlUpftYAyOVXvQUrcqOQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "workbox-core": "7.4.1" + } + }, + "node_modules/workbox-streams": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-streams/-/workbox-streams-7.4.1.tgz", + "integrity": "sha512-HWWtraKUbJknd9kgqGcpQ3G114HOPYvqs8HaJMDs2ebLNAimDkVDaWfAXE6Ybl+m8U6KsCE6pWyLYuigWmnAXw==", + "dev": true, + "license": "MIT", + "dependencies": { + "workbox-core": "7.4.1", + "workbox-routing": "7.4.1" + } + }, + "node_modules/workbox-sw": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-sw/-/workbox-sw-7.4.1.tgz", + "integrity": "sha512-fez5f2DUlDJWTFYkCWQpY10N8gtztd849NswCbVFk0QlcSM4HT5A8x4g4ii650yem4I8tHY0R7JZahwp3ltIPw==", + "dev": true, + "license": "MIT" + }, + "node_modules/workbox-window": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-window/-/workbox-window-7.4.1.tgz", + "integrity": "sha512-notZDH2u8VXaqyuD7xaqIfEFi6SRM4SUSd7ewe9PDsVqADuepxX2ZMY3uvuZGxzY5ZOsGC/vD3A/3smFtJt4/A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/trusted-types": "^2.0.2", + "workbox-core": "7.4.1" + } + }, "node_modules/yallist": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", diff --git a/public/package.json b/public/package.json index d04b325..995f7a5 100644 --- a/public/package.json +++ b/public/package.json @@ -19,12 +19,15 @@ "devDependencies": { "@tsconfig/node18": "^18.2.0", "@types/node": "^18.17.0", + "@vite-pwa/assets-generator": "^1.0.2", "@vitejs/plugin-vue": "^4.2.3", "@vue/tsconfig": "^0.4.0", "less": "^4.2.0", "npm-run-all": "^4.1.5", "typescript": "~5.1.6", "vite": "^4.4.6", - "vue-tsc": "^1.8.6" + "vite-plugin-pwa": "^1.3.0", + "vue-tsc": "^1.8.6", + "workbox-window": "^7.4.1" } } diff --git a/public/public/apple-touch-icon-180x180.png b/public/public/apple-touch-icon-180x180.png new file mode 100644 index 0000000000000000000000000000000000000000..e642e4677e73d4ef7505dcc5ee5738ca44dc9b55 GIT binary patch literal 2769 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 diff --git a/public/public/logo.svg b/public/public/logo.svg new file mode 100644 index 0000000..fe894af --- /dev/null +++ b/public/public/logo.svg @@ -0,0 +1,5 @@ + + + + + diff --git a/public/public/maskable-icon-512x512.png b/public/public/maskable-icon-512x512.png new file mode 100644 index 0000000000000000000000000000000000000000..a2b1bd9d9a38bf90ee4099cbe10f49e1249beb60 GIT binary patch literal 9691 zcmd6N^;6W36ZiX$1L+P01e8*`JC0Dg5v04MyW!|kM39c7LlBUZKIsPO?vy;b@A-V6 zU!Q;A*_oZ)nVr|pYxakoot;;Vx~d!=HYGLy0C)=WvYG$@{x1asm}vinu40D%{{pkR zvi3U^3Izgz$jQl1Pfyv{*m`<;TwPt4mX`GO^<`ycqobpl6hH-%jJbIaxp*KqWlGlmf-Hl<^`U|k%=MO!a#7phHepvbj?A33+YDkd;z&j-UFF90h zZ?XTex4Y#5=McIjEO;h#$=ogJ>}^xC~F`vQD0HxkYzqIeL0&K#slNd*o7jT1q2QNnI9 zc;9GmypRME=wh6ZTotL}F+%yYP|58(m3PR+*so_9nZ4+-2 zC%#6}ePtyWBe4IRC6e-nN^yq$zXrNXh2HO(MdAic zU&0NII@EDR-Z{$3Ay*dAEMJ4U*puC+yZnDb`7ZU*Q`TndI?j@p%@yUd9Yk?5gJ(-< zi4o(a04}PW$|1eCryC6Aj-*u+7 zmk2(23{8|TF1Xd@T!0-x#@8*#&-F2gKa9ep>-Tnl2CrNTT6G{=o-W2QxIxMpg!%`A zjdry8fgdrkA9Bw*m87qNLfSK)<;t-naG=r#yQJa@ys1vuNnx*U6fWVxPgWhK6rwnT zQdf>R^#aico#9;NO83LLh_NzM;-$@n;ypo=+j#ryeip#!5VKVAo{bbLdrI<8^1i?A zyd1)IB&@2D$V7PxpsPwouEYNztm(<6^RNCvb z_D`_RpekpbIO^3;yqZC$Ny7rJm?^>t)>Em=vAADwA3KxJpZ0`Qd1Xc3yz#?E;0Fxf z3&MS#94D=nBIWnnqQvI8HfzF2YQQH^fjjfMPiN=OIu!ot>57hNG+J$2okUoSr$OiN zd-dRp+bAm;vMb8da{?U3Q?GMLRKzarld?mDjHO~3l3H4b5tdEw%#UjNxzcg*5T*4g z)_Rgy9;c1_ZcN-gHQ*j++9%P7vy-VJKiK3<(Bdg@=i2$Xe$Iz$j!#lLd*a8mW1mn8 zsBiFb9b#pr74Y)~%`0~q8HBUzcQS0%Iq2=irl!G_Tz8mha5+3-%Dxa=5=$1BVv6tD9PdB(0HE8$4;mSFZ%qQ-F0{l7nH(C;frY5i0 zABwHufI_dVS*G>mhnCIx`26C4421(+RO#Z=TvB$X1c=Hq;;t!Q3tseHrhgxE7A^2yDXC=AlteZ`Exr zX_p!labH+9uu9|kx9eJ)Q!Q?{`$Ak21@A8}#)t3eZJ%XM;%rz#T#5rqJNElWf7Lxe zE#S9*@R?%2yR_knHx1J^?H5Q;WX(@N2Z2Zr^?LN}7kbFASzl3wlu94kWqERWKn%PZ zQ_Pxn7fC@81`3>->=*z(RHcs-{nq&(j>j7bcKWy zbLPw{isPey;)YQ99Py8(n@n~wVl<%>2hQ%c4HwwbYJWjM_;f_}_J zq?@5tDgyaTtQRvJD-uB}cqc+T^-v3W8HmehF}^d0$c1l+3S_Q|#F+--*X49A)L5?- zr%OJ1Eo@acka*73H1G|Fh0=18U)`)(QlsPU*FpIrCR94YOhPY&y1f}A_n5e>$Xo1k zHk7(MN(H(!uAG3&7Wn?qP`O-t>(Mt?g3R=%pMj@{p{(dD67>>5y9jMg1!%*|%!v0X zVi&>cTOh6ZbE_6@#H7x#EiXbv(BL0hNFOpqKK4u%O^)Tw!Pl}RkoxqWtUYDX!}FaZ z_q8vJ!8=_V>3_)*1GS2)Ahvaf^uP;F^1u}qAm_-i{ehAg{sY8O67)j}m==6GGRCpmX{ZY>R`|uP@`Ee@}<6mK-qfd6S?I zR@j0yl}(tD!HQvzkMIvovNZ!%voIEN!9JwVUK4RG@jdD)J5;M2#pOhXY+uwS=Qcvz z(a^-KJhZZiP1x$YrG)niwdcR6r6uP+-o&_=I5rPL3zWvH8S_b|huUs6BulTr%HJI| z`ytEhi|x)?`iVldIQ=4CoWD71C$x@n+Ngy5G5YlhOc#PNwcet}WkUcPoLmFuKg&03 zL_PaE?<6JC1)Ty91#cai9=ZN)FX=8w`Kg;N2ftT0}s?s3d*`ZD^;-*F*F3#Bt zVR@69sqW>`51Uoyh(w7g_QxM=%ajm2_4Zw=mtGx2;WZSZ{bvlm1-Gf)+b?v+mg3Ji zH~XDtca8Y+0%xGqQy=(0;3w`03WX>rMwWEs+G}$!qKT~RJdF(j3nI=tJTV?+&z5)) zNL7p&YU4ccaKNC^D_rFoD3d4X2kC)+ml+MRmiMB#G zKXfLHZ9aQDzc6hPa8E(RXQO$2`C9!=QFo$$YuPk~$}%J z)*}YTN&D^Mx8fg9W7i~ge__3^I}6Z4$f%{@x6|nrABwO|Rj1sV#9#jSw!PH~!zxvQ z(40$uYD9M**K@TS%sPNucr`gBuzOcoHi8Dy?HJsc~4Z$nwHd+ZfayCvuAh**FkM~_#__M&Isa! zxi$3RoE(4%8wYZ5jTrpB8Q=WQ@>X~@)fka~S2o<=UZ;EKYfML_e=pTp->HhVr-X5+ zzwk7a0oCaXZcp~;Txam3BzIZu+@>wzj+&rq_#kIs&$IQ3T||m0+WTZ?*Pc>sR2O$n zR1iOk-EuiYiRn+RU>UXxwy9aV(lZ`w>yakySXEt!i$T}9Wb(MgvuJlsrGKd&G#|N# zHm8-uOG*U=&{<(_*YGeU-9ZPeSCryeME?DTM-p8&IaBq&Lhtaj{QeAw5vJs=!*h=JOhsOaPX#?$ROm4=_N$o-#~C*G}Y=SM0^>I??+lc@|iOsJ|qZGKU`S+m|fe259$pN%!1=j|^qiOFzVu-(BVKQp#n zh>U1GzW#ht!#SVEhPGt}^6`@OW`^#eM{@rmq=s=f2_=vPN#|ID9d}^%j$KjvO?a;~ zo5!F-jA6VmanMM_B7DB`ZmA60L$|JSdTs1T=f*dORxdXD=X5r zr7wPODW&bA&^%#6IfOoSs84$4kpXP(tvS%tq0u7s=q`GWW6c-3X} ze=)=jOmw5tseH=VlkY&JCJ*WEq1Hjt>v_1<0~+Lhc0v6%w!&=Il1s8LTe#R?b_oUC zSG&JagO%3H=3rG{kmd-=CLh13wz@M+MHzEw_0tZ(g!fO=Yz?B82H+V>2JT}D%=4b^ zZ*KM@fxo^R<4q=*Yr`FQ=wllkV>Q@J$GfDYzNU}NQ|~^1%#;J2(z&^EqFpYpYcN?`g8Q%C&?lXa2<2pSv}Bvf6z&Srl)1 z4YGv-Df}R>__?p7X|2Dl&_I|(y98m9NP)GOtMCy+m2XncZa6&?9{UtR`?w%!5>xZw z;ATdk=w6LMZTgd*UI$a}WPoOItGKDpspt3?4E?*;2HECyQn0x4BlQOiQ$J&;X7GDC#8CH&NoYzZebmvkXNsZtAPHy>nBIKKXI&hVr) z@ov+;T~!uq%Shy}`mBc&rozNS-b*vB@9&hAd_0E~(Lb1pd~35>MN(Mc%-ZG|oYgR! z9u2rj!1WHig64<1Idle8ziI03VvUWbFgq$p9eNwvFSY+n>3+o6ieW*#Gx;>I{x49Z zvnWb_-9i;RAhZJgY5HSao7Lu)b7F14u8aHT)l3(_i5v!lvnUq5D_B+I%_Pn;=9&{N zZW*Gn-9Za!LyQgveyQwQIc|^qNt2+c)}1-5G&QSxZh`vlTcqBN2ImoB2>fnrD_k1 z1Khnlt|rdH`a5w$oBBD6BFG=!F_&+9FHVk^$hEcy!7XZD1Zw0$%wpA;zys45CJYE_ z@jE*{wH!j{de|bp2SyM*qK;_I5PvJ(c$FQ0j&m~lH+vR=6}bOQA+5M0{JD$r53_ai zNTAy}E~}vu>@237AuHBR(_rSTE4I~SGdIg3`wb}hq|OY=xB7V4q}2URjyv2MtD4U^ z+pRtX8&l4A_JsTAo#^3<9G+{OJ@w%wFJe05@Y5v&>AC{yW_z>phQ>Dmi|w+iWzCP@ z?&rB&3s?J_IhiCh-xTvQ%H+X$IZN7Up z7#Kq!=yqsP&@TDTB)eYB6Pb2g&QGZu(KDBXzC2Q$oIL-fi4k_rJT{9l_t!^)RwI=6 z&axhmivo|SzQBN(mIz!KgP$9c9rFTGEUSKDnXN}vdW@#4e%8%%)QlSz33GTP6$Eg{ z=@;*7(IXOosjrxsf`oJuuW$SPpeG|$;ehqgdLk8Q$FMem_&y81kP^-jq1T`|MexIN zww~H+^@x(tmH+D{lbc;X{iQ53R5{Rw^!l0bZN2}wDlls+?IyBx;D~?~^6A{ors`vRQmMNS>aeQC-EE<{K ze~#O1UZnk9^&FF;%Y%f@4V?3l2zMlBUeFF1nY11cl(+7Rf~iTnW03BSYB-LnI4F~>KzD8Da(Pb@?AFYJR zW6|k=mC?c44cS||*SC_Jb>u#6m~(2d-?xuuX3*T;+f!_iPL$~@SR6r37^UYKg~Mph zH_ug`+UEgS7$$Vkt((6#jA4zjH2eJ+C&ytV!-EVphgqk1AT6DzAI||oB0S16Hjwtt zv&&2t6FOLYD%rk`5l&`HAl&qztF9bP4d{zhhCj8Zc5@JaTm!3aKQS8dx>BwfqNtNR z35*ImyJl32fgc_$tOkVFZ zLkpjB$ev};r`z~pntFj99MW{a(TTctm#s?Z3v8yCa3T*SrsBAEWj#ZMjy>|LA2b2R zYW)Jw|89b_Fii!(%Bn97r*}CUe8;K4rDyF)LEv!XwOUG<+m(6oHgf62Bh>g8Kv&?_ z{JVjXt*PfPl9kUE!CJwkSMU0w=LMgE&V3D(C_oKvxtvVGo(K*|{?L31E7;KZP0pe~ z);9ZknT)MZe|EIQtaseB3KXa(TKl)r9pU@iR+VnnKJd|x1)0H_#qlc`O8RDE@ns-{ z(BRga9@@^h*X}Vi1Q{1pU@-D*KD_d}DzHWq@RVzLn)u@|rwTL?LzCj_3pQc_Ej^=U zA(r+@(_`L<=6$ETQhV}ygbn1G7&&!FNZVvi=j;?_Nx86O)52aZq0fgxv7khy1@#`Flc;B;q}EZ2eE z^+aG>Vr%2OU|GwdS#OTA@ka;-sCh@BUm?Pz$iwy;)bL9eCco8}_IE-+%*N@l#&scMM087c`H@!vw5)^(ZAph2cXSr{@V#f# zVcy`2%g&udfpux2Y3?{pMWWI>OV6=a{kf0}Ht@Lar(9uf8kUDoYo!nV5s=sRLe`q@ ziVvMQ0Sur!rhGSr%uRF?_7nE1tC?FN)rJR{dlapYcKGfy&v5E{jpi$heJAkm6iJN) zqj=C4DhH7V1U>pA1Nbl|xBX>IQ{hNnC#P5AS^dF5UG~CDs=<9&?|J3RUE26d%kwb( z&?{{h;fKmkZ$~+(-f|vihJC5qPx-3g5V(RAO#Uf)B72X71m=*_&}icRs|5)YCHaHd zGEKWhqA5v{%Y1-AdtygEaK{mPaA{+v_777y7Ah`E?5>a*1{8fCb#+?Eamx->t+W{Z z+PkzLedwsMRN`a32t!5qZhemd@ zz%Zm9k(wZ6JjV8lpSCal_g<%q{O5+AFOsEH{=T2U_Ru36{3 z>?X`?qobvrnQFP$Q{YYmf|(&Dno?l-u9bvtl_X_ef&H;DhWNJ`{-3~inV#lDMSEo< zaI5Ph#jaqX=h7xZsR?A!L_+=2xovH36-=}ly{!>{zLjFIE&I7}7A5-G}NbN;<0;`GY zqeV$pp|JRKjl3&=Qcynm+!bR?Q)N}b6#UjGXO?H9a6`>Rbeh>)6d#DRtF}49!9QWF zLyc5nCD`3-pm!;2r5;_>(=x*3Q@W$qW6Yp^DG7!)y7It>uC&AP*)prr7+@2pz>Hv# znDm3h&P+)XGr)cwXheuGB*6UZSJIvh{N?qT@hJ7NQ~Oj|e`0$zQ1@s^2sJE6Vu0&b z3H;C2b4zJ|Ph<3Z6G4lrju~V>sKKs=KpJXn{xh8}WG2e##!lE`&22pFQdZz4BS7== z)^x@d_)4Z4EjEnfP!DR-Fs30itzZV)h|JMI3uw2|j_0+Qga)nesS<$kCWvpA$=`lLKbx?Kna^W8c5z=%jE&{qU$O`uH_YF zz0I*@3;sRsJ4VpxhKg1PyN!ze{j&`Y=wo#p$d&V>fq^{7S}Z1_87sjLr&UT&<%_eB zQ^XnpJ@g04cJ)`xFt~I$qtp*P{@?gwgHoc5;^WM78^mlmHYDn#dtb2Lo(Y5dk0Fwd z9-A94?f%&bZf*Vf(oZhMRCPuF7a`D5)ZIsAudl%2 z;718cbQ+H=Nf9RsdIw8n^~OJ&pjed#9wJ{3)ya-@(MB!eIn65d6 zTk^~p24kSn2@8!1i?AptCk+#~ zS!y|-fj=qL&pF;?h}g7}0ebdxWEYc=v10^{B;*enZEeLVAN(~?#tc2{`H#l;J6}th zH>G*J7S{S5wwLihYmM1;4!}N*=v_y=K_dJ4pcCZM4sUh7If1DY%bB6Qoy?Bn{{cyF zB`fKYwO4VUe4Kt$y7=dZy`2&Iw1`t-H^ZyIZM3ZaX$Y{pE`9d8`G7PdyQ_^aM4 zM@TfdqXYv~;`!HMd2y+peusb%>cNAG=~-LC^X&Lt`ZFs^(7=cGz zkjEidjF%|uYtItc@d*s-kApn-FA39IG}bfb2~%Uol*LVW3CXnrlk)jS0t!pBJV%pI zpe0HG*9Sh2OL*6{RoC^QA>Qm5($DzhyOPeV2To8Ug1zan>9v;VSwF62hkA*^T2--k zFxQTwGWC@BtuS*9FzG~|NjPI6;>$l|;Z_3_ET+FzaY`U`L*)x*97dH&V1^vSq5kW~ zL^>WN5f$xEn#TlD*g~przuAKce~I~04(6~7j74ke4e%bR z;<8fC*!zSAOm-QV>{mDse!ORchn*SfPa0u(t0HhWrMRYI9hF)j<<}p0rnVBzaqfUc zhexs%4;W9M%FaS0!#*4+Dp0g0G(JZ#|9}nSZ1-f*HPQ+;_6euaak9BGyhrEL)O2$y zqL#GqwiDpI6!ZBCUPDW$uRnAAS#!*nu#Mv`ve+4Eu0N4TXaVkS?)^1-5Geg{?K%Us zA1%_>kyKXDN*d3&OzV)t05>r!vfiUb#)iu1c)PPIm#kz5=}swd?JI9i#TuFTQ0P`@ zk%>qtkEw!_Q@twTqnT6mlKV&n*Q<4&k~oFq=B%kncOay~bH>--AX+(V&`WVK9gIYi z;Vdv$N=^E083Q}zl=f_g-#oT=;IBGQ*5V93Lvyi%xKY5`*{bV}REwY;n-aGuM~Kf% z@a*b~nY8LYMth983l8S%ju?pYjABhymcMwusNk)@;F8-U7CxfwkFLor_k2o~?R^AQ zP~6_pN2ymRZD(uk{2SGGFBZMq!*kqLWF^$-FM?HPSnMgcbQ?sYBpYyvV+A(FzR)W| zZ*97wBJ&ZnjkbSGB89}Qg~SsR)KL+qzN0JGye9J})U9XyTQ*B8X|os;9XuYKK^JpDDV;Z7KjYVa~*oL0k}%^X4fvfKo~FzivAS4ZIC#X6^Z5c^^bbC6ng zHiQ=d0VLR@&k^mi5j`a^eAe6)#s3~`E>zg14l5U;Vt;;@v1Pfx-uUqkv;=ty4H_7V zVa|4VNNvE*$1pTf694k~?U|PYW=58;eAS0bPOQD!Uflc25l< z-m8?Pk8==LsEP=5H;P3rqm?G`Uk{VyUnH+#GT%-i$JRse-(ahoJly^^;zmV>LVeOi zcDZ${jV(2{cKz86wQm||pvWI=`Z{Vn^$i{i#zwWc3yHN4eXAAqMK2;P*Ll9J(Zps}HPiW!BNct1;A){`OjilhnBY_IrqDbuXLp_1;%PS9F z0@t-ZcspV48Dkl~voFD~oz=mH1dq8%RdGgEx^Y~?F<{w0EEJ_fq2PCiC<#owrHwT- zt8a5|1SZO3Ga*9*k46~eGftzZsAbbn2jTj*8ehc-@Q-cl;oqR3c6 zr*UoNQHg=b!>Yq&SH0Lm>n2YToOD%YbB03wq8V?sAyc!{uLmDD?gEJ$irJl<{`3o^ zd>vvZT47`>aJUOlS zS2-{T1YB1X(|)OiNFF^=&1jQjqnv$Bcq)tWiiY#Vw4J441On!~dT%6Lryf`TVGcLe zhb?RNe+PCfq(WS2US=O;Qo@{g>3TftT;3SkB)C7rUVYNKeIGo4t-@Y<+a}tZQ?(^| zgcI`kvU7|C(I5AMGv*rQWuP>61Pw{zqHTF}6v^p5*4@nfm@_PD=!^A?}$e}YeCMi@u)(;rG#ZvnX`Jg%2M ztcOoU7pb!ZNK`(?T!720GjGN@kYn5`XT&S8b@ivu|7nlk_jxyJs5YE|y$gQdNpS5d zPMBxJkSG3o@izGI^Xe0?QwrO~7u&~uEG#5JhftDa$rqn_UhdA*VjMb-&Mc>VkyRWn z^Ml#bmX`GGGNN*yt7JB2*h8Fm1|r1Yv$`VDgd_Ck_@@=V$^~gy2<{6C7gbXdh&y4GnnOPIVW}T?>ib%P({{u>Q_Z%Rq#Cnb0-QE004R> z004l5008;`004mK004C`008P>0026e000+ooVrmw00002VoOIv0RM-N%)bBt010qN zS#tmY3ljhU3ljkVnw%H_000McNliru=m-c81tIxG^G5&xSm{YbK~#9!?cH~nT~*Zw z;CG)}rl$80LhntAAc%l~AP6F$B8rHDy%!Waid_*EJ`^iOKm`jRy$dK^T7b|3A*7L> zskfc)k8|#n%uJFgFa-0P=gDO5J!PN0*I9e@#d@sAdaTEK3;?;|9>99Mvar8E#&&8T zKitDvk5>``On0B}sE69&9?*Kc!tfEXvR@cE+yhyUR}cb>^>6Lwi=C5@$HBurto0av z)Fi(?pyHnn@{rii*6%Cp(TQpPtHt4Xy~mY(matxLSr61WQ|yAMF2JE)w7_0Sq|^2I z-$jU=qU5o#14Kp#UlqIB=;0pOdJH2bC8FrDn#^@5IdvdRaDzD6TE-0bAlG9Uv9%|( zIDtqcHZJ*ee~Ue1t5lO&kN-Uc+2E&QXJzt1Rl>-NWHQbaJ9RyAylSx)3%jAG%n94| za>nkKxO=_a(TVJE4`65!BZxTDZ1MI zahn>MzGoz(JlxOsGGiUyU^g+V^N&%swyy*1Y>efe^oXats99O9u{O1n9W}bs&%)jD z>5h~a3zj-CJRjd~OOzDUyD1zQuQ1XS8=7pCNUImUV2;I#!~MiBH`Za|NHNiF_V)(c zsPVkJ+!F5fY<5Ml%WFODt^2781Euy8*id9PBkaIF|Ki&oWGc^(JWV~x1Zf? zY@|p95!x*9h&$ZjaZ5X=E*|b@e~Ga!6Gx4m9pNxrDtOWzZVC5CFO&-ekw{in1qHFP zSWQ&eDgLZ?xyOkf_eR&cEPG68Be$6s4$QACOpV{;cw1`nl!whU$8r^QCfdw)wl!J7 z6K->h`^>HGF|U3SS@$sBF)p`UtGk?P-!QQ@f=De!_)52f&r^pCq6VMS3tWYq^#ZI*CdS~4$4;%Zedlk)duEWCw z2r}w1zR#0xRD&Rw@f9Us_j_eWU|Wmb;2@7#;ag#Y>ece?BonDD7eE% z!}Q-EGDgOZ{kX`;#3uT6vDkmYD7@A(u@#O_mUY}}hfrfgCyC_4rjGF&GqqdhdLOri zXt<~8e-0sdjbB)x&Gp`sY$Q3|-Ru1l3lG#R_S>3(y)}t_H=7NDo!9F0Em4!wK{gwv zd%NFxM$sI9aG0^fJzxJz*v=UiXmzEd!)Ss$rgwZjq3f}EQ|;ksAMqIoHtr7LI8ahd2b073iOSQY(DYld8*TvRj?a{GsZ{j=VXmhnA z!$^W!ncm}pN88(%UEygf6|`$pP_V#1y(5talGXZ{AT+pH?1SKwV&7y$hcMeenV~^e zV@e{SA?)RQ9#%Bp`3^N|xaaXzhmOS=jjp&?B>U@eOxr((W1m z^g|zXgo7RBvo11MyWe(Y3K{v}e6hEKFDN^v#~^BL=CyXSQKz7}I*dVHz@!kSInF;U z)#i2|>tu231=S%!2o7+Qk_UV!j3*c+Yf^8A?&|jzYxkft91%8&x-DiVA9iw{l3%Np z>YNe$TC07*C$u^sy=(HT(Q&Ra*GenQc7yLY$fVAt?Q4-YH^#40*GyC&_VN=?DtXd( z?XaFQh7J>)W|@Uf3mZY5OgF;lnCYp$ZGmQ&Iyy{g2oTAt(O|sMaw0?{ov+nfswd^( zEDKWY_XFA;&fZlaVN;hVc;26U#}8cMF)i9W>X(i%Wz9pMh8h7iQP|Wc+@alkXM1f` zlUc9O3;-RIwwIfgT^shPiIPOcO;$NFK+aL_RdSQJMh%cPmTvmSu2p?zSBw2F8>B4y&VGXhHla3tgu}s4^d5+=1sosUzRC&+?fvU)JFPZ2Om`HGbyo!@s4q& z7K@$TFRgn$dZ5lH&9}ri!h}SG?8D}{xnFDboX>>`1fykokWlr4L1=Kh2dZH_dH9(Z zZ3W(-#pf9-2pMN7`f{d*NKRHr2_TFPd-1e?m)Xq5v3)Hu%L+FcZO{xn9&*kUyo&B{i;=nvI5z6MTFaDvfB z`>>+VrHAfisY|1Vpemp2DKb7?Vxlqj^8*iPx70tKV8b;%&}&2*sswVhn-o0bD{DS) zJyykm?pN^JuxYZz)bxJTR?gFIrVm7otK}^nm}qC&TvQ)*-B$MSjAjpcSc}KKh9C-l zWu^VGiXAJj(bg%6j1OUoqnu}sqNkkcO=}8Q-%8dP0b!i?yHm-dK4s!?Pxm^2l)={d zj78@8c+`;C4)$E-s0eBt?+I|_qExD>l~Eh)XGm{*i<&CfqP=VT!|X z-RvDSO18CF*xHZG*W!GyNe)>rq^^pLMS)q4x z*dS16OHo~zoQ<+;&5w4JH7ZqDYoajK;eP5~D-}HFa^LU{Z?LsV8ccA7*tZffw^1T1 z=zXXAK4NgxCX8qp(-;9Qo zL>fYvU>{#{xo5N}Xz`+%{_Q?xu}>$2LBjVUM0JkxZ)G=n{YyXV>k>9|sj`2D9g>Oa zE@=dWU@w1HG{f;xeIgrdFx;c=6+20Uid5yT3!8)koaAfHaiu%`$Bl|U+4YPaWUEg( z)weCSz$cQu@_%@H>3H;g+^5YMVPcYw_?DiBZtO=ETkg!TWmV32We4+aqsAopF5D*{ zMRj3x7#X%V&&44dx^bovA~ncmyxBd9&M|qopJDis@ji1c^s!7WU2FMu@yLGE}S0jQIa@=OxC+S??os4Z`#FnbgQCY zhABis#uxm>9_e@W-sI0#TH+kL=2MUC^ugTi6@p)aFy5b(oY%u)gd|)jz#BcN$tOej zUlUFDHp2?1Brf(KG`d}EuG1ak)2`QSsq@1=nS8Pjzj|_p68}$_>^BPT^~U7W#%{;d zrMxxlo};%Cu%T2(In#phy0D)U938gEWeKLe zO5F_!H8cbVx>vzjCidJoCdnm2*in|dX`L6g){GqNVWtI+O1MJeQmuy{S)Bff$T%6_ z8}0$WWSAyZTeonrlIyFHVavK4^Q=fD7x}7^pUb_9C6BZc$_^g1*t-&s=x*tE_3)E~ zIBGPQ{y*SgI8jC|!f2;j=?RDTJSLG>!zh2&<~X8P=hl*nQ=7WON+;HZAaqGB$ic5W zVmbe3kZhW{toL}YV)~lCg8Ol-)0dS z{L2Gj?5mb>_JIzy_4WR(=*%QRx9coql2_-Qnq8vd)w;EeaITW?L^XlLdfXNJSm~^q z@bW8cU6Wf57=~%tN}`8^O{$PEm6f3(~_ z!!fXWnB+Ca7$!+4Cu;=47(dYFZo74NB&3qZ#vbsrt%qfZFEKu$-DP1Cx>dYLLnq&+ z#qXnh7=~UrdHAkn-eWB@>t70_M)MkgpUn%+o*T9~MeptZ;p>eq6@Qm8v4`NrT8M+Zf@MhmK zu0O?OCLoCF{6g6ex=&Z?WcZclVUe3(5;QnZ(HC-2BuW(Z6u~yIzXk3Kn`4-Adm@?0 zg<}5=;|71V&a38v3lzPff9ECjA;JWgY4gEeB3$;g%#t%j*iz!*8Y*0%;K2T#l*~ie%Ka85JR;NaO%T<(%=0#T zHB=)%%rZA8MH{<@1E;F&WY=l-{^2zXM?#IO#G34Dr~)^GY4&xiirbvtUllB$ygF|* z*Mmvw@1`J5UaylBy?@xIYsj#C~O^h zH6q#Ij|xc`;6TVft+BkH#jaZ=Qhj$T{AeAG42$3tB_Ai(&0LcTo(Ear;jj}^`xohz z@m?nk?H)7|_OwDQR&?x8T{j~eRf*&10bV03l8>CGl=Q0H0-FoMI1jox)USh5M}SQ{ z>CU7KQx9zGQ7_n^d_RK#!&nb_@+HUwdzX?}EOxoNp|O)@WP=M8>^Jah{5^THeCnZ_Zj$-q7!MT))eT(Xjf=D9>f0mL) ztT}njYX*1O$#5x}&2kqg69V);${}#L7vsx2AIWWOHo0y4CQuMy0e$iOi*)l&EJcoN(F&P@&g3 z4KA}JaXI(TjS9Xu}>tYYu&~q-#4ny4BV6neuXH1akN!Lef_p@v!TB~wOU5hRSQPzd&BF=HW*BLZ% z1cZ!Vru?GC!(y>#JgekeiL5-3$qz8r?P5#p-WdEs?5Eiyck>7H?2Xb7vc zzrvfeIHNX1J-_K2W1Q>!(98>&NEOvwKoZxInIaBPN$&?M+=)Q?-#oEQ5Qu3#$)*r=U^X%fyo>lgfByO`XlC?5{;q}bVs z;d*WF7Qtw@h{YD#Danq{2R}{RdclcnJ<^mkcJ-ho-rY5Ut6-9n4^ zwAf?)DNZyIVO-cP7j>`F9KkpbyUF2x>O7}A&Sq62c|}@2c7O?HxIU^2J=+*f^Q?=q z(b_qgJCxKnxL#T8!YE3g{i9;P7{nCp=3cR@!}i#~{aPLF$6_Bz4S4%$^Ovxx2Q_&U zge_bnc17~_>fAaJjC7-dkGs!2TUTu{^@1qp4`N>+_{&-iwZ6-Br>=URgROM0h2qq7 z_nfosxt8XmVZ!UI^qpRfy4zXo^nRIpYkkiA)CMub>r&guTa;W8^8Mwdsc^TK8DbZN z4UloV*dN1GcUkN;sYPQ8^V}0g__)|5iIFL6>ISj%)=J5GhobAe*-AHr`q14`PPd2AyG@l zdC+Xr!zA}xX&?4L*w(#b-waXT3md@**C~0YkBfb`tA)2ANrk>3;T@U5xQA*S>v1c5 z*eAq(2$_7?-Zwld7JJ@RzUy6fx1n582X)v{2OrVqpkBY;(Nf>*N7UD5smEiEuY}jR zFzNS-cW8H0=vSa;+Ms7U4~U%=5_RddW@&LezL=D$&m#ymuCcp4fNU*aDw0PE+?B!dEX4@qp%qhYqPI9rwwTe|N z_VX}S+V*moF&0kJ-dk;IY-XO{^g~wI&r~H)E%AXwcA2)eS7V~< z#C{h>gQ;#6`$3coc~@wwW{_pn2ftT#2w`*2m}4uliGAUN+C7qVW$TF=Xmqu*_k@Wa z_pD92>r{;*nVjE=ooZmc9=7m3FNl>qWu}#470phMvOzUuFrN*3x;JqGgh}LlU@(h1 zRCpsvl)(pkeiwwX9&mH03l^@$wX()=q;u_+^e)I|d`(*yr~1+=d8`>3L5TcN?5Z$1 zRRhl!`+FFNsh;#?*dP%dYe`JqCr}rhnRGWu%Bw`Rel7N!knfYkkI?R4VU+!}xh&iJ z0CzLb^F56~Ye1vd`k|-Or>|%-%Z<+RQTvCD6EQ#4-?ntE*aO~@&+raezaPRi9x&br z+gs%9o|6}eA{Urv%eCVjiTIewcE)Xo2JiBHcZ$VIik3OCA42JyEcc9E(lWR2)ow-_ zPO_^Nu8-;>cS*IRPl|mB9H`Zep`oKb#^xT;nnZn{+3oTfgnIu>Ghewqawo2x zSt^Whjo2qsePlC_YIaO2F1}U8Zzrds;}-BPvC~tx_??z{ZPFY)PZFbXyYan>rH5&A zTiC#7EbYSMDhiq`_JXH8ZwXt4k+o6v$ug_j zT^d~?c1hSE={?c!Jj|C8IXG2YPpKn^u(7AyHV9(g!u=|~>@Aj><);>}9eGH?hi^_i zm?80UoD)@*;SY;_qZ*5O5*(!H{7e!?^IfsecGm3*BU~=_iSGO_3w8dX~;X`p~)2?7vK;@e@*_MDxYt%!UHDv2@jb} z@rizwkD`23A4Y`=^cTtJpPRHL`RDYW+sZ>0vyH^R6cKb9eBp$aKfL(DSK? zTkm=WM>A=Nvi61?wZR{(=v{vb)7@)cVt4E(a(*m!OY&BP&CSs4NFT7wawle1zkMH| z)oo!+NX+~Hmn>SQS{?Xo6-RVS^4`v3wffkakan-PtkO`%hGI zdzj)x%PeTcJ^79c{Vkg z&-Z&DG(*J#MavyaL;u4@h7OtDj6ih`cUdZkEz_=0?P1nQ@o5>PLp-45zkcciwqBEP zntpqr1(tb7QW+@S`~NQXmAc3W6YkMla?~4Of(I?=2z39b*qQYqqcK^8TGv_THQhoE zr+dzSjY(yRpNhSwn$TGTTbu8`&H&a7oG!M^H$!KH(`Ur)_C;^EpFQkq7rWTS&R*+g z&0g1WwO$Z}8aKE}5-Q%gS(G94}W*On$pdL@HN@nelOsaH0`T^Ua)cpLeR)0$VxV zcwedcYr9f)3@d%#9zM}}jo;uWPA?Rlzv}t7!xlDodw2#yRC&FM>sw-)l0$MvXw%H% z9t#v}u$)=gh~;2scQG%1&c-HMTAhz5TiHy-*R#JYB?F8c>$7;R*P^J{?I9aPKH+IE z_VwgJD3<5iKAvJZ8f;~MhuKAq=iTQyb1l`PAgD3M6r0-GMyA-eILo~%FA;UD4RQ#3 zyVpEVc+}Gtsi?Tihr`rd25(nzpZ{9vn^ie6**wOjt(Z0zCWbv78+Km{N8C7m-?q`UDxq*qo^ZTL zC*9>jCx)q{Q+SA?>%89s%C5Fgcd??*+UJG`QSg1SqW`$jT^{zd7cADKT{&g07ua}L zKCQ(I-Ag2;d;bp-d*?)$W|l|7_%5|hCwj~itCUvR)C=woqe3DW9jNHMTt|LL#`gSH z*`d{Fv<~7(0+}{)k=S#-YPN^N*fAlKkLsd^>Q89M)HyM+r1UipSwR@#49gTXnc=sN z2^%LC*GNWI-UuU%(jYIJPH;5BTU@2&Hm@1BsE&iGm3%9V&E%k_+DqsgVzDI_ ziNzK<(=I)AtBFQvV70cOAmsg7S&Jr1&G($g-S2kS`kV9ppVQqhcE7h|YJE-FL*0X{ zGIGKBO4Ud`o15>>ZsGis&Gh&xZjLRgM@@#;YxS2XQ=RMxej#>LRecUZ-j!C`6?^)R z*j-`YFwTRXGd*-@D_wM!gO&Vlr#^`ziTH}@yxu$P8#c&glRMYyJxO!ABw~ax#+NMj zVA7srSel;gTJ6>RZc8k7WFo9=gsgmUpl`dtzdUVe8m_y@bw2M9yV}ymHdxzKkUYYc zj&?}cC+rrs3!8-v!h|p?s?X-@A_$u~U&#tT4%_*a*l)TPLkdFPKQ-Ast*N!SdG74w z=0TX~QBSRsaJsEURaF+R)9i0iwv%(bf;#jF7cy*Uh5N$nGKWn@U=%=Q2*R(v8Cym%gzeQXBcCHqRvO527wq zoy$g}!Y20eE?;q>M=aB>-3kl6U{;b3vgU|}-u3l}oKZHgoj2GajPh}_#2$9G#b$TS zmI^|hn=S6pRi>Hc;ZDUQ2qWE@BxZL>qm<3zD1MjtZ5z|2s|)_1 z>>A58`)(LZM##BLvprO^6S`t|%`QvLY<=K6BDHFbkWbBkiH4=l0nTuXd)?>{KF~Gf zE~#Of%lNvo?_`4E>T-3Yv}VKHlyVzU%j{a*t;$)?$HAWHVuB=cUD0W^}bY2BE>NUQBKkgwgIZ*Jd1% zE_9T2sdoES6}7WqFD?EavS}5ry|lQrD{*uRq}Ac!j5Ocn15uhKR~MYC<-{bzP-6G%jTd|A6wqaT{ z%J0(HhEI#AjWW6J700{E9HTltDW9o+e?Gib$)Bp6;cPfY?57>k-tQIrQI)fN5T<#? zqoLcL9_oEWDG7t#RciYCn%IYXt)Q{Bg>DNC1Bini8FtF#)Bh)*ZSAt8ZhR_0Crw9d z{Mq86t+(56WRl#Huc??}KOC;?TA%hi|4!|81#{fwCyup)QGrqZYGK&k8jZYpI7{r5 zuyxoVOm~Onc5y`2p^h_D+@M{P&&ULkjHrwB&=J>l7_~`%hPNpCTXnY|g)rSyX4yFT zYiszl*cTbo$yq*Hl}U22r)F1nZVIUbZZB;viBdPuMEIE4mwTz(q_4p*DF$DC^Wz>eAjZ_(<9gx8n7L;6PzT>-|ikqm>PHMHuSF6XRd{f=7McTf>{eLE$K;xX`mU zbbv8_8NOdB#vWXo8?>V?C6wD0>{+##YE;nRyFR(9;UI#Cl}s*MBpXXbsI`q|vm}+ErrF7J;mIT`Cm`eq4$;W*o z>=Ww!Udhiwx6L+_3lqYYVaqT%n`3SA)*IpL$-ccYY-E;)eN@HIQsVfu*hLnqmU{cN zOjq?Smz?#K* z2#P^uleLOCm;hf8`xKKBgYv)4^%(`f8&{17kNq`Ge7f6wO^)vBtvOjF8~LT!DM<`f z5NchN$O1vIk&K$)>?Gq2yhH4~OeRXSo4=?ymffm*z-I1M@*%RT+G%#Q)D59FbpNDx zon)$~J<=JrFgRorCH)SMm{gUG#)w2UE=!7F4^73v0UG36G#Y7gA}w#}Yn~22h?_b~ z6s=V9MPKzf$J|M7U7WDyL1ssHK@0n#J;|)Avr_(crLL=)CriRg^0J zXo-*5DNfumZT`=TK54I5Y__uY*p&*73JpOvcoS|Zmn&lN?%rfZxRv`7;@Hrcc6D)d zaZvI|_u-bsGTr2eCM`zD_3A^3g%F13o&Ka+@iJG~!X8qIYpF3R?XEY~t~3wHeFlX9 zwa(M#y&d&42Z1Rhyx|*+NZec3S>kw$T%W$7M=HC{T(Q`>_R!?=?smr!iE;afV%JwQ z<#Um*i`|*Hb)qDY_%>}0$23oPKK0Oyc15DMq=#BNC}r<=eBR9qYC9V>QG zlta!B#BNTdkBqmOA@v)0P&vBQ$oo`#ZFXU6$;Row1QYnCNj&gvmoi91{~q z!0rAU#)i~>)Q}MUy{n9A7_p6~J(6^Q9Q;0a0Eq-}I<-}^b(6Pw%*@n}x{p@>@x0~Q z+#Gf?*Ii*`_o+zap0I@*#BNI>un5!qUF-n|C%iq3b%Tn}`HPBoA?p+cPlY|eCeE-@ z!LPzp#`Ny7*sSyJ0mish!7Q;~uR0lFg2z1B{~j!TBL_dU!tR|OsjSA}cS-!puvRM# z2(>QI>R4*}QxL9C>_C!LayGeSd-#)9hr7!Qse5gAE8XvTi>z?39X!+3tyV>iu?U;_ ztJoZ$OWx!#*>AO5;&j`~;2?`F)8dgZ-3X^@v&cy{@j54)A@;P7gociV=!ql>WMr^K z!b3kIc4gSt17hC_UHs5N81E6!gbjxHjXqi-$qPy_9zLnvp~Ko;Ax-jsw|2jYYB~(N zy&SpW+Fvx``3Ecc-P>hk)dc4&ILvjHrs;$`T5N_n7I@L)cJN3K_dC8RXFS4q-?2pO zE}!-q)4k3`N@6egqi;DYZK^TX6>e7)Tj6mpXcmk8BkY(wQJ;EN5_$zW>Q`M9V>#R&V0tyEG}W08l{+egK$pd+facf<$;d%5F7w)KbTCMq{M z*{^)hg0uy~OM-3P#S8J%cKp={E0fPQ_N*`~UTphZSTqC~P6Hy2q->TC+0G~9$McGb z7&y_}9AP_S@pVm;)`9Pu2N$?eeH-F(%GxR?~YvPrDIT zDwkXz-BsDkDfX53h-H>rZnm)f}4QiSY%Fj2{T6#c^w&qYZJK zl1A)~-JIx!a8{*2B!5ZUBtLS7h3-gSoLEH&Vd!$w?v&NIa@ix^8c(ruW6xr-z>8+v zs??}I6W<30L>za+_CDa&@TXV-A;fR-b-SA50Z*7`rJ`K8C+>e>bi1;eWYSR(~NlpvJP;LyotZCuXNl zoRMiNJmF381S|J<(@@@SZ4tp~+8vcnXyl`odES@9mQigl$My$1Sd!Qs8{qq5@AAbC zd**nLSY)mj+@-}E{Yk66`npsq1MTR3v0sFSB)T&rE2mzadZSF$sLp7Uj7cTiv^K{_ z6g<>dZ4NNCLmWO*oBKm5UZqhlqx?bax+F3@jB&r&L)kSZ#Q|DHZ%Pg=o&15MlBRbc)cJMW| ztDmG08|Mo$ejYzxZyc7YN4z|I)m7f)M@Dw#N<)V!Fv}7<jt2vHcQ%A-)c7nZJ8T~D2PsyuA9`W4p zdG~maugfJ5GqhRo^8{g`XKh_-tX_F3Jf~%7EFA-oIr2(LP}l7g5Kpy-JHow0HcN!c zK_C?4f_%uPbX!1;72=dQ%36}TDcVFDGzl6Qv5NfFpjCxk{n{>O_)}bKOrP$ZNLH8Y@Yj1qe(xNB%Ufq|lS^>H>GT03erD;O!O5LL=8A{iC! zXwZztp0QV1gk|x!O*7qwHZaLn>aEb;%S|haTFkY~67y}~NPiBeTWWb|i3+8XzBI0k zU~^k}ESy~_^ZV3zQbk!LGWLo^Uv-AlWU86ALx*MXD7JC^zf%uOB-2`W)`9U@%P;rV zL0x}fMz9Gc`&ZnSRTgUF*P0!kj7>_Uk-?&*-6*+)X{2#stqK}s6*jNTY!S(-XhVY+ z(9n}G+Y!$(2Qt~XE^dgw?Sp<8{?W@5m$hrt7TQ9gTyT^l&5!R*m0CGPn|P+Tk>+I8 zDmgQLDkHZFX}}muERHkhmM8m$tR+KTdS^Q`m}R-`b#y|?X^TB;lnG`Hwqb6+iK9^y zQ#E>qQ5G}a7Ve6c#6v?GlogUHD@CfDqg}gtIc6qwkP#GAG-}Z+=V-I7&E2j=Nu?C8 zj8}RTh4|6FZkvz-+Ek1<#-+CLh{S5!lQbGNQ7exd!^P5FZdEKc))M7n^wY{@A5(9< z*~z_zhDu)JQRc_9Z5tXZX%T_3=JI^fhjFmHyx-bN9;V2comLZ^Y^<5(@{lzkFKLsL zPh+p!#cCC_tBtcUNfb~JDJW~uEY{c?~XKTLFvV>J*Dky3l1AhW^@ zo5hpk)V?wm=3`>NYPR-@eshi-Oi{9cOJSV6c}z*-xCf7lR#|!e3k4Omp&S?F)3LT7 zr>LN$L7TFMnowHptGK26S)^=yJ{01|x_mPO{44z{K%0_=II}v_?mc!FbCA5>WNwaS zRukveWR&IN7sJVM(c7HwN?-FxEEKTP#&FHc|BkgMM?4gS<*dNNTf0`5Y@&uT4=yFTi`e4QYB4E?0d%Q5I+@8@_zR?!nwAgG9=A|TS%hqcdV8Xe+)`0 za(b1%`-6THM?pOkG+V(HFj8#ATBbU#1wut@mpW4gWe3IQ*;rdBhU$Ej)jC1FjCLiB zYw}st!Ah-0#kn=^_H7F4R?ksO@FrWjKAI6UcIfndp*7*RD_j`f;R3t*iE+#wg4vn^ z&sk*qOw`3im=|dse2PN9i6hpUGtNpaN&b;WWi1R%kW)|_Ym=!u)4~g`*6g)bx-?oA zNI1vsu5^!^Tx5Aw@m(EeAhc-JxE4w1?b{#Tk_(kelT8)WTQffpw`tKBui2)Y2*0Z#jxyrc+1owg zb|PzMh=*J{wWUZ)Uq@s2^daE5B?m@pwvSiwnHDsemMNCm!QYK`LC}>u@ zrnI|2L5sXxU$0&ZZ09gfg)3-sxBj4AMG($+m3@=W7lX}n8V8Td+FEDKTAPwOz1m*- zgMko7MZ20f6DM-UQz~{Is%rfeI*23L%O7;Phg@MtA4&2;Tb0yTQf(qGXi>9f2V@XR zn$@g{IAY35MkJxHJ;`IEaV08hGYlVRjM@e(iQeY**49_`0{W8Z7aww#{s0DRA-}@nLit6G_vYUmHR< zEMjpGrKjqMXz{?H8KmMRK=0*L0r@nZXJNrwYRJ zX4=Epigc@QQy7wTfc_$qiCmOKQa_yJo&L(wp=v9ZBk5}J)jkuix3$Q>(mLfyuhkW6 zx_f~4TPZfztGDUL1c}m`-*WP;_*w{TPz8;MV8`#r_oM)EU5?@JZ=NrjUJDI8IiHU_+Ap*tfyQ zl6U<_T84r_rZ`N+Ieq19g^3>XWTLoa;Qz$l#$ml54Ry{HyRfr_eI^&S@>O${oZON4 zKHjxrKac7SdU!X_doeKw55~l_RYKjzE4$vv0jCdj#pZselC(_@IhT8M zs0u#x12G(|-N(E1YJP*2&TJI=XcO5_9H8KWTR5JvlM%O7h zhOZ6yTH}&y9pOoBuJNwW5KQ5BUKmun(t%+=*vV2qOx*VkN$t<;JZsY-im!gXR)6ia zK2B25p{`^Lg3Vt8bw=rrb&spYhT`XV?(tZA83Ldcq_O--pyC+v2BO@0%SEVzQ zD!_NdE)SCu5hXW3-myt??@b)z!~QDv&u#@^`iTHrd&Vs9OZw-&7k+9{M^o#U8Pm*i zaTIlFr}chCCl65=%Pv;*B~AsQ-mTRKpGYFseXh6M(3<3*3&ehy&2%pjF&#lv=htF? zFxuaxeWP=o=YA>a_BNt==e(=M?sc(0`=fmZwXwX$gB>M0|Iy$2q+JogsS4gr(kwX- zrw;{j3}CYhERPr1Fs@622UZ|l6+h&C{us|2f`(FUit1(i2uG+WRM#+vYKU=9_g6dY z=V%Xv|0|Ul*QLMhY}3pUw}v0Ydw8c72f8a1IK(iOp@0P+MO{P@MH=CeRil20g8{LE2 zfhH-%B%(rvyc(l44A=`&1ABR%=&`770(g)!y-D z@gT<(go0M}alVhKj}=4-aqJJx${O>b*SEOd2#dp#z9gaP0e^Z2P?e&qj2n^?sjKmy22nyBInt207DWxEOs@--kyTLcYZ;$S=CXo&D{XmC zb-PnoVS#a7ZC%frog`1SE33&3(6AYiY=#Ykw~fY(w56xR!q7FXE2}~4uyBrtl6hKT z`%cyMpYU(<91?OoJh(9xG^y)rcgnyiomYy*S&f>8g*avl!d%bUA#`}2_7RDm^KW~^ z8?(pY##FK*P0{axpgrLnc~u)vt9A{21m~oINUKGxtleBL>Gp9(rEHPBF}-+s3d(9K z(IB>!6&TgCLuLPP8cBDwS*w)mtI=p>8gn}c42Z8q^2AT=IUNGuU3QQVbF=x1A4%5+GF<^WBbm~v^fa>w#0$app46rN~|TRy0LSQ zZ_{c&hmc$oSQLoOja%DKe1QUzF{o3r=xoe&z2(#R8&&uR@5VavvaV@Cp&5qEeEQ5Bb zZquT!j~kYis)c%bM-XBqeFcKA!02Am3X4i<-LrwBNzuqY#OSp~1;#2{rhAE}2DO$A z-kmp~2i#Q=l3pG|a|USq*RQnhRK zOOSAv9=Cb}32}_@nDv=S-TNyN~u^A$}mbnQ>P-kElI%0(!rN+84z*YC$jMp zciJZ2H16Q&&F~*(ueVk`5_(6DgkSa=Alp&xC!a=7CibmfD+-2$bL7^*{uAw|$1x>X zDK@efMYyCW7Y4Jm&D#1Dqt_a3B*f9u8C1D4`7C4EFl4+XIK(V&)#!DdTw+IrM?LAl zFsiu5mR)_JmX76L*yGzA$qjSKkwGY1Dc?uLUXroDrbR64rEq&IG%FdA>6vUsvGdMhlh=6X!@05yE{I+COBgri6!N#fw~Thj_=>qXWBeGN7aq zSTC=9i4K{gh#*(iEZawnVp+TF>fX;FN@R{6x4Mti(&5Gz&9@jcLz7LDnKAe0ql2PN+%sZ)a_j#wp1Y@wYB*$Nn| zI0VH62TB}I8>v!ogQ<4cVYr z74)5KIcUxiDhjLL@YWI;wOYFpM_E1?r$tlh)EEQ?OdPul!jtZ|Z(&L$-B`}?FJI?Q zBkaIF1DiGy3d#27hR@Pr1S?4iA|<6>TnUNHQKQ;)r3d2V{76R9V5vLWwW`z8KU`5< zz5Qg3s3^${w(mtO?#Ns2GPJC*R)&_rhind*IPO*}ZgH)R?cP}}_f0TUtE~o5yBMjD zAYJab?{CwsB6K;rCn<%FDnWg%LI){kdfqK0C2?ze$;_`P_9>^V9V%(D!NDRYuPv0j z5klT*%Lkn(YfwJpR=7!%L$e+6{i9&9X5$CyH<(NscGVkkqzQ}voH_3w&v~C;TjKMzop0OiyzY-TjZ4+a<;|WdvvXZEMexAD6On@yK2I1)#j0Vo z-lPr@#Q@y6F0IONheXKFhJXXBxmVg#9~*Tm9acEULw9|X18jg1I^xUrSDPCQD=d5y9|ZgoKVit=W6{&lp{99~-%*pVV7^*qXWKZg za&crJBi2zxzbH4_$UwZAR{+*2V~^;*o(Xh=vJfl}2zDU3AJNRQ{L z+5I`ILtN%8Bfie;HQRaNy%miC_9mu=m)D4C3luk9P=rF)DiUrR&u&M1I`he4GPa@G zc1d7P={O^1J6cQo@7OBBD1BS^ZP6zwuj{kmR`dVZe9_mWUNzK_p5s<@uA+Gv^sl{k z+~)N^a=`>&8!F#x;*kA)O1*D_`l!mCb^;;?#yWt8Q-)2hnih@v{KI`bq_Utww$FCD zHXRnimOY)rH0yt+6b$`!#4^||;QZfm1-zmpQxCbJf4lK(0I$Fw{|}D!G5s zHcp7uraVx!EE~U2OTjdcE1B0<%|E|ko*u@Lg?rFa{Bs7GF^~7NXw`L3j~*l&2v;0o zt`(I9lgsTmps;4WGZre*S5-e1Xr%gQ3)qJvKV*k+A8Ec4@S-4$Yt5eN&8_7w9l7wk zeTQtd6exp2H0k{VlhH=B?Cu6PCp%>VIK_0AL1JRXCXP1N{*(F98og7#5UH)t;5l>W zvfTa#bCW1v*Q>IcmPLf~Bz`Er?Dc%%pq^n;;_i2)eC!x}Fd#MV2ASFEV#GF6f=PXA zHK*>7#QO|V@Iy?Z8wI*bETmD^mMu>hg;T61f*w; zI=g^`UiyxegE89`A>@9o91g}Vn3Vrl;#$4_#y;b;ZTQBJPfHQ^eCmN}j7+Dvvy|V!m3D7G}@rW|A$ri+Xe0^60)Cm$6M}Tdctv;7~k8 zX1<~Xx0tBQdp%F%7pA|U7Xla#s_fv-mw!|~Z)C+Fr`cOiaVbSrj@!eP8n#!Wr8fdn|uv>40J=ng{J`RXfB*1BA|0+eL675ZjK zdn7#d7uYtw{;O5QZ(0Ogl-f^JmcE^q4Z-nxU0{QIUK(hro9jIaxu&>9jfN#plyCzW-pVB znGIF=)|Q|ZMJ`^OKh5H7c}0Vyw&z|>dUM1SZ|Sq;=FcQbh@L?A*ER~ZEp_$vM=P@A z?s>SmdBZQH76+4>UlsqxJi&^0`}nwwe*srRz74)K>tkmT7c-}avrvrFimq9=aO4nb z245%;HkR!xk6=*EAYM%PWq12U>lG;2G`F|e`4L`sv;Y)OkYv08Ivo;|Y_a~}ZSVB} zigPRV{R)1mIfD6XO{Vw8-6RPNv)q?4EOWM7ukbezKo}gYn%7;`DKU zoY@|%L>`~|F_7ws^<>95%=LqrJrbx&4Ym4lPL4D*#h2bbg)#_y=r>xHoJAr&rFhOE zQ>6d{ZtoeY5VbFQhy)k&#qDOAF!N0cLYa$f&I`PzpHYPv-Y_doz7&cjgPELNo<68)q zumD81|47=CEz7scmytw9*Si_tb?SPRGbs)$qa{fhpb_tq!fKM_2O`Q^$r&(A~x2AZ)(Ll&v_&uvWdV`mmr*J<`9pPN{n zvBrjyq+)+#&Ei7L<)*XZ zOs@>b9U8ZX+^l?G-I`aCkm>~##3e?a!lcKULT!8%ig~RWk9b+%XYl`cS+^ZoZowY= z4N9sqlF#A2s>aRRl zhx+FaV+=YPFc9j2W+Pg)PXa%9Q{;#T>bsDs%j~^c^}5v^Uf5lpHaoi^LbpZ|Er z{XY44fu~Hsq&Z@eEn8O4pp*T#?$7fuS<7dB{aq;QM{%Urc83-3q@@d+4AY6R!)|#4 z0;6k?UX)8$-W<1IaS!Ry51}{XICjF+?J;G<1NtdY!aY3%&mR0s2N_Gx;_h^kS^QKK zp#A=&P+3ZIi~V4S4g}&5ljZhK?YDC-`|-T%{_!IP)6|Vt!v?wjiTxvBWtB*0L4__d z=9zkX!*8IoQ#hfP=0*kjY0i^3M&8=`lw9TKKY<*VGOW(z1&sy=1N&D4FCRBXjlg}r zS|*gYK%X*5>CA%b>5h)u?mn$hYP6XHpd5P^wCm>f!RjQc3gn#9K!Zc3O3Yv@L^#?7 z#qumQ3KnG5&*IPbH~MP4%V~MaCS0i|{e3-A`0M?vMAYBH9dgX#*`{f{F9f^9B|k0V zNB2TwNhaAv)j}Bnv$o#_fZ=ozM@%X=b=8>{4(DnGuj4O2jF{~uEU6XonUH|wd-w<` z;rfS5U#q}<^ zf|11*0YR)1mr#ZaQ)uom{J=iaOEYsnT&eEXZSR9p93tWpMj5%dx>D3-El#if;&!HV z1+3oK8(uMXRMUD$=LLqZh`*WM0MYohr)%kRu|0(ytWpca>kM1xI)TZF2@fI}v zeTyQ`Eh}gH7hTf6+6`wM|NW4;Lk}5nRlI0RyMm}(oVr%N-H4|!HEYtUAv^D(<{Y4n zDEeV`zo-ZrkX^O?))eG}BLbw~%;rnlS5-x@v=RKz{d0 zhQG$^6L-P;wmR!8Y8o)eoJ#Y&^pFo(vu%vy$9}j!VyE}KIod~1?+BBNLfH~57^|~m zWB%BuJ?XbO+G5pgX}+}erYP3x9uZ+JAztqchtzyGNl7bKe_Dw8qaH)`A+x_gBGH52 zxIEyND%{}nOouZjd<+6c-KsE)c44r?JMLSaVndjFw>KSMSOHrHn|hjznSDmBQ#K5{ zNU!46h8vSS?ECqjN$a=Am~beaaqF%e)XG zYo2IdK*Vf`GjLKj!vy{^nx>k>^|8M5sfaT>_!hX-&h-x19Z)AD6CW7|P2bY<`6!Yt z$v4MGHW7$>q;Ygo@0xpZRt4Xm_8O-8~*Kl$iQrL@+rRSNxvjz z6Z1EZrs@gN*;k?jv*NGYN{LxhqgBFpAwCEaulCy8|@vAQcr@Lv@AN@JWy z2FSkvdz6Mj^)o2{Cj$f_FNc06QssPy)st5zF_7$(-A5xSz~=uOD1wmx00Ksyc}v$(uUk zgKBP;D6OR|NmHJSP|HA}0H<@UR>ID9{vycxOz*-Fg5lFGC-xxnC%37GyFdL^Dg!e9 z&IVO~nJvRKS&eb1V`u2AoA>SwI-ILAIo~s`cvj71=Ds7_bvBEej)zZk@4lk&jADGC@<{TJ;F9mxsf;(XjTJko18E6GWmHtY?2PJPfU5IcmM>l-%In$1 zf?#*9_?kqCk$@kJ#O0%ceGIlGR|4@liiUX4ADq@$AY zcWX%ANDQ+8$N$|GzO?J;Dn9WSU#-(bK{t`d;5MXZT_?}(fGi`w{4BpZ?npJWG z2rm+GCa)(BkRD}y?r!aCF(VxnJ3EWSe0&%NZK;)nw(?;=kRu`A3N2ooWWz#|dJGR8 z(J02dxPD&~v)hzl(;}y~{UFwZ6kl`=?F5a7t7jg(Hg(%^6>!b%ci|=YXmb;LK|vXS zXYG+P?q~UQvSbT)`$T1P|$y0uz?J=s0S&+sN5lPZrzd*!wafwp-3hr6{& zWZ3&7&`+}W7>v*9Xb)*6og_!TLNI}*y;q4eWH+C`0R6k3Cq*V==QbWk9`3XstVP=P{~7wN$V-RC<2!oGAIp|ets8IXGDns0GBE*c zFkUT%rYEHb6d4t2m$#%vl~u=46U)IQmJS9i9rNeSU%19*2++ixZO7e!ac4eg4NmDn z!UNZA%}#=^D2@Cmq^agvVz?2%``JIcu1Uu#HKJ=3fXB;wh+i+-$gOOvx|*oF>7n^* zCI$?6ay$YtpHh@m+he89GsMov!^;;*U~;Zfl&E8C+?>o8h26SJ+)gWAlMRk$F0SQ# zIRzWs<3+k0aO3MjXMZsY4i9rDu~D519w)74Oj}lIzffhj!?hoOU^z3BDl;W-{4o+Z z18rMnXj^^xX7{Gzi3uA&72A8Gue1p3l4JS_|Li*0rVQ^LhoX*p4JgSJl22Ve_mT?y z(tcxdcIJh*-uD^xb%goL%Yx{#kTfR7^+So1l*leCc!qPSGVjSF#J|nVtt)N>)8RLQ zkZa0&#cnnTyz|M?_r8u&P6Yt0)~oK)h$iY;ot{K|KM0`bV!#4WX6x#6vYRBI+A`c< zBAu|v%%ikpw@7NvnYR#?Kt{bWD;si=r;vCjpI4!@Xd277uhKK2hZ_Ljut;p9cckI+6~bl%96d)PwL$( zq13@&pFf@V!_+Le6zBL=ocJ{>*Fh;W1gYGoZFi1ct0vU_dKj&U*5fs(=kuB(DETi8 zz&Hl~Dqf+92>^9eUCny><{N4r(>=>}PxBc;m|9y!d{xI=R}3>8MZ#FLqETqV?+u=T zJMSF4Z3I5^Ynkv!x)~qP<>o^?y1hv_m9_qwlYew7!}7ctb$neL?nKIYJ>{meRLYe4 z?>>O1K-Sh=Q8>NP#%o+Sr**O5fd1B}ZB1$C>kzG@YVTEBsa!6oBM>7qK-dZI3R6ze zDya!L|G3tYQ-z@>2qq4Qd5VP@s-qWj#ZE6CxN574sOJ$D(xT%%7s#}UyQ!`u-Uon| zk<`!_q}j5_XNij}tCR&)QtBF)v*P%WG5Y&Z9-f{)V_7RG^`9p7Ik z11h)nE^NJFJ`bU~7Z$Laq=U8;7tCWFBqXM2fdr9*Cq<~Crz0wnxbl7jhmFI1h33Y< zhHWRc@6RbzXLObBq&5zh9OoNUv|dx`x!BX7fd3lOi+_dJ&u*n4(DvWzc=HNQjrA9+ zv~xu`zu9~yeFqpbJ`a)591X5QBbq64Js!NV)U*x5fZcpuGWIgX*PGG{2omiu@ zMC!ms?hy|OYa%;LYqYdu9~|u!<3U1AXP;{@-uiekgebn1BUfcua4W#60oBaBU-f^j zu8`k^p01=smlta54;*9;Pmr;v9mLaK+7@a5u>Bz_EGjM_EF~Z;X&?fW1^}hSrTBz} zrGp4)HDC*#Q%zl?B90* z=fMA&s42=4fpYiz7ysX@p2&IpZ$uwpZejtPZ!ouvm!`s8L)FY=rjXzM71X|lcl`l? zZ0)}SeF!o41OUcJq@K2A(A2gaK6P4*39hJoetF`p%+J8daW7qDQOfMin5BGru<;xv zR&D1|b;!)7{mI9Pmj8)=$oH0k_lk32K#u?63?-oRM2K9VvL&hq!@V2;uA&P4uX(br8z}5lAazqn~L>r#h;h zl;}E&Q--X%kvBeZgw%E13Y=odg9grCLvm-cpd(7hbzqCIx1+)*Ky}!>WpM(DpFZ}{q)h8E zGWQYX;AMJ2{x>_nDm>y`lcX8&*K`$IBZ+>scP|v8L)=`tzwbB#{w_g#Tk4$Q&!&E0 z`LI7j-*dx5?yaO)s7XGR;>T?drFYBRBQf=&cuU>D5IL{`UP%HR)CJGUXqC0&2`E06 zAJssL@YbhdA(`hQnRV>c z)@Hs|aS<-Z`!a`RjJwo2jfwcs@7_K<#O$vN4GJonuRO{}F+QdSb+Bp1A!6GltU8m+ zu8nLKRO8@Usvk*_!K1y5yc{PS_f>ABtd<-oyN6X}%EhG3vfS+YVe56^I3!U_Hap5z z{UTmxbYw?;$k~DbGKs5wUo51dFj7q?JgexKDm6CJ30+|$;?>ac!W*k=Dl zfRUMxbLo_;hk>pr?dDnnKE@MnG0DVQvC0cP)Fh>Z%A_$>amtWoQya$1-SQVT!g~t? z-L=OchpvHvk-HizZJp{5TzDJ_fTp}rqSQeo%_VEFTLQq58+;)yP-%kUym=(}dMq-j zrX;2rx73j14&SmK?bI?KF1Bta=#hp(O(iKHUYsa(1<3}d&(9s{I}?P7CXq5}0k8Z; z{g?*S*sEZ*J(5y=idL3Fx<(ZbE_F*88HyY{<=&myGGJXFRd$j=qcZo}5S)k++kEKP z5Ptx5fIM%GNf)g(WiEbjXS5TtXwMc9pyq3^CCZlBrVg&0tyn5XA#OXV>xJ4=|6rKg zD^)K@jIgE*nQbdl?|0Mo{nIJ>kwEq%@FFK$)r-o^bW!KNx@MJLF7Wf>3S65G?3=tM z<{T^^*Qk4Dq38c>OsSa8`5sXAvB%t*4EVYp#b!fZqioGG+^z5s%A^Z-@^wymR%^qE zex7fZ83e#cJiMTB+RWt1Byg`rEmch5$!8i7tj_u5G+vtZw9jk@KbA6=UB(qCW5l)A ztIODUT3rD zpj}?eV;O$1BLw6_DPU0kOlE2KM@Bd?oo4pFc^!9+tgg~k1(Wl*A@m@(t_*RC(vvqG zl`oiQTp~Mo2Y3yS$ARgFVYq!LNrw5RDUddp z>6)eaRbn}q-{6tB(&siQ3saN2#r&~7lIjP_Fu|SypUQ4J214Iu@63;53{)fe#|&Ylx$462Bp(FyCf(XvnKvQx&9GiZU5!4=k? z6q;uYSMOVM&2bGOXhl`N39D*%aHj`LNLvvl4HL&dx?TO`b#&RTca` z38QbzzRAv`xlPVg2wGr*m@;)9VGeF!)J%gODAb9=tXTYM0edwK>1QTh!9QO6s*#cO z)Kt&bE%a2+#PM3<=EZL_xVq!J2%-mP* zd*<8JT1caEL^o-jG1$#aCZU#rOU?jLkqDNFGtSsYi}`B17MzK!ait66nYi<=079i* zIqV&v28QtwD*orfPjA6LD%XN!AHT3kl%_bNA-RkPC?Ej0j|xRDld8-khlM(l;Z)=A z1Mi{J0UD zP#H{PvEpOF>7RDZWMC!*toZF(NOI>y zEur;LwU746BauB;qfgnK86!tp*uGUo8+?Jp>j2jD zivd`=tzZ z+{ntya(5+Xo9cL%d48OwfVs@?DQ2zV<1Dy;uFkk%E=ygN$xDiu8pSeC)^}6}72zy1 z$BCPAI9zAy-*S6t24_i*2pn#g98c8a`$k!|y`jSF_Z zjJD+9o7BbQ_0F64NS(ocf%G`9Y?aj7rVBjL+hfxBrHdaqtoN;&ZBFLdx94NsEmnbb zN~R8N?&C75*)b`)9IJAZdI_xLj3C2tpQ%qP6+xXXRsj8t>9>pG;&w#EuH=!!F};O( z-KMu=Z)FFmUh?7=YCkNXytG?7sahUZV1MD0h9#FEmjg*2zcN`0yq74whA^jJ_V1L6 zCcnzmm0M=a^%@(Z!A-xK;2wIBpxPOv zbOT3nz`UPgS#_c*)8?HVQQ!&SU}5g;_p1Ekr^Be{J(=mma51PJxn-adMV z+sX06@ncMB%v<8%P!M z2|8TBJ6ertl+$T3@lM(*CvM;dpDj(=r*_9fJ94HsHpuC2$zh=L22d}Ud+HE3@Z#}; z6{w6EH`x0cwAU}cx%j(pOS$pTktXkvN-ls3oko664AX$LJ@-~yC3?ECEKj@zJuKPa z1(Mqq>VmV(3uhQR6afw+tT9);?N>eO{)-BAK&a*{WA|g^@Km5@$5>S;@5xgu2^&!- ziT7MFR^(c9)gP#Kl?oa$)1=Y~F-4Pmu>iOJn!%+k5CDDDeFq({n`$GcaTq z^`Uh=#-#BGx*|5;+Wf&V7vqJoAbmWdnfXyF^XvxI22Ug$CYj7`FPz4g7^TS*>*jma z==GyVL9DDnuGP8@=3OM&ZHOIm&=H@vYQpfXVjm0;6JBLH#Hf<`f*BBlkxlV1;*Gy0PDL znVjQsB-5(?r)O0{3K;o&>_Wpyf=R}=2yJoZIJ2kz>?G7n{Q6kE#0 zD}%JQ2Bt!nY81RHzFS;qIh$7})U)?7j@e-hjt?K^<;=eR&>Gb0eHnc^ouSq|11}Ug zUg#U#`{chDupjCM{VSo&zblRH^0U3F>Nfp*Q=8xZ)y(XL*Qw9U&#nEjd{j#FOYFE) ze|syb#OQE!JGz9u?R0^^$S!A;*e%b#`$y-v!KM9vrWL?*vFp9B{7j-t+DW)?+nVPB z#!)-yeiL`jp|V(Wypu+&vQl(0X?(z;JZg9~G0SH*W3l4I>nARGBR0e=^>P{UTXjET z#t-I0^}-wFto4%FTs$f!Q!tcZSn~(8IVmCh#LH!<{bJtRSGt&y*M-sfjEOZ4djI*m z=Fgo$32jzi>s09VkFq5uE@ literal 0 HcmV?d00001 diff --git a/public/public/pwa-512x512.png b/public/public/pwa-512x512.png new file mode 100644 index 0000000000000000000000000000000000000000..13083be27e2c451ebfe6f9db276effcfb117f47d GIT binary patch literal 12070 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 A>Hq)$ literal 0 HcmV?d00001 diff --git a/public/public/pwa-64x64.png b/public/public/pwa-64x64.png new file mode 100644 index 0000000000000000000000000000000000000000..5d30a47f5a2986696e782c08116b9089ad6ecdbe GIT binary patch literal 891 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

P7UM^`7d+VZrHC)Q5VJw|^RmCn{j z`kpTo+}oOs-Kr$K@fj(Ec;h{S{Gn7RzAD{hWV_SuSE!#GpPPB^W8J#wdu&E&WRWG~%zvg&y9= z6eywYtTNGSMF?%D!QsreX&||z{Z4hK(+-|#D+~T-#<&GMu{{=m!l`Ev6ErjBL>Lk5 zB>H+}Q0 zkLvGAh<0k6#Lkpq?x@To%8`{ah$gJ*@Y2~=q*b6mA9dJ$Fb(dqAE}l^U#OVc*If=! zn{HRZC*?S!#BC^f)+Odi+1a|Gn+6OaY_faK48otHqVAYqKln4TN*(UN$L zN#Y>-5;dCZ_NCP3|--7Yfr&V+*sytCJK>b{xpUj3^ zzL-pvQYN^L$NL$sLz`~?(&C*=Dty83XyD?n;=jcz)z3wNeU+pwVx#}SvAi2EbD;@0fU z(clsDc}9A2(KT*_+1m5kyy*Qz3jF;Uvl050?ojtMrhn(Wxrh@|M%kA@kJtS0dF zRT#`f9})9amdylG=18U{wg1WPOvUuU9@Z4BQ+uTTz%;ON3!vqCwRGUGF>>RF9|?oh z!j8E@zYDWFDmVKCzr^Hnk)=geM_jHwof(U0tCG)p<$DVJ<6-~ z@m69Jf#1rDD?$1?_jA1x7fz%ek2@Aa1Svu@-A%9l_1Ww4P~XJ$nN^&Z>>HY}vMCNc zu#4u<&(}5?DJLYf?57dZS$rnKtsU3O$;8=|;9^%u=v}U0WOXj@6^o`O3Lu4>VIq-b zqirWh)3QF|*C@3J5$t<|j0%sK%#BF@G2Rmg%c-*F)9=dKl!kpUn?D6ADB%%JaN3I= zOl0ptikQXfkCwXYVVZp*{L~*XqdWYjE^W6N=awcnwylD>EOE3YW)j@*();*_)aL2H z!x7wN{YyOud(xSXKfNjzXm3qR(VT98sNTeNtZ=b){~E>5e6r-xt(E=cxIXL!l{pV` zivQ!ka`5Ag(7;Ha%sb%lblp9LAQk;)6OAI1+HY%0&+t-<-~P6jnbUr3+-!n6X_yW& zTL(9X4nFzJiVN?19Ynvldkcy$<<-gKTW%U67FejSj^$&ae<|3kuMIm7Lhe`lJr!M- z9tU>7o?tg);{Ei?ntegGUqoT=!M-bfZ0VumJ)K2WsHw#OVR5{i!PmvPKJzg-TzR3$ z-B>c7R;npT?Qw18LlCR$`j1}3Qx84VWKWN?J*6E4oA`Lzq&~b~rh;Pk z&An-ZxEFbl*MzkECZ!Aet=C^T?Teq2?uoZAGzX$F7__zn!;8aB#STs4~hqJfw+wrg}A#hoB5DBTHJb9h1VKx#iKt?_4wzt)4L z%nH#Sh*3ey;RK?kP6_XxDN^rTkHDgMm`Pa!&dnb%cHY@>@Z!e0Al~X5=lAue5?|#D z^u>g8q3LZv1zvi#6$#wnt<+Qw@*a57bIIedmRK!cw0)XtogC%s5#PIn(rbfzq? ziw&!KG3(i7t&!?Nvu)cR{70>xElsVxT?E)M%O>`s?@m+!4DZrRjQe4HW}w- z@UJVAv}rm%>*q+&Qe^vqVYu@0Y*>`T++PPd>HL2==NHp$-HI&+jIs`WNHPlE%|@dN zwLYOoVY64Np<+-I0P3fQ572uQYtun_nWH6+E|{^)OG?-228xkirRSO0RN9`zf1}I# zSnOQ8@~BewLg6tnll+n*d4Ks5qan|f_YRd|@~)JyiGhvG{9UZ;ZgKRfYMS>yDW=Nu zrXr0{#*W@j3WCodfH2HIVZyyi-?%K9H&8LiKrVxS2C2n)$@X@2sQXtkIGBL zZqu~W^E)+sIeq(r~1s2WlUGlC|gVtw-{=@Ra zMa)%0^LCtmoP;Hw(8~Aye9=Z$=WI}_V|SguhXqrPeJ*}zrW11(NMgbSq3%JCu;r04 z4UE1*wjAQ0WtU^I`>m~r_^F|=^Wgb#wg7tfbDsHg@0ft7mf)J}XR8OXZPIpOY7zY& zNXh#-zCC_X_4g8asiX#5;MJTug>yVWws2Th_{eH*!z||GMr7_SkG^!LCj8#x9&<^WJ#@*%s{jQ8svRtnSEK|Ug4;GQ%aEBMb|Syu~Au@9Qf_%?tG4q=irUfNlu&g9u;)ZG{9OrH5rpXBS&o>JQsBNn#z|gJ8hEm9%c96 zvt5=O88EBom{X@NOIOB%wCQ~~oMzB=Cj(ilcTrn`4MC)dRKyG0wFDsyWGx#ag-o_@ z6t^@J)U6!bU(%wRRNn0UgK}C+?!QBk5IO1RtP(3nqy+4Hinn)Ie7ZLnvTdhiqqlB; zbEx?tqABQHq$;b&v%k3PbwQlZLM)T`#MB}9ShL(xo+WXcWJNSB?yIbcw0R&YzAr^q z1Rg%(>P9_G{Mh*ot`Z_d^PBgOZRDJie7{Lll0ta>fh5l;$42PI;rUcpIn4tz9$BK# zI^{R|DD}6x2N2n?(Q3QbEI-$Oii;_*>acRuhL#__VgZ5Mar{SDzULY~|NF^H;ILp< zACO=B5%*Qaoy4P5nSItq;JWU4P~HEbI}f)0KNq6^muFBrS|3QPud?+;0~i+&!>Rdl z_SMqGos+fF#em5Ae;#8k^}dmQ3A>c$Z&sN4J{{!dg;3M|fckGCU%Ep7{~I6@3*Vot z5Cvp*y)HlwZ2xm=hCSV_1c>p2tv3}m1B_`hzBT*?>{V;*<$`oRKo*WKX~iXS0#Z{VjMZ1OwB^Dc zvKU012NbbO##S9+Waz~Zie4HWP)_S8zWniWwBSu55==4iDbh?8;%MqKCx$xBHT=B< zsI^Lu&5?sOkD!-F6GqNGK)E9*J`etRpWi@t4FF41gOI!T`6#EZ0Cpcf{nz1ofc?So z{(`AM!v<%`jQ2c*w@LD~kYzV%k#S>9jVLTqpS%%%Jz3YB;WD@4*8etMHC@2JBb|kp zhf6u;D&O#K=aAh$(BU}1nqWBpFku3fc!HE+DdXMl;#+$ zH&tof(a7v2q_}fYlt^H`JyBvWVVG&ivf#bo&nP@q?_L1Hpb{JQ05LK?!*jy$LfW*& z&o0X2zQ6|wy)smV%ToJ+KsZYbZ|~XIYn?CRlG?K_21-{2FBWy0WE(U5R%p;#CBLSF zB(&|%0p{>8LBP>~xb?}_I2xF+ZM249bKcC8x4-XGQBljMzJr#%|NEQOcR7-`R~W|3 zGEoYWTI)9v%amA?W9{|a=nOFdn-iVAwwcr&?0Z3jth>1f)I z0MkYN4Gr$YyzVerZf=EL8%X~f7l1p_Z?1je5#-~9EX`yT6AHZY!z_ifp@7vHm#Xo( z3Fn^DoW`}Ej18+lLIr?lR!>QPW=GA?lG8t%0!+Ll){Yv|ox9(H{UieexDige4=zDbBR^h-aAMg79C@qBB3>l( z8+sT6T9(HgovB|%c!evvhj)8nyR=ceR=>=|I3+va!mjUKIEg_x^cDcPUZKFf{}z1r z>Q$Oen>IHtTXCl|s)t#}OZf_Y9U(wO+4yfxOZve7z`J@h)v68=cZ)4rMV!7cK5Yg{9ift3DKB{jDU z_o59f%++360hk*aH0$R6y{I@UAZlz$c&K5YhsQ;_5)Q}XH*NV)mezUl@@#L8>m=-R z`cj9#({yzaqlFC~)h)AZrcZS*Q?RF6tVGP>pE9zd`3TQ?bLFP0Z1pXPR>B(m_UhNG z=K&4gVQx_7VU#%)A&}Y0qv86+Q@XGvoo0-hBrZ9_&2S=RwGwNZtg#>XsLP{m4$+sb zp!}uEE$#)qxH4+v^FY-v8f8Ap)r~tJLx?G~Q{Xfvyn&r80hm=fW92+2d{cgCEeXMr zrDEDb?W|jLG6RWt)gBP|##eEXAnO{}Lx-~Fcf4(`{ctFk=LX(V8<%pEMQo3#-3|~L z_1nmKCssIM!45Y$$f`dxCu+l-DvT@!a232m0^9t_n#BHRh#hd_WR(#>`sl=OW# zVX3MZa!Uaf?CRcK63Luu02rJMzGN(DRugoN@oY^|cD20tJe7i8{`R`oHp4ZnwD0@# zKa5Wmxd6@Pl4Oh*n_AKKyo%W=&!G8>Qj2M8K!g9zWCay;oiz~wT%ScaS2gr9Qpg2_ z?2r;YX69v;rCPu>ueO|@@NQEpC^PDu5 zsi+5GYA&=F*2T#S^prIMfmfFe*Kuz+Pke*44Am%~SOPSvoxYpO+cSN2nA@5Sb?+G@!#3QHq znROuaf7Z`3z2}Q&Qm;RoTPqU{-(I`RKDIP<$}f64cnC(nD}b>DHkGajb_i@E%k-CQ zu?I^XCkCXfr#YYMY~w-b2!TMr8rZ41d(w9TDM5OdTj>PCs z&A<=6_huV1BPbKe2NHSx_9YH`&1oP)Iksq)qSs}Cyw4>ETg=47ScI0`o8Bshuez=F z?p6SAJ4|7<*{3sQ>cD*GL?Dzbv__mGuMNJZ~!%s55#5{aH=gMa;tMg0ZLO z9&xlzFa#N z>CIskw(+#7VRlW&=l~sAAIX-ZW5RMRyZc!`6KxS+w(b-yMmv-#(d z4mM5GAoupuh`&y9*qtga^CQ3wwJ8-Qp3C*vtc+VvXNg1}%BkeRv>fL;1XKs`bP{e~ zhg%_GABl?$DlB|HNoO-i1BJ&ZC^Aoo-yAZjd)HI*+2^TKF{%;j9N#|*G1R0|6EiV> zut;&B#_AZ%Y&?D-2~)cl8g>YRtZo9qY6sZSp)v9_n-4}QA(+}AAPVaImQz9veC^B}zb;J8>G-3ri^omO^xY>GlPorXQ z%$@xzva)&EZ_?Ji_gPNat>T3{#rjgphAUXPqHq%PJTl4%vcYm+Zp8N@BT((`1b!-U?+)y7LzIM-3yfc)`#s%BHpJv&9Yzj z|Bs6s%c~5(_IThgqf4%e5-&C_`|@7MIjh*P`MsF)bRJvh+5bRlpnRE}pBs-FqFQpR zh~*oU0>*p4_1vB;=VHP4aT8?F0vUi;H>5qci5O?Tr z8(-CA?Mz02?){zh`hWMwnX7X5ns=Au zDulsn&lY$w_&Ls|TU9QHz|WX@UsLIGE>wIld@xyad!Ag;yJqJK>pUf6-OHgN;#<>i zhkO?s<0d}GcU}Dcfk5tmcgeV{jtT^yGLVhyd>YfWnka5oJU8RL6BETk!`quuJJ0z= zN9q-=R@VLhY5X6#i^8bOof;=ao55L)PzohZKU2(JW8UH`wMw&{Iv1+{-tAFJea`D$ z%lINV!hZDPAo8->P7hNmoxeD&(i80Z-=5Q6>r#@9?fH)hh@|^~8cqFg;WEH&|I=Y= z6V#Wo(Sg(!~-WMMGHNZ)VsI_44#H6`Dm8S|zmSE1( znE!r5^gRk-AOryaej1SH9w*%3I=QR!pD_%gHu3%{G4vd_@6jg3%U-CyEB#OptKkaz zG}oY3Wiwy}NX1K9y?`6H0UjEsrr#xOilV$`?ra)zYJbwzn|s;Xdbw8qIO z?YYA{FdeXPnp(?Iev3I}jKc5TR&g)18!>8jSMG_6sSH#(u*PgTm%`cW;~BTB%=$c) z=+h$Vix^r=L3Y6VgkXoLZ`zWp_b~wKfAbZuqQXfuWLs_w$T-S3{C53P7*if#Utby^ z{#IcL>%GI9@dJ6ao*ft_-nTLQbM?kPvkM^Ad(QI&(;VFit141Jc>p-@10r`spVlGH z0COVi*~+Xt;v3+vRa`{@bX2{X0hE`t)$G7DVYSE4?f7|ouVJkW3zZMeIdRq_b{OG| zcB5p$vp;hmv(0fKfIp$>Aowo)hLI?1x%k}#sHNzgD#Y&}sdXM3Lod&|5&_42YZBip z`FAW~WxFMSgIAz#5&!9H0Q;z>c3b*Fw*`p@u<+(WYwM?lzYZxr zlZvvrwG_+}E{GWU%Zu$YsK0RKUcHJS7=cZRFI?}t((h}o{ zyIq;rUA~rcmIX6|*F>@83D~UOGK;vO+R~Xfw4{uWDP)Zf0=Kgg!sMQ*e*5Q;MXZKm zgP@=?6I>hX8SZhP`T*+w?sU@PCHV9P?*kxF`E+-#vG)EWJ;f~W@*SMUIRqep8k_)j zMlWCe!2|jB(YJrzeJjZFQ74N6nknpCx|<+Jc>u~pqY`!OA$REniXk09??fIj+zl|m zIi&H`LXOhKoDu-*q~Ux3)~P2=wBYKYV~cfPvg$lwu>1xzVW`hHLEgSF`fL9X0AJ7> zfF@}HtaF?yi$N4Er1Y@3YH->C+oG7Y?a%*FWheSy2QY@SyASZ;BW$a9F0w7UMTpL#yKN~>xKo6GyOfNwFD^6P}ns!|18X$e1-ye|5y}g8^ zG%+YQ3kqB6n2DEMqsQRR7OX$Glq@+>$e#ajoNqET@!8C8u7RdXe-@7`r{&W%E8FGy zeuI>btyLBcx;rDS%*<{`j)vAqzhkc$wwV?|s42i*!Uh>jpVrzV3K-r)kZTM2Yp5 z_{$7g|Aw$qj24{!mCc8FkYQ*IKs9XnuMAX@@6)XOYtoBTm;}^~2a-k(s@kz({fOo{&Rq?;h|Tw4}nHE?5Y zOu6w%*II%q=79BLl@L*srGzUfgx#LMoC$)qid*l!bH( z>#NpmSH{5AH$=f6vd-1gIQ(O!VB*Aq%bop|v?>a!&<9W6sREDYkp>~EvPDd+yel(# z3amqZsZK1MYZkD^Oyn!07|=hiCgTtNRsi@k>`Bj|$QnV;j(*pgoCR59V8I8nb0jga zL|lnGSx@<3CfK?UF17;o!bYr;OBXwU%}_@pdZ-wSyLlGPO3@0`Um?XvYejp2Lz4<{ zTn@oYptLhO1H#}Q2U=4?RQB>f!8qli2Ca4{I|TP@qzJ@C{nfu;j_KMQGjX30n>1^6JG?50 zjGGIOkN-xV47cq|c8Wg%4k7gnb+nj8}WVacwiyn6X&sG#{pO5b?ZV1c=>& zQp63(kqI;u+3=VvW$ACwQZW3o7<}SE;upe(zwf^0aWd;9GB1n-@z~BLyna9K^!+!( zDX|8M$_S7ls!8t2TP*kNfPpTrF9Jq&Szkr^V(3I|$Rg;M;}^BiRKfIM7X7uyB6^<&Skcq z>75lh2YF`WIUtmQq@yl`=Drtz4$Bjrqp ze8-5W=uswX>$^n~pd$ODO{Z0r!7)RoHd>A2>-FF*w6)n)98XrxLTnVZo*U55q1C1M) zE-38mG`ocE0tG-UxIYFd%5jiv^eJ*DKB(RI;PPQ$`mAzZ5XT)+GfJfIezSg{=w7qj zL1~)vi!1^nQWED0Px@Pqwx%K5?Ly`<`zV6_9Z?P0hIs~bgjn#!@g@zGj|LbEzDOpf zA?_jI`gfCc5^l0iQ){4Z$a#U@V&WOX0BY-)sZ*%T8%jeVK|23zCXL>Pt?^cO{h$g+-VzZ>@1@?c0w-Ur75!^B+(Eyj7P->YS$0GgP zT=;pR^Jz{DDxP=1i>EA>SyB&4#j3*nRPVEJm0YU$i)NRm0S?sxuU-ozV(81u$t-<5 zj0>gZfueG|?x(FpwJ>0JMKv+tjWLALV!9jjZ{Dq-P&!PEHp5f23O>oBm3?sEP4O3H z?_nV4GXbnrT%v0oyg;}fUcj<;dvfQ*Wmy^*b8^$x$q*my$Cw!HcVVU)G_|2Q$OS^Q zA|Dd6;{1JYYH~|gsE(!Ef11|vmvd^23Y!)!rpD=iAQW3UKobl+>!f*%9yO|#aO6a+ zJGWx?S@bq0Ev=S9?<{cwK}kaU7e}dLi&8}{`W-vESyu2NHL5lRj}6sX;H-bV`ShWn zgsE)vj-FxFNAtP}V0>JnUBnY;_GEMVeW@#nNABYfD)UslANb6NP(-_i@m}3CVn1jM zcK-{;J%9czfb42-{_m3yiZ}SF=NWK6`?ED#TTREgsC$Yv%Ua^_PSe0|13#5}N?$~H zYi0QjjSNQ8Si7F>jqHp!Nzq;p*RR8yhJUtq{nyf|sq`TdRBYU&+JZO?MNx!a8J}#G zB}IwPvp;aIyZVuT7ir4Nmg!#ObI^s5)9Jpv@~t!Y@0K?sq@m$YnZ#5PjL%WqzWY#$ zLD|=Lv%$glWj8xR5`&u-q*tvT`R_g-Df~ABz>G;3;C_MmeNCOh>FhXDt@dspowv_+ z5L9T_Rcu)4y4t!R^Pi9iW-t98Qe#Ha|E07TX#`z2O&UxURtTeD6ZokTpWGEq7w+9t zeZ!N}@*Dg>miuG9(w@8j>d$(v;k7eKH9sEN24DhffTgSil!ODGDIn*3pP2%%>WOTp z1z=qSdSAm**Q0CzQS3$?G;9siuD0X+Y7k?Vp4iaNCdCe_q^*fKY&flX%>z9{q|2U z;E{Yn!>gT?uaTk-B;kC3)_ROb%p{cHF%T z>(|#n-J}8ZAX}a8OubUsBRjhQB3%L?h`|A5BETZ$5fOm{`jPW&5m|aQj)sp+n(AuA zNqY^3ydLY9^4~x&;9KR1L?oaIaRB;A-0|L=5z*?{aO>jS%1zmKG&(KoUI`KdT2yy6?`_!nJZjTP@dDzD_CGe(1<&ABWg2j@wd& zEsst7Zd(1Cfy|F>5}fS-bSAZ<6_bf#!`EbLmO!4;YxHuOQ(hKd^^Vg70J|-biC}P+ zpsDQcXD0Da{5K8O?O*QoZI`u{vf!?o1VWl_w3h*xVix%l07{a*cBj9b4oZN32y24t zkR?V16iYxMR@_Q)n`9agC2CY)U#D^`nS?Duy^@`qPm=FCd#Gr@R5O7l&2YV6nhZ{C zBmwG~!YqQBk0IZHL`qg7zTo%zrjv1o$^-q6USaXxeZC(~jzFx<$w*LY0i>MiE1~A4=WdP2rWY#)_jE2dAJV(^#Er6r_`+od!HY>mjFK0E6`?n z&KF5Nd}by=Nv1|dpMBaiO8c?)@&;UaNWTJ2zrDJ|{AIDw9g3T-b!O{*#L)ZsmIiC} z!_cgSYDjN{Yp-Z~!%Z)0EKvZm@RdTXqzbF+L$t@QiO+xlv@O%_0sz$U!9?wOkVR(z z3JwJ{LYlvRRG-?D{#BH`|2r~B?r;W7P7(lY)c^kL`$cmJ^n+Lf)_?}VcjB~{Wvy3_ zON?qKaJg*sQUNjdV#s1bU0^+uGc`_sR?V19`0#__G>{i~4c_~uOQ0X_ZP6&d2%wBz z;S9UCq|)RPw>rIrEGt{j5OaEu@&n%jZ+mdlQvg)hJ7{Q*Liq1>bz+@)l=lzHLB(0V zL}5UCd&(O|=-Gu^`c7|=GhZZ_`*7@O`)J`SE&!DVMwz>p-U^8s{8~9$pZ0mQ-jzbD z`lBt0s3*t@PB|Bj9l$;72$SNKYhvHKb<%aEc&AWqVsx-hK+3)sc2&_NKmBmsGBC7j z@%=_bPYU*)M>qJCfS7#DVVU)8b5sR!D->rK|FYw+S*J~>41O5v?>9xcCyLL4+@P&5 znL6rnimMBNru2_Y%YvR-&E+?3!V!u=b>yW}TjQMOibbDsg%0Q?Ow|cd-@y0hqqYSA znDkW|`iLEqlphd{O1V2mw;PF7HthKc1RtN)60+edAsdJ?uuOtDjda_>{vXQ@sC!erL3hO$bS$DTT+h?r%dNr$c^v#im}^jmS(F_feRxuMl87m9BgF&dac!A|Hx@yg5@ zNPBcCLdU6Afo|tGD}g6iHh;XL7 z<(wiMN8pxZsq9b?n~3n5zA8ksg{f%r8X~)lQ-_6pBPr6sT$NHH zOU&V{UlI+}8!(I7@*;?M1g8n-Jmou?){4T-Auv6}U^48ME`aR)7b%^j_?u{@?ns#w z`$~})`?D?r78`rsFLV}}_pn1jUj->ZnRpa}Gl!{$Hi4aC+DsJ5LJSxVACELjcr)~il~)$!?BpK&1}jP7BBKm?#2@Io?`D#2Ptqv_RYK*mWP`s{$WM~5 zgo#j#Sz!xb{Tz7~&hbz}Fq4EOxy^HQ%0+HNsD!H%FUP%O^2h6Z{uNk!{Fw9^&qHU{ z4afR|8^KdD3mXBoVHG~1XZfv^SMNL#M1#)r1LwY&8?7HPv`BTOD6%}7*!cG-@K`dY zItqlu4Tvv%3?)`b@)Hi`qeEIOE2XB8=qkq+aDJ~Y0f-dsFA3YLAVp(5s7l@=!5mA@ zH`TVG$K2*UOT zR2$ukb>F81iP8(PgS)4+G4-&dFGEs@TkBQZtM7#h>y)SE5LDQ&yiPre8BQd;>+3#X zv3iqf0+^5*bUk|k1@o6L-&Cp70l6=cuu^6&PO;;YR6n@DFAZ6bcPJp=kdt6Ti0`KR z08OFKP84VUVy%Q?{`u!LO$^$dRV&mm&@UtfsfN0v0H!(q$D!`g*C|IIDfNlNAF0To zGo=lr6n#is81Z*vB8{xLAoAq!Byw6XUrz^!hE)jN^}T!h=j*kgUq4?cLR6=+ML2Ys z$oQS|6iOEMsK1rYQQK1q?8;zN)!aV6%^@GkdDzcV021IgNoiFAt)h8$|z~2 zkr*M}4W9SB@6Y+3a~_ZL`<_33{0X{UyS81|>zOYO&Mba26@4?dBx6o7sS0kU<^%uTy zp-(=sEYkJewZV=x&uP7D8<;O@ek~7G9lem>DEB%W>PLIWhQdgJGLj{vg2PS{Uawfk zwPh6koOw2UPxJWobtv}|eRG0e6|)hKd$`7ju5C02x3!V%v(Ztp9t4@1!O#3FMzY69 zY=z@e&~_>30{=-|S);gZwnPt2&$;#^GCGNl)S%2WDLzGoLp(k@?`n>8*MCTlSqc!sO= zYU$&)l%d4N`E4YY5f1NAJwpghPuM1?(_wIJ85Xc-C>j}%ZbCRwM8!rjgjsCLFW!JU z#m)xBWWQ0d`KkgkGKhYI1(jqNm5i>862hQmtRZrt_D90q>qye%5QdD{EMLK$+lSKl zGwYnfOH5w0n!#QjeMlXzH=em6GiRo0B*yf|L>K;9TSjbm(=I`4A##C*c1hT~iY!h} zW<}G_8F5Y6f-qPRdR&kLg7Y3pY)~MXI(Xp0!m{?VuD8E$7LX3qp1L>z~Y0QFkMTqKk9D=3mTi*K*!jvrg z$qPN*ji=mY^ky-ayhc+1jahZ}C6~iRKI6Ed+|<>@zAXX5x2rgoUoZP0l2 zZTK`_hex3}=`xRB9?Sg(dAKEt)f2GKb zeeNeX80%?=bmaKkYyOAf_D0{~logk}!FN<9h72b*gN^5w$0WNU-4fl_+$iQh@^nL= z*z!95OVzM&{?8B{e462T~@!{`@}brzJ<>y=Rj>8O_hq58owlUFv|HbGj_k9u|pC$PX}uj7UfTL-D@ceJRdVVCrd z_DH>SbKnz-hTqaGQCXG4EmWdsY1GY;@$?E23)E{2Ad) zc2bR+zCaZVV!(EXQc;o4k+$l6baptOb&Z3@{1(2|13`i!mEmZ@x^=m+uJov=OT|+K zcgOo}bZz)!NTivMMHt!*KC{q3XtMW#&nw@Uo)5O=H9|FnQI=tbwnp&F}<<2!YCe`@>6uSN4vaH3ANPfbC+5A zF+taS-f^aEm1tf%-cgF(;Iz$?8M7@^zjg#gnS#n+5W%r4;&^A&v$lNUK>@2r)d*qGftk(bKZ|WO!iq;4SqQP8`shxxmSEqNf+)=Qu_qviDbOt zAw$C|!AKVa@5xr{k!fKAxAKBluBL1ju@dQ#;c4NKyC^i|dQx%e;2jbB6nRG3>N@4;Fe-vs4v-*6&v`$kVWJMW=e{4j)&rwfTDmVKFTIAFGz9ZFn@ctHj`?3 zq5+zV05^Ey0O@RZf)YM*S}<{UQd@ z4LzDX*BG}d30MqDI^~mDd9iegccagzA@R42*f4EGS;d1l(4c7GvGl0c?q-r$g0gh9 zAC82TwR~U^A0!`>`jO8Ie|YJfh*>k+{G>Ql(^BU0ocx%*+b4a_3ZGmfYg~Djx5el0 z^kMPTa=Yy}xgJ(XW?XA1xBZ#g&^afc9%v4aFA41kS_oUf1Mj9l5A)%p&q^zzZ6Y@o zX{D%o_=i-DGec0|=q>6t$p_2o^q$^1 z%{hkq>8`dOW&GtPcmeJ=F~~F%Y-&A7g=x##Q0QaqXmr=(m$77% zeQEp*l_BQJ@q_;j&tBnLQF-LK1#V7pTt2sO^bHwlAJvXr_M-B#+f%~X^83$gAU-nV zoTHTcq&&!zB_qK%o_hkfqcl|6kePAa8Cw~F`kWrWN4k#&2UQ;C#w6Jk86Mrw;iY|B zUc&Nl(7DQQv}W;GGvl@YGi~&ZLD6Z??B>NIk~OMlnF~or9~Pq<<>sW82I!}~f zJM7)5l0(H*bCQ-V9`Dq>rh_9;!hJocq0XCXCbGM#k8BrJaa;okoPw3gbJ8wIi>iWU4s*4iubf@fyXQ2)0@GtS@_kZ<4{QvKX>BwU`tajb~ z>9i$$e$@o+{jc?(L0j3e?~j+`F@apmy!mMNs6I*V-(UchLf+@_)}(!>I-)0mU60{$ z)#N{i&T!@bX3n_<%I>-!f40JF|69iQg~>amujN&nVyEQ2j4Ts8y6scCvht_`6Y^n_t*Qr#N?mE=mN?savPhSXBYG( z&vkJk===ku!jnep>Y@V*%?>%`waenFOM8ablb9V+yslOL`x2b9dd1!7{ZtluW!=^l zK_}hM8oyN3=_;M3w^h}N$+z?m-p#Qa*NIdo(|)ewBD;6^T3)~}J_q!dA?$AA&e7%S zy#dV+E_JlTYQUtbT-Qa8n((t%sa3GUnL7)12l=-a_&|Pu_(!K)&qc&hs_~2(A?JevNV3-Q_!=kpB2XM{q9D9)N06@Yi+?>AF;^XaD0 zEzmKe37Uxrz@7M`#W8kP7+G!iU@Khw{`-e~fCPCCl)QG(UPJ)xBdOqbp)S$%UW0G- z)#VSS$XP_q(HPgT5Zz56j1o=z`lz2knVU<}kxu}%ft{eMuL*=6rkxTzGea5xH)*x` z;raA;Dthc^K%?l@Vw^9QfuogBO;9g_IrIbS$rA9WVj%bMWaPsuMCZ}-Ye}844}hA; zI#Tf@i4|ryRQw#ogVrv7vhnIn5%NKkLJvV(#a}Tv-2%1Mvg}i-u%9VIpsVmEOQ!HE zyQzZ>iLE>a`J=@Gxo)ZzEq|j2zxrRzfrGu5z?e$fv}`}(@0vBeOtokBXvYOpZ!kx> z_t6!*4eVHr;OoLb2HHoGGd|RFH@DtqaFn@x<4HeSZj%T-K@r?XlLTS?*U>Hy9yp&Aca94L%ay9$`; zH_cQa-w>V5C%6UYW7m-f9*XaI)Wr!_dz|9d(b?s|22rB`rRV;AMgR4p3$Te0fC8Ti zgza`fIPwC*roSH0<1y^bUlb_Z71N14-(dn3o@95Z+(t(Zj9e6A3jtaD?y7Z8Lcl@( z!$8zmZeLYgcALE{hlfLicOX1X5+DOZ|F%$#ps5l@ z*Eb7s1m!*&&ASj7erERrW42s2ic1;WO#PGG;sEm-P6=TSQvq(!dzbGJh{68_r7r3T z5c+vkK$@a32J0pgK_X<-ju|IV*;q3=4iN^ZGaVU4mLGMUMXq8+o9h`+1>S9L15^6D zcs?z6%O&x^Rfa*4#;OMfCcYd{-v^GTvg4RQt$_SMCw=?V>OqU|wf|!fY zC2cx`90TXd+q@_KJhnLdc14QzoOZ{)L;cAo1FwH=0)kx6*?#QP`|GnG^;?O24us9Q zaGXxGltY+J$-18_t!*}M_AAc|qh%mWxXI2bN8ce(F|fZmc9m0;Vr`I8=#+R6)JAHh zhBH)ac*_(`UYzb?-geia)^m+~Qq~GMt5OinwUiwbm5wGc+V|ewze7*mpdRRoIA(&iJtKDVqNyGERg0hD0BI&v{WHPF#&w9skyf4Kg}DU5fh$ zHV3AMa^_N~_393i8c9PT)tVm7-IVP7iJt6;Y~y)z>1rI`7Gxf%LdD7*%Z`p}l zO%;47Ig(?m!*z=4B zhiN^fUfb61+4jn67UXN%WLbiMAI!xsazb&m=AWOCli zzX+>d=7}82A!)FuY7K_rZ9MX~1$jc%(sJDzT7m#d5 zGQ{!Rf?R2e+;Dc-LhLCxa&Sjww}hE~*`M@T>YJG!<(0j5ZNXwDJ9HU#m;cC2kOUz+ zqb?0I#3paMOr$8_$9%SosI1Hb=xCUn&dl3H%;J16D=cfQsHY1tMk6{*r@f=k6(?+) z7v1&f?)19MX#P!vvi?~Umn)0?a8tLsUpHu|Rn0!Vl1lF*G6=W?s_R?bK~uo-N=+gD z13YEZtDUd1=*YXGX0xT-4cAPtIq4!{RZ|~l+{Lsw8ZGzaO-iHAhUpSWyCawzpP~?W(r~UZ%_oC=PYKYZKk> z%1M_`pB&?&PX&JzSorhW8%N{yM|IvGi)ZD z8F5|E5htf$?5Y1Fy=U@}{MV$!^Sp5RD??_=iQyfh3a)7hhB(GkEn#P#t3 z2n&;)%^80L=V`_DUb!9Nx|W!>-x9ueO#7mfKVLfot#^l?3&D7%Jrmq*Mg3ooeRM~b zPwU)u4EBQKCqwChM-Z#U3VFTmi9_-R?b=J~vJV#aAD@uw5k7^brUDq zUmb;Y=Xp}y8jnB;8rD7jVq0&pcI9_vrY@$4UEehN-^U*M_pz_@;ItAX)6z=qCp-)* zTK}De*Rk1FJ1tvPm;MBGo%LG(8O{G+le+?D#K5QhM9p8|qR0zW)nwqKwVl}qu|_Lm zxYq7L>z7X{>0syrr{z3D3x^p97S$C!{(K+k>Xi>Z?Be9Z8rCKv_7!yhdFQZXjcVh~ z`Csa>p7p>Z>Ez)Y^T!XIBm!)hR>GV7hB(Bgz{vWBe~}h%p65T0ONKfqwasV{epsQQ z27JGMM>`2;r^lUOTD1bHyc(fe1!bKo1=v4FF@vaGFEz+$&`B3leOO`3y}LY=N}Su6 z>c=V_OJ+E=7B_d8%%bH%do@UCfHY<-Nscr#>xa@i@kEW)k%b>3MFB7f4P9QKQ6LW$H z-;KtNX=fEMJnq+AfAq;6M3a(%Sxay2%kkRAH29FFUutm#YOffW@zTL{4cLtNYqegC zq%tdjVb(nndI*xQZ*ohF>mFwD{`hD=qIXHym|cHS+TUanW#u^VI;O&5;-NmsbKZd6 zTm;Tu%>IoaXJv(e+!~e#$ex&VNylvC6EMxp0f%skO}3X>vrv%$NYUPLs6X}aI@!cG zhvVrD;*Dq-$>?`LoH-Q~5Exv#ZuAEDnh597^4T#gpynI}$>PDTj(!}dM;pV2$%7uu zHIZ>-L7iKtU{>88ytaN(I522dWq!=7Be#1GlN9L-dR}jMH{JxX7$c#2TU#vAXb^mk zmT17ZIqtY0^lXqc4BL3~L#$m8@m3vAqQb{_D>)u?RX=(24rJXDEJ&`U_|X^b07u5J zk9q=Bqf;FChyX|c({)L+!gZy#{Nvmm#W(VT-F@xW1KVtUFV_ngRR}DplADa2;mx5c z&(HI30h=Vf<0v`1ZgjL^x%CsysB-IED>OXqf<}E*0gWr!H*`R(0mx%mMns+fCiDCx z@BX-JT&DlgudSTlC+eVZQNDVoU+ZSq9fNZ?2(enx1yt|7#RmWr-BSqrCZ*sTqQCX) zb2nheTiOGb7h7Y=3Adz7;7;{M%}R?r8@*8tO0@{J+ucdPGGZJ~CuIZlY9ApyMJ||0~DYW;8ln78FR#-*-s*7 zI0d%$r*-$2BE2)fw-*{fMabHt2f4Ve~7Wi8?D5Ry9#5EDP#9#Xf&6)jB7+bVxRP|Rt z27pi6yHK@Irg=5fJC`>Fi5BXQ{G`iUz@+!x9s97f2HH(D7Yki$x+%d)qC(Ocy9;5- zzB+Y^timj}a(Irzs0(Kslj^BCE=>@#|G?lAwZa+Y7jfd+BUfl;-ozaf+3NHCuLp0_ z$P=P1;^gi(n^Wpi)4^C}jio6`=qDN$r8a+$$kJlo{$0#ikZ&5yF&r7WYUhc6_a!pW z9E!Z!A8bxSb3QUMC{TknFqn&r`*I!^-$aaCNT3G(Xnv#$@5<=9!0+!lf5z#5jPGjq z16j!5Ll1qjst>n6i?D*v^>|hRa77oZxFYBZH{2ji0bthp+=JGUDz3c$i(r%Gp5h1W z@r{qM&}uq%LA2k&#`M}}W24X4>yf@9o4%SwqB|qEr%7f&$BvS;1A&o!S>y zmXlft%`&A4)DYAR;8Bltdx-VOl{F^xMFDSsdR%yts!uK`=M{`^E9BpLVB{Qntr1Io zez0~w;=nlIbhpnvu!;v)`%r1|m0}Rtb<}Dj53%ww3lHRE)L+8(ZWjcFX=X;jJY-{l zX*>mA@=OCg6XhlOKA!h0-!RBH&)7Ug^)0CC)F|~~Z{8cmtQhSuC!W^9sBrqtJAlRK z?FQH73kw=r1h$(`3B@1pz18bhekE6ZpEK;dGC{j`p_^R-lfX#xSWOAl+{FG)Bt;B? z?1=WtOxm{jiy(a|&*L@kLRb1MjW*ZuG{)@iRGAOt8_(7vlQxsP`BS(Gl`j5@MG>%_ z!o21Q>s7O{7doK_!12`=Y7DXCQB<Z+>5Y6-VK+>|tM&+4-(g%koO{n}Cbhun#_tcGEzGQk-7 z1rP~pa-Qh;GV2x`EKg`a$GdqqGsDZ7T?EUlt8I5Z=e$m3|BECW>4f{Aw&QQC$$6nX zm3J(U$}^wPje_E~CsDoz*o|=*x}^j(LTJ|pn`*+e7s8zEu}6S-h%VLvXZz}KID=Ld zCnJaOq&lM%|9!#GLjj5$X}|gJvk56};pNLw7q88u5xUk-NkeA9CERs@+|4#+^L{Y1 zSM6SI8zbwDHfr%76200Lk3@ntfM@GY-xq^^0?&cO+>zI!6x9zGU=o`U&GBA(yC|=W z8>g~3M;2EZY0+Y!Vaw(yQ7-c1Yli;*SD!63EbY4KZS77e4aXS{{iZ=4gFvkO>vOf@ z;b+hZ-WO47Zp%M}R4;`5B1f`SB%$S*kn1WtI`W4vnFyvHvMdK(vpl}Id)}(qEnoVBg@d)xN}3@=@@{}fzc(uJmt_L)5hR6e)EJfM45Fr zs}g}&Yr!d}E?Cuw9ra@4qN8ki{=hihoF(Dh{I4?JN1yC}bvuJi5>-PBm}`OFWkrB8 z(ms)<{7JoSL9uzC^rz+}Qi_bbzIO>3H|^#>aofjnE1lwQVax=m6TnUor}uDW-+ja1 z;C-bx7R<9pO<=UOz0FVzv~E?<_MQ3{9hfeI?3CVe`N_EH+$Zczq&6Lm%*b=KbuAyw z8sZ7Jf1spwaMe0TtvD|9x{3blI|e--74)$AimgxmNHbN$<~vZZ^4ZJ`YB@>Is61oT zD{iyKQt}*&IzOxty=^REW<9yNS0YA|BMLE~8b?jK3+OVIE<&^{jJVRU7F9}c=pYqT zI-0B{MT5Mg_|^Bu>PB!+yR-QsBistmcFvJj1`%)p_SD!Oo5@$|CosQS&&k<^I`7|| z`fy2{bSpJStcO)Gq*U+8XH#_nLW`GZ>Bdf3+uJB+=TVpnNi%kw0u_+>ct%c88IoWK zf7CBtA4|0wP@gS&eNz5O=+Xdr?7iP-rv=^I76R^&`a7ix_*U%2!xiM`-!DzQ{q3aQ zr5LJdcE%5z^g91uwYvzeZ~a^In;p)zkRZ?1{;$$fo2bKz+Jl{jVJ!v{ZcMFv;?m_w z!xPE2U8FD;ij;0}Wr%XG65-S#+x~8>6kMig%ulaA{=k#KtPJ5!ybw_f1t;R=pFiPv zRf$ip%zNd}gCI2%+GvT-d`mgP_h6UmBJt;`DymKT1s2&ls8O*{6SkJDHyM!9RaKmo3}G zacQ@L25|<)%I0t_+dqesNQv4i#rTj4pnGiSNaPExAwj(=$7eXmbwj z`RRZBp6R!Na$I2!o$C&@z!r$^fWqD5E3|?Rbx4T1$a!>(hG z%UP*6@ZDFzfq_ijN08sf7Xw$T-~63}wV|KxLyxcgu)-d0FN}f89S5KRcz^?hgLWSd zrv}nugxgCIY@~tuFCr3h{}fc_3=o+ic!ACD%=3r4L5d}lgl5BC17_->+nm> zBmjurr|*c}MhPPp&K14~tB$Ut<2Gh}PeGW;!4UYyL2TSgbYWpcAzQM?`3tC6c_0-l z48Qm%mXXcvL{fje_E~V*x+&s>UUGa2yI9)HP!6zvp+Pv_doeG(X7~5$dVqdWCxq7l z3TrD$Jq5;2Ljd|7%MtORpG-R__J?2eD(W~rm$e6`=MR9K4u9~KP!K2o0o>xPj%q@o zNFgEw14rr#yHop=;^wu32XlJY08{6gV2Dm%w^#63F%Z~-lSoOFDeqyn&1}RVu^0LR zr<=oNErRU|oUUhnE!yxwi_5w%5tg1`1Z%56`{qMg&=Qpy&U&e&a?-mqR{qHL8rWMg z0pcfpb6wR_&r`4d)p7OSo2eo}<#|OM(c0SmH}AbuaBm&~YE2fEyz@-Uq9{>U66hx0 zKt8~B4+ubu3 zyvg5HDT3p9`-=?40gioK!MH%y=+I8U}K#ePJ3$s4} z>7`n_bOoYB&3&G+=_gtknDu=m9q#1FPf)WorCl_qb}K!w_m(eTUHbm+Jt#NQCVci> zUu#iF5r}J>-FX$pdWO{uZt#oc95C^HpHruLPs%fY5?9F`nts0#hI6i9?wa zD|NPW-`#sV17fjwcGu`EkI^R%(rOgJaRQUT4qZv_DuI*02LL1eDhQ%}0RN{SRP&_P zJ*SzLI|S55)i!{Hg?;W=9D_6gYIB(#GZmzppe{JF01EqE7o=vR#f!kK-K|W~q)Chu zj)gDF1N6KKsAbRm6@&;0Wr`9_iF|qqc7keF4#pO3*OX z{T>fzQYOel`vK>I&Z0$Muraf}YVpK-YG?_Z{GuigDXr*A2x@x=yD`f`z3J8&g-QTS zi|J;4e)xkPFDZeruK=8`olzm_m1=9H%-M}VX_oGKP8*5&A;>zb z$FWc(C@kiNjK{nx2Hy$0ov`|iCRz{BYaknUsc{>rW55a9xzA1(5fsQw2ay_TL@{#U zWX{95JW0p{m+>TT49fD$QKH_pi}iq{xYE6<`l7qpJyqz@55Ik+PDWP-FueRux5~M~$1( z1tNRcQ0b4sx$0h7&Ecv5 zKv@GycFl&&_H0)YlX7dpF0zNcp79&#uZDTV_J|H&GUI8C^I9~(B;a4n8bGd;boP~P z`f4sUPeCG4dF)LyII(F*APJb)ntm^f_6_F3dWcAf*c*hCDiv;TD8hd1yKcEXt+g$l z9kz&bH}7?Ufw|3&yk;Lqr}cFCyMO?~Yn@mEW5^!o4Up zMhc_X$Q#iuX`d)sSy4YR(%MfFCIK|zkBj()#xis7ZSQQ}LQUMV)6Slgx^2H;CNu1_ zCC?nKL1~Pt>HTQ;064lSZjd1NL5fJ0n=g}2DM9_j03Ty@metB*AJa>v`UR-&eXf`U zVqiAY_I&VsCT|{WX}-0LF~Y8F1FRE(;80v)VEoU_0`*qcEt~JCqSKMN44H9GatQf_ z++xTzeKG@I5Z3=Y!y2LoOy~=B;w8-<*rAc0W)v*j6KsCV*QG$hGc%UWYl2sN0*r*W z+%%N81{p)JR0&P;ZnqLuroi@xs88h!fLU_MMll+LEcp1L7w(C8^u^cmBBo$SBFJyl zXo{${Y1HtPP_N%i%goe;a}Ll{>ko%*LlZ2GENKvB@Bop(|T%>{$<7 zqbggHrkC{m^AKG+cBRqQdh4`hRfKc1c#DdFb1aqyyp5XPn05J=(Hmt#(~el->^2J& zmo4UJwkiuibM!6sy!DYCU|faz~4WpQ@$s1&GNjvs;Kppi3Wx}Cfa5=}2$ifM;m zg~(<-*B}|=8ALQ43N{;hYr&S`=zN;?Agso|_g&rky+f}Xq%B#E>u60~`Q;VLK$TdQY_}D< z2`|ZXW|+1fWtt6sBQkIfA{PstRdC%y!*LZ`EIrwmf&S?~D1MDMvyEp8EML>zkxgHO zu#{j)>G8F~GYnno<=Lg8nwG>Of@_fLi0gR{*#4+1B9+0Hw^>;M7m-9ExfcLhGc&7@ z_i+XXHzlY3f^`2X@A7)qR4=J>gCvb_hL)zfu7Go)9Jl7<7&XeDeR zSZU{IHu>2r;ytl%wnn+|ma!b`nJ;C&@N`trQV0I=TV$!nlr`TV(Iu1NQllTUfS84* zTzk;%C%}}Gc`i2GnNYqCbN$&3E-%&i$F#>xzf1$LIj$}yRo7ob(sGyq0)m$~bwK+! z)^V1USSi8YX=Pgk<0R;w>@K`WYU)>el*fpcbYAHtGwCI1wQqe~{QS*13k3`5KEUr! zvHPk6`1&kZw_$k<4(ClN+Rx2yaE--Vh673#N(^pu;|d+BMB#zlJ2;#m!zMJn_4WgCIsLvQu*ENr|!rY}wH51?|p^Kt>kOfMa} z_FY#SABbi9?HPJPV69k#C)4;`mvv58zwDa20_XQ z*`0eKav?1|Unqk8z*3PL+jcej_*c4#P3CsJi4K`jtzSRQ_d=@tuTpOE+^iN9L5xfE zE#kZ%ZZ$>tTDQllb;Vj(rd$$wSmn7KGR4jGeWPU0tN(AChszezCZt_->C!n+WlQX! z|L70qOa^S7MN1#gA)}38wm?n_a}EM78IgECSbf|pDfba!yzK0C`x$Zw=bPXB4uk!Y zo*}TE6)#^h{PpOWFF3H6mwT0jkkHHmce|n2(gHb;>$@WI6wMLb7}Qab8kJZiT3)FE z$=iZOvfEz{=HL`)k`IYK$@+hwrN+Y(9s2@>GaLIWzVjEQjCHlt zocI4lscGemDdT}?V+c1^L+}3yLQ?Z>O%HMY14$F>EJLy9z5J^JIYsX35`Wt1&rNjF zfPZ7Qtfor*;TzGquW|VgC`BLri*zIZ`{yIjd|3Wi@qb{{Z@(B7t`iG#9stG95|A`y zAZb4aY-7!z`RMf-UG`UD8`Vpd2WT}^gn2n@m$Ny%cwGKBm)bp(m~MiYVFlWhE+~^bzpi0 zy+YDHV7tr;pdQOX(Ql|^rw3>XHv=7~3FYSEozJdas#43MQ-89h zB`L9~U=aWWxD{Yzs{|=i!=GRL_F)(rJo1_XBHGJx0e{snYfNA^=SfJk?L9$&tUwQg z!-L1}&xzQTSeb|*^UK!UTd$8H5f?m z4(hMQt1vhZX>v#}fbB^(;00S?w(Va5scFqK1u_(*^-@d;QK`Ch+JTbm%Dow=C8Jp~j=H)LEnSaaK-w!Ll7rlSuu-G#k{ zgJh87uL&0Is}K0SG0zhGD-;wjNzd{T?+f)uOYc&^;=*On!&B~3RSk?|6~F>FPVCOL z`S>av^fHb|*s5^_H)LwxXOlw^HK{DOe$C=-*JlP;0NUSyrERQwra)qzUlD}v^Td_Y0l|CoV(?qO5}w=9xP@6%9sZpe@h;m<;Q+i-C|Z9 zRUXup)c0M1`dVb!o>)8qyn7sS*N1um(c#HS{M-P})8hrVI5*l{(VTsD4(xkg-yxxj zaend?eIQP2VI~;FKwH;SWb^2?5#TUnC0}nUFc=ByAQB3@-%hI{c#sIGoW&lXNsq%3 z(J5P}pijk>fwwhCfpb=57E{dRg(h{}j**;n;^4)QZ@ARqL_NDbh&3#7n=MQLx)w@1 z!uvu&2UAVF)Z}lW%JCT_seN27Dbf|p4Wob%SUXd%g5LZz9p*F%N}0bB+jwNbe_aJ} zWKU3=PY1k!&iFJyVaWjniQNKt`@miZ*-!@Bvy>}2@lv3cYc!R`BXp z#Wavn>{B0mq{|}4!2Y?cKG$);gRHS91JUjW3(CGz)Rs2?JaHP570wfzGOGc#TknZj zdc%zEheZ*|50L?3Aa}Z~b|0Ox)IpU`e7Igl7l0Py^5fX}nQx4zbE(N})+DVh24o!X zxYDGa+^$1zG(!C`k4$EMr7(Lb+^34-eCK>&OuakQx!EiI(pS<@K)8&6ME>*^g)LLl ziPZggJ5>aX%RWZrF0s&SL8xCh7{5QWz>RLH^#iWf2~RYl&Pyq*U7s!Doe*e->DCP{ z=@vE-179i*xA^aXm60(SEY#tw^aJeEgl9gf5hn-k8Ppo|X|lcnecqqtYn^@w8-8d} z)quLlCoP5>F!^nm`cct`f|btI>u8qJ#E8323N)7l7ndLgUE{)|krEb&74W^P1RVfZ zyp1TbYn*@EUi&dXi5=kGQ08TfR*C-Z-?fw9Qx$IrXC^9hfWD$@)x)v`33MTJrmk$h zwy8$kz{V>Cuh5#`smk7rf{4cE>GZ3t)V0k*X4t*j+Vkbokfy(lu52|pL&|{g_tl|l znsVV8QlfIgBcr@15DQ_AXyvoNQ^nHPEPJl@7^xchaw9n)!XSyAN>t!hgR{cHRLJ5{ zDKJekx$HTqY@VEE-kA1Oo`KT=I?)y1R9+9R5Cz9A=0KIY?t2F86*4`;Y&X!NRfo8% zt!T{JNut(uXV|$aa5WjB%@w_`(W zT^(BJT<&j>kk}1rqLuDl>OokLy}Qx&*mGj8n5m2}84(MIB5dUH_>fSvV(>wWtg=Q| z`gXcEkW@CWoY^da9r4}M1=Pj_VvjqjD5G-00F9QCIA-FL0^aP2MW(fuqmEcsV3^z zR8jHqQmrH+sjDj62;*nXy}8%BzK5H*7d(@q;z)WzFF(Lt_QlVfCM&UxVjKwdYY$Jx zlb8#)Kv3o5-v0-aCz&*0Ik0K;%ojYR|!H!0L6OS+2SW&qc;rld4h$WX}!pTv%79{=x0w4?WXl!dn&k#TUF- zGo+tk{RiLZ_RV2S+uQb#8kmvr7eU$^pv3+4#!mZ*8YWF^6W{PzAc$_c-)Gkl=7pr@ zE%JisasZb5t@jqTY_pWw#NrJ`L~o-;T9T3SzDN%Bm`^F4;e1RQ;0R@3w{3qWbK~+C zAki5WKq6;~R03fZEtz|7!Jy(6U_2)a#-i2L%AX!TEh12^TSnyDzZz5mMOFK`SDWSG zJpRQT&GgNIPIA*iU<7Ta=eD2!ND8`?!j#Ma`%7D{3eWv$0Bbgg;Q2zxj?g$#S>oS@G}Bh|!BvAAzL zApt)xY|gz1E)_!FUT89CFvvGe775U)YkRa&;(71yd+k{vy$U7lV!MrT+XuZDR&^}7 zE^qN({lJ*#*NxwG;XGkHJb;kq_uMqS;H+by*3U(qIM^tlLBpNM*eWt#zNt5RI(*w( za~1Ct9O^1M(GJ(*O(4uvAW5ElXS6w|9f#V=k;Bp#wL+qFJx&4Pic?LFU+E`Tdc2$&$P%Bww6+vDxkWR-MSIX{SD z&bmv7S3!+jzlqa>{@^EQBRPhY_G+2+bA{T4FF&k!bFDUo*;fbADFzQEQAQg?$ZO?D zyU@Ytpi2>jv76KM=Me0l3jNY3Z9&mVq-$@sLG~H<)Ni7u^;iMMG@89UUxh$8)Vk4e z`+rE45D0F}Agd5sjm?|mp##_uVSZZltZGW>_-6?|AxcspCp+ik9Y6uJI^3XjVqn?+ zkZ7BxdtQ$a!rN&=6L~J5<$?!LAHfQ!4E#0xqgK()Zq?d&IZ8#8u)JJpy-x9LCNIk# z?j+|s)K^Ud^9RUreN?!)OgmHK@r{-FQk=j>QKvRl;-avw5wc^f9L~{p`5!Ds&b?J? z8-5N|D`+&sH^#^MuT+Te^KL;IL4MiX98f6aCO%+-8`NRHBD@kKd-F< zM2`kQ#A#_KoHKQ#%DLd$S-3Sw1X%+$hG9MB#-E4f<-p0lC^u`Sd;~12#|lO#F6aO- z0%=~^`}d^%M_-*h1pue%f9k7b^CO#W%`>a#dG6JL0+0GANF`0wZ0ucVI&J?0{?Sb#m%~FxX-}}!Oe+8sRe%G0 z2+Bo`rni9{VFBbt+?5?ctuVS1?4?5hxQPXc&p`9zm6RmZCWuZM=E(c$3HCSuJEuKx z;Z^_CL9L5bf z(+4m?wLfVFqKE@LvohE4N#LvJf{d>G8SuMqcWq)!`WC1U^-w16ecE{a zi&956MKL^dGJJa^#kmT=MQwr)I-0Hpb^o>BLvA18twv`#x?Po>2qUN_*HTpDbYlY? zY`DmHttu>{NRohucRWYx;M;(=whl-~-4A6>Hk#i9=t-Oh1=!s{mE#CZo!yKm_q{8w z=>QVq@_cbMDG1(qgatDuRX+WG^+@g`r#c3Rl&eIgqg4f1z90J$k^bYKMA#Y)mM--b z17-R%&96wX{8@QU+WR*KSGxNKe;2gj;dXXY2+Iy=Seyy4N#DFi` z!7D*MUX(KUtE?Zy^SG@V@^d!YMLQo}YT16Cd6e^pZG7h*UYEy)B+ca;Nd8E10?}S~ z8I1L7G)#h+U&!4ab;PtB!y-_Z*78)vj zf7(dO3JrtKGjPZZgA%qG8Wi7TrqocgGt>ro{!9E~xW?@Br0;RP1*FltX#2W0ut{nn zEDjEnLqrU~<)YVtS_m_qZxRM@b4al(VDR08o(PUhFboigrkZGl-9ph(q~w%U456vr z^77Kbi;BQGHZG<-FK*qnQ8-TJz%@3#>FO^-Gr0#e!!_l*fe&JERLx=_PT+Cuye)DM zTviwM_D!8kO}T*HgK~?eH*qYID~_<>I>F8#vPW|fFZR+Gn||U@`Y}^-KCM+0+FU6-c=+8u;x-a69JtP7H%&jgJfkq@hsFG;CvKSNg^W%O%M;bcu23#Wy z^qn7(J>%z$QPUpEgBO~1aU2La`tXY&ZYIsdssMbKnAU<7 zNe*nWozlU(ue&eIFNw0+MomcrsuPz<6C8m%1!DUe$REwi<}LjLQPiSYBtes@g+-kQ z^Yu-)YwxAKQpDHFv%)VIGkfij>Es-Gw`Bj0uqQlC2mpoMnQsO}OV2hOG!3{azPT8u z=5E#s^eliY)6h3BSAW)MHmx@H<#wAnCS|2$m_8j@P8xIAA=?k4nImf`Cnq+f4H&ma zo`tvR=j0BHF^9B?2dI4D#80bvZ*&9wNGDqaIzY`H7tgr+`fMfYT;#do4^~%_TV$7dK8DgB^K7BBf-JZ< z11gj649BWuv}DbBmhyFmjzS@C)Psjfp$K7epjY1DgiGwB|fr=z~)%_YoCR& zIXLZZ-AA^zKdYRuCUQCDpucrTpLi+AQ-r7Ut9C)9Tl zv$;`RKp;{w54UxstS9AVeD+|umuvEs4NHPSrry+%mq`we^0<#5E{8)c@QY=AH|f^8 zoPb|a8rD0WrYKTI*@|5*%PfsXVLtJW$$=+zC`P=asY<~9(8NHL1*VLO_Dw&Qb*-~e znyFfrbyS%_{6q$oZA|5M$%}NlzkNOic?%cGoL=pX#~387<>K%C`rq#Q7a;*o9LH2b zaw!Qrso$Y-z}0uYv0fzgVIwI~g&LNh%tYZM=en#Y64%@2@ny{hQ?lBY_x)>71^>>K zWg1}c-fV0>t8uki9w|_N!R$oPv|8G>J z1%wF_5~BoELO{vEqy!Y1iV6Y}(%rBDqZ=d@R7x>GC8fJdViM9RF?!_4!E?>;?>Xo7 zdtT2u=Q;cbEUtU^z5DunKJWTh^ga&2ax$-)Y~g+}(#3+po8~mg=Ghkf$EttI!nEpt z2z?ssPQTRebGYm;Of&x_ME>V_f$C6<4kC}?F2?q&zqZQ1M=oS>-n&E-PVO+gh;{u9{5yuT-7CvN@F0XNI670w@1poW}oI z7GJtIPxwK9{ohaJmw%wqnHj}@{r>TT50UJsXg`_r?}y*#Uuh0dtq=|Pzf$)9;z<6_ z*ZbcfRT2I(Zvfk^+jC>Wz!P`DiRTg(afS1qNT|GoBJO!n6JA))#K#g-rU1yYB5v4` zj8GZ}%*vlKE0DsN!5dEGYDO5wFnWcckKD&4J-)BMlX7sHm2dUW=03Wg^4?*ZOEIS7 zBk@Dvl@8jkvwgGvPMq&cPWIEAWV{)5dD9GvSsj7@{#_o}AZAdeTiDE-k@5FckjHA1 zI=T+5`r&X7Q0d~ zL{Cq!koVF~j>Ljcgy_IW5+QtqNA9jN(&d5x ze#K%>w6^6m>LWSTSqRtkX#X{xrXLboP0=S{dS(WO`aZ~~S|F{`j{E|XMhX_X>U2;B zNT9JYf2j;W!Wtl0UIW_rbf7E|{mvc2@QoP1nRww(|{f5q_4^|`7%%9$Yh;y$1)$kY)+n5qdp<1xLK2myh zbsJdU7J|&dMq({LSr7bJJ%QS3jL4${Chf1*Pvz5sI-nkdj~t%^`Q17|4t|0Zj?rW_ zuC(31YJQ;olLDr^fNYoeV2u9sS5Tv$J#mG&O3`kD@E$-UD(Xx>GqSwTm6kdEFwIPq}Ii2R%H@>ynnLbb_)IJgn?=%VPGv8)KyM z^@{dGNDK*l$B=giTftw4%AQsOpgX5}IpGZ8yc7F?rO=$`zx*X7jr-+oU>Dp;qRvB*2c$o@9( zv;nh!OC7STrq+4nqtu7xV;?Z4{(PN9=GRp1I`i>Y@7v|ZT^*>VokfG8GgA+->o0Hf z?wyvXx_BvYSj~X;eGfY2hWMHH4GjjPj!|00hqc@C#9vLU6=3q3i^ zbxfdHOJy-G*~e8(8eMmf%8RsK5X&re<(-~SPIU-VJ%uKybH~YV$O!so0Bldrbe`l; z;c+++P0A$@1&3=Nf-n9Ay1TpOt&EDGLHlGxi0x2mJPqgcd+$PyXVS0TnBem5M2WI0-rIKJ&^LS} z6`N@#uVHx63d^_cAEyLZYjFQvAp?%lOiZ_C^J0fgD0kfI)Fk!a=!7l1Khy0^(RrTT zeP!+|b#4P9e1DIghF%yd`b+cd_@t@NK`LK=IXUk|#c#B6Int#iLZ-9LbJeoibED8Z z<%Mmg!dAul>9O=-q=2t8ZW5d)n{YWu^UHzhPJbk!APp7fpkLgE-nSnuoSLdQ$cnHs zx^8>U#NBtd!G98K2?>vubLOCZTlb2cP>aooaCy{ybSuY6hi`u`w0T>-rLNu}xWbH9 zD`LXV+IRi7R7IyTKPvtjQ4Q`qGy1&crNkZs{M$B%xo7dRuesz!Xh!)h2LH_-d&Z7NfX0(Q~a#IF0 zZPn`fZ1m#a>2SbS89iGwI_hUua2S2Rd?6) zTmJnqnC4XhRd*jSXX)vcTNReR&0q;eJ)$>~y}cutTNqJIn@S1onDEZ8n*#^kLBfq-akaYVzlszjL4`gi!WWO6yt92J<49qD4ZV;B4AHfBH6DXG zu9-WuM!!t0<6V+fZ2Iu>+x9l0J2DVeTGGUgAm8Kla&32r4-B=~jFy2$aLhaa{E^kb zT71x>040c4E?Febp-f$s;ivHSDd!<8Z{|Xi`^y-z+lX6+XXDn#3KGc@V(XIY!@>uXp(TQ9ZH<1o znsnZ3MIgE4I>Rs2Ui@tpmr^o@&2&l~F7V>0_=O-Q4F>X}odZ~MK= z4l17?7{Rv4QZy*#dFP~c7|~#wdyR0^digLcVV%P7br(3MKFISLvjdRWHR<)UFHlt$ z=6-flD+4wfirvCLZ#!O(@XgjvpYWFW4S6EbKMN*HZabsJDC_|K3WR?|Tu_@o0OeIC z=##0cz5&k*dq84%-UjHRzcF}Z7*S3iY)qN2uL%VN*!!0 z+8o1TGNGkMk>+X83#x#W(@4~8^$|2=)ZcIq9v;naSe8M(PY-!T`GUg$gi z81Xz$65;iH!HIyqVCPFH-Jmo_0#S&^u568d=tJn;)=CRUOT-jasZ|5qt*il?s z9D@@O6&W>wEC`t?wJSmK$o+etPxWE$T8v-9@>@*+=$e%)z1GX}io8g+?(Yv@nHNJ2&p3c{1qF7ssembT%VE zNUVlnP{`&-K&a5>7OP&9z)te@5*5h?Z9g25I53DS^<2mIwm;0Y%dcz`nPX*&IUn*? z3lD~KBWw`lX2Yr{NA%j!ebLGmB9CC76PKxL)C9t&#vZUZ(;Ah_ua^u=SZ$M^;|tQ= zlcD(Adz7Rt*NNUA-K+Vj3y5e-;;7$SQ-s|H5M4W|sHFnrj^e7)peN&}oWF8-?N{zk zL5Z(xe7~QIoMt=B4JI(`iRHnI>HO;*wQ@3W5fW^Bt7k^1J}m?LkyZg-^0^KM<^FH4 z!FP)*AxisNP?_Jg%H;|YceP`YoyJd*Q{HuthOf>)ICcp@8`sz6#mPK2t8y<|D7L)2 zp9;7A{0cYPjBazwyzD%3^8$mb1U`84JBQK9uX;}9nNnD$md2AHTJMo!tMXUtQ$3-$ zZ}iVk3%#dc?0?8(SwU)V zt{P;1pfvg0F2SwX`6l7;{Sbyua-QSR=%2%>f={3-A!@zcv#Lg)$;?PUwX2Ap*I}-a zWmwfc1{&Nn5d#N=EwwwFh~f{$SQfEU|AY=fnHst~$js$)MnCwz#gQpzmV=h(xX{yK zh;ehozbz&rO6cX=B;w;jcICY`))tpEIm~SXpxuC)ja-`*`@l2!4&sBKeN!dV>B(zF zgtQ_Ie}P&Ze>&*kja`Cxm0eXW*n;u=>tY=($EC)L-Iu3O-nh|lnx@_}bH4(8i!vRz z&B*^Cb&NjE#X$0hGyV}xC0Ee4MJm^J!*Nx*!nlVq5^N0s*Sm+56x35~`ajSy{y$9x zwhJOpvdC%dK~FT>N}M8$Ac(1+cRLF^#0;tihw@&q8wmpeW(0w(D*Dv&HEr|>sPF9i znnM5AhvUXdyZkbxF;av>E94t6?%?^!w#z)J<}Z0KOpQzGZZ5TU1weo{uLA^C*_?4n z*gJZ|GE55u)fkojV(tbvTWP0@L~0<9DzlPt-}7CmVsrg@Q(#gl<-cKQP-PxjECGAFkZFxQ+9yqB<7Zr=Bj=yn)b3N_%bj%pk$WF?YDF#y zdB1;Q{(QdNe#*WpMYJ@u{%qs)W$b?~VUfl=D&Mj_(-l+FvBP)t<5|A@WuRCq1)9Uw z=g?W`*nho{rm+$+F7{3Rz3|?juwwIj^Rlx)uim%c%2FHM&fWx{CRM_v-OK4}PLelv z-(5nT_O637`qN|T4mh0**OaXK4BVw9&GqJsgsJ)%wTWk@<&+#`!+Kfrx@MRroS99^ z8T>@LAd86q!ZQ-XTOUaX17{N9qCNi;$p3QwVc!V;4r5IJ?XTUDC&vDvEJSJUOL*YM zJ)+Dug8$!)?f;hUYFZ~u*O{e?7?gK2=RdD7?#j9yZQpFX+MG?){kqJ5vOZhw0#t2Er`T<-pe(X1^sc(QCP z0I$=lJ@q2#qn>Ak?~JhB?k!~g1TRWpS08ENWVCO>ZykSeUfUXP8{4Px9%~kXmcd$g zM#LB5$|CC#RJsW8@pe1{g%ADPgWv_UaKYv8h8^A_Yc_5Uu@A;2|9ste|5C>bm%Y7T zWOeuS!K7?!RQdHq*pVO{#XI0XsScigAPwl=1^xMnj3X)DLxm_vVCGM|?RtI7FC_Db>#p-B#hRTi_?fqa!gmWa5Ivrjmpq85rU*=WaN-b8lhS^rO3uU_*OuoRI( z{T;ZqLThZ)brzs)B6@A3!tC&kBKH{QJ*;JsP{dp2s! zTko;@%%IBsTTi`UYoMdwnYqc@neJN`dlp9O#wp@(jw$ z0J8XX#1ceyJ_A`!#t$ zEitwI8OZ%P29hRwP>x?K12=G09^GhImf}Xi7T%;ZWj*=ln>Fl0^Q72PX!-pjgjBRI zfa%f;u>d`P1LjN;M{Ipi33Cl(ivJrR88rawSO>KmO~IHLL(c&qeKR_c8s}FoUNHcY z?Qu)sQ0fVQPh9bXZ;!tis`4`f3o9=Q6=Wu`3=y|&F!?>Z4JG24K4<&*haVM-tf;P_QcU4afDkHrQMDLkiTDKo4`x-1mNQACM)&Ddro z$b#a?Q)k7ivtB#(HQmer;LN%z^GNt5#kg!>=db~^$P2~#rM9CWPiaxHI2Q%Q~`T0WVAWD6n%IQ8CJxPM)#&456a2!t|rwYf!Bir2zrl&;O2fE#4X(%tXIvEUbD=olZJZG%IU5l0fOUK+RzWJ-h1!m-8 z)zee!eT|{BTPx2`e@B-}T-_WM*$%+6G2c<85M#$p`E2oHi!So;#b`+wVlouc!+Ts8 zKh1*bJ%TH|MVt&0Hx=yxOb8}C`IEOeP1}BCf@CUpHe%wHqg(?!DRN}$;Lc5A3^Gxk z{X&RnuKVcI9FbV@avl2z@|#HD0qz^?S<#}dT~zOU%=knY44hPNW^xCHG)4M@qoV>x$2S5mV0C0s zcsSNm3Uxaq#Tyl19GVuX{e3pQ^cBfY^J1t^P8m>3e}1H-S_$NCw2rWZL~ptRgO-VX zFdu`po_GWD#H8yYe(NsvyPfp8?ljo}hhPTc9Mus8Vv;8%#Fj#K2)>8l;$(ero&(T@ z4eq)J0`>tHEiKHUH#Fh#PxDUemH?DH*+4kv-7(&MZA9Gr1yIX2#ca*;(Gsn_d}?n} z4P4L?JdpZCc&SFk;FQH^uLD5-CD+BB=XWQ+Nw&)aMaRTXz}paCY1N_p$^~}hK8{})VRCl(Sq9{vuLtFWyMBt z-Da(R3l|H)0V0(hQE5Mp2jX=qj^)gC;w4yK2Mi4R7J5>py}B6O$9kQDv9U`!aYP>n zN47^)U$wwNCTQp=ds7=N*@KXH!Z0?^b_*(-ABeHmb<5+w61pDSuT*Px1;<#ww>BfTd`U-W4PxaR{DY8Ih}Le?ZvbR)`)Wlg>r0%A?*tv0JAyp1hi=KOj3`%%kuc>%jw$#aFLf;5^m{-D$?7-uDJdrw=UU;N47o#E-$jwo z8J9>T2&3*_U^!q=JfvmS)_SoyS)YV3Um%KsyJ{eRs=b`N414oX-aM+>g3D?dLBIFk zAAb5{yHoUFM2ctNJfc%Ofl_ri`bubFF@pco=5>xNP3B4#o(lz-!+4qV@DSiuw9uJSndGf8&RK82?lzy5nyUd@ zjo4s%MVX_!0rb;4$aRdmpparpqtBTk`&2yuVa;7bJLFx;z9lGp{c_0VtADi`BxwtN zqd}Yk7Lgl|ZOwxaCenb-3QDo${dR~D8C`I|CVJCD5(qn5cku9b;1{=4l(s3!{mfVJ zBPKXI#`PT<^2=hC{c0!z)tA2c2%j99z1cLBr(n=wW92%fBSGY@k|vu9gA;e-PiDi_ zM+t|1v9AJ|_)GDZL1`7Csu*nHAL%O*cY#T~uZ#L5+Z>5!H= z()Wma0zsu9BZfJV)^yM!A-2b78uOBR{M*anm2N-h4kZhj7F&V~nn6P`QvaX-fL`Vj zV3Y$`adJtuZeUIO%!wD?{B^w5L(G#G?$>zWe3{rCai}Oqo}gdhTzID~AFoDqV8+w~ z_Pu8Jsx`+2^=5T@i)-Srr8d!Lhpo4XolbVbLtf+Rogc~ASs1=s7cp*_S{z4(!%4JT zj+eVtjeNAYSnBpY-Ckk^@^4C;K|Rs72aUos=Rm#2&`A12ufE)kH z6rp2I7BNaAz#r}a0pm!(DPeNUYkkZDFaU~qRKiB)JCi0set@n%VCb#^aJ(2`f+6_c z7s3F#0%j{LsghQ)$Gx>H>^7-H8EF|)5fM)TJ&*LF+fUDR{Zs{?GT=c>q*bsP)zX9d z^yf4mh9eYXx->kI4FKg45HryHKU+|>HfrQ_fGO=j1Jdu5srS)Q^B*PpC((%s z=;W}c`99vNyplJqVL+EdRPXNBf-)T6!56oda(pRTGf7|+xE?tW`0hT>YMj|4(uw_g zX4XF(H(g2LIYJ!=yMd}I6ez+JcuL{I2}5?~#;r?{X| z;5!}2cS4$VIH-dd1?7-EKoVbxW@{6@f&Ku|JQ@d3{Nq!=v{oxWl>V3w((9X-kPWv5 zZUA_{oM;6UG-JWkMwyWW%w2Y`2woORv*}TF`FJao_a=16)J6 znF6|lJ+!F7#0EIq$a5XTK+7`(QhRd}q9DM#1gbtvWYrPVWH}@^7M}naFyL}=dIdv# z$bJCfbUv}RT6sar39gwQ$ITdZ=b7_0?@h8zH&>@>tBIUIM_KwtKwDWRV=R1G?Y{gH zG#C#|J&tz5Mf$jH9FmgX^!lap2BQzI%mC(fIdGemMO;MAu!fki@s&KPadVl@v9dkb zk$h;v0Bm!6(e1~d9Du$VG6Cz^A=&2{@*uf;f!=R~R4pEmDHbWB&cvEL7WL=Yo+9~( zj$rI25JOd%&^8zWx^=Mu*X^YlveZ+Mqg&qa=#)gI1ayxZY)ZQ~Iao~q+jM;;kkaU* zGP!hsYbNM?v9Va(bJiLp-XD~{j}6&_WeKZ9S?DyIy*NcpU_0TJ*JLiubbW5Xe)|W6 zf$2yMaLhX1-QgY-lkY{O{$Bi+FjU-Jh1?6-lmf<4SIC`G%Cvw>eZ3wQs_0w64oB}6 zgYI%;lva;U^I(no4#^7csv_>s5tlJ4+EzA$ISGt5(|x0H z+TqwfiN7`y9et)iAURLA44B%k=Ql#B@3Yxm<_ij^b`lrb4iN+bK~iuSxHJ%|7RR+d zNA)%D-FpbW_JhxXm z57{Pc+CP{$zcOTBC!vi1Joku<0)TFaK0dFvJQzL4%{mbdbO-}4SXKk1IAokZ+_oS2 zjiLgiC$IHRbYsNqTUrTPQ7S8a3L|}P4nrvEYaE<4akmlJFHfNb6IG1oV{Vg3OBs>PjmkOZtex*7<+^8E~@Ke`?9D|ZlDC7ZbyPc5^{ zdnAKQRTRWuGNjGya$+Pg3T=?TcL^2JYw83BY2GV_ln2=82v#EO0`61H>oi(kzI%Uk zH~a?ZEB9F+a%EWc?gL&)l}o_t#r$k&QHIAZbZmf~a{`g!b&Bu;f4Z~;!54XyF#YX*w|*$=CTOBcB{eT!@ARi}Kj=(gb{Pv8Q;7pOtK9ziAR+fKbOGVGn6HkWgQ&(q}%&hmv=6)K`K_ zf6cVYvIzx{bcE;1P}0N3`TVGOJkNTt!w4tgRIf5Qv(<{_Vc=ko)H_t1hZ%!?r zl~A7FP|`TL1;w1pYO`9=s4mJl?Qx@`5*TnDeCLCx{>i13eRjN43+%4)2_RpUs!eh~ zX%(yQB7uyxc2iBLdO7l#a%dpGgtC2mKp**M_nOn|fr1?Q_Lhndio#a#3mE=&EzX)p zK|HN{MHz0+qWN!*sUzU~CO|gXTWRWFwlFm-PTCdCBF4oz9>g$fZm_b5-4nmKWX0OX z$~5?HYfL5N)oK&Z_V~`pU)6JF7sA+v+s{~^a|G9^rS@akBnfUI1I>pwh1H1nrvcO2 z4-ZdB!&)`kRVUbfGgy!X?IB;!goXtM#5S9>izDAc+=ZPf%()m^DCYuqwl>=@p>nm) z(n(Uo-^aGQjB?$7gHxqt?+HL@BoC@WiBBp?S%qVLpwvmlZaZh|SQk@`tT-a;uC> ze&8-?XlOF|<@xPFpgGxCrkrFvDj^%qmLntP>@Y~JLgf^$vfW2VpPf`%7?zSss_Vr} zC3v^(+e=^ayTX^7)1u{E(5I*Ul$Bg7nVbwRS*N>JM_&ur9kAK7HyLaU#^?$%PQxD# zh)$@qBzZ&#qTgT#+4=3`$~CH8(|6@JsKd_hr>#R=j}(Vnz1x_^&Z|Hm^P^wZW$7^t z*ag(z!!Og1rDMZM8eNV3^TYi*N_mc8Kc;Sey6BfS`+O@y5_7SQYVV_nUR+YMcWkFj zr=%*p?Z@KtkA8-k`+rHA!>!eG)2@UhA3e0nbPnff@o@9Ek<5?W3YPkab31z;=SC8v zX&>Fp+`?{NM~51cg|;`7WI2(9#XtxCZDMXakOyZoHzQ0rx9+Vlz(D$;`6oTrq;Tea z4*mI!ttno5(qKkr1uRwA8I_$5{aFJtVSm6Ldpa}D5+@ncAvp-GCalDZ;YiP-){>K zsm!G97)&bL;<+cbJ;nO#`toH|ujVo7`h(0l{S(-?dKRM`Go^aK@-&nmUR6n>&0+m$ zG~dh+o9!2ZQt(|=oRK{~#nn!H=xBdG-W}25W;iW+=k1#+ZjK2!h5gYbjG<>!F&GlO zwqZP?8&=tJ^5)(y;p4^9-DwH)X+ISP2oK%>{{;Fj2m!TYffYyucYurO7P#%$EwQy;$tgfwKUIe?_#Uo(?n@UnqFAMZG zT`XJChxD87z9pe$X1*VAH=n%}3dE%r@zVW;f}I2PfiMBes)uq+>F*j}k!0db5mVvu z)O(ULrgRcHkJZJtk$2f3DAlx^lJqxLQSpUi!Ovi%=Q)!o&+9RR$&F= zBmF=*OC>NxuEzB#h`_egjGbdG;ap|qK)<}G16`W~S!_WhZyVn#_0n^3#3{Y^I98d5 zJk6Z#;%2=+kA6ECU9=>}AozSc-WFOpQu5A0zaoi#gZw-R1t8uA>9}NtJED&T` zWS6odBrsaS2?(c*5NRnkdSA{QvEk+Hr~sERaW-7q!Y&(B?Sk@|RZPR39YPGc(lU)c z<3_KV@gCvzoO69p*q4zM;L@ze+3GV3n@}9!YJ9obnbR>)DRCv=N`amYyH6@de~y%Q zN1ax~FC#L9pDL=xADeOHtk{bPZ&Uf$8^J;fpO&Tgi}4D9@|dz`rlsgtOws?MVh!e@ z2==!g2@AZKz(W!jNHTjjm#Y2{<-=u3A(x*@lHi#=X|1xtz>La|jQ>uLJCwa$L*Lup z-2DNV%57Q72$EiQdvC9@8`hZkP{6}Hz~aNN{55a*mq2w5LS;QNyD`whKMM96!4?C7 zv~>E2sYZ>2ThPXGq*|+N*7e`r6&t%8$3!2gG%+oGRz|f?-Wc`f@-?Y{T_+({re<^Im)iQGNI*jFu%UC!*pJM9qbsfrIM& z&jb;l@Ps=W8r&i0OsRxA9`hU$Fgs1DMq--WowaX$P81JM6gw4m6mSYy7*0-5qb2TO z(R;o+mV@R_V1yggC7#~5-o6<=#75KMg60$!yS5?D@uT45@doJy{m-Ebhein^$5Akf zd5tPxyQ|obEZqCh{?1a315x=ppZ<m zW;>)ulf;A>Ws#znrY)MwWTiWuj3eeIu!?sToek6cKZm;w3=a|xAn=idq5Jg;+o3+t zOhTpRY#@foMAmB*`sV!h6DCBH=9Dy4hgbB1qg>k3#6bm*OV;BHi>ja8HP_?z+SgEI z7<$&Z#rflT2*daX>UWoJO54EoQy0GV9gSW8;;(qDFC}evZ{D!NFl6Euh%r@sF=Uoe zFDsGGn2aujn`AOQlsUYXcjV_iO}l=aUD;Pi|G7j{PO%-GD8*$Nr46TTodC8!vdr+pbCJ%p{6`tB!)(f&>Q^m`>WSJsJeyQhfvjz2y3NSM9FlQJ6?!3L7ju$*>Ek@=QTodIv6h9NqNC? zo(`p*aTJsylo65yJ7B->a-d#QF#c~qs9y}Gc1Gz>A?99w z!ryU7cW~z6p}sddsLf}}bu6^vk=PL0tH$}fnaAmXi+3R42}H#_^G7&MbgINov~912 z;-yU#C)&O*ljM1Etu=MA{qA;OX5en3K&-sCVy0|eR=@r;8LyFSOnVmoc|Z2=*UM@y zT?x7++e{vGm)|(uIc4&4bQU(`JKp*Jh<=(ql(nupOJ6hUp2}{?5@z8`h1tGpub6Em zA^jOg1pLToZkA&=&rR)xftFdF*x=pAPp2`$XVY{zb1sEc? zs3aBy+}w;>w0!^5n)yrR82kc17%s1gCHj)L?Y|-tnkXzV;#FO_yw?8t}(8pS+G#)KAGl6Hl zR94nhl=uJkW#iuH{p41)urK46x?Jl&Vbv(Rgz1uv%x!#n#&tha+7*d{KfYno@Kf`1 z+%+We>CwEAy$)Cw!76SBQJ`rWEG1!>+`2EXi|e}0!-#}o=EW; zv|H@jzjM09KbTnm1DBrcj!vB1a?ugQ?%o;6EVyD>(Bu23N(@4inMvT|`^uknrlvLNQ(=hc~wpE!uc_s{oA*)KfIcEt~Pc91&4<7jFIal&WyvqHuo{c=3c)2-Pdm)RE~3PjgQlp#?EC@+iu+V zx?g9M$muohf-eqxGvRr$a-G4)wwv*))bzh=>aS)FKO!&fO1V?eexlRVk9UlFvWPSX zb*VG>>Ord{zI!Bl?L#X4&$)39C%1CJ@pQC->{j`Pe;fguptFYE^LM1D^Z9+dzCPik z>gjjg&e%#U>niM!+{gT&*>f|GavYa>I@OlPZnqwU$@S42XwL0v7#b?{A^qX5bM@FP z8a_7SVP=@=@2-E9_+8o(c#@cTHVI2D<{N!nmszj-K#>nVd1QgMjf-0|;S7Vn)OG&` z8SK6>TC~q)Cn<%XNv7lXH%sIkJ9sF#cIAa=dAAAst%d2M(;i3p_3-jyLxYX?I|Xa{ z0}p&`ensP#I`GNvlN)ts3vJQf%p;oX+O8rLxNe{EFIVOAh+pamB;%FN0r+W4PWxI( zxV9Vm?_dLNqg;Kv_Pzd5zMAKNk2FQ;zVQe&=nB3Pkv11{I_z_H1n(TaKQ=kxr;|un z$Oj=~fA}W(kfp}eZPeAPF}i8H#X;80OdKOp$L@*rr+(HN<4x*#(G}!JgYZYk|K1fE z{97YKf1flM=fyYggd6Snle1cf4o(syYy`VejA0zVo1b|v8B5u%YO&Wl=5o5UL-MKX z9&URCjU9xSKhGPst$dG4FJGz9ueO6!NOk^Mx(56G*m=>+N+z;i9>-}1{|hPi{iFSq zwAE_t^DD;nrRun{dwc$tXbB(rW%X=b;^hZ%QU(@kV>bw9@;Qx4_|&)B9%K1(!eR6FR^8DYWYE*_djU29F)>rZ}{G z$E+8&g;xf8P3lb13~^feTYHAsP1S$ix$22eva0r2uFfn+$Ch$d`M4{HoWm-(Wu#xy z!tPWe(#>`}yNg1}Y4G<7h&Nr{sgS$dv}Fc`l7Gf1N>R4hdOPp8oWn;lKGsXY`EkCD zz2uJ0oR8rW5n+?;`hQryk9E>#m=ltBO9k6tj)G;1eN!1bmJfA}ZSyE6>;xx#g8ty1 zP518%tPx&2dfFcAtZ&L+^depPuHaupM|0s~Ot-(Muey9uPvkRPdX?wVr|j_rk+_oU z7^C^cl--(|e{0GBYckp$T(Yu%=V&$*Q#QX|JZZ&`xcLjct(#sxS%_>*5Jm;1u65pT~S;P%`WMECJX z%$-S3ip4%kQH!`O3Glz3-wDo~I58CTCVRJ(kdkRd-UxK}R1o@0_qGF;hFNmG&OD_g z;R8P}32V4{`jw%d7Cs6hUI@CEw22!|$O!!ZV28UW#BcoY;fH_QnzA}fL!&c^4fxw! zk4cyJx=!5F5`IILOZ7D2v;3KvnNHKdp{9%Blo`B!(|Mz2C!{EI?0vBPR2>3LWx|QL z^4ykRUetW3_o8(Kyn${Lg!s^lbrpr z6}ox_Jo|6<`KcQSa%ofkGr;3|{o@vK3**0nq(2MQ-;TLCQG+UG4*}GE<&!53J_iN4 zeCv$L+cBaOATFMGYX1t7Pc{2na9W7{+r}@0O*Vp|$YETHrBw+y;Bv}O+~I)wihjQa z#^S&M5)Z@-mFg}B$AD=RYm}>3F*V}%XgrqE&%brD`=p2wyi5FiC>1rZEB#5dk_GJ1 z$7@Oam6esA036W++_W`f%0Z(XNR24)Snh8f%6+a=VQ*xV@hAVqcm`^bjYzD00m3SV zfLmTf-evlifNKAPsB0&Jdt!$Z)p-_r<#9wysud${KM7Emgq$Pu z+@JI^Sorm3eaOJc=4k{R2_<}D;7bZof$x{>Rz#m^Ll%BD{a#&9(*7w#9KF<0OQSb)FOpQ zef%+2bI{4%N%Kg%%wgJeU{N?G!?5FPkAeNOd)~YAZ^bRUS$`Om=f7}nB>!it1kC@8 za_1!_CG&u&+Y?|r2A-Z}z*A}J&(!hWsufXBLVnJ6-B5Dy$cA(CH(h*E(%evF$oV_A zw%;u*EH3{_+WRK1gJcCEuc^R6Os*UQfcz>u$g;#M4hNQM=?bYvaDM%5Lz*5-hlPT7t8ilztI9sxsSA))TI^X+j^9R9vi zh{e(F@|>#X6>ATZ^k~tlj>`{;9wI(~_BuJOWv2L;vVRwNuU0#7?+~?4-uoLb4o;j( z=5-!Fo;U(>`j1b4JnI3RY*DWmjSLTpiyTY+`+$vIz3>qL(vHNKUyn?v_YzM^`RC|q z`)J2#5DigzXrB#ioJA3%(uW?zbje$FK$h*u7P|*nr9xWLhhrdfMLN#s$}~&fbr8Jz z`UOb6aXj-C%^z2a=>K{rE%sQgkJ7s# z#r+P1qgGzQ19G&XgRgO-`m>G=fV_K=lg_&WDlUuEu#Vjq&&X~D@!LiR;DcIAbL%Z4 zx;vv!L3pI0n=c^Y5p#X=GtYoDwj9tfs_kMI-R6$~kFaux{K9#vw6Pnds4{=Rz?SbM z8vi&NYot7*C>#F%^ahb&J)uW3^wGKTltC;p7r3Vx_=6l&Q3a#zPwH`=?Z1IjZaJb~ zsWE5)l9%EOT*4>u9i;T*CYi)&%uI-<`TMtVA%F|Kw8;0eOj9WvFcus+&S!nS*IM4JF1QXBbGj;gH1}ifh-Z2fC132#o3X!Ny&{0501u)vB^&1fMJ|cWn z+Tc|1V08o8Qa4poEyaPzsoaR0Pq={|pkh7b=5N^r7Z;NhBcEx@-MoSOe!zs?bE6U~ zcg^*IxHY}(;d@DPI@=))mQL?Zoi4SQ5}5;bx>9t1BkX-M$wyv2W74}39UFiK?KUiC zqx4nhtCmaY9PrktR;DD~Xt?h;QQ?w5n);0TXqq6-+6I2RH4lMcl2Q;6!8cS%H^*QTZVGv(FQFGC3BOoR!)U-= zAHHx&RM*ys@^e=W-(0ea4Z9))t_`wK65CuN^?IjvKA{kCBS@_ZaAYcvVdfnSy5~L$ z#2BJy$xv=-CzjQ5ibpv~WyWWK+2Tx2cR}>lu+O9ZH3Scj{&vD`R23<2>PZ4DkA#UM z;5_MJYtasK5z(5P4!_fbYq+EKbq_41@ZrqBsz09xzDt3wQ}UH4Bj8M*8riU9<$}9! zOZ>Is$Lk|BEBgJJHz;o(;3>5>AAw5mS&>Ys6C8$=l|B)@uHg9uM4fpX%mA|7NYc?u))-rfQy zXZVlrH6(XyN1zwgJ0;I~@&|Ku@e&~1cUX%{1a*PBp#)^$%6(J6mvQUBEao+A`RiUV zEYi0me(r++Vn=a~ib3X3qe?@1TwwCna8fywA1}>)-?+q@h|8cX5w|?qMS1#+W7mE> zs9tdWAe1*>DG;z4^wrhebKrrr>~o#_7HsA_fVDd|_)TZMjorz;>)^eZa`v@qBI7#* z9z2lK*q^d-6~sg<9VM)j-L}2^9ak`Kb1Lv^_bJ~Dk*~l>dHyT+U&=-`d}lFi`*XaK zj@&Z#9oqI(BO{q2nGelG_7#!2@qXUsTEtqAkmmM8+=yrwpX>V#Ht88kItgxi&4Ii| zDb~~m9Wq$5MpdWew4hjLG?E8gOP9dDi=7Y3iB5tgel&jHbZ4H=2sRapBucV%b<~51 zN`P^$+s-Y2KD&U7Mcbig-(*v+;P!Z?n-OvP`6)y}sI^s^OBlP1x}=oym&1ws zTpuN-@2B?RK8G&^F51VwLi70GyG-C0XzwU30OGE&{f5;OI5~BH>rai0xfz*+8&2D1 z=rVO~$M?OX+0zta7yn8sQ^dYI`J@)O7f9mi2mc&5bPnI{{sG_n0gi9{ALU(XJXG!9 z?=Do7sM``*%966(H-=;vi55lK8A+D0OqMVhZlM&BZOS%8wqyxoXOeZYObo^tOEPw2 z7|USH%yZQLex5hai|73_FV9@pIp=e(bAG??_j~;o|7V9|!^h(_^Kx|iM0Z5hwK*Ro zHOVLf%W*zpObvANgV{Ly?Tx=s790_VtmWCwO@Flo47ssV?C|W$G>o z;3>)}nWhs!XIA;19(d5{h&8%F^@ogS?2%hCp|>)xe10PQr`%|PSW}l)luP*FZDxgL zc-6_89-o1)daeJgo;b|)$b9A(TViB`1%9x4JPvJX|P`({Y7`vxj z=wiAN3WV)X2(!5(jfV91M-P;gd)F8EA4X}}ABxFZJ;`*@MW&A#8tMWBCC2xw#^E5z zMCkzJIiB2Hzab?D??IDmS8{(^d}6`Avr z*s6k0Jyqq8weB7aP5crFAj8zHEG__W?nzy-a)<#A>qm)%zM!pvi=<9%8m%ENi9)CQ z>>rbXJ}1Y{Usl>ViJjJHvJ{SQ9eg5MSFfL3+$SNOe9$Nw7E&axNqu$({!7 zKc8O{nUwXA7d?HQ`oqxl`Wp8N&=RLH(AM?w<9Ze({}*V!z#-b^8gvppT~Fl{<$g!< zi%h~G1moi8|8Z~l@%gZcb{OfrlxVa*pd6k4d;g5{zeCp)nDX-Zhz*)~ zx1@-~s1#MfEudGo$^mz(MZs<@_Qt|}gi>k+noT2&!b#;Q7nVBb0MAqW& zU7oCA{dTs4kzmj9x&h235NNovs_Gz>1(A_aBJ)TN2yf+k=hC0KNHxzDSU>nESCS7p z%K(m0UQ27@IA^QuH!+gbGowuy3^qVeFsMHeMd{8!Atu#uX6SKkZat)ni%WyT8-N^M zcWvgG)d$XzaxAiqC)C0MAt~0ClYmssC# zPE1p^oW~Q2xdj8EYLPc^q@#1Tb{vWaL7{ol{jVn5wFxNMsTM+IpX$+8O1I1~wXyaEljTtoI|@h#qVdnvt}nK_HdYW_63siXt{TGOuhbsW0Dy7tA^8{D}F{vcpvmiI7 zL%nZwsZD)lyVY3(Z(ic1OH`_bHS2v|B&D)`7+n>a40nEwWGMFcR@&SatyV5;n&`as zZfTpZIjcLTGrLl}4+$@QkuPU=--%1l8jz*efpz5LcDCHzLs%4c0Wt=d?-;-e^8ET)1fA<%r(1d`c%@vK$SEs8l8^qKC<7NsK8n)#)f}#;nAQ=1oKu zN;?R-85a?XN*O;X!=9w5wAGE5!`_wGOk2M4JIlRx*f)~kPcm}qP95{Rb0@y<77~hc z?L#eA#lCc$j3dEn{IMBZ+iDi&{Z%w=QAZt}>C+mZ9nrT6eF|n&kasfr#%uC<(wm${L0>;@5HCgaAAwkknN4 zM11$M-bqH~a~k1m2Z0_(Bx<{Mf&KHm_8a_@3hUuGHCy{+`uvRR3h%yGjqlc5?>$5* zal+SHuQYfi#aS5Sj>wm@F{@*y5Q-z-cvx*^5Jwxfz=RKJ5p{C~gc`DroZxp!oktGo zuQRT8Axf?6uZR?baXSy`Pw&{QmP6Vkqox4WF|(JzJ*q- zWjPE7DPk1C$mR3}9bwf@?G?2leg%`jQqEpsWuJ8TKHcJ zyBXSxm9{4GyEk}LiB}olI(6K(!}CMH8dNk&ZgDi$?tAo_)!Wrotr_#kr`$SQCiIZh zy)ul>BJ_csO_@8jqSR(1-!|KYCR95KJ(?Bt(w6m3*RgzifigE>hgQVUgj71?%YE}~ zX#yATS8**>SCZIcxp0BvG0`O6#eb$Bk=t6X$;)~aYtbR6JXrg-+ir!mu_xxVhVwJz zt=@Udnw;;48za+0JAd9P359cMTrNsW5LCl>p^b_0+jLwRXG>cw*|p0OrE@eoF21}4 z8mq)l#Iy!dGm;^r?+b^jBUv!(3Wi>pDcU0W#dw(2{3%yEuhQ(Gj@f(Gdt|9!M(WR=tcf-CK?xnOnq9I9@G~ zV9h1?*GyjPs{eY7{@#MS!&v)~d)Z@`@(Ky;M=zsnzpQ3_NRiess*s_{!^l5rLyU)_ zV{e7oy^JO$3Od=<$+Us+=H^HxiTd_;SN-DU^#%<+%j-tLnC!E?8Y@HTs*wFZg|9-I z7)#m1$)it*t8zX**F`Z!f9%eQj&cc!66%=?R)l>B-Ep^U(B4g) zk#0=i6T>!jLXM&~3c-us6q=~>*)(f~i48OUIveKHGrzdM+0Uk>ZBuSS1Ev_lTG}XU zzd7QBh(o0b@M3WUYOU_A=iyN0zulW*^bw3Qgh|aHTFq7RNnIbQOdV;mchz9#2LJtb zpB6FhusVs~!YNa-->UfcRd#>5iPZCr6Wj5|F6B{B7yey6{TTw}R0qPoi4yx>ok{q3^vO|QYJFWA%|QPyVX&W?NX zdco+V*ra_Dq1fB*kOXBn!-j!AJYbINx2_*^>AmfT8ki{=s(mWl;=3%qeeKy(x0jA@ zMD?|oGMC45G_Loa644mms!~n}W8^}pH^LUFn#+Tw$y!piD1dh1M*1W>e zw;|iV3`3$|LU!MAwt7$N_}3XK6QI-t1?hKc0Y6oGY$~ho!^abobYywdQA;Qfi$>nH z_AwAF1o(=45Fsh?>xU^}n`skaEakE%ojb1*_D=aZ>4YYbaQu(0Y=WON$X|o+>_fL# zmN_Q=jw$!3HTC=+;}eqa9{%5NIsPJ;C8|-sS2}_+3J+mK{?XByA;w)TE2QOk(Js`y zS89s2aol2YCw4*wLRM@cc7c`$FJfcpX{{f3PbEOrvh)?m2ImnZo?MyuuuXmIhh1;rj zdbyj_m1=bZ8Mf3(3#{%D8ejfk9NVdQr>=e0{@!}*8AYGnzkHT@l|Xpb97$+T5d{*Uv>>n?6xJ!RT5*cM+J zdaYhk=iy$c+F>Mr#Mg+xWz{i5z1Qakl)IOp0+ViqLvGGGT+Hi(n~4%1a1hlRbC2;k z64Kv}uOtB1jA(?E5<4^5W68JFs7xm{eI$G>3GkgQKA>G$Z!ASq0E%DS%O-w*A(%5XP;)a= z!zF#+W98B(DG_)}^V-M@gr?f?N498r4&rC-iOT}R?(R63KKW3|a+QBE?9n82-Q>ib zx~$11zVZ7Z^;3q1^R+rYsQK{wUXEbsiSCwW2ZcF6myLVA`MB@+F9?)jS-OCIJTue{m&cBH0|M&G&iIb^08An~dl20dVFA4?^WRVNEJm2$`Y1eLbP2b^mxY zF;6TzY^PRx+ARvc3U)E%enPe4gh5Me`%B)K=rv745jzQlR&C{@bn zXJG_z@>JE&~UHL3u=bg-7 z`mL5-77!7f#6Bxc@s}yt)>Z2A_KYSMhRoLL-|M%k{`iF{<`Pkr<|LiwatQbt8{RP} I(|3IKUypfKqW}N^ literal 0 HcmV?d00001 diff --git a/public/public/screenshot2.png b/public/public/screenshot2.png new file mode 100644 index 0000000000000000000000000000000000000000..4d7d2a9f83ff6d863a1deed0fa76ed3c7cdcacc3 GIT binary patch literal 43665 zcmc$`cQjmK*zTQ#=rxEw7%fP2(FW0pAcTk>5fKr+&8SKA-l9bBH3%Wv=sgl$BzhSJ z6NXU+!#G>cdEfJ%@1OIoZ>?{A|H;m_J@Y(!Kl{FZ*L6?iV?9kuG8VFH*RD}&YpEGt zyLSEb+O-=4Bt*cGSYi31YuDag(^gY9f?EB}zL{=h$2f4E?q(}F13?ihsk)qcOKVY4 zYbz^h@MAUlM@A2n)zoN|->To_;UTPj{P$pC=?|J6ZS~5=$L6K?@p%q1z}tD?$Kqu< zw#}hel%hv8CY|T!`(Waim+voreK!62>Ssm+)0<7djKU7~ltRs_e@CPo#ik(v`gEQ< zls&-jL{L6LT>ZeUA(kk8bqS_EwZ*Gzy`ZOq{X44O5s+k=zSC zM90Ok`6oHA3jg!{fiCqh;CNz%);{fdn#9RLcGo=;903-AtPQ6#>d-TS%(K*{6e~QE``k{xGyMl|YI|9W$Hy@j}`!~an zXC3Rjcg$dy7g)Q|9EGk0U<^zeKay6}@M+e8iLtEG-@m5_*$u?8WB%CZmNUk8qURd* zk-(|uJx6nmE;GlI`by=U9Y?>+-_ZM?ZIxo?Tsm(0I9**vOg-w>sZ0B*hE>3kF~csp z9jB*oNXdGC(;nj2i%-^9Of1$(`+jzWQXSsk*hl=q4<>SBR>C)Qh>67cmSOhYXjPsm+E3x(8R6paYP|tbM z@-tI<7+8R68*h9LiTeR`W2N)83^2!V2X`z2BQVR&{`_hrwJK9l5Lr)%Q}>>=w zE?`vl_&1xp6~4)BEpAIua}y*II9Z}=(ELetY?5eqOchK%C*1=gM1)Z8$OGgHgyq3-2s1<0{_uthtBZKYh~S8QV?t`1&#Rt4p(H4s>^V**WIU%gv9?Nyq)Ii1|64&{IVn ztqfF@7D~}JIFq?wOs#m38{rwxZ8Fj+Mb*-Ov^A-zo`c^Dq&d{&2r!cK+~hpi_?i5k zfcSfXdbEm)K2v+pC4P1wr~McYmQSrkhmtdHdmq*`)}muy6DNuowpC@VNBZQ7eMRj2 z5}Y4S&7v>pmUb3-YM4!h+fNZkaQ?v=RE``MA{CM!v5O-%qX@*TLqrl{p@-Y zGgGKZ{S$3V*aQs7piQ5#Es~D^dlIiseeGh<&}v__-QVA}8G6rq6@x@>P^1hc^P|Ln zxfxJY=i86wwES3z?tLI;TVvHGS)qK$UAu?L6?jsz2|J&0h&??(q8j2kl&qGFpGTY@ zVXY18HRO-}Ziv8mn`A(J@FP*89J3a|raRi_YYiNMXQosjyfT#o&LHsYbm|Z)ORE{E zAV}PSTa<9dlL$x2&K_sxE&2{zPyP^nD+EVJ8hEl5v4~Z=j8Ss^ZN2z48GVW42#S+d zGCcQ0Fe*?_7_H<<#O-VGinrUK?qP2~(;9>0O(HvS3RBNtv+J`{ zdme6%vt$gQ_~G&VF`99M64bOoz-Dip&a?)y>5<7x0>vMOGFpvY?0=bS^{HXG0mZA4 zeRE!@K=ERg)7c)T2r}po?pv@2;ErP(V|)pq$A9dLfuj@69!Q=eGR}ux-aj*>bduaU z$={2=9Lz&@VlmcT=+2-E*ujQwg9~GCG_wSXbjZ9s^ksW%wMBX%{N>97en+^YIT;#sF>vWG7<&*l? zj+Oj$O~=FJ7}S{=oS7v)dyEZ1Z>wN>J!*5^wW0&Xxc+nWN&T?%>C{cK{?M*EOU@b3(1G5I@(>0B*ad9u{7q@lj2Nb!1gMOLXZ!H1$YFO%m*No-1a;{rH z^S)Y+2amrV;Ro7lks*(A6)n|iRqeV%NGHD7s9JIm^uHIA^x8IpArdvGWH=Yz)2hj2 zm60UI-o9tHId^`p9z_}n!Fu&Z&`#7lJaL#TiPd;^t{y+7u@_+T&TZ+BPvz69mt7xj z^3yxEJiaaT^ih1IGmLW~2)_ISNGSGYKw^aZu~ zVX4dqnPVa62t!$J57MLW0%h{ZZ-!=B>g@{*f7mCTBhAt9yLR=p3e-FEIX;&=`8{2# zY>aB{V*yT(wSo_C&qS-WQoaPF*-Y~6==uyP9LWuFEV{U1+g;W_nJgw?l}-(BcfieZ z%+6Z={%$bg7(+>4nxpIRZSf7Omt$C^unng(*GfqJp8BWLlY=^&;f@Arb|PIvF7w0H zhuKzZk<7V`{^y~3mv|gU-FYmfxYMEp2JVx^5fmliuRXM~C2ZbibsXTQHEO@{0cjWQ z<2?S*Pz|&=f6_j`${cVm?0nY@^^xSlrQ?E&w+$^(XwPPqh_<@ef!CcaA-j$(m!M&m zyhF&yOU+!D1U{i?YvLZ>Q89-yRhtV?F>isM@DNuozlxQl#A&W>}V3HRJi1FxlgT=!5X#Y zGO)j5Kj-Ni=kvL04j)V6g7b~XQ?)OC)&J#$*NXj=_O!jqOSo2JDiT6d$FCM2zJo0} zjcKC!t~t23DSCsX>fpKNGR=L=Psm^-+44GpN(gcE_4k{$^dZ3kHcT|aSjG!=7Jkg1 zul8v=B5g)w^mp>Qb*J8M0VVDCh8ZhXeT24>Xuzbdbon#xZsDvPS&t3qBKj1WTeEQM z{ZuHOZVV6nR7bd(r)!7CmV_S@fx5|PLF2;8f{Y)(4#ObEVMPodPzG8scm%1&Tr)C< z)of;gAg%7&w~m7mc`y95iS@m$iDL2{j^JyyH%0Hvd%gPpQD70~N@T2yWvPpxHVKWVk(OcoI zHV>_}?8%hVN)1R~g2k;{r)Y@n>w(=iK|TEOPrRyl(7t#x#D$?vMEbS@EFQn3%dw@< z3T&!9B_r5fQ#S_$X%#`D=D952(#5Ii@WYHpeMPThzrA_HwKzjxRLHr(JyL!CAWnlPXi_gq%8PW9+wLrV9K`cl?Czhq)AtSP)te;Y& zitcnE*ODs@+A-h(AxO{RHDQE{eBAyd=M#xf)snVIs!ReM#ANDdjT%U-3JZrt$R+aE z$6ZT4=u^eU8;k~DcVTylSrx(j_KYTg%qRyFg+hGQNYLX)rS>ef1<`D@H^4VmmYGP% zSFzT&mt+%b%o-|KL?VO=_f~9@4SIBBk#NIR!zc_~ zj{klg{RIPR;F+B=?dNB!(IUSj`&N3w*GOHDwx^{S+{e`!w+<<#=krj{Pns@lN!)5= z?oXa#)+cdM@7F0PCwLz>xvq@0vr4@wTFRy~rJ#?g4q0ZIKN@RD@~}PoHs?%U>?RX` zi}ztjTo?Mo>LZ^Rj}ckTLJ$;#M}0ObPhuel#7eWCwf7&pNRa22=eq<0-O*t8SDZ>2 zOtT4^pOyWz3ISth!o64@=ec&yv!SXtY7G_HEBFnS#gzbyCN zBvI1f9AJVt#O+3REUN|nVMPzxTL)H!J>b*-ZEcRL-q>mNPUbA%bN? zGs!g|S@)u_TFc#xaEToGmFK^ddr9TF^&Z%ORw*MGKtU?`FM4k!UW!ByXAMff9(yqR z&8adM#x6Wgsz}#1m@VHJsF*Wo%O)C+TXW5kghA6K?Bn#p=}yfW-h_VRW_b6$%fCQK z?fwU_zR^36H7lFfZtcSB@5G4o5Ye~qv9LI~PL&zR#UI#x>~`I|K>YahWTxljdb^8{ zUNv+=1Y;p2!hR!0lJO?zN9tX<;g14zw^#!Cg&9;xl+2V7`$>CpS&bhC>TR)#?ALeH zD7pG@{4r*Gi@(ki{4n&95L^+-9@s@Of6hL&YW%{)aay{5q=Z^gNdw{djXjTg#%Bpj z5p3sDM!Z-1gISsr|_RPlU zwm33%WFZw^cs3bzbtA2(*Db^J$alCiw6qYJemTw=j%1Exe7{H9+UkE(B$wE&e#sB?x7JG*P7Iu z5XIglj@uevXd+#KTO{dVS!N|w^9DZ#AP~QV1O54a{E*DuvPfqwo` zY0+G#$Dxm)bt1-gMxN2>L-Gw0o;T%q$!K<;j|BU~&O>ApOUFjvEBC{JSCoiy;=nTx zB7%PE8MO?e(JYv-_zEKob3yfna^A~E=6&YIqU_1frm~w3Ij{RfFdn!2iZhw^g_E&+ zWWL^Ash^(0s}(s{j3Ulc^;bbt%PNgf@9>}#?Vha=C3%YTM)GtzSQLJ~!?@vBz?#~k zxdt?4ED*`{M0JkF%hj@g1_pseQS9HT`5u((zh`PuRPE51=)Q4@q8Q|+tEid!oW@W8 zMC$v4h?CVUhV@|mwO^$|T)2l0;LGU|g}M>C-XnCtt(rCzv&DgeThFk5ZgIT@!cu5F z7SY|lx~=dKwRE_+)HKRl+}TzIzpPr4(tS6Gyt^bhRpl0otU73I8O2#)*=2Y>MNLiQ zFe&+ITtjhU&h->8#H&s87pQ`b5zQq}+Xl9M(o0{EUr-Hi`uu*<$C@>m>A6D>^cc`d*GpxwM>k3wSF>Bj$uR(xGi0M8bhBmA~ zy7!Z^WB2>PWNA&NXXq4@)idIQywcxs31T_t>6WuWUSV)m)bY>qlTa zIwK(~Z^2a1R6x7VJeGyM-lp4aTBEY$7Xza)=mh#i{*UO+*D4{OM%#*?k48cahyHfB($?~ zcQPE0|CT07q=Ql1-HjJ=_vpVJ8n?^#0gOhAxq=f1-nq(p#SkrOz8mjJ=xbc`b=-vC zIVS*$;5xfW5X-wRB>1|p%1ZS?j^8dRC8s0+3dY)~s0!J1dn5hjkIMF5?vIIlH&s@! zaUX-6bW6d7$g-cIGgPMQNyzlsly&0%P4#11<*d?XfTCj%T+kQkev0#B0!$Wo*c*lrg(Z8BbO6Z)WEzP0;A_s3U@o zDEMNSAaltKP|hjcS{C(KCbPi3tVs*g$J^d)pT}7zB+lcSmi#$LguEE&?QUWC`A5*e zOIeD`ADQc4tBN&g(+$%0@Uk&oXSP)%5(S@RC#B7x$8dpLmsAaN)Jc+Q8!3!dema$V z+I=)5rR4k_yn&OS^%>;?MRZ%^>ANpaE9)^7dERdbSEuPh(-qOoZE;-58{6&F(C(31 z35Ke2BD=e^DPVo)G+{joBf5|-Cz@*znW(?eJIP3|;KgeNPLqW&pS5#adE`(nnG>E=J^3=wL#J#f4^cc; zb(Ry@bL}hSbNSABC&m2GkhY|0#8{aiOg)rO;pMj)dAi5@x_26zkmClQrMx#(nrG%_ zG;;^kckle#mhw%duUSx@*^>88Wg&j|Jk4oL9Yyy1&o-rD7hUl6wY4Z@1U=2Sj>*!G~x>&uBZQ{a|qdKJc1hTaKMby93xfsMxu9;k&+XMOi?J*}nq%hYUvDIwMf` z&y^Qm%`D2O`cDOu8;vdDWU5Pv5>sC-Xl|h!>apyKhluF>_ufn#1)upR4(YEG1-)4E zdFoi%&$1-leffR6X-(qRnkbruCq`i!-N}6jMMY3jyR-~8`$JHoNv!=h7Wu%d)YkH4P2TEefe}13 zw4KA$jJgqoK1%_OWR$Cf&XV#OsL3FJfTJWC4myRrKJjtH4ccbOjHYOX6k0U9%hmXw zV&rr$p(V86^9EbV0%t@y=f}F49#tFW`t=0xW0tKuv=YJYeGDd>_Nj@xdGhR&hlM^( z2H3&1aG^RL;!$@pU65$5ljAZYWv_c9sbsfHBH1gDJ9N`gIxug=R}D9=t`l4tzMN7FkrboYBwL60yEj83^vU^88duE# zQb8!h+ZiNwW(MG(B`(sQS@D*YEgsm?Q)p5WU!S8AZS7vBmaqXoW~7IYSa(sH(pHqSvd(DJN0= zwMhR@-m2s70gu)U)~ddMW=0?#n%f#TJO#)bU9A2@Kel})yWex|IS0V`Cvhl_ss4^2 zpQUuoXKXH+AWC}KmNmEb^RMnopN=~~ztta#c6U>9#dNK9eB<<=xr=P~tNUn#ea)-sV74$f2ylN~H|TuQ`-EC?nU+s2(_gTlTNRWzAmju7;JTM* zpTO9wz?F#P;?P4_HYsKtd@a32G*4;*O-mv%fim`rV5)U2ABK%LNBM$UhQ}w3BmMo( zpX%cTt<%4L2s_%j=P3}J!)^b@hASA(hRgmnJq8JN4RZq*7$QhhCN0To2k5Yj9VQM3sxonL)U9Zl}0 zC5>fyB!YeMcxPW_8kkQuUf5HB0jmfLic`!lkv+-O`He$7At|!k49!C)Qy&DZt{=#m z^~lfy1@D7r>GSg4x{3=7oh!9#Hr%r@9lK{ObSxTKqz4jD&j1^&e8mDDaI9R*%oQ*b zLGmT$v6R8}?hz72jq4hODW{j~zmH1kFsDWn5@)PLh7W_$xnKNn$2)XvLo_FpVjmU> zs3Ci~aj%#J@IS|c!06YE^&za5Q-eJcx6%{EpVQ>Uq6Y$8y3olj6y3*H^YIix+R)l9 zO;qhB@{mh1UNjkZ#Ar|B&CfH+bQ~ey=i%(i_RWR`o#TM1L3lbqeGo5U<*`DCwr#FC z9sev!9^ex16Po?}Sil_4%NfZx(d^0tt@e++7WvWfY*#*)#zWo;bx+{B!3%0q$J)5dukT%ZVJxyNehe%AO1m%Ae`a zAqkTx{t}-hsqT-!kS>H*_WrZnK59%wLpTo+GXkk#6KbR7g9-YxIyx(U&D`|%5yY}K z0q1VfjZMLDtlp9b*vC4*1X1=s((`T8B%Ufv@6(Tt@5FtO zBg_?5T=8eIlD7$>xBZNttyZ$R981HEKc~F9B2l=a+b3Jc(5tffv0^L|MTc=Rmy-y*S3E{zQczB z1{X$Km_EpQHM=n{!2ecLEGiQI|Jw<-q`;TR+@PEG%o+tJ>uJ^>zOL>Ma0Cqk&MYV^ z`wkU{;@!D#PRW2LH>7lVPG`Y3={nlvL)wJ_{v{zJZ*YErUBVpASfko502}&4G-Z#B zx?1R9d=NBoex@S+uhNO7YoZO$;IK%?U0$8kk3T+1=p=&G5x^gzt_CYz946BP{2hRv zg}KQ$RE(<3q?%Wwgb-(_nl!-MBIfuA7%n#%`N=6V_;fP{0dHCu znD!Ka`47gi%c~5_>H(&u>ae``-#be|mlqxKT7;D*HK~r(%^GMYfcSriF8pw{bCu}l zR(DABXq9JqC+3R#L}q!I3&^f*+^XB`Gw$jOqfPZ$glP&lE#J^i=8KJj1OYzmBiMc) zqt~hQl0SD%+i?Z}OjOerTze?BZx;ae+p`f_B-=vHuNv!)Wx-N*3R<6w`Q+qvpfY>X zGqmuPTm=4DiBZrJPdpqPwT&Qs#^;_ODPo0;##xy z4o4Qissyw#LYK`Oou~aeF^5}|!vKS1p0|8PGHU<*qxM9xPU)N*9I&7z>(7A)Y1;2_ zOqF`bXQ@ve8zJm!of~-OAocb+ppV31n3r4Qh2bnd^U}LNOLGG&hG`wX0T@4Ck3-H= z3otMRfO~~74Bd$zdvm}aDPw?&7eGlGM&o`iPA7BUjAc%}v1az)((=b0|; zvf5yMVYwjuxi5tp;=53dk%2Ezh^eAPbJs(@U8lYCIPcwvd6R4Y2rC5Y3b9=Sn95{F z(tZhaBtfVWo!HC=R ztBsDUiH0EI_4f5t^TQP#XU09z{U*RvbU!_wb5TXDI)G!O7d)RNsRdq~9kJjwY4)}& zjLHiJ9D$X2%??r8XwDJ`Tf?Dl+2P@_cfbkGtvAVUhm6SEk7Tv{?2V-JnvLX}sx;9@ z>Sjo4x9P(z;r0|PA(5_UfMv)p^z`#%TOxw6qy4apnZUZ|a2f7y%eBt;1YQ}gtpo(2 zFcRArt}`=L=F+kB&qHj^X_(&;5L0bRO*Sb)*HcVXu$0$*!l;)}w($xjL}?Q5BCdVW z118necef=toxU$iCGYKi5lK2 zRYwr(`WhYVG1sLelh>uCu|`czd0%8p-Fj=XQ6ng{~Mpa#`mo1l{C0|aag4AOo zwUZY#ss4NbJe(VIs?ZZ>;nu(6Qf65v?jpZ)P#*yBgM62F%LUw2~-_HVLve80k-*eOct*Pvs_JJ<<9K{!(PB!#VwTNWH2L38`nWyqF* zTwzj{!z^IK6`^Dk`E$v$(&#vTxrHeMTtXFR1q8B2$fF=!zQn8F;rnX?D9Pq^K-+}I z>9?-M$xnUBZ^;>rm@#*0W0(!M-JU8JoFZ}jBF3TGO-)3RNRHV+R7JAM)Mm;1RFlc( z3e*$yPBCmZ)A#K^cxRe+&?kgkY*|(G)p}k}6YC1r-{*E!G96%MwUC$$pQJCq0*l#jxJVew-K!DewlHeiqkkNPXyeE1U zlogi9WHAkqb#hG^i}-wy!Id?5aBaZ6h%*{o!%5%OJSNg?rr6r?!*RC0yc(%8bH#QX zLTInsfO6n;d{Mveuo0vM`>gnq^`&dvxjybqL~$bqsk6z^rQE9-%TjENzFSH|oi%8? zNq7pll2SgS4MeO5!3$)xgTMnWXVrM0F%IcJIDH`NvIuX9IU}YJvVTcq`MhI(>3M^~ zBx3OoNFP)f%x95HMacnC`!Ef80a4u4A z=9=2$^uXO_r048~hL-Z4ITYAW>Yan@iLp)IJF_iW5j5)IBgy>!E=&R`lYAH&{=@h; z`|LZX441d1nEUrRFMklE@11@Wcw*$44ibI-0DjaR2?4zsFHkr3FVCP_ZSmpa$@RxX z`U7K{%_^JhVAUUkZIj%(8JHqyJmJ97XNT~zG`rqaZd{rAi&AvQeYiT0q9)~W6Z!Py zUiZG@Y0R=4L}e6+DE)$kq;*9y7mO~8^Ap^R`5S$}CiWuaaC=&(&0HCbdNKHTPN$owWfSoT)`4dRPmwJjD!g-w0_ngW? z_nvF@(wHidB+)rQ97C?zcCqJP_sB|E=DHF3UU({wb0Gk`u-ym7WD)1wm$h!B?)?EP zGWt%}UNZPYoz{Z8ey4z7q1A`_r_!Ho-#E?qYe>sU8dwZJ@)O-R&Cd&%EAN{AelFk` zjc~WE#FxE8B@MPwYtUSIOv5xjF$7Ut7W#x4sD^jSs`bJBoDjA-_EBbeAn-X6a7(-S za6(5F=UPs`D>iCMe6U8ZE`;8YjuWvHr(?iAP7ZnAJ)E#0GwB+BtktI)LAZnrSLXaAY8rBEp*v{Z*j$5-nFp=-gSt4EHpXv753?!eoZNVFKYRW84Uz3rsZ&|KwgJCot@(2Pc z))%ydkz*qHP`IATkC93Ae6xqE7dNTvWtP2uZ|DuVlC8Q;q8>4d9^h0kQND}DOOI|n zZidb#v@?%1H*7io3Bk$)S&;`;`Ze|Q##U=6ijq5JuM(@j)MQ{=zL1w1gNJv-%*kr?2RPjm%)na4oW9P3 z$T^0c1EJKeni0{YSU^=3-P)tclyc%bVwp*)&87ZGDjz-=Qd6a_e$XE6#zC1X`_=wC zP?fTuZ&Psp0c4qmV3(R=RAwZcmg{N_Ql5i3`hKb{M$iD#E%BjfV*KhWu!|ZAkXP2? zO&`>BlSq^Xhy43Hj}V1Tp9WcJyMZM(BrSc2;180pDEZ5pxVgi>%T|HXpH=vqZWrl9 z=L5t2mRG?tSfqZu4;vL#NK0NA6>#ChXoScJBrY|3l*WJ*%)Y0Ih}MvG>U+%{{EZaVp#6O%zWz5K^Mil z3VEyJQvSQ}qi4WrpcKsqR8|?+kA>8RWO3?`33wNuqnOY&4vGB!TJsU7I}CoQN%`ob z2@mpWkJ*f?2}rt!ah$160g7DHi6U)o;300Chat0*1fK9^k7P(y!m*2fUAl3@fO-^W z5PJI2#0thMSp!J4382neGD}>!iqIWcHM~jDyCTcJ3YWa*-`*yYF$fN_y1;1xX;T`K zd>iHx0N?*>SGRdN+)25hx0$VvA#6c@r)mj2>PmSz+sGYnid1u|K*DC&t#z^E_^pi` z&0J5__x-g8GlRvrt#){}J%qB zUKp=P_L;%-X^mAC^2_V-f@N@z3~!cT;;5xSW|rG8X7SDJU9Ln;C~2@h{?eMiH^RTh znEj~H(gT{3Fu0bjzn~vm}o7E>Ye7ErmgMBGgY_&p`wXaAD6AM{NNv%()xjCTl|*a9A|{L{(LQU zeo|wla3yH%_E-Dde@e{^>Pj#00J^5kABeQK>;fO27pUCpC_s>BXMjOa(|-15lZmP~ zW6uvDt#&}^)Dg0;P^Xl|D<4@5;ifj_6E#_ffot#8O0S)Rmkt_^D9XV$jji(L3A6FtXu4=^5w?x_575U;0o z32332QT6ECDL_%-kbYh_EIbJVly^Q*d8h*cQeOKUSc%3>=hmJ3r`we^hg{P|+H{uj z^j!d$sm{e6ZqY@tJW3Z;ZtQt5m?9)BnZ~aVV(>lz6#DuvbC>DU8B3q+EFk8SB zB1s2P5G|YphaG$e9`@3KKVNKuS)}gTvZgjVO!9fY?U6B7Q$du1m;}7~7x?XS0>ZL_ z_F?X-)sDOuH<8<(1o|wQ+x5KJ%z`dv!XDACitB>6!2p@@ln zv*Ap~$t?La6uQ?cHt}3M$KR}Z?>jl-v&ZPiVQ09}%n7t?;+gfb6V_+h>p)NQE z@Bi*491{Gp8JF5L`yu@lLGDcmBrdvdqtep3Mp z6Z8~&EF$7CSv>uk0J{PwpVSG{8BKGnv*KOzp-|j!yAN#PYDww zOuA;9+zQ{$)@v(Ro4mswPU@qS)LXrGJpFoezbGCIwjLDr`@Qm=Z*prn2WS~ZDC!T< z+Kub>>|l}~J*qChK7Sgq^|R`9+i942qj&-Akf}=e6V)7l%+OfiAI)a>b)zr2KqHEj zDDW_Gn^*^UK@v-UUE?ND#Glv>0S1fSRZ|59U@(IpZj$p@ws>xP^#DbMmtV|H@U<+~ zn-M=)#a~8LKPfllm4e*aUGr^L%F=9jGkvJo^7=+%IJaip=KU}?LD^}r64cg*;fv#L z(?j85&+5>enN{BbVI?$?pur8Q!xGC8+njP84MO`BHR!WOY+IjyVr z*;mBI2kGyfJ}pDPYlzB;v+&&>>t_}-up1CH7QL!+T+`~ta1lxfJDe^;r1dp?8}?z? z`_s$wV>cx08L_d2?SD0Q^Ebo z#fdd&009XX=26wiZ=NPMYBJHo0g9Suyz`_aW|1+5)&AW7bUlq_o4A1aFF|3iD7dTq_Nj8tphU;f zxyFQ(sX3)-{7G4SSh>isXYG6fQqFP_cNDk1vVnylbR;an%n)?zKqdRj?e;`L_?LHZ-UQUw=^{o`X~A40>YbB^$w)PhuRf>%+=+;Sfc#T$ zHHN^C%W;}oaqgz;^AyOzCa2&cBU~#_tUaM;V15HAxP@>L<8!K;_T5Xi8YtiNgtTwN z2&2Y)$C3vm0stW=dHAUPQ;-(s$2-lqJYwZ*z^?s*At-9$HxaGpOQ371o*f*^ALDw< zSu;Y6#u>h^u~7YTD5(XM?{Pc?p&+M-0i;$1Bbw~*U^$L!AUEMEq{cY{9{s2tKTv1x z+^jwV@PngXS&`msFMyG9%<|8uk+i$5^~>o_!^zi@lRBY5=hmA$jrva4hd-loXa$nE zF&QR4tIYJLJ}r)c?4xbauPQ7m9edwn+&5(1R^CG1ep5w^o?Sv%Y|a)dIUbAgELr8f z0#Tx=VKt?XJo~(Hnh&eSvD;@mx1}cMWe5Jk>viuCD=p9=FqUf+A;RsaHlr6PMD+O| zWDaj%=ItmQ(!VkCjsDXf<%8TCu!@ZY4~d*LW|@Ga^uLY;_8~9txm9Y&K0?G!Y6CmP zy!2{x!fIrg?fUl=w@avH%ciFa*t*Tvi!z1ohEn1n`p;L*>ZVn)g&BZw+5u>LwrqC* zhxKXW<{5#rNWFQzn0XP$ETM6*>d!Z@JK&X1{x8#!A~CWDdJUvZ8TBaI<3DU zS=b_!!1|Q$gAcDc+~_{HAfB80Z2IJ~d_m!=^i&6Mnthg5D#|^c|Anj+1jL`A%4;7g zZ{!;Oc3VL8K6dKM(H~^?y_;{=6Xk3x-bgp1+^x7jo#&i?+CrRV%{+`oYmf91)^Dr&ucK(TMHW_se}-bs{)kx> zU(oCCp?9qH6n1Gj1|mg{uHSS-%4#4?HA78r`iCG|MM|yW>0pL8d>ZfGvPM*12w`Bf zF!VtLH4cdDo*yeG2`nACJAJFv1?Kf(k~*mD4Unq_7-*L|%flLg?aV9LBS+-oAu@}X z0C=Y}i-*hSI032s>0!Ry(fdGWo9pXrAOWKd*a?RcTmcYh)ZF=)Q+$D92#cEw@EqT% zr$X$Mb3IowYNV_7S!@XIZVOQZx!E&s5h{h85K}Pak37cTZ_hMB^V`YN_u=8E&$6-&^_#pP4M67maZs`*1G@6R5Pd%OIdyAYy6{x zPfPK}!OPv1;@@LWT^^6CBBt{$f>zj7h9!x*KIitAb9H%U-qe+RG%B{~8y2oh_`D3c zBAxM6Xjdj!@HH3cgAVU`mAdo94QYPF?)m;~B+Zwf?;2YxI-l?iDvCW$*IZ#ACk9jf zjrO8(BD=f;dK5GGwLMCOxF-Iv`&Tu zG1UY2Bg8-GDdO94yOXdig6@ZbAZ32)cqIHqA6ZpY4M1L4$n1twrwe3bNGsL^ptdj- z@Fn2Tgd9gEcHXZps|NnFg=ztL>lTpUi(%R(jS&27-l(T~XdyCvIj>1k2+&I%G;?2M z^_wM8Jzniwun^3HtkNGYna*w(zr4q3eC6~HUG8~*4I4lQfvX#Jy5wNSGOcYBzYY%9 zawv^bsplqyat23bAQ}fqW|3h|X88T*s?u8r{RG>x$sHwSPJ1OFL)&Lrg^$bh6pwzh z>O~5{RsC6EK;e7#P(cR;84-JC8UNgb{h4yw(qv27pVs*5r-us@dVn;jC$|PddPZ&fZh{8{M52fp-szCi+kPzk9%-V z0QwuTROMzVc&=iMw{3b!2^T8?_nc!2e#W%)4= zsB%4)pH)|~jz0oKe04J=tlm+$qOx@l~%eW4vd8hn=t23~S04S(+4b^k} z?}KAbFs*74r+%g-I`v~zi37<$jRi7CG!F*{o*2iIh*Q@nOociVULZ6bw6YX2KZZSA zs2E0l=_-brnYVm>N}hiGdRHgX+-|Q`!3ZJH)KlrRx-}9yb-j7-`8c~V-t&EHv6e-e zNu#0^0sC!fYD(wHjs5=owUrfX_lv%yKXic`l)wg=8x&VfHxu8{q9JnU#!ICvq;aDq z*GwkAOV%qubiRYq_2(!BwQrQu-j&{?SX5m6%%RaxC`vU>A^rE>T!Qp~9}(!Gr<uCgnFD9v;H^j zz^$Kj`4gQnrxKb|O@FF8x8ONPmc-F@dQ@{nC;@d&1Yz4XiZ!ETqePS1!(NY*@PMMN zzb!0DE>a!&8!MKHtX%Hh$M-fQ6Sh@_v@2n;Mkkso5vhgg7ar(d$$KA5rzlF?To=B6s_G`tg zSu=QXr&@|2rbK#s690zHASI|^|DxdvMXVM9EF$Kks=HcFn8~9!HflC8swlyNQq>lG zQ1k8Fi=dp_J&8-$km+0r%}vX+`Y|_rZgl*d{__h#wh)M}9X`XkUJGyR`J)R8z zJz#hnuGXHX6=PQ*g znkXG(^dZupUiv>r^}ZHJ>BcYJf5x}N%9ng>79F(_z(}Xa@dhY1-6yVs&vHeAJyln% z%6kq~(;*C)EU7J&sE6pj>|!*zWik5TS3$wPC1hF`^hp-LdNRdD<(94A+8>kvSu3EZ zk6wA2uX1zcvQ2MC&alv3x7?~ctl`d^X~Cz-V%!>px#MAOhDA2%reQ_v3maGGFWh%q zRSVEITJZHM+Sz+L;cVpSXfQQP;mp+&P9>%f{DEhBS7Zt92>zJ7r1*>v&B2$9{a*ub zq)LHNkBS4eoxnd(^=13)j`LH?{|>48Z%^5Of-yZa#Fifp5VgY+qY!R=#nU1<5Y(sx zH2(4%u^xS;3!W>v4{)HZXUm;Ofj~b#29U2|8_XK@HvfUs_<1ogp_T<|q*r36NIO|$ z&eT4e*Tm8*#dCMwv`@78?^1{L(`pL=z_w2Uv~sp9KBy1q!(Rtf@jpXf@f1OqJ@7dH zN<6>(nQ>H9eQH!|KMH~Yit7+}`Y(zQYZUb#i_T+?xYAp)K<%%(3aVxhFjNCxZLP~C zkuQLPBI&-9nRc3RHvD8YI{y?f^r5fufDeV3TkXid@?=qSb#~DsLY6J{de**M#Rjx} z>A-Jnf~qWA?>GI{D*g`=s8*+j2P%m)p&Gb2k2m}T&<_kOb%B3t2Y7T+@8;V@yihp@ zf(^0yU1lTR!78(8rh6I~}mw=33Ld3^= z=1;F+7j*cl1M><3c%B0C1|;(GQA7ZMaohoBF!WP;=`J8jlK^M1pN<<2UCdaIGiZ2Y z{7K3&^+&e6^x`=%S^6OVy{?4cHZMIl$CQCiInFB^n}vgkUHN?QQnBW?Wo>5;#n zaYa#o^kr^(T9~BEqD6lUbD;oiwJz(97~2bSRfM?`z6Cn4_6x}IzkqJf1g-~7xd&9$s*V5z-Lw!h zss;i9w!hr^$$v(|$!DzHhj{Z{6%2^Fv0Xb3fVEA2!OaK+T9C#1xmF{9qhtGP2Z$wT z<swCV=0M86p{3~B-Vuut|g5Pxd_ zr@=8T>J(_iuV;rqMG@Lp!4|F+<@u}B2oT**{W_{BU*B={g%LeVlq`}YRdWUE`JcKw z0ZogfJIN6F%a_mvXHfT_3S*(8FAI4@NsL_Il;#E`}#w`9a!K%%7sLY^{ z=Sj&Uxp>sYRa9gS=)n&=9ypHhUF(ls2a+LEFu?dvW&^P76V}Fg_vn!|kx;K9v3a+_ zu4IiBka6YHd-eKY+9}C&ewY8ce887vq(lq1Xx$|2It*_by1AzN#1d@=;KX&n+MK9> zA|1F>mjZE4ujK{zv+vNR5|iQPAwjzVfRUJg%0%!WeeP!^kTiL1sWt}NiQs>+ML|#K z1>9?OPILDGwB<9k%=xlC0O!r1)BDG=PzW^N;#KL4jAPJ4n5KEYGY>ZkAyDm$^tr@e zc;(Q+)Xq{&tVpX+5ceonvCk1SG{E%r->?bVxcV9o-(BFF8>SsN{n2rw4a`LU^;1NP zv?mM;w?4W_7=KHDK@5mmBs4W?FlFG^B4X)eFf)N94czW`xx*<#rWX{gpevzcEr{O> z{+LNofX|IV)cyx!?->YJ*Y}O;z4tm=LbM==Hb{sPy#>)r1ktS!J*FU%$4%K>7Cxc}9!22xxg2v{`3%Wo3zI z-1mB-h;`+$1bOD&Q9D5gKNfyOynt3U8%IO-0O>Q@J3_z`g4j(Yy;p!=AaXns7iA~# zy0pNbVc^eLw|fy&w2fYL4V{9W|D`+bvCB+C#?{?s=Qkm^YLOC{t6J9^(_O}2VfB=t z)_1auPaW~rKXFrq7sY`49GpRLzsv8bQV0PY{3f^9GqkRv#*w9lCD95(mrSaV?C9v7 zVxRrR0-NV49Y9{nE5|>a^A{FcCP5eLJfp|uxCEDmNq;fei4&uU8MgyofO-fXVcio7 zJ>I6R0G}^HfDY{3;{UUn{bVPNDWXgPVrH;u9qj(B=aD~nL4er_=-{1YZ};5w7Q@Zg zZf@3Y*!M4g0^%fb5f{KKzD=%6`z$B`z^r+KesLIRJZFvi+3ba^H3B95F}F|>2~!EC zeVq^LBxOfV6UTzhq~vxxK;Q1d5#i%KwysdHb~MnZp19IfWEa3M)097cK`0nwav7?~ zi~;yOa~5!xR2K~^Zm8(&NW~u+sy)Y{6ztsrYjzt3a^HV||2X%Rh#6x-+a=mE>V4#hmA{qJ(W=b_zEuqNmfMOE$3XV`+A=Ce5uVyAmI@@?E`^IXNCFCY&G5 zm0BI)de>Rv<@*<}ZE5l=+o@iQ6q(!%Y-veQ>ruPMoy9Q&tKR;8Mq=o*Zy44g8!y`3 z*M}q%szU}bLDCC*2fa4~KLHhlay)v$TVwa_pp@dyqzjXz;h(x>gMM8eTrkbZHcAvs z=8A9XRkA*yWb${V6XHO{K<>``l~Xf5ss09*z01#j69EuH`h(}NkG#kKa5(jYQiJ^W zsHCJM^2=?NQI|}m@7&5s0hf%wdD0X zw88OI`C`1s=iPMfCyv8yD0AGiv~c^l$PL>k$S?^#uu-W(vpuEx zJ$8yx@4mTL2UV`VHcImm2V@{4J-}?$V|z zKYdJ>UJ__>3t)4lrCLEtW=!UveUp8q8LL*dJi=Qhw{&+ywK<;sKeQ?Ee}1;j1lFe@ znle(PiuIF0`=06C{!zng3q3_g&51g_*#ke)d5w^*%ct54|5NEle0+?m9XBUQ#$DWD z-CbhkV?mVb28cOdS#XOLH%IL{2-ue#h0Q5?{V!c>^?a@F!{X7z4OG%f_PQoW$4Z|X z$TSG(q0KgITok-b`iIm7o(d-(XK8Rs-dHD8N)@-RNZlVLfD|3wJ`Dqj z;6i`Xg8|JYH^m7;gXb)Sf+1Q}wisF`d1F6Z4_tku(ZgIdw}i-cs4aRy)to52>scqv zFANy6)!*y;1wYcHxwrcwte}YrClM61!lSZFuvO517v0<@)?^qRzp9`DaoE0Om4{+kllf zD`Afye6|NH&8rWmT?KVO)sIjoc`oc1Tp!cIpq(@R^(pa7LbJe8F#u?f@Tp&+V#0CT zLF-QB^LKPZY3Nqx$f)=CFtKN=_htAUtzfGYP#*opdrw72aSTT=AIF#N%cdJgS=7W= zqfuZ8DRt6IkfI~J+8x8kFy;53FbQGaR)G|$&vFjY;%6VEzW}kZoW3^SRgA_BUP|@S zt>~P*AIKEG6t3gp&d2fVfSx@j&tDcSKY;QUH$!!2qJWBR@~ni?2%*3q@b((gIv$Y; zBz?tFVy+9m;9Gpib_HzX+X0D$M6cp(cUcB;1hUtOJi}R=wPZMEh0sVb*90+GR^c@y z0^i)^w=girmZgQYNRf@9Z^UK#aijXj3gqPr7pj9#hmp?YW53G`9M0#umc{V6&fa%0 zF|PLBoyy3z<`)A20Fw1G?7vtgNqT2Hc7P+ssS`cRiyRLd#xr-uh#Wk$aCA2pdYfdA zw^hvT@?V=2Ii9|Mm{MF-foL(Ua{(`GNOt_zZkfcMQ5E_}Q*aN%hh}_ct;Zu?{d`34 z*6sgB`4zYykQ=`1k$NLhX}1f|8$pTzh8s~W#6Y;%R&idUSYCm9mMowO8etRu{gV{=s3h-Ft^#Lep@0eB3#tQ3x-TYV&oWr7aHtaikAp=qIIg;N_7mj*!Z6DNdf+H zJ2$3y!e#$espTsxPie(&`Kgx>L8~QzpE~yMc_eI=Y6xI`r$NSkCAj7z4w6MqDkm%d zS*d>v3P0dyI|5R>$~KoTytgJ4u!)jBB|ou>&R=P2KkR4xWDHO@R8bIS5xZmp&Ta}I z|ED#+pH%)AdwN9KVLG|)w0u66AhjbVs&3|A; z+nWlv;=b+iWi?M|7{>f?WGR7&#!YJYb*s$9`tb#}pjo3VA7UgRXCE+sEd zy}+S3FBr&A<66TF_J8d7Ub%kW?HKSq$q^VQA$r1fNhd-lYf|QqT|w^O`(beMdSOe) zF>_J${^fu0dhIZuT)EY}7pI_CN`a3o@CAsRgEZiHQ~Sh@oOXll;91w~A$T09A+)4E zzxQ2z*m8n5Oey0NHgvU4ZWoWwHB>}MW*AS(^@a|U&u8CK=~tHGv0^-3fu;YnTi-i6 z{vfx937uu`S(*%CKI0sydD3`-R;!3<$Ydwr3K^@DieY;20QG`T;{l2(+rh05qPIrr z)HVA#Dl|&Fw}~R5Q?TpVkDP!V3RQNPg;-(xW@Y$_r(aok{KC`COfMb1`^69-K0&0P zVx17>98pwWY@nbNrCD;Tc#Ll3uO1{Ws_Q2?1njzz#2~7o5O-aDG(~Qm80xBBh2ZHI z!Ye^%#TYM;$CWl%B*SGCbJpupSo_1WD29kwZgQ3VtWLsgviKKYAPTc`-p2HFq|LSa z{U9Z|1jmC(-@7XQ%zMHn_-%)7T`gaWKHV)Lq13XNdd#mwj-z5_% z2L_x&w95-e8Zw&HDux)Y(>Z|&kwFN^OSzXNg;dCNP%A|^iMGq)A9zqN)RbRa_#Py) zZge` zV#d?=I-&05Hvqjr&JAt{%JecHbr~_b3fb2wN+E+Msr!2~m3gtL!vh?0K$gH1I`t~m zX*IKg!&+_DTgGoojYEuN!C~8qyVv*=b6wFGz^Uh z%oGGu6KzCimJ&Mam8O~v_`$2S_e^8Ei7^;?O^Pxc^R0d}zXe>&=@?tBGCT&J6@Kla z#`mg>Qi2j3NIYbq}5s9blD*E&&MO*m zuOCXTE~-~z5@YKSD-Lm{190frq!<*Y?`um3fB9n&lg)&umRoYQ>p2vpd2s;m*?ze4 z(uybmxF4FzZ+0K?PO+kmg z2*-UEnhb{?)#4}6j+_>juR{9s?SEKa-NkVAV_mt=^g}!zd-|_RK3e8b(h%u9Inl(M zR^J3g8uyF3J!YDeeZfEQ@Z=dthR$yQ52(lMP^M3IUC*YM5KGE`dOr;g{O67R@nTV# zslqSs5f(QA&!Xu$2re3bNAcg22p~~o^#v?xmYxy0OkxH8?#ri1j@L8)J&{JdzYaz# zaQU`~pKE+3vg-LifZYE}-xdS7%VN(SiFhdZciB*-MjEG+QOz}x?{s%PxtwJoJ?$cN z*reSTaJQDa%-8*hF#9e~Ed^@jl@p1djQsEU;zirwq*!i+OZ+=T^pMYG?qpvASnQ@L ziR&~*EYig@rSMML^pA;;P<|Y<>9L`rf!Jj+0|6u7jt(VxB2ebY0(8y~cP{QRtAEb{PZOBg0GnKqixtrYBehjb)f z_52^vAFx5oP3T1n8^$5cHSQeyeQaa&g7S~)mGZY#VF%xc{&r{X9wWcXJ{7RH6p`p& zfLjFnPB}kgRGeHDts#-&=uYKSpE!ay(qZ7$9c9vs;L3-3^p<&tPc1uf?8F-lJk8+% ziQ!<9qhDSM>o7-Qj_j98&68EN4st$1?cieezHeoG5Z!)!oWk{Kc~P4*o*vfr;9I9S zYM!en2J64TZOWSzTP=oG%gf-F@kuh_MPy>MTH@a}f;1U8UM-_rg7(2Yo+F+(M^zKs z+Z)!Yoz!Honc&=|!eWBcJ{CC)^jy(|o(RYHH4(BE(74}&BPXqg6Q(kYZ96!Yeag!L zkOHCu&Hg5L6QW4gm*kMdVL#72Yx@SxT?vn&3>+sPgseSs7)3)an;{ zG_(qGd%U;nnnO8fQ6w0#3t$RzSHggZOoi;?eM{6((Lzsmy{?ca|CNP#*F|yLKf8w& zdr~n>RU6GsKIA=Gqovhh?H|sZm`k{C? zNi5b=LKf#YXtyJPXfeI6n)0$nCA;@T%f!N)YGhpXYw+AzKrpoGml&_Clz1IoZd_tO|KLgBac32wyYAKW?&&zA6I#x=u!$<}e0Ap1*^I56mR zv;1bgg2qQ>ROQbDpR}DrqthR+i{QsbPcE|I1CH6V{q@XHdp2z3T3UgzpTiVu_Dl3$yc9{Oi&r7k`%wB(Mz0Mn(l8pbBSCLbtN?^x>cM?GY(UXsvCg+8-&CxuOO6SDo_k>s+_6J(phy zmllPQ2L|gqPuAMZfS>w}6(|;BIMnb&f+5Atl&yCvYvh`V18zUdDN!U*a|1~%m5Zl< zsYS05a9kB%SqAH!*2L#XNBYq{);rP_3yId8kr++5k#swi_YsfBnuarbKuAd`=l}9sc&j8Q5+g|-r}o>4iA{72Tqfo zh7)pUlNKuKTbHPtPXw7id?IT7zh$kpi$%Y0O?d}E!I*uX5d-83y%b%F%Xn@asAB^q zG;-BW#{M|YUz)U{bkcsFpL<8zgh4%Bp@S=;sR)EPo{X6|$FRiUTn%&h7FrZelUw4? zr+DDud1X&JM!cuPhPdGo6<+vVF+O-A_JoN&Pjg7E_A65GFwbHei@)8bQ`ZaV|u!p=~BKTkW57)lR`z zMumH6jy5&QTZuj|58p;UG|rm)@<;yU&Gv1|#3Ha|*#MdZbT)Y`d{fF#oZwOLi`26Z z9F2Q{h&|Ii-@`pzHRT+yZpcv3tWqOwiz}02Y0ol%KnWz$$4>7q-6eW9!&0nR!TVx( zOjHLc2Bc?uC$6r0OxY{X-M8t4Z=bt7x?B~{i4*2*B>9Z%eD}VMG|KHq5mt(Ti9jA# z_n$9@lig;#Mdfy>VLG3^wCS6_WW-Jyi_E+}zJkXw30Hs9Sqx>59jsf1{^NQP|Z58It+c7^AGA zaY9&&G4;4$2Qc)1|KTd-RLB5#_X($d##XfA@W()oTPJ_}o-aKsG#|=zp3TMb5$BK36@}hu`nTq<) z$Ak^)swuU%U7=2msP`FuA7O%%0;h^^ik|I)jr7C-l_Bvkt&^VC-XpJ;W3!tOfZ=}s zh8t4m=~qw}8*o*et(u5>{RPl*8MWH7yA(auP+8;Vv=*cz_-VBpxOLo6946D`l4KnM zjWBzaZK&a?nR+QGK7Pq12~GL&5})0?$P&G&@Obx=&shWC**xd(=vM@gBfa0k${M!} zO+}6fiVtP(Pq!|NaOp2z%EBB3`2I*+a?zT9f5}!VS=G8%Gk$C|ahOH(;jBI9$rLbt z4|6^a>Mo4t3lVW6&4?&@$G#+{AWIrGd5)iM0+lzPQLS<@B!$!zo6_42GjMDe3onHBvp8?-s*#qp` zm-H`_;4Yzu+w>f))xb0I$2Yc}OqY|wD3J9oCdcU^3EJZMfFU~3p{jXcGewj&pb>8t zz}c}ZdN$f~S1(hMx}W?!O#HDtW{u_g^FFqy$cvU|Bl9|6%q8d#wOQyJ z+snKwdAA`u)*VbGtplRZls!P6KO&hb@*8tP@^!Unw(GA9n zC7*PmSmsLTNrxcLX3J=RSuipRj(vH&T0W`7teKuM#rkoN!MBH*W1DS?PLL1bcfEY* z4$Yyxat}luCerUFI&iJQ?EK?P1~&bVqiv-Yduc~Qp7qj~;C6YDkz4dW+rtdsvIr1Q z*$C|%42bUpti=Y$6w($9;UNY`lJ}9n;isX-k4eCh{}-085G*t)KIr99beEQoyL(YmL<6e+BZ3U?|_VhzA2_B~+1_tR1@)((j zGHZ(x(+Zd@JIgp)Jas(AC~i*=aqjRb-CHY``lV2LUk@m?tr?~v6>ngB+ofJkFE!4rr=XIFyL%S9s+XMf1RedEz@ zU(OF(l9|>QT3V3Ba*~cDw+3*2-|ghsnDt%xo^-Yo?8Q%xCAV)vi9-UFf{G#CgCf?N zxEz6kIU>uSoXJm&sp#oJ#SM1wJjV-A_Cp*FDG9E7CB~{4&`%Ubb zghA`$b7>&&XAfIaaR)#oSUmp0ApzxD1Pv)eHJe^yC#xD>)UZFtvYulL3migH4>vi;Y#%XGaCmARV~3C^1Pqxg4tE6ul9&cLc<3h&0P#b?(xN zD*;0)#8LlWYu5d-!%W;v?6blw<9NRISmY!2z5CF!NyT5}@~uI=*!y%Y&=WEhb{stJ zmEoXSTw?SMUp%%x_Z&)$=+Ng8q0UwToJ>g#D$3crgJQa*&$<{FdD%4|&8N_%_&~v* zV;h@~tQcEuDtI@4>Y8dsunGwjuo;X(oEBRpM3Rm%ai|nYyLaBvnlOaLU?6CA5TniW z9sI`iz1gsvhi_mv3J0bJvYmF_`FI8b7DbN#2f?XX&9un!d*eA-aO*P==bgj8Oy?IK zlG~)z)30Z(kV(qP9sW~_mf2?tJ8jl|QHIYH6tt^D`7?Vd5+1~~#l;wEb>i@_zS_d` zR_A+vw6wpxb62&aATWQjmwR;shJjsuH0NqugM~dde!(vgqS(};P|-Jj+N)F20ea;2&!XZlroWj?+fJe-0~nYxy;Xo z+H6{Bax8CM%mS{})k&1N#whNUIwIMok*`alU`0L&Q~IIjk%va3ZoY5MG2VfML`Dwn zs92i7Xco$9aK=q&?G;A?38XtTxspb!_7+dW8P2|JmqsfOMGp2E_t3r4>?}eq5=mO$ ztVl0;is`=2f2D3G>>6LixooFRxmgRIyji-=QvB+{WHMPSs=6Mo1$y#EIY59|lGl4? zvRtF_s{_ih($^_xT7a6KEDTE~gL}el99zR7_XL0Y_U3B9W=nKA$IVgC*{)o-i7lqg zvK4J$#CGGlD$r=wBJgzhb`~_Zp7ZrcEizn%e1M>N1>Z?V3K8O=K>DKDvlCHB(dliN zc%$8=9Yk~?`8cZeUC}t3=3o(`-#`VH!1c^d!axK0$!H3{!*f=@n!WR~?`rqCE5%1W zb~|F)vk}SKA$*tS#>q$55rI1P`Cp73(`rEI201SiS6}iQp1y1dI+SIad+eO&)l?62 z)2>z?{%RI^{Q4qmT54wE!qI*yZoA!9Hl8^@Iv*vh-Bj?Q8%+*p>{Sr$PK&q$b6&X9 z7u!XH$C~@-h-BAdoiAW|l$Qw+H1pGNgIvWfC^!FH(%Y1R^P)c;W~NQK*k(|G&y z$M(3zLL!K0+fy+U5B0`obJ@7Q50IwqSYEk?3e%o0TxPn_{Yhby0DA#d<}|{q9O@1Z zc{BCWk!-+PxafQ1b^mylw1d9*+Ome_{>>RtTb?Ap$w4#$>FE#xZ)_nuTYu0=GHG4s#`6aH?0dN@BHqYEPhatI6O?!s_XQB(YpVO z&KR_cyiR75mzx1vgU^+tRd-+p$fCOMO`T2eMoa*inI#Z0L6R%wLjvqAah0Y%3tn(w zF($UnaZ|jv+^;y?Uq3L+9C$nqzmE}j{@k~m(RqJ;$Ax=%WiSm62@_q%8DMacxW{!4 z>+Y38P={M}GQpF437EEr@EWp_4)raikKh7O+DHS|!?!8x4IMX5zJNA{$DllmzkZf| z?~K>{LM0Q>4+J>PIW;6y2A;Jn5d)gIgi5FOi;cs&%HSKMC17!gh?pH z(>|SZtPylu=^bjQvHf@Q#8IPa$0h_kgF*#>54Zedlfj?yCBqE3pJa?}wCd#b7C=`S z0v#g{*zJ0NO<~1BYPVJw+@E*7#$^da&K%aIYDjWF283#Jk$?(|R&1Qz1Q2Ykd)$ZG zWSAF6v$x%D7ADb5pF8e!+}*k@nP0Ea4yP3Z#w#!s33R!r4AYmU@xs(mZ4bSOPuc&@ zZ$7udN%c{I1HhF~W3tI0P``37%R1<#)a>0m;;m?8pZA_~vIO)Ok^E7DZ+~ST0OQst zTgo&KME1cogD-U(Z%*fiP1_=H7rJW)In^?&Ixnv$+5wS?^}&}Rg}UV8lVSHHFiP1M zm;$lcc!0+8O(SqO$BM00N9mjdy_C1(1>J>OI1VuZke>rNACSG(-s66>B8!Y6=jaCP zhtz;=lSNiI()#{3B-(FSZ3o?ia9~vMfT1-riMEL~9o|_5elB00e>%KwXa;b2Zeu4# zI{~-NfFHwbTaXnk-=ZEb{kivB@lsIv5pRs<8aEkUo7npYWYkVb0aq`OTugmH1h`j3 z6Eo7tTp#pcPa|q>PAY>F1^}JX8Q&E02ryy~ct{6bpZh|^-;Rnd1=kJH=OGfM_F~eQ z>$4Jh;Y*{I(aicX{lHx>5x~VFwDrld^6iOnY?TbJSCa1oH+YxKIsqLfRsEtLay9`v zU2wgrBufx{F>F3G>{L6h2p=}Tb>E@3o2%c&7~TT{h^pNW!db5KuNk`3@gBD9{7^Ny zqwP3XxYt>(I{cP{&KT|)bX>lYz-x-qR6TYuzxs=DWoj8oZT0LS5M>mHL|xub!pdr>)~7|26xIz5-vT!j zB`qNPY=V!nmwE}Fb^CochwOA*E$nv#O!n#%hw?i8^KRO9t)L{2UbkA#e;4Qz@SIzh*lV0AfJfCY$uIbh$xtyt^aWJIdhO+p`XH609J6+TiEGNaH1=&5WlV z#~nwx`yYe9$|d7WIRV#f9g6Z`=<&r~J&p=!*0}3oxvesxS1#8gNW*$8QIv=Ok?O~m zUl5ODMwNyvrSg^spt~(4a*!EA`K9)Ogd- z3PcrL$G=_8blg%0a|>h0@Jj)KTa6=L)33PzVIeG7#=F7YG&kk1eN*1uH3ANJ3=`(m z+0^ojx@_aomqok%wb@{GzGj77p@C!kIYx7OB06-r?nB(``Hg@`Zne1&gd>A#`p0uY zS7^CTq%&y-|DhR&@BOF@IQ#91EA!8~1gtVv8)tjGIRARGm3}YmU3DAB*zhvS^>mqB zxmOVl4?H8xp5ZY^=-^gXlOR!l`x#xBT52WkB8)E`@8fOi>OR^5UY+$D z7S~Sn^%LEUqm>A-3jYKPwt4B(oAMR^?XQykH~OcZdr4G@fXyUb6`fW9wi4oBsJ01M0((d zt`@k)nSOh~`-ZJ}10hqBKN-DDc>#q*)E6{YfB@5>_Ask$b1n`(~K?Sgjo+W9k^ zi1l-5tPf``&HuiguwBnulpW-2H>@LTU zG%-sasZyXkd&~n4`v{qJZT?t<6R$LHJ(X_G!_Rz>z{dri6{G%C`?!4Uv*%6(m^$C; zVWB~#86lrP;P1~^Dl7x_3Er;-L&G#mGsOphi*^7buh6K#7^L@3r>w&e?{znMe1UQ$ z5Q$q^ewVQ5+y3c^FF8lst2;*$Fct0t*m@BFxa4++bnTuv*Fd?9pejFXZ zUkx4P+ZU>pXg#&4V|*QWLr5 z(xnu0DLS^QY!oGQ6877+p+haPk8S5cLKzHmOnfO@b*R zMZJQH_bwG8!3*afry_ry_&FzVG|p-?e^np!$T7*#495q8GuE-4=XgmzsZu9c4bm!Q z0tcF5YzwkCe!Dpyquc_+P0JqIcv6q!w7LqAGJz~aDttkjSPu}AUS%GC*cLDbZI#3S zG7vzTkxjn^osvKwBaV_2qv!TyoCbx1!eTWfPet0pSK%m)zqCG&StG#%gFX}g9UohkWY zg5Kuj&-$9MeP5jppBHPThf|Ks?Z#5@G zT?zPQU7fP>@RO*X5EZS88Vzkh&!^T$`Ta_tJX;UH(Fbuw1`7ESVhL8d;eYm32TnrZ4 zfNyr%S@{$_3m98E&+FupFbfa5a!C5lN_^`$n*<8E{$A94w!3B!PdJJV$TnJ_HT?yjlMhG|Bs9#k|$gI_MrmqCgFEu30OFv^dN4}ww9*`#`Nh_NA zi!(5C0-64TC_c|GJic+0(e?G<4*5ggL>RW8NI=;}WP%hhyS0$w8>se}CmM24cgKSm z?PCGg^|eHwJYJCe?sZ6GxhrEFbs{h)xg+A5H0H7M(=BW0WV`*}!&6_Ez>3IF6Vxp} zZF1x(4cmaSdsqzX%RBofQ9&;Qk1~Vm58Ax~t47yK#bH_!X)dCCxgyVrT86)UuLZsO7Gp_lvnj`f28{p ztrNL-lReDUuk=;$-%U!nf#5wF;}fhKa(PnHz^}PYW0zj0z*#?r&74Ecy{EQ1Z6>BE zFWY(Ds-gY(wcQq*ro>xA#H^7^@XaXv`ls|z_`Y9)>_f*1mpM9=|9rj6F!F~OfX+k( z5DV3Z(BIHSccRHx;Ce{6JT$4-3Ici+sTE$F?2Cwx*51{+ju94EubL->q%#K%P zY`%LL$CZ&RkRAuLG%@JAhvC_W@)Zj(&U)^R)mgd^Z!XYDrNhYx7KxfBw<{{$Ho$Ep zs_|)pspg|w8Pi!W?f&lyY-f*EbU`&%J;)qW!-~)=e$9AmnJdpZ3;D)%r@>@4w;>~F zu~};Z(XYXQwzK)u{@Kun%nvKm*?{%N7g%o^xe^H+g2Bx}t3h*7x{6*-keOBPdtm3W zJd|}c$eo~OPKY9Rd<#s!3+Oj1Oj^HYk|+8%PjYBwGqh1hh}8@Wl@gxCAD!L9OJ^l- zwEn=QN745^mICDwp;_mROEUbhJT5=o9+{5_eWU)$5vPq>Pci(8<^>rbzS zPlcAnT0fg^o_c1a!c-k+d$fEp_EPyEX_v1k4s`@;M$jq+;AAjj`MeWkh1ond$< zJt3;8419G>-8g~G14-SsC+hr^IaDsv*5<&7R7k0Q}8L*}m9P=kKPw4(cKhoL&y!+W!}#Q8s0U0(&n)&f;2&^ zq1T|OZdr}yu&k8$X%6%r4rP1DB4BK)9^>I0v&*HCm#};x38UqT@#QhP#MPt|=4F`t zrjx=Nga6`fFGrEx%@ckekF0PNoPo{=5k0b5fdRR*V83+na=0hoFQ$Q~=UH5zwclHk z_{eY|Q4;t8rz38HHH^bG>WN|_1u!?a$G&-95}M%M1Q34n0I!e>nDjHZOjYEw;t%qj zvgga;hqleXyF}Vcz0Ar_MvyrzB9v^;H8zF0NjuggKr*V^D1-!7?Z)J3TIF}SpzSO- z$vJU)jlA;i!=5DjrgGo=akcjxoMeAki_htd-vYoWR)Q3Ezcv+->B($p_)Hidwcv>3 zkdL)N@}|pym&fn-DJzO|+*KO)nvqs^%iRdCrrvqOb_0JI=mN|E z*7<@i{tx}o@#d!(yHA2a^W7*WmOFTh zF#H~z1IzW%R}Yi&?k}xtRH%<0oKS{lX^((SGak0mtTpREV$EYpR&TB&2WaWAZob z1N9nbX$+GVam)~gC5^7?GOxgo^uB#NA$TOv6bZ)MX_Re0TLbaChy>dF3t^AdsSam6 zw!;V?E2ztsg9?83QXZr5EWOHdn6eOLe6EOWW;4-6WbI*zkeac*z}E#~$PZ`S)Qqgu zy;01sF>M}bqR|}mFxh%8hy^N8MCNF5td&w}St|R^63i)+y28oJu7A}zYf0pX^&F0c zciCz#p!Dn-X*9@+hm_qI;|L&$kx-KKLY-vjrwrG}7vJ^R&(&&Ad6h;cd6SJ$TloH9 z)|ho5bq-|Cu>;A2^_*q$SP*&ZExHpxFm5-MlJFSK#$_D+*1h3t#VxhJv``H{qyzw;y8%u=SN_R|q3?L%(kQ*(?;A!0x@W9zW?CQjIrE;gHVL^O!d zPo;6Kpmm)J6<@Km7iGFaq4WmJLk9*Zs%mxcg(`ju*bh#| zb;2T~^CHc{tYRp;1D?u3_gu|vAu^cMWMAvP3;?wxAw)*C83!h@{sF^MtwGX(VMDG+2pod0OI~yK3ax#K6qQ`Vrw$9FVVhaOH@($JCQ~D7U46ZS zeUd8a` zuM6Aqngz0!t zM?D=_t(hnC75%IY6OVdDud{@0`&Gyhk4z^GWPoN8c+BRVuerG$n6CTtSNwO{$q9~M zeo1@jkcRFRu~KE(W95(|X#B4-8g)NDrjuq3FI7O_YfMVN#9G&3%H@emsp(Xu73& zfCdl}FLlG7e-;7jeAemdYzQ@@NJqe?!ZCPc^*&BOY!;>_Q)GCr1V*{?!D}=qs*0Y5 zO^3sO->Ylegy4g`k_w`l9fZM ziEMf5_X~{|3yObEV(Sqa8jsq`7ti&GGahVm7SBm9cs-+)YAAIZF?$D~c>nS@GiWpQ zTiwN?nlm!i)C`~c4KBa`|L{ChfrG**f51e3INi$b46~-7-&3`%GG6Z${Ow9ATez4t z8#R6uU!_SG)8DolAA+ctP%IIPm>X`qNt)Y@r95>l0~H?7Hc*HPwEEZc8B7rW%gTJMB+M*cVj+H%Shh`mR zlErv6p2=7`Ux;+bAi~y5hy=@+5TWm#GP^3zP5fkd5wX@b#%UhYs_K2om8db>2&wQ^UaM7dgQNf zO0G2Ww*WWeK;*^Q@%&RoTGoz^Lb$$Ul8p_CPc!Nd%Rn*@V<}gNy=_x)+j;({V=Spt z<8q&TAvPE+2Qv&hL?FB_gs(2C!6VEED-w0wpHLOxchP*O^6zY!*i0^_*36_Zt5xYb zagfV!wwD7oPi$2(iX1%xJn?C`z1=SjrLiLqx2N^*CPcpXB^Q70bSRa|O&3o?56eL= zFB^K#yA22e*992j!+kU5Wu-G8O5-PGt>gIt=k-pejb7Vakt0)WYdPp5#yy4VaH94w zdt(Oo%91%9-hL^PTQN2D?^FSf_)tV8r5W%gyg6BmzyWRt>k+?x^N8*&d3WvY)(_32 zmdSdX4CL)6)d?xD`Pes=6r;9(j+atb+Ump_=G-d7zOJy3L`b7&!Gwk@hG zjk8swT&J_o7Q7gt+p|ZzOI9y!Gd$KlM`Jm+ch}+Q(Y*nW3B`?w`^tZtx?ypVu0!F(J4(MxzIn896416&Vc{hk9>? z3h1%p`8My^6C12FOJ?BO?H1!!9$b6YcNJRMpHQ}{NfR1ffd!zQ72dq2eovUFbC0zc zs+begRLDBC0J7R@J#6j_s042G%G8wAOQG^m{Y#0}=IGy26%@B)mg`jz1aZ$>C1C2SUucal(A*JXmH{8HZ6}(5Q|Hr$}^>Q+*)hHUMlIW;4OTPN|abK$?Q=qW;U~g!#6YfyCWf&)P-U6;{ebX!sdO5J{X=S2UTkF2FTM>#gH@KpewFd z-bD|8>&OK)5c=R{j7V`EXL(IyJgggq`EEp1y~7r)Sve6DSvB5;j7p6LQD2VA%q1I?)flpA4rj7*l{D_>2wK-l!V(ZH zk2I|c**iTD&yl$f%bt}-aX9mD2b`QshdbEf^KB)J))a`|ta|y8+f@UBwgI7Mlc$rL zfkxA{D_f?G0C{OWOJiHM+GuB^D+CYnpS~+ns(ylM2k?A20Fb^rP<(Dj68e4zKlFels%FeXzdeX%;@&- za~)hd!;dDN?Wi4P>3+g^_t>*(|6umBxpncY`-w@{EbXl(e!3^$^S7m(rXK8_I%fM8 zxYkhiOlkCo=gyGi={|0zXfZ59;9cA(U1GvB+QNxD`j# zD>+f!Hs1ZMW?V`(aF|??H=8J)1eOHXrNf=m!%u#|1eATeAXizvV6E)azMfx&dOAE% zg+LGjpoj*eTYzEdu~CLUXb@-4@sCZap=JJuXJ0G|HIVeEcWFeB(lk46whrV4 z^M-l&ov&vA4^fWPc71q{im?Dov#hr#lYOvTX^!CeVAV?caAXB36S)S%Uy1Kp?|x7E z$vSoh!D~}YrsRgE#?IP6wy55^Vp^|wVJtZzwssxRHa5& z9NG8Pzp9%5sv1oh?MZ@bR;N_D-tM_m(XocNc(ftUrXM=#A_gj&H5D!K+2G%6)N3S*GvW_#clgO|8TF^RAo905eHV$93Yf7HY zyAQha!Ti#~u`c4(1b!XTu;iAtPWcb!iNR~D&TOQj6K(4Vnf)IdO6IhCwchN0ENE$h{yGO0BIiJD+TxpkrR5uxlJIvm=E0uL&im&+)9=q_ z#JWV9)b#|E+hbM@_D`-dCLD?AU|RQj%t4 z(KZOPzDFkOr-1ai5~LK7tQq;(YtMFHDqA*geP_&eXHa^rQKN6(j| zQG9>%YE{S5yo+D&-4d_FQ$~l6xcZuW-@-0}HEfd?=@0ikkA$NG*W0t}?l(!G%RzBN z-(9z~OBJw8-wB~M4UG!7rbUhF`)t1*C4EvFrOCtA#G}5eo;0#y&t37u?`UmwX)n+h ztDOAA?<}xOS^ES3Xr(@@C|c_Q81faoZ%`l7)y!nD&fx*X!t9>Y8x{xO{XgxUdpwi> z-^V+soGDatN+mgrL{SYzeG7#UB8QPva##psn_?uQV$O`O97+!5%$zn%$b88uhqWB$ zY!2JZ#_r4S*YA7(b^m=o?)&lGf4g=)9@{?G=Xzi7!}I-m@2vh+nQ=%*0<~_wWZ9^3 zRi^yV1$o_3S7~^b6JZsK)CMr~1sP1b_*NmeD8@dyM|-s3Y0F}0hD=;E?;#P!dqZ)O zY`lQ$NBaqiS|b-?wdHE3z7aR`rkKq{w><&A20VG4}(QSgv%YHMhmNM#1hxsGmpKVjW`lPth0U@h6knz5RuYTNWXTL!nk7>9l zgC;~Z9QR375k#iAmCk-3yX9xf?THZ~_0EIo!_Jc-7MD`?$OpVGhtt3AD1b$yyk0B^ z;o|qqn8d}8Q2O)(XX{+)S6p$qa^F~7u8&97W!@6A=-)zV9}aY@sb2>a19$V8k=neN z)Y^4s#$tloxRq05h+fJvEh3ejG7ujft~CU1DYYj5lq}aqM2jpgrmtVi3nM1FZtoYO z%C<5?E$p>c?zmfoVk~vzN%!q-U>)W&B-VuXA}4uVpXKc}x%BK72|;C-Fph2pckYJM z%FjB~PfJ3sd#YG~TEbJ^k%x5n2qt`KT}LD}G0E2supD1Kj6+if)`Leh{f5hZ;xN?re_r=Y zRq@ly?jgnpL0+ZJxPj}SCKkab|+yr#VkxA-E`P=R-{af;TcqS`!K&~ZM`)%YBgXvc|RE3I& z2gyl_LTR$X;!{bm1GAC&l|7-%i1Xx(x{l!ZqiW;fT{FsktB?T-6j2TWX^zjR}1{SB1vLS`8}_ig&Q#8E2FxNzaU zvL>Fo+u_Ch!8Umn$35;J8TL0Z_xPCvei76BXH4qJJUNqDkukQx9+AEXwNV#SaaLYP z*3X$asD-q9bpJSKD#4^ZfSK^zlS^})rflSM4X5=&bWQozLhbRY2rwuZrZNl9erE<& zDakCii}Qf$>r{S^5&9$>F^B%C-ft*hc3Cr4DI3>P>lOi@&c4y3psk3mZd=th{rYEA z*vi{iH}!6Y`PqlgW7Zu1n~6Q>`PZwv#8)PpQ3jq#gBnOm+A;w7hUK7*+rsufb__0Q zDp>ec@sj73;$EK9-{)krFB%7`7jrf?ZF&bxJkyR|DgF)!T%bv(!!AENn5-u42-VB7 z=i68uQIC_m&23M=Tdf7S@Rk&X`%DJS!2wWHqk=#{+%`6GtFGmE) zx7uEmELZ60iag!W684Xf7uyqu8dPJcRHg8^z>aBMqIcD`EyMO@UE|U|uo!b|{DR|~ zSBD^7ZWQ(Y=}d3WTs>Sc`HJRsO#4BN4gTPR-&S=35BB!AkZLpb+N=Y%?x>Eun3AH3 z$KrkvTxUNeM!4Wb^A^qC=QX(qFQ}jv63v=}d93sZ6ior$vlo2TA42k1iYl#8C0yQ(;O;++7>iv#92{EH=K z4%~ix0B{(&axOq{5$By+UsAuDo1lP+i9h=8xJ-4tC4ZI2@Rz$0OW0{=TzcMEC7k}b zn+^$g0pt$J0Bg&;I|(E&m6w79h8>Wj<+Hc}Cb5uRcgCd~I5{0?`{obAwVBDF$_m_2 z*~o?BYQ?4tyX!LWerJ0HNl<~k(5XBHqTSon0gzxZV3>^qvvPOIO3z*dr0s$PhQmsm z-r20jzTI3wa%`Cc2Ayw!&)ROo>gENQTgnOYCcrfj5|Tk|LZ+?c74##qX^FB9q&8p& z0o?iBj|%#T#~u>q1&CLDT&%~SzmI>=%c4rF)7#F^*Q!A_)??1)F)%Xf&vura?pKu; z;;sPAdPO#_R7!;hAHeeO6g=?0=K?4(LnY=yKZEE^? z+DkUwpp@nGozUCK4CF|iy^|`P-;*Jtvo)LBSv{GJr#NIt{t>Gd_0j0 zK7FYOovNN6WxEVJ85)>Zj2lWG2Zws1KzN3g*RjUx&P!y8E}z4VUpDd~=wdpbGoitn z_H@qz$)A#KcGEe%jNB6y#UpYeuU_VYftY8o0cicP! zxQRLpT!A2Su0KCAN=D)^{c4rlFe61BZ<$xN-Tu@zf}?a`(K`xrg1$I*+EV4Lafawj zcba(DVmxQcY@e(yHI8K@7EuKm7tC~0VxvdOf3eWyZla$n(IIfKTYOy=6e_uvzC2iK zku$8!UTVMU)WPw_+u;KZ#o}3!;1fg6mj|N>raunavCx=2wYm!(g5Hx|Ii4Wlba4J@sv9-Yp-Q9Z%Ay}7ocDd6cH;ydsLxw0*!$5`ha5uAk? zr+{e*ZhJzvzg6SohlX|7{>4%_TOZAxp!YM6fJ=Vyen)A;b_)dcjUlMbVh12c;(2f2Q1+(pUudLIrZHGv z@_VJ#EVKm;vGCC4(pl)8ckqeQ$A^tB^WDmVA!hr^eS#ckou|)dslj2#Egqu-mx2wn zrr!JEU95z-Ma~+>0=1^GZ_jiULjzL3b;)vAub;&v%W^YQ^8#x5sgx$tLmLKmxTqyB zLXKx^hM(D^y%pglq@{q}+Dc#b>kC=4Qz2L=kW?BN>y=j{qgC$~jdjb{0i1{f=zfNK zu@xUv$Os+VM1mn}rqZ56=wnuso_-D?ryoMcLFD1AM|_!~lVh63wL%*hmw}lYGao4JC`}Sfo((O)JI8kl zS$fGhaK_A#{46Pw5|-X>3u&ujwIZE2HmKXA)n;chYSkQfA$?iAk-8u-$>>?IT?q;O z)O?%P3YhxGAKy55)`uH{HuM4P8Umr>;|VQZ1D(BuKO(f_z#z6$W*p#3i|#8wzQ$kZ zOeG}{V+BX0eD(N$wdl(TX_9Eyu=d7nPMaNWI8dP9UF5>1(N5w7k{2JTD|SUX^r`!L zmu}>eAXpa2Qsju9J=98_g|`JjTFr@(uLHF&9K=lz3BD|5N9rLua`E`r)g&4Gt2boH zhq}}f>pA9jdp+tNas7b=GA>x5bV2e=NL0He$2cnUhz_GjK(Dl`gsLn4*xvbuVJAdFL0rvFaJa3t!3x zCJ1d|oQclS*3LFipirD$k5b|wq&B#;JGvBJzHy?Zy92IxpkhOO8@cQ<)c*XL7oy5r z;RdXI`;zFIkdVaTx@1K`jMDw%g^L??8)?4t%xzr!(3p;;qIW%|#oC~dt&FiqQ=f|e zvwo-fK>flT&j-t(6}Qjz2*gm3v&Pve3>>1D0uFFxXU!@wX)=L4SEXQ&YkqbjTh9|R zf=dZ2Q$rGqM@qjotqzWot0k6Cgmb3Ww@_WB^_Le7I+7cU#^b;ZPCjPqyG}rw;#BR~ zrnMwi`vN(Uk9A)azSE~GXrCK{RnX5WS)&*sz0E(m3xCvgC~zKb{Qj|EA@lHNJXq%` zB0G8TLBsam)hn!SarIwbfw7DBu*q?}fF?<7hat3N1SxZ2ryku@%p+Fx9Sw=c}tvvc*cHrm05Q(?kKKP;~Z{bTSeAQ=0XjD>oaG0L$OO2-7Z}2h! zimli*3v(2BXliaIZfLxyV&fIcb37*GZk8Eniqf4WRx*$D8e}g?-y%HsvjC@5%nX`!^t%{k_nMI?DeBHKob{%Oa~VJC z9k4X7A-suz7ozgIbzqb}4l)iSSTd81M%n$OgYCTq$9{D+kv>(FGG&Qld!8hG=6*QI z`D!EOWP;1OMdOybnkm_6`qBSW@3R#xTvMK1f^G>V4-#cOZrHNzx(S~Pz4zgxGvIrrGl|?jSmv`Q)9NoUo@?RK;^O-= zrISk```}H6% zM5FyD?B7l`e1^^sf4I*F34O#^pMF46iCJA1zbr)tnS|FeW1uaT~F(!!k4*M-EQg196Gq; zOY?G;d(p`)wuf%Ckg>GwPFvFB*e=KI?Y^e%x^;TW?OU4o!7+q`we#qHqvtoMUgGib zZ&?`$oy1iSL%&FNJqMORiYhUs!Frswany8VYvjk(b~XNu z{P)smS|Au4$vzq)C6Q!*1VQ8wY)L0lGMD>By*-=-L+hqfy_1Iesv=(pDT3*(32G-5{L$)5%1Gog>T_Oa zb8F4mTuW~<4PMBk((Bii#63crkvr?8HJA@t@nr0Q z6perxJ;*kRgAi4c?sp^FIi4qZ`e3E(Gr*wkRLY&8k0yX6`Ti~vj1p!OiW#j*?Dl%$ znM?^~Y!h?&7OJa6ysY<*-)m5W-!!zpyt(zF=tQpYPmkIP_u#JABARp;#1h5BzZc{0lBc~ORyMLjH zv%Rt#l>&{QH^Lixcu536P9C?pI;qrj>0eRgR1GCvh1L1yvxb8~@uqxM&?zjD6 zMf*cl8YYlfF0m4zA=Cpy&NEZR=AP@+>NTiA=AT0_CDky|r0-^UJ zBB3Yr2mz7+NvPo&ywAChzvtEeP52Bm*)y~Enl)>!>$~#ujU-LVgUYAKjc$SLlaJOT~GTy*m^aGaVl|9ptF*KHch<&;SxIqvRD&~E91J+ ziY^N{uXAJkWuCZxYfsMw)$$m(FVxY);F9XS=jizm$3`q-H$)SLn^&XwYVIkQY}S`} zJ6Y5Pf041M)00f?escNUtv`P(j=7J=IV$XAb)yPRYqc&A;S~`X? zCs@eSkUg^BY-8Z&()R8D9e!pwo`ebA>o2&SwbZiTD~GJWH|`Cj3n+THRl1H=y*ME- z(Ul_M{_FEyayzfh*w*r}`|{6E#Cp)b_wwSFG>Z7fBv)-*e>+b<{_)582QU@CuiqZm z{%nU-drYrRdLk>^<9R1rVp!b|c1cyiJ3hQ5hmHjJc)8PLnvCUKfXsid=gga1=TV?} zSn$S6Rl`qgrq3Ysvec{qjoZiRzsQnwu}E1x|GR-CMI&%%B!F^9Koj?V)7 zpMOXKi>L=xK$buUP*SqSZWkl%zr*OIy0oc83gDH{8!x$~CdS|n>I)$O>T}RQ1Oe*b zvOuhmm}36&@7i)P+cyN@Z;7IiyDQR^kE!X#W2$pOo~3~CQGTUPCWUvJCPV*sw0;4h zIMvCxYZs3^^niu#eqmh=qieqH3<-LL5#GieQk_yIZ*N@K&^+8P=Y{3p{@1wZugjsj zl?~NWJ&j`mbWi~d8-wqvWMt0W7zL(jP3QL)u0bktXGx$$@E;p&YmB@)cuJFMe>3gS zS#vev+xAeE+ktwhqWJaksx=PFx{bm$m_u9IMN3E5QFkat4|@MhgSnJm$Z)~!b&}+L zbsjwuB5?CwyjvvW0t?;>H z{Y)C;>fAoZ+7H|m>$6bkIab;nk8Iaj4=R7!uXa&GxDA|m`r2xTfag}&d=bL*<9F}* zj$B3&*2!5bsny(l@ITKF`IP2CS%+)_6REXq`f057<0ke-`LIm?F8%5W(70!HzHCFQ zLC7U#U<#POj90`vD$A8N)A1SfHsBhelOqP)} z98xKO2q<~IANgiES_qyW>#_OA2p|G&D%NIt;6m%DRowaVpA{S$2NPxJ;AEi?3vGde zMMdCQyWVy1KwyH_V$*y)v%de`Bzb|w{Pp6@MP4K94+>$S8?UxXkW`h4By*|0 z24GPh78>U`E2-M80*2MtusNWr5WMXrcbc+NR8q%y(8{5?g$Ph14yseK5BE@(p0&1& zJ}(;g)>ZdrqBx4J>iuQM7&(O9@(mJu?!Yyk|GvX9!omaj3Fx@8frA>}(pEst`)l4&X>nA7q)WIGl84XL&s5)|c zZRjVY3BR;8RP5v8Fy-@=bQjV{0t)*22Tt>a?Iq~5+ras!gZBLTJw1v>i_1?4D0T)+ zN_l15JUo1g^qg$?l75AoS?KR5~9y|KL~;E9+$b`q}`xfd%E3MGF~QHvz*U}4o} z)`9KE_p+6JABS`I7#{);lYy+qE3+6U5AtGfx@EGkdhy+S12W*3>KTRaa)3w1{r9(t zs1h4ZN~6R?wcEI&P3Be&FyAsa(=Ohf4?gzTaJ8;eBy4KZvdV3_S1Q{}=W3*_)9=Y@ z&*wJq6xPEI3MS0cP$Zz?V!2)| zCehhZvOD&6!RVg!y{YzAL7Ng4bPm4regg&=EXvHlNA<;FT`Bx7}_N9f#hicMhY_^H)N_gyt`8D%goHrc%7+ zddD~m1{x$ThyMuG!Gab}PCC$>(fSlzH1Vsefxg%P~+rO~7-aA#vt{l12O{Z^Yw zlmuJu8)>tF3->?I(49zNI1c7fGhw*F7aX|JEw%PiDwn{-A}&BZ!N8-mG#e|jPKg~< zn>PpNX49QN_Dc}FyIlC~QROo#d;1IOoxyP2lcva!`^Dx%!xB*IKVj1tFG023zi1Re z;M1QkZ7rW(id=r>98qgIfALe3;6V~%i(OS*yv#*av@Cg2_^XFNz@_J>;YmuGs!lGJ zrB7U_u)-q_m3{56nkqyB)kptQz0s*}H5v(<;8V zG6g9OQFYzc>;dcxX!;BH9<;chSng<%0I1DSCPHGq1_;jE32iDs%Nl-bM5bmpv&Guc* ziZ);0}H#@Vc`7ZkI&zmcnjl&^)MaHj~+|a1F57=XaBTXi}zp8`fG_ z<)%F9J*Mwb$3C7#5!YehxtCw6nw1Ve-AoUH9Xrkf78q^6hrO4RN7 z2G9P?YX?-q&XA$V?GgO<`t=R6sfqf?pfZ_HPdM6P=51jj*cc*Am zM`G66O3UKvwsid1+nAmSyK$E7+7um52KLv9z@w==9-scL>};>YnxW;+a0&Saj3Q3K z$*Qi-9ZOT+NFd)Yz2Zw#&URAPvUjCwd0nT*eobMB1SN4x3}P#A@ssZq)3!31*v2^B zwPm8(dmm18kDg2{Mo!B1L69)s!4iVQ;P~Qkk$AOy1p4s1&*0vBQ0-Fkea}^VwPtHq zIbuHLbV`8iSuO>r-vF+ptNvcTw-ZJL3$|aV3(RG^a~zH?Ka8dJ1)^iEpBLri6jcdlPR@)4q%NC?j9}q??O(2CPDSEs^W+K}%5BjwNxiKWnt1 zsnoXlnCp-C5uP_i3W9ZOBn(>p!SB24J5)7oo5IJY3nG66wzLjs3VYaqfcR@`s@8YX zE>>u1v`v)mShe#|UfLBWV>~zD$#^bG%rUPSjxo$8I2Vd*(D51ydPi4J`wpr%3hAhB z&4!AiqM+?cJl4yvq>^YP@v!HSV7TzW^3R)cByE~Fl=phYT>%>VP2$aT*|pq5(Yn^g z;i%skCiTufsp4dru~n*VFoyiQoyc(r!1#46`=jNIcDI>u~nyIrOY#oaL5 z!pD|BvytmfkMJsOi!#&K@C==}s`)?gcV$X0-uS%HBm<^992!>D$1N`QBl zd->zD(sgEyHyZpELI#5C>-Xc)NZrANo842Vesbg9N{sp$FQ7Mt+fGM`rJn?kG1~H7 zRlc~9^!N>4TR_u~QkWVlzL9OD`dbKuyqWfGBSZp9jML@BeKdc*dhG|}Z5EA3!;DV| z_vLIz<%I^EL(MZM@TYs(%6>Wj9PhZD4GKg#uKvEsUu-dB9msGuES{#lEU5k4$4YqeeRf3%r2Mq&p5x00niFuf6=~KHR-p8(5$i2FaUFch%I)IbEZxsDuN(RsDZL?h?;dBIIx$bvl;PQhQCIAq9O=FgM^wopWCJE@Qsnz=NMHw)1m`X^ zq~DQRe;Za{*ZGFK3dzVTegHa{m+beNHNK%0tH@y9Yqqy5$|!b#sAiKS?BgnK5I=5G zbHjQ=((-NjldZ>Wj3(r_@0^i^u7W@FXg=-ZgX!idk77bq9orbXW;?EMME^*YII*Cg zIxJ`@&z=%zbh8L5C`MrNufp7glF?_NerkhytOWicW8-Tu;s&Qss>sySi0o%3pG1Unv;Iik# z!THYP!0REN>GLU66(o!o*I&2w(nHrMq)Wn}sqEmL;@b+-5}BpZ3b0F$a?S60!o&JT z^FRuUH)zX3`rh}n5l_ksthEG}GFJblS^u4OI z*m}Sx%}W;OSrPVEs@8?ovClxW1A9^CST*+A?T3^F)2s+>vAi2M9)4cKYng>HN8h5nYE-P~ zF*UaL(dn@?9SdihN(wVAnzd!qMb5M!q53%7_--xD4mEmYcwj5^pVv+*aB^cjo6uq) z8oN~2dHj_41@!P~wo7dax2A!J)5NV~>iGJ#vvS~oHkDy8$hvQ8z4sw?K_3zKCIsCI zgSk(%@A<8$kHwg7B6Tw&98yeg313E*EcICmf=nsk-)hH^FOsP}(#iAJ&oT{HC(jv+ig2-CA);>9g% z_lM&o^0t4t9VeTAHYFZZF&6EqlFa*`3NPO&yd5AnlSW#CsJrFR(y9Fd<4x+<*PUl; zGgGjGfr=|*y=f);f$423gU2ojGk`lx-Z_%QI}f(-0av4&=PeH1_ODX1v9*O|qi47M z`c;y1n~DzCONSJ2d-@t(P3q%ijztugiJjXxe$b8>8@hehl?%sAJNsgG#8{eMsAO-K zglo8`I$UnIrTba@J7~hQai`z}|K&D)l{pyab_Kmyr`Bp`Ihbf)B0dP`{KyYHkM}jO z8PUG6%RNkCovmThexo}Z15lD(>kEBKgS36logL1v#vXx6j0|^-ZUYYA=s3eEolA=A zm*l&+2JB4QR4C!iEW0z;o!&?OAPIQXG;dC~2F8?QGR$cYaSgZKQaORdB( z{$}kewM}lxj9bN7Hw@Y))f+{k<*Y;XI4U6dNJnK71FsP+OVaEqL%l`W2i>yu2Y2P3 z2eiBmsIAetvxq!&De*V?eO14k)9J%!i{-fUVlxhnxhui}OM!)6d?SdLd|F!)!trk) zX!SnmB}B1hHPypx+G0R`TlV)=_TmHf zBY`kzrSkmSX}Y(3Cts?KvdC4G)v~66?JF}y0@n@2He8AkS_Hz?fLj zs&NcUHTelboe;ip-Y8|~+*onSt7Z{~;EboQT&9(Tu|K~)(@c0MZ(w!dFZ=LatqwPWao!u#pF5<3I)f zF_aN*tfAhk&Bh%%aNmt-r4%OmD!{OKlTBAxd6^w38~D-=ZfYgK{3l!**U6Kf6oQc2 z%4|(^g#`M`>%omnor2uz25u3xy|VRvgL^geNt=ts7Ue;^e@awsXnJ_koeu7oqp4va z1t@8-^YF^2hibPz#dH}KOT1CXtCp$T_19lOfw~tyn7;pJ-o_-;SaO37H|G2Pplk_- znYvZ44~J7l5?+o^xNR5O)MgCuf)=BD6rCwArcJ*zvIdF{?kqD1U8JZ#P@Brk_GuaW z5I97T)&A&?| zu$1D4P3k!tV+FuiHU-jjf)<`!5gO0^=|nK3u0A>t5*P0Mxa^Bi32s+$cV7yK52pEK zx0j1*Gz^nN8>qAt+I;HEYkw2Up)uX{Rl(UaOz%0*u`H*(t}C~Lg|0%~Zhlscx)vVW zaI3!{t?0?wu&VPds%P68y%(&`ZF`ZrHcig&-+n_MxU%&P{W;a7v(uNOo%dzO%t0L~ z;#sK2;5FPz)NT2#dGFA~z9gDo`d|dA_u=fPhgBX2H@GO#X;DqG%8C z>%0|5`vRvobnjJ3l9r*-z1ul1Gn}?AFa4_QG>P)IO|~?r7KeLWFubBaK?%oMdA1zm z%8%dWXZd2~-F~XEPw;m*Hp@|`284_LCK9qWgyvCAR@<4VnEk+b@3^^SrgJ(^h`Zs@gu!LR` z@ndol*(8yXzQ>T?sr{{3Vx;)1aa6;4N*J@Ei2-$?+V}JjTvgZL6Kwrvq1UbTS~BLfq4T5;31js0E<3{?F=_$y z>MfT~zROop65a-%vwd+cnNjYdbqLE3$CJL;0Y8&4zW1WZnT{9P&dI+O>YY`o)kv%L zr`C9jK-J#Mkn3uAD~{tYx8yqhq#t{6(79B6#Y%8x0*WiK$Ls4Gr%le95-;3uT|J-fucjm?gni+*Oxeo4N0x%)D9Zh{S zA9dTzGC7W8bHk{Cnk8m7AtSmN-QS2m-njAUTHT4T*mjJE=Lu>TcCz5NW$|6++&Rx% zt}&mTZd^^-moHQkn>l6eygVpRt(|)yX|DqnN~y^8)A~F+(lN}hnHfp*u|`llC2j$F zP47&Lz~E(3bC3&ENiQe}s8M94nHPRloAhEoJdXNinf^4QwomWT@ui>QP}0~j-#-BW z|4VEs)}-4`3dxICHZA*9#Tatq>vaEJ-j}o8>5ur^e`YLQ{FE2Ag1ylN*_1uMgVOnE zcrV@$QGRP!AAGg87alkdWMb~^5;vd|#?&9TQJY;Ow# zR}g>CCqC6YJkE&|d!Dm{y&|C>&qLZQ)WRga_YyhyYE~kQym4ef;<`rCvFhro7bh{w zD>nOzq3KWkyG{&xcjj9=h~D2yzNWL_dd=kgtBZO;XDZDZ5%UWLsR2o%g-v|7a#Tjt z(coXI0qd(DR-y+07woUIK&(l{s)z1_VddGS-f=LoEr-NV@DF0&6<*aS`qe0cPnF|z z7%hWprlRM1;M^~ou7s_XkzQ6J5uao$ABjtlX_7kfi76>FqIoQJ*!Lz`n{o=1k_Pmm zZ(H@3Y)9mZ+~+WZvedwP)!~7CF=L?f_8~?aaegfQz}pczf2r`Ys^~>x==_PK6Ddyo z$x4%=3(TLSuI4UxjJSL2!`b*UtIGe`)3A%v-Y-9P(Ctxt=XQyRR2MQjMAII?o}t zT2Chq6LjAg>2@!)723aUThT1VSn4gn+`f z{(->4XKrgv0OrC9_W($;bUS2##UB_bLa!~ak{M4)aT#m zd_xZ2iPl&S3TGfo=Uu%dFaKy|1A*gMCSSvCiJs+N>Sv|@q4!JxDm#cp3w_W46Kn-8 zKY{kcG%)}&p4b1~-U&FLqi{WI-|ixoO~|oBk-$zjYBc9Qk!U zo>z{{LX2+YMjLCZEZG|V_(LC#CaAkF^!)#n0DZR#IQ}ORAS<5v->x$b%lBUXPZ#jz zmDB%Z2ABUnPWLbU!R32xyPSW0%i>Oi@_#Q-y!#H{AII`%m7a8!%l?d1N2ZUry_lIFO%)L-Q?EcqYt#Xou|Ah5_t<>oM+};1{EYQIy7i3&g!qC~Q;ye~&}6hL&YlT~X|m><_%QQMau7Mp{R&yY_6 zvabLjBM3Gpz-^%`rOIcqXIu7eC@M60>}{P^VxdmSY_zygt3 z_P#kCOxxvuo5>%X2#8PXD4B3_+neXW4dLnPi>5aHZ5DUQvxPRD0dVC_9?M2Z(W6x3 zhIupnBi#ayx=wg=aQ};^L`MRJ+@DqbsFmDM4AiV2ezJyCe+4-N0)gBdxeRwJOMUR` zFL$SEjXV9h?h_+Ca(h_A#TSWL-$<_bM;|T^PB>i48jt=`?of5BU#=*u9H?cPHyb{C z^r@@1{~fYz5-Vr@)MOMt)5(OjsWnzDn%=l(S?>`tWgX2)yp?&iJ2!OK1+w(cX*FK1 z5o)tGR|kj~(1q@kRb)WFQXBs9@W%(;`T9cExp`o9DoMD2b;wKT5lha*Rv^oQNYA8! zqM(pZmsr}_n>^L=vUOeUwrXr|1OukL(N0~j#E3-!nd#O+=YxtRl9XC_5F$jB%q9o!zdyiy=)(-FLeN27O^N`*sky({nR$r>q@i$9j?&@Zxv(4}r4)F|xs4 zP|qz*44wFB$4+_Do?qxfjV86Mfme?yB@;-qJM^!%)Iccf)R1_`=E&n@02hH_NkXc1 zVBqn=tO2oVwN2>G*#{V*2to!xn-2gj0I}$2bR&=^BSJ_cX2c@0C8ruwWh=XCAIqr= zPq4X=?{YTa*%*zkh*8LqJ_@MT*F&AAX&D7=0nJ6|{&#;C@iVfu3$O3nmjl`>;`HmZ z%Z@$U%DggD=RBZ@GEo!bkezIE%w%W^U6YRZZF%^i-L3h*va;f?zc5HbO zh=uJ}G*)Q!TQxckpH?vipoh=_0G501UjSUfbp|^E9V7chSX&V13bg+MX;Pmmaj4$d zt6{g9_RZh-%MJgQxB6~Bx0DrTqAvN{>P@8;jkJs+DML!VnS0i%=X|VVpGw=Bs2%!D z3Evy52rOE>cz4Jc@fCVI_tNO@34yh}^M}DV54A4^G;>kH2Q%uM>JZ9p$MF&)S=&Sk zeI8BOV%U#Ih>a@9kZ&5er+r5e6Y8W{VvW<$u%yPi4gGwJ`Z}qq!TA%Y?Go$Z%f38g z-exDOvd>CS^uR)oQnW{D#ev26A13>PPI@SlEOkudfyalpVen5v!P=p?)3r%R>O`f; zO`UyS?c&j|4|+2d+@JZa{2Dh74(v$(mHJOHpP-EG&$yp$SOy`g7GM zb;Ap9y|V`*4zJ`8H*+B1qt^f`f`i%0!^eAo6xMBr>+t%|7<``9f+izcprO3u;v2d1c(6T40v4kBprI%T)SGzK8F)e z$D#H^2D}WY^kC1LUO3&%P~$-;uD z5ghVvWAZkV3mR-wUWb8)N*%Ayp1*7Q0iSB3u}sIyp}Ak`w>EL@^iwJtf*(&*ME}NS zOBk|i8b7jIsi(vH*C4a$p8x*QoX(-Xbtfz!P!sru7xK^(L3}}3o~kXUCoMprcZVFHvTc5 zb!Ot5bwEjAkbTbDz<@_sG@wiYYS?r%_4C0#?vcnh(-*G?5hm5FrEb zJdjDvdX$qPSxN({=MzM198M1rW%~M{XzADmrbQrA9Bo(ZW#U&OfuZB<-dg9b&>dqs z3+2T@Id*-&yH8ZWp8^zE`IU4ZMF>6w=r>&NARFo^E_i;eYI|=i@&bN1_K#oDY$P?nI2BmXhzeH0%EmvOz`Gyq!jQfCvPsD zMpA?J?n{c=@QXpWbyw+f@mB_vTJB}#qiQ=u{gn+hxLK0Wi zqFp(onA&h9Nc1Gz;5nh>l^EF_%OY34SJJ6_PF#xGW@G zkoW^p*ER3&_@Qk15&2m1m?}Ow4m09$34ouJuiQ%m97BNAauxks8h_E%74^MZ1Q1;c zD0q|&c9{5;JO}dak{zNMPt~OGjh*CR3q7brc8TnM4PJ_{)RdC8m_3E6aoDZJ*SC%_ z4~NLpx^4z(dg>y42LRFALNAo!ASbu5gCpA2EKK-X`%ONlEZXHaJ|_;$T)&t+`fPTH z1C|U+`)b9Mq5<{OJCm!ZN02T-a2>F3MD5jLbA2zxn5hFhWW@zcuCSfH+SL%?7XPYq z@1>T38a=V!mgd-L_&_KKc5z+^%cz;_N-q(04603kr`TL-Utl(oQNUA0JVyJNo)_V> zxQ>#fJ&&ARhw_lrw|yJx_qkJ!;bM9xy+W)c#822IWwf;pREoXfe94#hw#w^(NpRqV zcc(X0X~z0z>|Xe*cHP7#1A3njqG%jQnNcLTl!J?=lOu2YOJVMf5lturwU%U#MQ8h= zEE+>T-FSPC`8MJkZQL;*Yc{s%slWlv=$B?+?zKm; z>G5%Xd9+SSm?HkbSZ7Lu3S5-}xdmw_1a&2MEp<5DK1%ny0d8s1%VhADc@No9o z{^gf`hy>{FSkEH#I=MGF5b#QDoNW-1os{H4f##dEmF95c&(E1K`WMAt5x~BUvo%a- z5XrxKq-*SFq~&iNPd7Be7Ulg;wmhDl1-Q@=j6sRW7FXHID`o%K3g5@}(bI zaX^O2sp`aNN5D0`3#-L|XeTZrx>Tssjvz|5AXL*5%7(EYVud#xj~1L2`NgQDcgtR= zjwH0AlOz6g(Z+fC!}3kD{RQi_3b*c!2UVdCH^!!NF9$Sp_)n19Wz4#7P+`~dC|d$I zzUJLn!#K%M*m6Fo&) zv0hQNw>EHfjiPbAGW6iZZG|wR4@XICE}h2n2#^`2@TV*DaYi;uphGO+2VCCAm3CZZ~fJk!~2!!iRll2=)OivfVGxff* zOpu>WF*k(9zOrjFjeo^%ulle!71CQbqs{&b-(Nf9D5a_Luvp?TbFY34h&?&{sR)~7 z^p{>vu572(EiWLZ3g6mjC%&0KZt#X~G^qx={a8_~Nqeeo1HcpYujb8RdTp%O)6uM= z^vczu8$0zkeya)ZRkQ^WiX}W8)N#@J5|KJJfwlku!*WHRw!=SG%}Z->uJC3TqgPRf z3rDMij!)6W&A4Rjc zxbQf_G}`zeAD?~=IW9FXIZko8Wo9V5yWokPcmw?*#S*^1Wv;R%=qzRBmws*KM{oSb z$TQT4Z$GYLeLZGw00IBF2w*QWcPAFb?;ikK(zw=#=b88|ha}1$G7mqU1dV%?2UFCA zl$RJFb=r&~f?!{Q;gG|$&8G;Vlmmac%e<_;tFaMuVr^sqBN=iuw_bIJDk9pLC^P(> zsoA-J3C+7CoCulbhYQ1yiApn%#}urK%hh!_wUfZ&f|Mg6`$1cr-+;GSn~MCH);TqM z*1P=lVtaOXM6HW`Va^U3Zo9J<*wD5C_!=D_2!4`5o_f1@{x-*)s)Ca`Qwiss;27XD zpelCL@M9OzIyC{DIP)$k!{St|u_k~|MNc+5?83E*3ze;luP}jfhkZc{<>dE|b?lN@+w+?=) zZFr6)o6z#srpZb6L&+uMHRX=V^O6Faem9t`ZGU&pU+iTbHE*BzW?G47gMt~DKFfx+ z=Qvv3f~8}vv#xo#92d7GlSkud4W`+CmOR*1=RE0?=W44zkmZK|yweEj#4>*X(u#rl4p6Y^0PNPZgF=>|#(ry9!Q;2knDM(SGCejY$E4 zg9FESA&6pffu2x5pQtE#4jq1Yv~ynKt3z`@n3gS-zX*1EdB=!#AZm@X>ps3fUNF~( zdcyS0rB4F6o=H)oSqd8!5t}S6a?#Da(hvL6P1H&E!l_bxPILB2KpG@pEG|J(rkO9<|%`)QPIq}R|rC} zNt74o;`BZo68;%$LC`2X-U4&y``n}}oO_&y;l4B0YN25PY@UHibdDtmM~g>SV?yiY zOjE-VzKtdb*lZ@4%DFDGv-)A3&W<{Jy2d}3k-`fapqZGcbUg@af$$?J0B(r^3YkD{ z$IOlZ7Y#3Iz%gfCorfXXLi(%R!@vXN9LL=9JQKvs$nv~8ld02SIhP6I381EW?Z7OO zob{x=7x@Gqwh<%8y^gM>*h;sBinjz1pl|N9(sZ69-Jf1tQkF_bfEQ}icRzuH{7)@u zhi$*>$PKU|k1r|sp)@r!6g?)~5>?3?kAqt9=il%;Pd3;r1h0%CknMXWAQ1I&x$HyH zpOm4~x7~JE!!}G5-N#qZWTz~@#Qi(dT<)<7B}ms#7f_WuH}4g^2kCs2v@SMXJ}q}8 za0)!Utr~G>Y|>u+WX60AxB@f+*6zl=xN|}nK5&U>Kfm@d^1QHR%O_>V1PAY2AS+oO zBn>6cS%?+$D``-U5&OL_X$% z1?SsUqCl!#xNv!WFnK*ENP&&qUh5mm6qqo$FU8wZ_|ib@TzfnzT^xH_8pRKtc|6RG zgTiM{op@20xibgQLdNEkOSX*Bl7YV~=Esv5Jt2fRpkq)Wv=W0CC7+*RfY!f?Pn=EU zu*2IKgJ-CWcY8Gm9WQRoX%~xAbv@Kxq-V&JMcZ`w)U5Zn?}U)MMGZ1q1@Jyh<(>A0 z*^{PB%9;mT!=^&8#TotBFQ$b-^g3=L>o=7+*8QM2pvf$>jW)B^orTIYgX*j46k)y^ zXbxBM^GNy6t(3D(0ZJb^yx6CzMOT6G=}g3Igy%!Vf93ev3pA=WQ7(U^p?6Tnn}Csl zhB_iBm!nF*ku}*B4uFRvudCvsoOQy*uIj?iYrXm@ z#kBo{aVYMU;VQTBZLs_Y1RD>hLN=P*lsybpu3|-d>e03nyYdZ!y^`QjQM0>0xw~k; z!%9ml3J&eVvYj$6C!9C2w-Xq+ra)2t2GL28W03H_3TVY=l%nsaawKdUvks*HaHDrv z6{ST#T4!7n>r>;&<;MZvFQ3{oee^|{Ki$6KR!q!PLKH`y*f0CTa4%Pu?n~+do9?E`;dk7bNeQtPCsq_+nHjIq z=&3AAa;*UT0|?&lUe4zG(CpQZ%^A77BpFD(B{7e<0yy z6pw60dpys$J=IDywfl0PI7YcKY%)a35oqL2^RndHalg8lB@pC%PMsHgc=jPg{acR$&iNUNwedr?uzpIYca$$0}bgImm0M;o9&q;+Ev(XcZ!&5?q+upK=Y$CQ7*no=2D9dR_#XU;=O1MZVIj&9jVkPCO& z;@GXD#d>|ZEvOJ`Zg#|7q0wS++0?U5M^sV#3v(`M_78M5I{DY(na+H{3jwc>hJ;3o z{(ZO|p~vFrwJv`KPgIeUba&#=7o zdv}pm^60LvCl+{c1H*a!J={N2^?&|#7~R}^WN6~r|2YZi7IT;!&?=r?aD)Ig_EyWc zZ<9}FDSB2J=ctTB@D12rR-TKclD9K~ZrIJ>9iSFn3drO;JjBIs0sZ1Yox~Gp%FcHm zFKeHu_Qc!u>+B0;)&V`vdMzpD>D^qmT)20y0cK*JcF|&rU5(Im-{7djc205JbswND z{s7B*1T;>B1df&3h4zW*zS#Bw+K7(GSN!xD7u)a;KqH4j7&X`iU1}HgR>l(bsLG9h z)EB?mBVDo`l6lGD#R1UA>Hq7l;kYh``bmsC?6Uu=xwLudd!SEICiJb5ecpek`rLo! zCa7QmfUE&_1IYnulkgX@K=bbiF>Cc2&`ZQY;R*v_Qez*+L(iE|Az=W2@=-UI{cbZG zFhvzt2Gxewfued%E(EqdU4PVV@^rY+q#8-x?Ugjn<`cTwb&i2u@b@U75zp9uApSDt z=!yS#O@a!}KuLfPYcH8#*O_BR0@bZD$g4u*1FXgT?AlO%ENd{8;iwY|m8Z|TCnnC$ zSq98h8Lu_Cc`uqa920gpebj$>)J(o8ii%|yTIpqK244cS_qTX^09|mg9}d;uuo(de zZ7lHU24G1X$<#f(WsZv9(Jt9%4(`2Rn6ZQ9ilK#|WNDH&nnBS|`cPp+hKEmT>zR7;bY=6Ti&F$}5{N9yPvAoX;Q3A|1&v z$ezdpR4#aqIqV@o{z=WpQj`hu+Y0Xg_-^li?Yes)&aX}RfFO(k^wq*aA$^xRw=tGl zrDEvsHFGSg>oxPM*}enB#iH+ZJuD~B*&a0o#Uh3ue!YL5cLhpLHCE|P7lZn>Nk0zV zSrldw0pq?^?`Ir!`C2_6(nnKX2zWq)mN0=>Ay0|t)E~MWl|aAS;GgVb4R5ks8S=OTaB|x>ry02>q}v zo!c5Vq4=*ai^U4s14c&LYic?kbtX6zaCQxvb2$-gyPL%WD!7Y>2{qQp&<4sE%j)k! zUQM*296*)CNcE@z&xE`>e)Q82XzW@whV0ZqI>OSSXkbknIh^HZTAJu53Hvo7;=X_< z16;^|{S@ieb;2ugTWO$Cw3km@_%1W}9Vkw5`gtl4mzkhn1e_xB`+Q<{a?)h-p_ddd zd)l9Q7X&SRTxGdsPD>7Gzps zZcxu8!N~Miq7Im8Y$)Hbo+4OsB`4=7BS3X^pObTZT^Q5+g$4RdTP^5)?`p2EQU zMBDNcXmA?;>Wqf3AiY}P0n}Gdf%2wm*jTk6#v4r=fBM?9?LY@M$sZjJGy^$~dP;Wt zt5N6ZC(ixu6g`IH)3W^$;iyJpJLz?sjR^s?gP~!Nf!g>!ZKkO7KmOpqE0R5xmrq3~7PW(n3WI&+q`r>SUyOXOV!HHm3^?=x?h4`l_urtB!sS zqjf&uVeu8OraFL`j-~6G2LKx4sos9&yBSFu(JvW8sXI=*^(TMoKIbaP1)^=<>gIlBS*$!4P+rf-bicv7WIYAV~fAaTmVKT=B8ahd_lZ|1ARJ5kQi1^M+WVQ=k&5l5x*+Pd{>7yqJ&#gUe2oR?*o%d^>T{{g5;!lR`AHIU%@ zmnPF-zrZt<-*7>qS2*=*v`W9&Zk@x2v{lATh`uDnZcm@_Y#j64TSha-hfoDSb8TPv znU&vaNatC`maV{tOtX5*ykb6JYR^*%8KnGw39vcX9D(<1u@d%d4UD_q`c(*j=UB#AK3Am68!Jzj zK<{}P2yZ_$DGO$Ufv%4A%jLr3w=4HT+8!XBd9v+s|Egco2_RY4|kx0$e>iA z%)VR7`)eHb86cFe5N$BM9*`-3V1&NJt74jvOU9|q)bvQO;I ztp>^7F+Pt>MH_#c*4M}R#D=9`xOP7LwilA6Q5D^Wn#YgrH;FgB2KvLM@uxz14nLxJ zJrPydmk=AjgYt|Rx6QAgf5LM|2o~qJpvBTC(S+jCMj7jw?@6;HImT?FCv+-UKHwt# zjz~b#eu_^L9Th_s_tn)(+hNqkpcKkC7=z2F8yhfTOlSR*4@ikRgYUMZbh=0N0MAWo zg=s1K0EMVj#2&Nv*{6rki!k=7AB+e8P*E=8oe+k6@x%pf(0gf&ML+j(7nkl(JTz{e znZPK|cuwYv4+)9XE_~kaQo}6^0roe@M2HZEEbrpw_FJqYOtZYV*cmob)?u5|dljfz z8xIqe2c7n7h^A;xI=l`Yzx2d>vcmNk*JzBDg*t%yB)2Hn9}Ph1Un&1VPB`0 zzI#uy1Z5uP&}K$RV9M=)i3Qsr62@;|Apf*j|4m_x)r59N!Ilzfoiy*=vM2bNH*3mm zg?~-Okh|5StFWK8d|6 z^m6L+uy%LP)N-9Y4x%6xYl+c_?-_#KratJ%D43dg-q_ukaz~g7nOvqpyRnA~UzU#X z@b3-2M(H*!GhJ*C9d<)*90m%fpNnrNVpm_yT9U#PdB4ln*gdnFmEw)W$sd$9bAX7| zxQt@o#t0eX#g}%F7>tB0Pa23$D2z!rdQip+1*6>I>cs2BzukIL{uRmBa=r+=tnZ{) zzxHJLu%xryDdL49WG;M#Ne{;eflg$z|CzE3M9<1!$ZLug>(|x|~3sM>^#~02=H*F_SHV*_l-4^@U$Q#sYT& z<#~zDeymO=uS;HknuH<3Mq6>GTB6Bk+VAsj<(A3={cflJ;@Nx^3!dN2HG?U7sXHn! zSB6agLBXDsf|gNkHWM75TW1tH!lujGf)VKWUhgxXCOhrI15G)fEPosbV0G-SpSyf~ zQd0_ru8o&y@cJ|;3__a|5!Wg=;&?*XAyZkw1vjHZ1t@Jc&!qMRi;5^d#DK}FS4JX= z;g@wcm{T?j#RXv3m*24ZZqv*1JPQ2w^nan+lrK885(YO@=*2%%2r)b%U#D088>Rm5 zF%QzwzH!su2KMEfogDFHh;V|n2N2*__HV5GpRfo4xA|$%=kua(9L7wze+^XhALRV^ zM7nLdcf+s{zUlNvfrhoPH~U#ln0COuo&PH#Z zaj;p|ghT2ozP>&BFh5Z#@Rst-8J;XrafdI$EuQIOH{iOGUB9MN(6Jjh#hP|YS_Kdp zX1*@>!4}{F2OwrSHB?au?EMW8-O}g9De1t2F#Q|&N9{q$9jlTlA?}|@UEy_TiE!l} zZ;p1~W!EEa(E|xf{^6b8T`6zZwEByF9+5)R9t>8Da!7nPqJT%a>3neB&4J`M#Z^d9 zLJAco@+~kAS-d4)3OfusfZ`-5{r$3Q@3pyu-8od50C~Ps&ZqDUr$}>|!F{fJeNt(C zWc^OV@}}?jOUuWZr+z&rEGa0!?v+4opF-HqkG;S~So~_S zy?I`lvuO;3$(R6-x$-ZCa9Ki};Mj|&Q|#qNH7|906PT6j-&kkz+daRq+^le3eM|~} zIbEn-dio0t)yX4JWsK_$6s|8_)F)`4U)N&L_Tmqnr~-osrCTm&S9)C1Y*$C8PdwafthRR zgjMzhrs-ZodL>{EV&QMo#eLjU0U;49uaYJ-oZ+)0EV>f+?z*b?{evW1O8M#=>ovda zJ78)Qr5I=@jqywKTKm{+2vWXYf>1r06d7yr#goOi*uL@2*H=EIr>!FGd)h@hrl9CZ z+O-3w@EYKNH&&(WrWAEA3fo02&$!^mbnQ6^rfN+;ZP-`|FOv{DUnY(>wA0iAbM~Xp zH`OLC=&?=Yad@jkOI3uS(VqIQ&)VmF-G00WQ-++grWjPOUe{_-AB8ks7>bLYjG6hK z6*M?cVrM?D_ElXuSPk|q`xIHNYIj}XXGI8M2;9@B%BKlH1>K1bfQYC7U`*k9=MJ^V z*r;u+=#G$aiB{nUNEFB>_>mMVyha8G=zqxrqFG|_8*bj8@(bK$D{-HbDxmq!OrOJc zcm2rlO@tL0>@FCiUZtsEnn*CS3=x*caM7sa^=1nHz za!7F*Rdcv6GB(Nm6_ix9GNPwK^ddcO2o?xYe*|3shix?gF2jisR9{^i#!fVJ9Eueq zuYpxSh`>0hB#EDjLir#QrJ3*9G`eCC02mlFp$W7>;f6;WdJ@w)8L)An+u$!_h9w?;0%7w8He=2J_*MDHgU0ag=YJ7jr zeZ3ORporFMhM@UE3PLyz8H{;uZ;d9p(26=!fEUoyw7U;af<8*rA-x?ke|ZI4jeE2W z>~$vsw|w`)TL3kdLD;){4nXp^Wn94eEJ6@Y&r~i`nQabgDnD(bkAx&4tr%49pabEk z20Up#(|`#0VC&WK28UzE#s@r)IdCF|_-&^FZ+wU^n}Ge)J6l7L?c+zil*+jRA{c$i z8CjT(n|-h3%s$R|h#_c+8iX-=8hAia^%kpHjYay-Btt2@N1W5zu_K8)ATCHD1EdTFKulQ`sY#U_s`f*N2Vm#d zVf!z{{V!uWMHntN+g72#pL=9o)3f{Gkm{u7E#>dewU)|f(a%nK9DOXULp2wV$&8NS zM$OYAQ$V5AmG*s#l&3V<|N?=;7R~L=YV`0Sm2x+&;t%PTQkg zo<_do@d{4|&g1AGWy>+(?|J_Ecs~#jsy_|!fDY{uP6F9xdKjMdFUI98KvIgTt$AU3n;;ell2$>tBxx5eNJ0yUCehczZo@1q&H$4^q zXRD;?p3jDEJ}~qi-PSa~(C97&Nr=A zg>KG}5imxD)&O|Bl6i~sru~VD6g<(6J`Cg24;`$F?+TPX$EK(&vur-eQGHCV$$73W zO}a!}A-Z$)Zf5j_8`ke8&Ut7iUi5b1$>i4f>O>Ob^aM=!x6PpOq9vrR;OlyCrEz8t zd-UN4s2t*Pz9$fR47P+hj-~g<2n4VFlEsQTIXHd(_~qy)X;jBY!6q9x>h^$~wly|x z@^&+hbpYExg6B;;dNl*s=8z6KH1RoD88v*>n4YlBD78MCQymc{3ZiYR06EJ?ksXAQ z{*{zY(=zw5m>JRt`wk?lroe^FZ}iuU5BXY|nf@4xLhTWL6ZQX6{)$To0Z& z)3gt@n_UxzREbaKpj}e|WSnsx`3{#Lb*~QLU5onv}80J)KRBKDWIO2-+ z2BzC=NV0RZSUi4EJ82*%_=m~8Nj*(YnPw29`0SYkiyE!sm_yav= zu8UMS?IszSi6-JWO0d)O%Sntl%;`O}(_0TBDtqfl!%rQn`h|tjw|OJo(UJSd53CfZ zk`At&iws?0B;)Q*k6`bNoveBcw#kHd7J0Rn_4|s=RID1w><6{4EJ@O*C%^(m_+w)@ zrxxx*V7Ky)D3r1gS*G|w)P-AK^u2BI+}}%msLsC$w)Wu@R!M4r9|~(3*xt&1ZQ-fKc?kzFTl31 zPj(*{wX_Y@Tt%7G@cg!MT1x>o-bxSD?;I!}?z$mFik3WVoKt2{g zLsc_tD0iE>CVrikWxw@|?9uYhFEVt~#_jb!{`~>^0UH{Ve|YxpB{WH3ABq{xsVUxK zmp1lbpRE+zu21P;Nhf7v$69G|L!>g(Zov)-7Y_;pF`A4m&ukN=g-3r?Mj=* z?Vf`@@1e*nWu@e=BHhv2h<=Z2pg#Dbv#wdUfL*&ubqE6}?lBTa=%%~5n@egeT7pt& z-Y3)G9$Ba2lShQL)!J0TK^cpRM)l%w8gO_QwedQtQEF5ry`1bbBPq*bO~;tKLj&tW zPbWpPn^s}RzFPuVUEdwLfxAw?g;SIvW5%O#J=|;e@DU^4SF0ARz(K^;{W0qF#keSH z{qnr?z)zQMWlq_Oczgtem+53EZw?^OPWv{sJe>n!gj^NJK1BVaucqLmbKbyw)4yT< zA1DVNR?PDJ|M)xF+8=!SkFdleGFfBuU0 z*I$d!RRPR%w;pHfK_3Qg@9>;*1_-a^5cp5ba*PzW$O>sbNC^Itb@G2*s8&fsxD-<~ z|II~#H8Pv^eqQMP{LllE4_yRq%-ipJi)c^sS?|}o&Df9E7R{1vX5@mawkOIN6=p1{ zk;9H?QpCbKWz#4f(A>F;@J5U7!DbIPxrWkujH?8uzCmqc$EP28IzoB{gEX z-=&%7$BF(~Sv-E{t`RQ#u=!OOHtEfK$n)E8X|ic#NAcm=v6}icD3(HziRI*K-O&_d z)%+{GHxCqHOmb?(7A@}3$t*}wp)RaH9?=l{A_(+q*ikeN=t@$uHpQH25R=S`ta8qF zyM3^S2*T$Qz%^8@5zF1X`E76k(BeqXjf~x=_73MopfKXTvT~7*=Y&O33uah?e)Vwi zp(2fUIN7@3trbu!X{MSQqR!8(5JNzJB31cRO&}a`85K^Sx2Iw_=n0GduUDD%oxfw# zuts!&Pon-cRJP+jC%K6CeL>3yA+`ucT+um9Rw?0iVE$k4AI%K`*y!eKyuka<%bk{F z|Lbz_b#@(Q%{PX!5Th-#9cY=J{Sv=lgg!)wLIWqmW)J-FWw7O}e`xwPLsoar)od6I zcHEwZp;nV&so!*t`fd)gh~?>K386c~meVlH#k+>V`SjFC`9E_iPkn+ul23Xff*%#7i|#g4FJ5zstj1#R$w zl_=nWd+07*>Clq$q?DQZxqu6~%kI47o!a@X59$HFZeJx!>TkWYEr$EX!Zg41rokrX zl~M+Z7~SNx-vi2|kQ~N$Zpu=xxL1NZ;`vzRt7u+9mGSVC?$AIOb!_B4@J%tCLBrb_ z;2c&#FJ-ez4su2Peg(QbEw|xhvxO5;*(cN zURTYIO1 zT)W&9?(^wFsJ1!xnl8Qb?e0#ZkQc+x=_7rZkOE_@vK*LE5vb&n{*6pelAlFavVhe6 z1W?E;9<2O4=4F%)x|IN^5uoV5)s{3~P~)-eW8Gi+t|1OMq!G}oT`FPL6%`L!iMd!HGae^A(_^=`mYa<4nOlDuM~tfjr#=8@-9&Urm$gUoZ} zG62a<+0%fMh%YPSQqk|mdAl!YKgHB!KuS(XnB5K;8hS=DU<%F<2y=yutJqGIup=WQ zS2)f~6hcAg84u{|6!zTvv_11p10-Y@Oa$2>dXay{;>#%ZJ*uRslyPlXZyPu`(RSRJ zm&pmDi9ZhKl|HbCa=KmPb=+5K!JgIR57Qp^J4^A)_rphXE_=>}6bxeedyWXfw4&-CA*Qj55REa_h zm|BloVOLc)qk5Tg;SN6XHEVtJZYc48L!;5>ErV4~DG$!0XqhL})RR@Pe7 zHw+mM&18I$R0`<5)p%F95$7VKF$;&G9fizvmE^s)-IM22> zeTf7JB8tDd015O}ntqYQY)lqC?+!qL`=zfxs>jm=oOF>O;$};YF#V4m`G}EpG!nh0 zq`Bn2n^DjN$iw>ROhEX!8FPV>OaGH@t#sJs=i?>$krxi)Z1aU7S1Nq*ZpmkHkNgkh z$F-Sl3UWs*eDtGJ9vRkDzwcxtRL*mp&7*+x_@C9uh5S98BPeSf~)YJ_|-UP zZd~C$NbMD@u7E)9joR7_i;%fQ9S+nw+KfrOQclI-Fjo){Lfoy_Kf$9=36ht!Quu7L zGx0Lwk8?OWf;K$BLnj_Xc$pE~EG;cvAMLfik;GvrGRvV?^~J$we7rsF6hy%rYb-m> zz5HEagLRP^aAk8W>~~(3*Sr2Rv3p7(oZ6bgS5dJqudU_sWIDw;C>5=X{0+5g^=l>7 z?nK_B?*5>$yRuz_>7w~I+lz~fQ!Lsg26|j5_KHq{b!#G`w@_4s&Y!1kH9hV*50+!jT zS4IhGw|w1YM<2yDs0e58{q6}Ua9N(doC^81XePr4=?tW6nw==>_+dtCYvC0H%2X@d zU_379uladn@1qTRu=oz2Ywlqp=*$VHFZpP}F;V)r2o_1jqyuh|@LKeA290$-f5{C2 z=A!EJR^OJ>rMKgWJZ9tZ12iODi#8*NPUcgp!gx=+w z2)bMKEUA+*B?c5gRb^y74kfzdw*0l4;p1`1^t4g}al~r+E|2Y2JvT%#GvKmPd*ydh z#_*B5p})%LY%qU9Msa(-$a9DsPBDXP@}NG*zUp<+Bky?viZUlpff;LkYv;JnUK;INoNoXQ}ME=cVllpK)TLT66{S39G=H$PgG z!-ZDUpLUbU0XFN*tAV19@O*E!&yB}g=qeGl3=j;F-rkSK2}yH4(%##UmFh8yJ03Ax znGhZJb^fwGk*5xAHcGvf+KoUB@v~#!HGZXD%_g2=rO)zZOUs;Wu6%8+_mNW znc=55*Lzt*dU;;|`73L{ zSkuZh+>2LfX(i%wp+aZ+O&x_n_+D3`h9k25*B7;poP6v42S;-In_r|lsYYLLTa3T{ zat5fy>`^OjE9z3yNpT$Uab1N4JOWRd?OT@OGj6KZ_r5tU2fwz!Gx_nBN+g<0jRkuEBiW|v!4`(i|8_CS5Sdagk>t=%dl6Zgp*MlFQrxBtM znAaMbmelb0sVn9?HFg0VN|K7kn)cVlsbiGdDlig<)CohJt2rV1uvxP#&Z(Ay6s?I@ z3bcLp0oq(w2R#W>UVaYRu$JY)GaqY`fVoP$PPZ z7(Y|zQT(p_qHVEvcsSbpMa4p@r$Na_5Lw(4tpkh)zgsidFzO9~XV7qB*5!_7Qn!N;>rjs^^Ib#YCfj)YPo!OJWcfj_@$cmCrs*u3>sOR{+&d7r4x>78T3 zg+nHQ8)u~5g;g(%l5Ac6aUa-Qa&5T3EMZp0hGAt`Qs1MVW>pMaB1BZkpct08EY_9$ zB}bw1m2H2iJ26R8k;Sb`^Sww;;p3@0Hm(uX0?L%ilMx&gx`SGhpfzc?swR{M-lMR2 zT&He`rCh1&#tdnCy!ZVQ%eG#0t-uU=lFOE;_&I!J#MRs0i^WPF<`L0GQWP#m(*Mtd z#~1Iu0vQm6z|Kdi|Ta-F>)L!D3Z0vBgbIuVVVZFp&||!>99i|VSmN0Zx^ctk z7P(d|Iig|@vfVo!*wJsKP%dl>S>{DW7QX0AbAAZ3lmfRjds(y@`D1MtB^{*@Si0-4 z>XFqvWfx2r`q!x>Hj-R} z*d+uoLCj+sk#m#Hn){bMkI&)=M_xP?SBZy-NRl)m=E1Fb=zjX_p-*F*c`rk-J1A$2 z*!EjbBNJIvy`c&rRQ#n28em>5|FV?w7OQYq3+pWsk_(>|6R1RZ^u-?XK?JbXj)(#S z^v7_tX5&+0ytdV}Y`_Q#&DqU6!4ez@tm+H6V|zl(9ztEFX2S@M$?pC^f;X_S=Fwj$ z7V&rd=`7uRR!UjK+sAYzAA{qqM*fRFh|*PPd-Uh^|A~T27ff#N+#`UJlmInl?fL&v0v|QQuz1}{xBIO%!ljBwXIUMy2gASC4C>c zgR=pT@#2Y#;kivK(pTfcn5q-Idy7QD%&sr-5$~`sJ<_16O)lzdo(oR^*H##7bj2p^ zaO4c|d4fl-CXnwm$O~I(*&nbkf_ZHkno%1?Ev~eKi2v(!-^gaKIU1~6iceZmTmX6S zw5*j1fO~QclY#$rA9F0l>7;;}UiH7m1weTcs)s=O`g}u0{LL*;NqTFx`<%RUTJ9eG z9}^%`$cf=*zW99lkNI+&=-z+RP5-~K3HvuOkpj0&ce!CnZvDlQa6wF?Zay6B$dqnl z#@@8padQf&47IaFQ&+{R@4R1^(|*At5x=2E6b^Mp7dQ>;nLv2024Eq2YR@8;F3t`S z1cb2DQi$Vdz!I=jAgmF(!#RKMl2ttW*w&>#J^uM;1y~20Y>%%A2vd{Y&y39WfZUU<32D zMUC$-=g#I8*?&KjFQCvlXJIjO%l$*Kyr|&yof7S_aSRaGywqW)r|Uge*^~evPV10;kN&edtN&P?e3w zrMNF}nOvXKAE;h{evI?LzB}nOEfc4jM}QU-3IQaEekSt%^89t*>#yis zGs4a*;T3o&Isq8X!QeQN_N`PpX%vVXIHsz&^#$m@$fly4kPA<5ErL0DwF1Yzc#3W& zNF$t})o1168Y;vadG5YFNsoa`HI!-wRC&+?L#*52UhGy$cYMp{2%H_31neza&4@Y{ z2K`;x?cE+4egG!C#eB1$^ZEcaWD=y$Z6;ec_+Qq;J82eXK&weoxmkA)sEmtUJe^Or zb#?1rWq}k_EqCaYMKs=?X&~&?-hy<~8tC@eJlh-P4MJF5FR2%T(eQX)847WhOpuE8 z2P0?l*(4MhHR<8hBd_ZK8~&AlER}G!pH*KnJx~}&_MM{1G66Ts%Ln0pAp3p37wX@d zaTV-3VyVQ)M*d83X_j~8xLYd;w=ktwLy2hXWSvCf{Zl}DE!KD$=80!?D&woB41Dq9 zjGi;r_#J;R2UmRE><<9fQJsg2CGj;5yW2~%lLw*ioj)F%cy<4J15M&>VX{vW_(157 zRxEMc^;~;&*JpOj4D5VPNT+k@5`NxIFmSU<=F1DU3iGBxi^AyccR)*wLP33?EGrvw z^7UC((2fu2&;XW|UXiI}_y52OsnDC?eXmX;3js;-tuRLF91cG&vS$B+$XcW)f zBT!#_mW?1Z+RXw^knylkZV1@}a3V^iwWwllp9=?T?k_ zj`*SJtt99%&Kf@_5_>NNPTpYk8^nOj9IqR>TvM};bGIBd4E0+aQQFSi&!zxSBGIj^cOFL%oQ=Lf@`r0 zwEXHSAVTx*<{C0r{aRPBNuKFU{|S&B`5(XRItOdcaUG(UXp0xb1xJ@y^}JK6ji(8I z;l36zSy7pGtqC|=C52k`iI}hL-j zxjSsWvb4ZrRMWljjjrRjPl3J39!U-ykJ7i8YqPEZfiu=B`0;t~xsP^@4|jwRC6l;8 z9?jQnLyxLNbRydggHsTovw<1}>w3vugGPwt!5&PBQ5jzu;ENtjb|)AK`zx**2{9Bvj#h3M|jvxEbMDz zm3NN2<>r&RH0+dOY!b5&LaN=M9dTK$_<0mSa~a zx1-P|Mg*y3Mqbl0nah<&v!61Yo~Km#o70^4Q6$)@UW5M2Ex*{;B$2GBx0asR`hu8e zbKn;_r5hqtu(?^>sB*&$+4z3*s2KLZv+f%S5K z$u>ddvyzzUBhfydDXy5`7>noNe5~Tqcz%-+u>V6i{W2$G`%p~!MARqyPd%+ou=MF> z=f!>oH-ocp#c9neP~zHy!>|B8h`V;P9yfc+1qpwXQ%99O>(;H=V%u`II^NcPHTc$vQ z=GJM78*wGCW%{p$+w|AiLq*+bCb@v$)g-*W8E#H-tESS2%jtzz6NFA(_6NJE$4Ef;O6<)QjIU8nRg6VV&)xlIvab)z zaWh!E*j1cnR$($_fOXhuhIXI%&}=*`wQ^Doh9AI-2;X2Js~JchlijR6z>-%46A!ZZ zF@Tn#TOVG4I_4yU{$MSWu`V>q;Lwju!#)S4yEQJ=33;v6%wHrXm_U%cU9m&(WA(ka zr10)2ax-dW#V3b9Y!Df%V*x+ntoS`uA4T;Q)r&*5J92t#&g&#ZosRuL7#1-b6IUt?)cEQE+HB1$Ym| z?m+skeXdnjZ>tiBTAxTB_Ja2wh0BYwKI(z6F!UcHI-sZZd5$bvUjPr}9`v8`iY0lg zWP0jxWYx~Y5)^iq-qv1mH|Wv3!G@N!yQkbq&)pOvy>os_DlU8w5Rq(p3#rTBCCMu! zHkwL-#4No6EtopW)OHmtPcw9EV+$BiIoy+gG_(pWoek*a@q_0f6j?~AS;MnbF`fft4Rx5rAFQ4g&zV*rnjq>{sC&Y7gOk-{3-5 zH;p4SqY)A-(CyyE>Q2pf58qk#1qrL8RaEA;k9OycC0_!P@tzCvWxs}$3}!?znA4vO z-iU0=e)2UK6Gy`#Spb_J)BO0AdhI?^!|$jm!m6Bf3fqV4C#G#4ZUg5Eq4N_GKS#va z)5oiZj*e;9$CETUzg^Acsc`&4|1i<+%(nBEhOH!0&21&0FBl`?Pd{Ib%BQqAMh`-Ktk_zxGIW z+%!mqk6O*qI4CHnDAg3m-rkQE_%qZ^i=7vArEmn}+j3JMeM!c}j~0M)vCI|q$7GT` zcwRLn7K-9r7f28&pv6p2^zlvH(^&3TyeX-p8sTejI2=MG(ulVmtSg|pZ!+HR?6?;A z2uLlil;kLDsJHOAE(9F9k&yh6lw_qf`;t8akkGdG;@V(oo`aqTVPRBxt!R-4$g(pk z1R`GmJgG;__y=IaEPO@$F;!1PrFM5d^WkU7k+Ws4qi>Y{)L+G8AiEMDjIkwueHXv> zv$ZcQHh{et*@f+>*XVOAz2fYj)!=MQe=bsLpGC5)=F6eG^<#ZdZ-=N!o}G*IJE$lT zcbNWDc-k(^^re|(tB31Dw{5sr;Mckg4H=bk5nqq6iB@k2fJV`-R3Wdau;fs4JK#?f zLye_B#o>#Vk1Wty4u~*(_Y^@hvmIwXx@CFS9)BE1a5`MV?3*A`;vJ3HOGRu!IyY(; zH8EI@3}g0UvmdfU4e%c;P1tpxN7f;i6W?-BN6jdqXO;x=v0iRA$Sx3Zq*C)imAF%e zXTK3JVr`t>u~!raA@Tk)FF7cGa) z=F*&yxzvCdP0v1E1uUO)*yzs&Vcy59%@%y`jj(@GW4}ZA6k;ecdy}*(9w%;AS5t^Z z`9^1vFe`tIbrTjKj_K8fJ=kpAQSiew8JM?rR+%`HY!0{*@N#AMNSlXw|6vpGb&7A# zhk^V9I{?6Ba=$GBv1^DqbvOg$pF<(~*5rZW%luEKM1w4WruU0`k>K$=)~vOe+)>K1 z5WaI0->B&KpE1i*yDJ9jN4ZpgUg1`yVnMGvTcQu^A~p{RWWqIo2CNVsmC8S0+N!qE z&zl{+wUg|KJ342tsxWJHzgyqWpxabJ)I6$gGYrL*jB;8?b;D`*x_0NV0WRz2e?JAW z#D)J%yA<8?BmejfuOrxZ;;QzLh%gZ$!~VGbfFRNc8^EV%bN#5_)+4rm4sWt^kwroAZM7FOLsG(0hU~C(*As{YAD$YvE+XBYa4}L-Q{m zQuKTDSc`r?N+8(ACBObRxkizQJ}8W^0s+_0zpX%blNo_C1r(kCvLC$~_%8;y0R0bZ z$nh7OyEtNxc(1?MJBm`iQ++|l9u+{GMn+06Iu7=c^Ntk>;(B~MUgoIuZ_Uj9vhks} z%;WlVQeE=4d`#K-_(2uBng~9mx6n z_6#BT2jN3SqQ+cvS{UyVISb9-Z@;hnLHb@o!_RQpg$>XKRk|}eaBJfvCr5$Gm=pVN zpRz*E$-H{#0SR1A+&2#>!6I`2y+bF6Se{0$h+;-S#YWPOfiSF;CghY0{xyQbk0JSR zjaMGmGkBRj$AA`&{o$as;8cqnyA{uDPKlgX7b=S)$HX^lsoWZOMntNx2! z%S*6zgRq;&KR>XiP9zoq@U@A9s*=prHU%J>w^AHkATfu*uv)y=+^VS%fon%mOrr*g&gi%eveyPRk zpe4B4b-FJsyr|<-0I;P~ut{!FV5W)tJkMDNt$x+Hs+mTBe6>8L6>SC|I5@YdL<4ngFq0ER!;BT(%G(0UA7zT$dhckF zV5XLK&T4WJP}MH|A@@jplE!LYu1XHq2q;r1JGBIjm|E~cmqlq-k%o&Bb-KWOKXSV3m`v@OZbNE4rK)sa~c`gj(y3JmYv_-1aeIw#RcN71%t-}qJm0< zwMR6~HOMuAH~{hj96&II-a#qp?~CAg9l-fRj|rI{Gl5fvvR4Mu^$}FNJ+08IPyGHS zCZFDK1z{jr2Y?=}RbXQ|CuRpHA$U_UYy*qh@We(eG5I4Mon-l=eSBoqB`*0lcgW2_ z`_a@DFt=@Rmo^?mrUc|RFg5|}>56wTP%GYn!$}O`3wodzv#{Irsl*8gGS)vgax!ej zW85=Ag2x4dB}2aHX`?^jBUcezrlbs}S3;JqN3&SJ$XZV7*(UxIQHD*$w*e=sR!qQ5 zrita23Zr=RfCp#pE8;P|V}5*3DM9uU&GxxzWHAe9a1EQOb9!XVm_xcI?zGgI00L_+ zX<`O*L2vDFS)xt{W4|s2D^FO!Y4{UV*-|H>tk*NIkx|Evme|O$e*lG~89{deuRe*2 zVPN^yUI$+B3zyRf;tzm3{Q)FQ*9^~*TqSVmYx8Io>5NX74k$^X67w;3K39nd8f;cJ zo3Bdi$BFP&f`d0yCC)b(FHMk6Z+Bd+CK+!DNHFbjp$vQW4Yzn77a)*>hU=ab*pu;P zW)REUwe@%``WNW{NTDE8o5tmc`YR~&o0b<*Z{viHkF=;H(lfhI$)o6Aj#^Uct!P8AX9v=aPFF#K3RUS=I z)nsSC6DO|$a4I6`H1`dfeRUD7$9_6-z;5IPPP1773q3-8fbzcR#I(DUY}Z%{o<4|x zgX7gJ5TJCzJnl!0@X&Gyf_=|9GNzw0}#( zcu{4l#vW3giJyP)!;;z;^xmc1i*a>IUI)#I8&{x+RMzNJdxm>B;KT^pj-O0F!TRP% zfJxMLwV9vknjz@GD%+5QB2T`4*tEE}fMm17)dAeCWBd4lVQ2DFV*U&-@Y?nu^=>5+ z!1G(t_4;dfnopk`2G9-0C4SuHqBBFXq>1+<3(#!o#*hOUV^!3L>rNbELwmWPOt+o1 zK{&c`{`^L9DeQr!qdDvZJ_|y>{vX~CfpP}Mw~~a1jw|e?!B}FutB&v55p;S2s{)5s z;^L}piQ^ft;tty2Jdk;T8k>fW2cX!PW)3D*UqSw6sP3ChIa%s>H?u~cZ%-prfACtM zZG_gHFizoA#^hUYt!B{uqP96=r6ADaKLsgkz{Ymi8y^`fydB=fxJuoA8a~O$PYrh( z_^h0yXGUjnmDzWGbqTMgU>++sQ)qJN%TXwhT>FknoDm!$>3>nj&mnbVjG74p`yK$= zH2!&od>PM`TTmM_cd4QJ!r6TN^`oFNenAfSQ`;VuavRkJQUu=~T|!w2j@`m9mDs~i z?$~MA=A(c5U9TQ$irt5-`AVTc33%`L+x@RDybAltOvx;Be{@ixif7qLK51Z4)Na!e zb>A*4=w{@fd!79%{CN(Fm^#FC-0y)5MPmLi47qmDT|`yoOk zU>VN=ka<9*+SSYfC%HG;m8gpTz(ML*zHeH7gn&K zzIOw}te7F@b@WqwWR+VW`xq$J2SPd4v>HEf zWBzD+XGZa`!YlqVa)CT=uAPz2<*r0Fh;=(BA1l@uJSN8^X28cV4n(4)FGqfWGj}Y$ znbj}C3J!~w|0d4Zk0gj)kd=cYw<;#R$WP`@=33Qpr^DK(B(T|YAGAHkjiZ>wd~pTQ za@GC0*>DNN;4Jx+GcYGzDZg(4!;!?=*Ja=2!XU3rB({Aa$#Gx7PdLhA$-?Z(0kNyA z_{ZI8E}HKZA|)k=_f~Larf|lsx~tneQ4J*Th)g-f05NS-!2H7pAo;R@ns*%={bG8` zxJN@NbEL)Zl<>}XRWjod3vX$xsy^n~6SsFmX2^t#JnLHL?|(H{2b9QE?r0)5b<7}h z9neh@uw!wu#NS+tM#6`x0yJ`Bp5_9MSPApFnyGK}}+2>p%878;+WxM+OvG9L(?|Ygo z=$GMc9yCwHm<7P0g1vjF1{g8?%Kce*Ycpm~G+6N_V)>~0^1I8!%a*<4Dq^$m3Zai8 z_Z>I@GzMtw(3o@Op^}rOmh$&WC<3(~fR~|wUO~=tw6>wQE{FR2S{b#CSdTyAM`1Nr zn%O?AFpK{dxmj?Uv4h1cgNJ4ClH1a->J74X*xf*6OFD922Ve546T*->9VK=hkFCj;8&U%uK3!| z1^(}~%F zyHWRf{RD6ws*ullRS0aGE%Bb}2cgr7kjE|nwGxvgZf%}F(#+OT`uaPszUusQL>1Mq zgWy>~WX)M`|EsSjpzw_4nJU#FCJ&xaB&+*7|&voC|b)TQ}{4AXgec{`c zs-Z?cKnsWOe_h0P)|F6asGn{6@!H;RQD@Wps>6f+u#Uj5F%+33yxC!yaQWfQn_0pL z4eu<`$h=3T?OQu z{sYK`vpV0~>n9tf@%^8_wceRhe(7R@>saLtvvFABEDT)_0klpbCIzk<2t5P(Rg(_S zc4@}QCsU^&K@Q-pq<*?-XaN7&?=XqSM=kH17eD}|H>?BfTG8*j{-~-h+%B@d5v-GH z%4(>^f`i9Fqznd$&H|V?6t+t{bsoR+>flQdEW3{dZAGLkFtu*9xBc<%q0{uGY=;i% zD>3r2 z2k84RT)3I4m!^7#4xxiL*BXK6rBn`}kl%J^t%|P4Dw;CWA$mu&$HuScY&Qc~yL~W) znHd_>-0!yl7%i9Tb=@e(ChjF2fw(e9u0?dW1SXZ7o>U9z0-IJCb*Vv*fZoEr1W_M$ zjrYVMqPN+P4dyR1BhCQeYxkW`Sc1~{W&5>biXYj{p0RmxuD;pwmnD3_Db{&9CSNTgwUZBKp zz`!pdkxy%CpqBsJ7k;xqv`0Vh0$dd1?Vdb@Sb^V0t7J$ywCgl})JPqk+7@GAW-9x+ z`~eYFaP|9ZQPLRFWAF!&&Z5uef^E3$5eR~<2~_$nH^N8DIKR0PQ8bIN6sRQ+#>EpbR%k!J|u$B zj&eHibS4Pe8!gB#!|`8R5!aY2k&?-X-x?qAci29kMtZ3ZFM>{QmpS|R@najIJ);0g zt8Y`Ikb(Pnx&0}~$feamo(>#8Dr?rRW&CXQlRkw2>Jv8;{A2RKesOAPx}ILX=JKx# zfXzwu;B5Q;2_BxY_ElQv_r7hsE(}m7@GpYvRy*w1Lybk271YocoN^25#=v z?a%$+H_q+stxb!dh)u68N}xn*4G(P{&0l*a?#O zAU5v;v@$*>_dyMoSE0I2aF}r}7aWRKKK*P1-5A2>=wqdK3XBnVGu;KNl_lcSRR* z7PjAqJQ}~D%lMDDGg4KW4yuQ|0ecI@v)AMrJ2a$RwPk1#z>YeBgPY$x>ILnY$ds); z2uPF+=w#D=;W2VSZe-}_2eG2x-w`e&xogp88CY11L z{%4;Rnrp~J+)7C39fWu+PvYk-H>ugTzr_#itt{`0vOhiW3A!%rbFnqDn-|}lv6hSs za>hwO6s-WKm4NN+kT%go#^KBa`*wJA673TNKNEnP){xq$fSmB||9LnAEGd~&kxsoO z>=ug^{7yD~d#d9W9>qKO-;R=Sn`# z_bg}sSA`Tz6CC(y(=?!#4Rj%*A;i}%6% zh@8}o&IsvCeWW=VV|(@iUTsiS=!|zP(kod0Z@1QEIM+{#-kZ^Byl?LQZLNpTMr~B> z@=wzdQb8`9g-H#5Z&bHSCzQMwuef9-FnLy6>Vmr!rV<6(L8_OJ zp)(#xZ$O)_bXQFXDd-;^@q?(}<2!d5UyocA!&i23!GB>MV zN;n;8>7MKcImxF}uJ_EnY7mT=j>05q{g?Rh96c`&%pWp;YOFe7K_X0q*;FwTJK$p1S*=n$h{sq#0h# zRlWZmpjc3>YjaL#L5bV6CW;Gy%MC;qgRfLH+XQs0ot@t@ZZkmg@HuhuoW z|EX(gpITHV=-RctzRv=4s*OPbQ+bQ$0e?T-kA_myY+fCvcfg9EXP!exbYLn zl;ykP-fY3qiIci1dYCB8@e2dV9jjGjz?!3PZ=OQ$x8>2&$HvZt$N0&vYTzk`q2{Zw(s{TD;M9gI^VI`u{|xgzv>TQdI5Ei zpz1a(BzTNfhC`+~(kUf=>n}gP($%^D1jF?t&6U+ImG8<(2`Ao!f7Ow+2S($~Piouu zQc}ZBIx@A1j-40b%k=iyF$wE0N8gY=goyHX8fudLRl$OP@!0Kg?n$K&2QsLpt&<6&g<>^`xuMwY8)!OH_CAQx|~fd}WAM*{(tKt|t=!hJH#Kc?t* zW8XJqqy16z--0F?Tvc6YxM8g1(|^SiIyKMXjd1jP{wgQ_*M|T8)xFuBm6jCH=&Jo& zE&qE(9x9Y0637Go<$ql$?JRx&@l%KZQt`jPDU(kgw!SLzAfJXN34Gqc?_yj2m?ofL zKmB_ZzuqE4%0Of<{d2**O~3|veC~gJ#MO_rj~&XKuh4u*ZY4&$pu zd8+N#wKR9H4zT{N+O2HY{N|ZCOue{RPYigL=)w%0ihR8@Uqrys5DkGtgGSBL%&x0KhQKhvb}R1d-v6eHnAWU0^IB3ZW)!V^)^^9n zs-=fNTMNHg&bTS_1!bWn>CG$8W~&u{$95TNVBg-qcTlVUawAUJe|&CCT`P0-&G0|h z#ksX=BsiwAznA;axoYc`6k@E`ai3>Az}l{rq;G|mH={(@?R38Q&E>=?yXKc$h4MU2 zk{6sAM^nFO>)d$>I^I7!Z(}WX^vBp(NB=;WI5)xAI8TMo=YAma*qpFvuKp=@I6Q0M zj4WEgmXt6a?<|s1HES$6sx$gJl5y$z2dDH-2?#j&2Ve@~9v@xsemU`bb#=a4?R{_R zn$eMTBt7if0m|cV7i5G>pBES@52iF^XlLrgSmA*X`oH&}&YhN7xsKbtEn7NOP|v@O zQKa1(WcJK{2{Z5V#E0ZA1S)H3>gGf+ApW=-02XxO#fmkw?$asaZ6FEXr+{tF8-9q$ zGLNIkI(0D$^p2U>&%dF|90oZU<#|s5OG_eP3)yGKa=EMudq-z?B!0@%nj5oFZdL#C za=eqqYK^zK;^PFfmV?=WI&Gg)<#NY&(grCrs)^R3=V*2LkoV71^fWwBh!{+8{)_hJYdK$21&_XFt3`i6E26LGOSL1+MI}Z{RMms?1}iB>w8)l^sxTJ(p5}cz4X^QPuBENNr9W*z=iC31d{G2LnW%P(*xC=>Gd4 zh+4AnOxLk#VL)>xZjf}csu+kxbou`ydTDUTf%y!IYuE84>XYe@K>b$<;IkB1TaJ#u zywRbYsoK5*#sMdx+|^$Tra;$a|5 zE%{BhDJXZwKsJI4kQI^L`hIIj2XqwL0Eq|sjsXx>36P9$IYmDQY-qhH=ucd|dpE+9L@SrAV?0zeh@}x031nQ>-JXlIAT{Y1 zXG~Xsrf-Trd@bS~^Y_7D7u@$`FW1RU*zgq|*}s2(JKR)-@kC)QlS@w2-8c8F!hb}O zDFn=(IPhczqmhS0_YU-6<2{Ft^E{kA8qM>_sUe71!JHgM_ z*W(T2+8YU5+2SKeW=xH2SV+13?G5g0F0Jx`9RJw{tJgHu=uqL0Qz@gjq$WPWf!_&P zNVFTekS$z8>myuihM#=%Gpu~e0L6?gfBeL$JgeFn5a(Xr`$oEgZ@MV}3709*7fR^1 zSb-i+(X0>f(e0uJv6Be#5)TnA6o&`~*kKyO!k$d!?(FhDO&^FW12|E%h`<5wv#TdE zERZV*uaMdY+gF7J6_4fROqVv$d$bhBf9AV34}l&e0gje!qN=f?+8=F5vu8Wq%c}{X z#kyE|8RMekQu)?Z=b2xRGVcOBnTAhRz>~!;e*4QxiM#&4df6`kgr3>YUYAW}aBk>0 zdfN@g&GprK*Ph95R^+0YkHWmzsOfjWLlq7;6EVRJ$UqyCpHud(iJ9(R`9^rZL*ZCy z@7(VmKcSIVPX3L(Zo!haH{q?f|1knU1pX-lYZrllxm`x}-nj&4i%x0N@`Uy4*4fBW z4*IcIC|*v6{#we{*2$f#a-$0V^?RyGdxK*FT@%X7-7VzrSj6DKle*>c`&Z;Q?*ZlC zcc^@2dulf6R}3^#uDm?pTLZwAkGeC$W{<-@zeAm7OTYQr)>v(Ei?F*~a@uO3=1t2d z5xfv9ScN-y|AV>Sr%!*ppA^^w%nj3t?0Q8p5G?(8y#h82+TjmYxl9Pcx%8(JZLvsR zAC%t*y{1<%bi4{)lR4c{Z=AMn)2NVlB|O~f9C#FI{kfnpHL9vEc+fENk)(yk_Br=# z&oA*@$QqB5#iX2A8-5b4sIY52?ZNMDwJKNTj@9o5-UP5TPQW`cckwbu`~*;Znsb2b zC)Et0-NP-MXkiGbPqAH8`_=`4M0IDCaI=J5ZW#Gi1PM)GHouTxbg%PM4P)p~txMx!f0$SDOc$KSqzw5j36=db=hjU?*@=qD6v^uRDW=UN-VBZQK8+I3CGNC=K!EbY=p* zf-uc^xfqx~WnfJ^3nHHGqO`uGy1gB^#2LS?PX&XB^Jk1G; zPh#Hsr&t#>%);fFpz<`W^6W&J6)*HG`a3GKC!Q4JZ)4Jfy`>U{aF%0yNXhpW{pma? z%hd31g$skCqRv+T%uVb6+=@1t@J1&ne(VaUjk@g^MY(TN=AMwPJhGNWa!mW#nj_k{ zd<4p)=H6yvft+Oxv7ylw%WsIW{V@8eK;fp4O=a|0*7As~tfmxs9v5l6NF5UZ&$#5OZXP@XXLWB7JIu?2W^^pagn#`q&;qq zyn?&%cu%z#`I@v>Wbr9dQ0@WqS4PyO{^>-)YyO?|@@t{6J5R63i88_63g>Sq{2L|+m)TIuCWTRoTyhaKKyfz{Ep6lwkmkX*W1+(mJe`l zbzgBb8OzIa2>Hessp4A_T&bv0dJ1<(FwwR8#75&z<7a-mULM-L3v5jW_@3~W*+(#> z^!3#9i$5fEwJT;-Vh%3eDw&A*ae`V>XWsGTs-gZ$i#IW=X3DZKZcsP~HL)ofyMP)qBw~7H5iLu_pflIT7{R#qXgK8EWQ+Lc3B*c3Yf3dBXT` z;$Tgfm_5ay!o|zab;?^wn(8w7Ts_=QNT8BxQ%*R!qWdK5*#64I>)Pdq3+AdwTlo9Z zp$sL`-LvtIrE3-(dM*a2SqKG|6yXa@P$j07%6%(&%FlDs^K+w&b3fHgtLQT|icIxitj@NKDL_yusbiz4Iy8wDv66gR%GDo_xZd)jweM#@i}}P?&Szs>q9FkzDTZ zXT;@G^onii`Oo>|1nU9|3Bn;oTN{?M{-<(wUDp(O_r#^K^ z=;QAVI(@dQ^&s7(vPMoyRqqpV6E))-$*CvbH)|;fT_m`pyR*#&|Ni)W5(|6p4K-hM zMC%Xx5&)s9-ob3I$#*8S4ATLUgSgN0-63%w)Kf0dPTxsVdA{3qVYOcsnecUVDVs25t7_AX3peB72Zw@3S1exy=A9tq{lx73B%*z|I_WB}i{}i#_J^!}(Xz@b zU2osW>3b1Pw8GZSf2(@Ndt2?>FNt_hL$}wRQoG_iPE~A@%gG~J+@#48olne3jPm_< z-Ro^KQJCv++s+4z-2xXBs;fY*76>3XHD>0nNM5e2$ggDGKzZGd-dScZfBZaIo@lNT zQXx@1z%9F#XdhKw*wvPQN$A$hNuAG(g5w9(mskf_#8{YuYX@mVCEMYwxg6WP&s5{8 z?{4juJx0m_ay8B^rJ)Jm=ARH}M{ZVNt|e#Ok}yM+sHsq!2<3g{5pKr&4t`+14&KPD zuw{N`tWCHR`|4({(-qOZdOAj$jzlZ3bb84RiD$CgarEhuQ=Zi^(m+3$~RE) zXINFR{rQ9@*r_wUeO6gzmP7BcljpTolmWW^F)RRN8+6<$TkxY5#^Y|r=3_<%vq3E7 z6GQ`Ig}{2A?e`*nD0(Kwa@{kp5%u*yN)t}Hp(n|Dqup~wtY|% zxYAL^!KWo;M1Fi{yz9DSLEv8f_mR~vsKMFO1K-|wI9p!!y)Th%xHF(Hh+tqEupFcH zeuh==&~$Z++=0=Olc*Hxrwj|u{6Z`yp^Fg$jLwmJ-`Wt*p&KGjJprwGq#T;I&* zCl086V7F}9oX)fl(BZ#n7%=VcP=5P&zH*}@)?Tz%;%D{A#(F z9JiYTx1SIzR{gl|?Lps5Q|jqx+(>4~Y>*r3(!JqRscDgn2OeIp66tP>&JAxk8a-S& zX^zsxnKd%Y-i_WUv}mhH`ZWc4!+QOR!FJi@?tryYS*F#N?b95C_unj^H@s^X`OLQAudWkZ{<#8?$i?H(KH%uM~6=y*YuRi_A~JM^;OmU8y7 zpFIy&?ddPR29?(W4K5Mmp$g=0A40`$zeFFAN;vg-UZAt})0J9!ZmCb9S7HT$Tg=#K zm)m#(-fPQ9yvjZYHC3fkjsz20&X<=!PT8#wnldm{uH%_92ryOiE(QLk@rM-to0>Dc%=L z{7v!-)>Xhwc7+21Nv;&Vo?ZMasGsj%U6**?u9qE&x!AmGtxB3@dNYl$=O#FHgCFF3 zk-H)sBj#j|SmRi@$A&`r_{Tbt+^*c&=v-~8kVZf0)rR( z_G!6Zo?MGM3~#gax%}lzl7bdB=VVb^tGog}i~Lf&Q+?eogZ^Uag4f&TYn5FSBSJaC zH@?rEO#3>Pp|H?>xkxjih`a5aS`g~4Rm`2@{42Tn#JH}=4f;4OLr<@lra==EPvZr3 zOkXm+1Qd({V$)#vDRekw zpe)jdc@LCVzkXF9=lZ>(7%z!29Sm9V#?7&#m7{a<`#Ol0D9l*V9C@~rWBWGVf(P*j z9&y~b!1Hoz2y0*`4#$Zo^T^FP6Zr?+?{5e`U$%E{0pC^6dUfWE zwNaQVaUr~|h2>?okfq4?P==jQ^Vf5F5N$EIyY*wHg~DyIJDlbyTHB!8$Po7~ z$z4htSXeW2_3#Cf*KFTTX=f_Q4&B9=m=LG)xuxHmw|g0Tqr}wZqQbKb&Hg)IpJ06N z`Jyo*Lix+pHtGvYRX`TsT0yXXB!j>H(Bw>U>ht`H=t@5ZahlvJ!kEHV>0u%oPD~YX z2>z&c5$jK*P2U+LOck@<*1fdYotxPelp86M;&B$kaW9R|yOGY-DnbpIv`DQclQZ&S zJ1KdhZNrwSaw%a>sSJ#WIqU1JGRwe-;%4iFBit*knk&g6i`XwLydJtyQ!r1DyU;+X zUsRYsfDd*O@{T=vELFK$mQ9#v1HC~1Nk+`;zL13Ef<^fNt*(|^X~8MPA*Jh4c4)oi zQSolUPjh=Il^&DPk>ZSXnz2zj_Qc3| zx~Ev<=xP3)ZPX>D!Hy`JdI$5{go;n5QAdZS{TOP5apPUZWJ;%ik{tZ*X(ku_J;i&t zL!l|lAKld5{Ls{=SUuBAojLk;DUdkX%+4cDXM1o%m@r|QX^ywc{@6K18~gf8dOmte zaUt>%$>=9TX<#Sru;=nx%yi#&xkHQX5>gI(qqdr_!WrkP+^BVnRc!rj4s(Tfy zaA;F8>rq{FA+zA(^hku`WMmO)!a?7F>chd>$4_CZ*16ey<$Ci3Q){L~bWO7{pr&>< zE1*%oc_|${Cv2Kty;_p5Y$4jFiBwYL`Z+HXb*Uu;Hz%gUz-FOA;?to=8O2#nXr|O}po7k5YoFK>iq}*ceRY6{cUGnN@Co2OrKlTXz1^1E*Y#$p_2BeFL**X}H2v)?;xr zbKXs8tx{o1Xy9X)08#25_kh#X%g$drineW`E9`Qeb8bB6EWo7KTCfV+ui5u^6gC$} zTtB?~F(a}(rQJC#CJ^p)fquAWKpNHOq1)nX(t#^M3tuo3v*L8xFO1g<{lu*~5|1&+ z{ds!Ppg!S%x!yzlw6FGlTS)>1ory7uHt+m8v|gGOWvCxvTGZV^6RByoR&(72kw-Nr z1gMW479B^uc>APgQQ~u@1{j46KQd>EW*&+bucW8wk}MT)t+`dMk#8Lu22uC{54=8Y ziga?!*xcLEZ?<>^Q|`A=&-JVHbU0(gR*cE$$j8@6rC>~$CQ|Ofv3``)P!o&h78;5^ zs1o=Af6Txxc9X2z?6;YU7UJ04MJn+|x&>B@OvF%qwvJVH2?!a^vh>jlQpZQzE$48o zm7EQ99nCOPUFn0YP4;sRbhSOPqqI)OG0EClQ;ZsKs#H8V?>y&(>B=1|x!C=tT~Rwl zNflzJQlER?d7eW_tAPkwUlr9 zX?qq8`DHj4Bj0nbS%O}t~s7h5W}o^VAsIR7N2cbhz#-jYl0bV*Q%9;~yd z3pyS<#`G^zc_tgoRfctjW?qwD##T19&1JI60!s&w38rsegxOZMZCsBr&t&J74Pe^I z<;3Ep@Jp2LV-vo&fzE@OgpC9g$j)2R?ri6eZlj2fbniBYPTsM?&^Ug1a{;#CqyPP3 zn6Uppzpi16;Q#X#OV4^)uGr!D>vdb15KUhr;-Z?^f4%tEs>x7v%$Tafw=p3q|n5LGFqyFHp*%79)$jY8;S>~7gRF)M-x;)^g znoEycjzu$kttWcQpQvWdAB}>U%of3OKkU4gG6yH+tHV#`ftOi3baw5#Jf{N!gp@jw zI4^J>|IMd>l>~aKa=#6tc7qjdY87KN6Eeg)@0TM^Y48SO18ZQUn}GvtSdhjSqe6rsSt45|9#^;kzB z{bfT-a&;Yvua|L6;3HNrom(*ahD&)g+C1Gj|6#fo+-#{nDO{@F6?*5eGbFNAIC`Ij z89MS(9-N0A%N`l}+g?pT1BJ+EppEVCmuB5#zo-l_G0Dc%9da|J9K!kE}qH>>YsiGCXoMp21kwsV?$4v(&d_U%G=*e?}UW{tFl@oSh}MaUm*I4bHbSW zD*7FK;H0+%B%B_G0oDsb-<>}2hvi_^Qw^dQLPg;d7@4%$VU|804v02Ga?Sp^7uvt` zjSWrOJcoaMr4YPW(dmv%NJ?K4(lGiBBPy%>99Cy>b~>Xi`EBcUy}Bb}9ep}u^_f`( z3b617>NjuR9DV7@FS>N1IVZ&0TXMpc^-%Cg>Icq) zDf9ifl%i-k*dJYKmshqQ3r>Gm6goqeGS#K=9Z$cCY$!WjW`Z$q)bCoI72KW`w-8wI ztJg#)zPX9%8Qd&?B3Dpq|L~%jo;u&g9Ua+GmkJN||UyBR4x|L@ynu8ztkh zvW!~Yu%=f=zK2o@wceMMVO>S%2f(C!tK8@*?;|GiUH5Jmjlew#L`RDwc2puk@{JHh zx4q<8HP5`yw5VyJ`;y&+sTa7eEiS^Glctw$Do}DIuwWq4e)MCM<1=)jDhRn|rlUYY zwseeb-uT%Tx(2m5M@1|ZIgvvJH_{bS+6kfsE6goy!S1$QciJ1C%5ZL^tA153Rn zJ0!0hPeU^8!IjM)EimR-e6n2yKi6_I{Y3BYW|XiPViF_=nMW*7SPgmO5-2`f02*f%n9Bj zp%37_az06vAatX8G32_UEu_e&M8hSymTx)hu0Q{vv(0Nff3O`?gN~3lm7@zT&16TI z6R+l9PS?qe5evq%K+R%l^9D)VDq2})Lb#zj4rt0t));gB@O!Midn9iAD@@m%>Ev4m zQgb`}p1z4uT8J z`K}mk4CWIozUMrmzXrp#x!KsvuK!&u4s)8dPZ0VIFPDp5oZcS!U;ZL@Ah@Cd6G_vL zySX35{s}Is*b}%Et`tM-w$qjSEI=Wg4ae}};+eX0<;Bn62HSYs(G-CwTl9e$s&D#q z{N#rCMeS1KO8rTyyKCA>gAB7Le(N)NC?xb4+T4VD&6<%l-ZTu=LydAjx*muc3WSk; zqzNQ=5_sFa+`=>YKxtb>37p)sDFO zxVnyJRxaWxmjcAn3mfO+?6;$OVHb>53wq6)m&Asf+<)4YI!-HKO0xwU|7Wde-P}hB zV(wrL7cRK2B}>2^T(U;rI@e`F;tDQlYZ@GTBm>FLR7zzSvMaiC zr-#9Ys>$ zNIXp+Ih?+`Nvzf0@O(Az1KuCX;y>Ec4?oi$(tnPF5vAuFqZH*hBX9#bDHI)80&he? zf1iwHBxr2X5nci_24quw`X#@u%Q72~EW~MZc5)@x%7vgc(G!q6X_Xl58tLcV^2R!5 zcurYiJEB(>tY~RLr_mRQUP0J%+ip}TjeqJL1!vLcC)PgrdEOu~X&n#Ldl$tw(AP3X za_2)0<1&ahlFSmrZjp|O`5zOu%P;E!H&_Le_0WFFf|=rI8U+;JGaGv!>CuEgBV=>e zp*X+x=43hakpsWYQTvTi6}*xy-+zM6mphFs0(=smdY#nUM&Wg5Y`dT&c3B<#`-*tc zJ?OM{F1oC0K$mH;Xa0we9~XUmfD?mtyT{o4gYY{(bHR@N`t|EUg6b!;^{coaeY%)l zr@`EKv=x1~ltXdf`DP7-1M6jiDo@gSzZCbV?#z&;&|^#*_0kR&VVr4eYwM*nlZZWI zvjF05yb2S}5Shgv!tXlQU=8BBq6MD}@i9;eLqDV_$=a1d`-a>$v*ka9Dt6;hs9YaM z!u`+g)R#HuWvO?x%C?5QCXS2}GqZmsP3k^&{Fr~GABHqi3~UHNVcx)%>DU!_n`UXg zL2M_WZafXqhW87+H>S|!&N)Yu>Vy!`hW;G-~S6*4l2VJ@VZW5?}(Nsy9K=_Im2eWaAw zB?J9A4E_WJdHP{F?ib0)D-y&`rI5~UdyFCZ+rRj9_^GyV8rb|@&-fVTs<7_Ixk_LPdkp6ueh45C?b27zu2)z#oV(60D?MZHSyW5~!qCdT$C&8UCmV;X$K=9_ z-|LqRD;|9zMo5*z6NCx&FK|9pD;shU`o(1`-DrmGQuf%|^NxTLb=Eus)EKwxF=oqL zXL<&)tyZeR=#-vuS_v0ECGL{nqJ+lJkM(xpCilLVs)Zf7YqH2`*0YMPBt?56yQjN+?~SQeOR8fh zz3%zm>Xth_m0G*`a8AED1Qy-M+-t+G)?e^+l_ib(K#uSe{OXuXk))yU4YKk?A1>O9_ z!*|3b*}U$aE9ZMqmpFMSEN`}#6G_YxK{H9mpRM)U)y*2-*PYqe&T9()U5zbtW=9s0 zEjjaN>9syC%x;v+OHO&r{&4Vpo+pf9ujkurW68^bPdSVlXs4I^Jr+nCi23OvF9yjZV^y(r~Cr ztQ#!JCyFXGXiTVeU~0gi7FFXynI%ps$+w#{{-wFzC!z6d)8x6Gdqg@nb(WGl)d+7UpE>3{RdWlc+ zo;NpF?Z(Kzvtc9gGxg0$&p3k z>Hf&K8X+~d(u^ANueEFve>axOS?H{kZU6Vo5J7q!f&cy`J`3mtZdCpEHwJ`Z{@1r# zJd%O`-y$GgBlyku$M@V9j~M|{3YTy2gjSPI?4aOuN%>uM&sM}XvTb-Mm8!>T$y$b% zfwbqO83Gq&lUm5in{b&1_rz8jqQaWd;k8L;599V+El@#SnA#5_6JW zOV%;n6a&zi9am6L@X9vHHZNaaavfrxUZ6w87X_f7vcIF`2wRoy-;c8O6aQ+k6k_5h z5_qnR9$^ufd5K%08EWp;!Wytag|}r8faE0{cu5DKN%~0XWP#KTzf z`?;L%?@A%GA;J>?I z6S;K4&A=P%p9+0F08Q)-OBE|vGYa9~;c@-0P~J(q4Bha~WHu*jj{))YDREQTBDk?S z0N9`aBbIwv2{fB7QSeb3j2prF+szp4WH|LO>cG%Kto>{A8ZyI=8~#dLZVxI;6Fm4u zP@U%{P&~&f8@Ak-?2O9Ek(5KqSg?)`LieYQ$j(7%qLl&Bd8{chXu=zqt9vO(L8*ul zm*r+zV4zOio4cJ>(rtuMDEH&8mn6_5N!(jD{!rLBq-Ya8UJVpS)-v6T2G`Q5etu48 zPF_Z)4Y&0R6Yxni~sfll;3y<+!+cRmqFxhQw?fShy%;T-`?5#CxnStyxt7^V+)@Lctw?-&`E|)zh4~4lsqDO^dwXHHp9ayTPk9TTjAhB)*{YaTP!;+tEwaA4QR+mZ~1NtX(diSHB z3!Y1o+=}XvKEp)?5olqa3O();LC9;q6u0;2+vkF(UY|sF*6T7`Vvj_-yuu9q*uNMJ zRKr#593(&G&w@HK0|}k4PlRS=gY%8_hk&-f*Q2SwC%jiWrUvULV!=squYxOt`Yjd6 zhEbAnOmJU~XMTdLxHPbd@)|cv|4gh0?(RpLOOu9|Cmual2w<~;;;QgiD~URBl}dE} zQ4}~f<=vvI--cinZiSiPi2|UEH(=O;p)UUCfPleKS9Ym=ycCBFM=hAawt_+Y@P3qd zUS>02>bqpKv$l-~xx1i$GpME|KKpu&ANSs zyUH$<;wG6NjZ_O%F_T=omhZ-cu^t0^(X+64OldoIs&zn~zJ1o=D(%+hwQQt|)+*cr zJd+Fsg@f+Uya7qmtTb4x(Tv7?oDqi(@Nx-(%)Pd`biF&@!cWFJIoC>2=aqC?j^V%Z z>d#AG7^2RR0v?qZ)$mK-*@K_o_Lu>jb*hs0OoOUdy-UE6825M-#5*WjKM=fO0#K&7 z7DUsIU|*RGt(FR*9qXzkADh)goOT88q(uo|4-fe7QZ|`ozeb6su3+|QDE@i;^!A}8 zQa~UT?!h(V!T;4T>90!dXjU*v>$;%+>1tZK-PjhRT3!n8QggKIyWrGaGYENC2}bGS z)tSv}2xB~_poQaL3bE!xSl>&&3^Py9ZLci~5>l&+1dn-w@yoIyYGV%m&TbYw`pmgo z^`~R3Zc#5iga*q=Y}zrB0cWMQ+g)G7E$laTPkjcVv%EhP0!jK0iDEYFyBS#OOfKdd27u00Qk@}Elnc`iX{D7Ay5QIE||m z!Tf&87{=C$SE=-TvYOZi#mUcW1t)Vfp!0&qZ=0;Z$r&+R@u6 zjDkR#AX^qP_4!ljw6l{4sW=kZl6%i7VXsh5=YTYdSWB}83YFA?H=^~gFuPW;sRb1g zLb%aP!F7NUp|Pd$1V79gGa~M?!SGV+7yVGeiUj)G=4XO(X9~*5fv^=Z9QtneNmoDWtSEYd5vRJ3zsoy+oWp1g&3(k>r`f2-aSl(Ia;rTrn}YU4wE3DMVS?CWU=P=L zj{^bRrD$Ds%OWw%ndLb~qAqS;;_5qwVR}QXiKlUZty1rcGoG8hkJqmEt`u;)ZSb)h zkyxvi=b8E?cEt_w{rG}KvgUi%jL2-~r$`Y6*k+Nz){YyGF>D)1C1s0VIRt>GzMra3 z6x0~s?nRn=f(Kh3q4FG2D~9PZn>=^Rd@@RaM!5qZE5`g>sQnH(3?~}?+2ybc#)A9y z5%|cDC>FY-m+y^?r{Pn-%AYBHF=00xlqgI*Pnb;Img@K`a?gpdia0t}{q@nF*tuO4 zsS1?B#+mFV++S|07lfrUAZi}G)Ar^z$Rvpsj%Ny{4E^Nkwh%Q-l`9b>tZNoK&wWZ# z5RDp@GLOcxt=l>M6uV<-P-*399Ty-q2R1YBzjfvFy7fvnN=B3qAjxmYfJgupfcafZ zx@LClN{nXhv79E&=^N?a>T{xv9<^XoGn+<;X_mh&C@pK!&EQ(^wZUYV-uP(a!0cIq zePMpZOQd<*i80x)(}Ozm-QLP&%y?(Fr3&)~6<_p9lbT3xX4vg3AVRhO_-_2YSuS$B z=B0H!15$OS9Z4kPS@^6yQN{0ncLUPcS;>)Zw&}?pPw>er4j_LNdjTeB^>cAuK7r{J ze9@E!ZS>40dg(g15r=o*e&s|9zO{KXu>MEJdWPbUBI-KqF-H84wVX6gg$>)vWFM@B zLFWIooRIQ6_0VjXvE%OtiEN3nQd^Bx3E8%kv;Dr-&7;duZyto=1&zZD;zGAJ2s3?nRZAtnmby^pZ2ARCw}Z)Ty5w zqJ4}aN!JEH(7#^;7CU~lAh!uKg7wLqi_}$c?<&OZJlafOY8gXu3+L3rxjxK}o&yQWysa|l1imVwMk|EIsrLF=Al zD$wIkH$-kk?Z2Mxr2RbKw0hSH*GUckj~OYuI$@gA0rn1s1$ktTR1TCyX-AH2Z>dT8 zgC?(;&goYDWYNp1IJY|ydh}17Xu%g!`f60KoRtSgfl>>`rHQ@-8OGV}uRw+dPvT-h9pj6Gfc>y_l?5eKY@g=9&krzYoG{>Cd?fD*AKKP5P$} zh_|3@1SE2K|6g36L*V{#V{$%}jcwoNzu(v>VqVm6B-WtAbqvbk2Vef;#a&zI4jnuG zH_iw^rtIhb7SC{^{I|4S1$d57dCQe!pQ{<5`8U$LbRok%&%UKDLlHOfV!q@R+k8Rxc!)kYyR#F2M;D_*S8hBdxpV=6B*ia&)(MH>4ckc~r%;6=5Q zwjG`S7qa9>`mORyRl;j#$ffaNobDtrUX2 zdj3AJ2yFW=;{E?$&P`?H60*40AvQM7wg3J~(%P+baH#V~^Y9jEPCP}@N-ZeMMJ(?k zN4Bahe{by8qlB|goj+ktQf$*-8$|`@AZt+PdAk@w8F~i_XFUKhObDI+<@P(T84gXn z=^VdPp*cvOa^W#GhMrTe8#|l-Uyvy-YgI(^ddz?-w{6SWpJpJ)$)??}7N4#6UT#8A zn?4E?da{WOz^ntDcJV04>_C3G4&cHeOlsh{UmHrsA(KWHOG6AmH2`sLRa&~63YG5C z2{yLVf0xO_Af5S?WScEyj%x0g8=6hq)xT5oT&W(xU^@t{!;WWq1Js%Y0K*)FnJqpY zRn91akYX9H-;O!4?r+4OGr(r_%gOKO=`9#M`c^s<%yROyHD$gwHZ{Gc--d1I+N`B& z2v)nSX$a5BrH)U_j)Rnnuf)A%$e@jsj$6x?{}+WvmSKCb3<69Jn7b(!9OkToDoqPf z0#YC3!aK|mL`Q|Z%Q3j|Oi-IyZs=EH&4h4vz`}PJC&#+~+Q@&#>Y57+21TP#HRnMT zI99A^_Pyf(+H2th)ZX=`?mZmbb&JlBx!5oEP^m7%#GHk|XwY`flTunxb4gaUk$W%ZUt9(N zY@J7QjS^aEP!%G9I#k(*1%(ES+>)jUb9Y%Byr0ql5iEPa?$v|ZAF%sdg@wKlWFY8m z6Cbk$xGK-QuDd8ABTO$r1#FH2%(=Xr#*5}ml}cKX1q=AMvNAF{sDIX}xoX-Z(3b(} z?0_yayc(|@@wls-gaZ_-PD70=O5DTD{!PQ;ke3-KA!GhT!2aCR6W48xb*Al>e(O$ z{-LS3aGU!xk}j1_Ee3F#JAGjG0IZN++ILtX)ZC@PB>M(0UVq>j*)Ks9r;S^uN8(8w z3`Cb6KB-ei(IGTvykj26I6&w9vX*On1Seb7mB0Hk-dy38pR*Lfe!(^|dY8lR zPEe2eH6qhD<6vk+#O^=O*(C>4)iE-iIDMiW@a&AkOf=*|FG}0(=U!86G@vYAX#{Sg zl3jU^l8ss{3f>`Y*M`sSFf!^|hT|ZJNOfNV-CW1ox#CfAg4hN+AHoEwo?*MdEP|4N z<(U&8c>7DPOKSLoih0hti#w->mq4{9L_0i`21r|Ieh?OTQJP%W+^oah4s~D}=OPRv z4lXL>1NVXT&=*=0l_hhvXS*&_Q*}+}JRupb!ICXF>i_HO%HyHlyZ_X!bd_{(%e@iW z)GbNf!lN3B+eT8!o-J82mL%IumI~c&A$7G`OR~+3u?!l<6crLvmSIe0+7N@W&B8GA zJ73q(^E|)TbN=!D%#6=|KHqcRXZg%>@Miobm763Y!y&*dF2km|#gMoLTF%3XAhT;o zv^N`MOEn>Z$cHPI1Wv1zy{IPp&f4_d=!SzFN~04UL`x)3lz>no_6__g;$8pfPkVMwuU3aG!P z5_sPNZ~eZ6e$3kHo?xG4B^G3vNu1KjcVIi<S^I126aD z_cX>JOev@O5N5Gh{od&UyOI%LIo$muNRw7%S7PY82Bx=K)dPH0z}+}0sc&Zy=E2+n zz3!whnyvE87k~IEH4#_(dZ$ysq2Q8@<;Fyo9k_`uh_Q;x7!YB%r;&(14lREg(1$=@ zWuv)!D#DgTPg%4T90-CJ=oX^|-s$8^lu9*DOa8e{61gbbTH4}r5h*cJ7O(& z{@tuDwi&^DkU5V`7gwO?=T$Me6H;IasSYu=3 zi#AIcWU665918t}TDY1-xIOn4en&s(x#@BzRU8Ro2n)}TUw>$PLolQu%jX$MBR<>% z+mvX>7mArY_hCNTgUJx#R4||$vMY&eRBs*FrfQ#nM86r2>!O#a^wu>~ zw6MPpgG+)cmIvBk8k!&^naI>{}z^>o=3w+y-@ z^o_a@W6?VAqI;5Gbex{rcBhCHTTay&xxDMQ?`Y@SXx3j|a}y)p2dB{`=943L%EjfC zB!@&s`XNOVW8(r1VrivahPDQ!`27!az4N~GXrGstU~i?l=G)VSe~2xGd=ZJb^1}Qt z0N1!%6U9$z`OO9F0#_4*SO?|IBZ7-@%>@M4vEj~<{JvgE-lWISNO@xAJTTwF4a$=j|FwQFVK%zYq0q=FLOZ z_+K<_o9(i`80Ffw^KHo@%U+1~7Fh?>FV=dv+O+T%*TOvq@t{!x=tf1Cc=v+o;mn|0 zav&~%Q$i>@?Kp_>4$Dui(C0tj_sCY0p%h0vKGAG$7Gf1lJ}$?~VwD?ugUvl%{2>vp z<81$-jB>lWF)|Q%WS^?Zvi@vsJG6W=-yt=Cx|>MJ!W5K4iiuZrJ~YYadCb*IzH_A{ zdXdNK@{Ki3lRxow-f45~NAq_%C%?|(;wbv_Cn3SM81wlnpkjk*#QX`R>OBAB&*P}o zs9UVrg9}uOmM>!wRTQ^loTf-GTUCQXtQ!l{2MTeE;p#|HgkiwM)=nGyr`raUsvt_e zcX6GL&xc0~m{S#ZEkT#Mkty7@hX!}=K0&hlMFKB; zad#WD_bR60=0LV>t+qzR*Yq6BiYwNYODyY=NiObZuATf9-IKE+w#z6h~J_yBloxyEs= zhVa}fOhtCFTp)N8KGSI~8mHzmCsz4?mKx7R89D*LrOF7^5ka1{c33>)f6OQP6N5$? z!@)n{dip;LEYn;2V-{o}&Zk?NK5FNl=AtpoUA4BwUe8z@6GWuWZ^0kAL$hT7oOiAc zvWubtVh1zK@_=_afRb94o_EF-eN4C99=;a*6Af1cm!_e`%}ti0W8M90C6ka0YDLZ) z02MpqCdT|a-|VRxkNk0&7hLM67r<5VJA$usF|W zs_r#sJ#7AIdG;SWKK|4Gswln#vRFV%Rl#*b$LTpr*8fMOl-surWt|53_uOLGIROq0{~uQi(fjp0E}ZaHj2 z5~tXg;{%6V0pwy}0?TF3YX%#M7hH5IfD6)JOR*@_bIw#q%4C5{^%4_PQ!?O#ZIC3- z8*-TdT6}uT9LPMlRf>jd6Pm)nLq_Dd0)-MOBc9TNI>=<>4QcfepISf*d0F%Bg{fhk zked&{!^dtSZxISLQ7@Y3UyG=wI&kp4g19zEx&86RmwJMB-~?V;{7W#FaL2bW{2HAY zGpkn26|Be;tSfBwFz_86qUoSegSv)@?XuY8=bbSptb{^Q+F|vIQIsnr{?hMJgWiZw zTALj?vKG2jaM0QQ%j1^$`ue|}ysi}$V7e=_R*H=A7i6xOhSrKfh}I|Kq}>f*gUPR^ zAZamI{_otzrh-%F;=RAn%=#UWZ6neBM(YG~>;|OHjhU4c$q&0Q4SSWf10TmI3F{p& zXU`_~6n2S%J_`%;jN|4_w&Yqddo3QcRtQ#IGSCi?Zft52j)tPozjH@lv|curlu|t6 zf9w}n)d;DADg%VssfssMQs#1BZf@$2zM{qY>6Z@oYrNcT<@9agX<4CqZidB1K5yRT z;rqKM38BKT9Xa+T5*@$c5}ZQc57DuIU81F$rWEf)Rp)W+&WW>|+{cE*;X4`)%CQQ!N^9d1wvUb_jln^qmB^ehN!2z^;9V)mL(F42wyr z3Hlb{@?8bi1b#aBmRYA=S z-gwm&9sBWvC3T+X#Ib1e39;f{Vc=Jal}$&NiYEO*3CrKtl5Z&%@m70GhA-qo()P?1 zznyqLoaCPwFtBG=7@7OQ{eGuj|4JO?XoAS%fh{@kYC_H_j#5z%Vo;2TT!YN6dS)f| z#xZJto5l$9TOKXHpQXcMm@4liq!#-W_w00MU2k1cv_+x)tR7x2!?I6a`%d3vdwu_3 zayQ!J@9BGt-JoIAS}?9FFxn-~=@rERm{w6(i-mpn(_4fAt~__XNx8eU{OcUY@(e}|^%S|OMc=-z9f>N*Jy3=1^W(eQ+6rt3 zT{PmIL&bEOb==?a#h=8Q?8hBh-ewqqO)B~>BV5}LJK-ZZ;!OQm$FoZr87SU18T~3R zu&H}nu`%D)j=n$rvz2R(ZBy*s?w87V%aLtExhT}(g>V$CvAeJZAFlKx*RwOMm;Xj^ zuycXs_*LwKyNq**>0046IXa$+{UpGKm*V%GcCyk4xoTgo6TIh^*c2D^_PV=M6P4JllLbiT(Sb0PjrVxE9sCiRSpo^0w&%ot>h{SyD>9ZUZ9 zfgVfSO-l}Ja=~pSNYfk=MIC+SmX+f-pPAs#B%2YcpT|qaga#6l!`1b|v5t0u2$Mi~ zdno3yqWs3NJ*_?=_`fGd9*g^8HyPWd2co^f#Z)k&MYClMY!*zgTKYTxN)0Z-PV&@H z5m)z1HK&gB2>hE`QrM`gA~RceMX|q6cw@se!r`tJHbGsQaX2R;<6mND`xWze6R$W! zB;s?tzcqDBhaEev^jjEjUHA)oGZu|l)7_oW{OH=Xkog`e;?l#Uy(4!w^@%X5`9@l$ z)$+9Q3ZDPK#QZ?__{PAtDB*aBY7oCF-h0@tu7)2pCl+>hj1}1{Kci7N<9jcTZs6YCyKWdq$5cD;Nm2@$g3cHyR zYuEQj9zHB7brzJp$Q3MS@YVLm90(sx_)9YA1mdmW%$Sn?>&ea_4D;dP`&!E(j`XvV zzkcZJ)h4k?bv?QU1Jt<-7O!%RX}?G|YM|B$sll};x$W+^RQy96#J(Gr_O{t$72oUv zq1LX0ZnEEzt6bdM>(bRynX;*X_7^$P9e4B6dBSyhE-S3vhd^0E(&p;4i?Ry|#_1r+ z*kmFMGt{CxRL0E2NAi7Y9S?@J3fph+nuqCeR7<^|%X!6~ruv0NEnEWTE6!qlb?RQ1 zib+y`=HczWPS=tGu2F3=t`m;hxvZ}?D_pM?`rHRw^n?(5nqKLe9mpV<{gLyha1BTu zB_Yp@TetR{! zThq3|u7q5FqZ5N|4I$$(2gf&hmoZ=SF`?ph8Tz9Pe*2MBn{4CMHs@}RONoI5yWyMm zFe$VzK@n#%(cH6h{io3LPo1g3&y?7qk|O0rI1B(~7KJ4_yNbjqp>?g?(ubOoGF~7p zg=(=5WMwDXK>R)L#?cVLxeZ0B7pl_t;7t1-6;&8l36Kfui{yXq42tHrYf{?Q#`m}E zCNlV&Oss}@5`makA*ou>zm?uoVoP|^AbIA%^$E288Z^PF;h)MH$)=hYK1){lkvlFK z^fP~4JqIS_9RyU>+)a|_de&OjVe<=GLWfI)>zwrp8!7iVg#L~@Lie{6Pcv{Uv@0yk zRi9`+eEt&U?IHFXB9X4nK4EPZ7tMd#U&aD{xU_X_k*^imsM(m6m3$2wkXiAyqPuS( z^GzGtjQYuivxs{7h1&0ZJMj1NK5N4EpnO~%j$tI z>UD^Y-E+!MlV7uc&U3*GQ{GlmR8MZTDR{Z9qFayW{EjMJnmSqGLZ4$`UZ zy@rN2Or4^EZT;ak3tc~Oetaubwou~b7gcmW$JaAdHFWU0yknTP9L7krIi2< z+CowMbyfcYDa)5;m*}(El8C)sf4{8FvFYh{BBw4U%7GsmcAQ4I7GN4Igbep~tzlJY ze0O;M6*C=ST^=ojdx=Yz6L|?ysINM*_mP|ngB8Z6S0wLXZ8S}eKWCb#&l+E%l(OE1 zF>-KjA)DZ^DLefdzcbzy)`DTgtdF}}RBaOWvHHZn!pqO9OH*j>lW@?tQm^2>%~V^bsEMMR+VAa(R$z1EiIu>5Lkx(+W=ocm?LI3*J z@K>I?;geYF_FT#mnLRTWAL$)!4$B-leL zf^ikkGUL=DL1)3b05W>`1mfLMDCX^D&i0SUCaL=azp5(+mr^(WoJM4u*k9oJ3+N^TC6;A|ffJGf+uqlz z1`AF*+wBkQ>I+d#YI#WA`Jp<@JtOFPYhYn_gOH!k+uzz2M0N9SD4#FcQZic9yg1Lk zNziWA*WH$Cbs#p|1ylJ9?ok-;7LC01RNsximTXvR`+6ttaGKQHw|)5Py9L!wO)sDp}E z;bws|i$e}$#z%XK;m%!=BWTAWWzdaV%5*`QxfOtoVnXz$iM670HsoQiz2gnmk!hvv zc1ns51bI!#;>Y%%hZve-rx$bQ;tp>Sp^ql&)UVWXSS{56MLB#Y^!0fdv(zsgLQQHR z1Dy+aGzv+F)t@eJM4adL+tcE}w1k$l&Ii@Zt+BBY8TDi#+`XZA?cw=YfDW=S!E^Ud zX;+>$X2*_ggs}=ZU~TXMG`tvYO58Gse6DFD;sp04ToZ-*=zA0VTM?Q?2d4GZsSmF* zW!n4P+sX&zgI!-;z>fjHGMt7O~(=dFqbmhgX(*QwZlMGvsM+}re3s=ol zI$fV(w5-0Hl~}1{60F4tMIP|<%;ER7+?WP1tYsL-DrBvI)_!rOx|>ZGoF9?cSEqj& z{0_pQfg)}puP31I&=6z;04-dFME_4c$Z9kCPc#I2qlg$$f!6H3|6f(!{9hmlggGG_ z32ER4csVL>cS6CA0g50Um#OPeTDlT~a%FhQ#@ShGY}%@)_dquA{~pdv+y4WJA>&7S z0Y3mTjQszWTh`j_&>+@)>i28Y{|%{`L1(gDk%XbLU9e7Dy9HukXHY1BqprtF3Nb4t0x?~+Ubfy9z^j!&j7r!fk!_rKNXXD%S zRAF}IATO_`tYi(@_@PfJvOfKW5Bm0QriW1KYm5KxyWZyO-<5hAqhzH^5Ff~Z3l6{A z$Z)rqtOTH+Cm2HzoONm}(_J$>=u8D0sjQ<{rYozN;gKjL((d~$$Yqsi$+~{rn%A1A z_FajSXCNzqi!jpCcf7+^s4$R$Z3;4Ofi04hgaE=o|9iQoPeJ(I(v=Xu%_s|+I=rFm zoPVLynA?`WY^H752E22(K?Xk>W3iNsCr@MpTND)_J3rRR=3)lol>KOxL&pN7WBY2d zT+uUp + + + + + diff --git a/public/src/main.ts b/public/src/main.ts index fa0c396..5b0d5e7 100644 --- a/public/src/main.ts +++ b/public/src/main.ts @@ -4,6 +4,19 @@ import { createApp } from 'vue' import App from './App.vue' import router from './router' +import { registerSW } from 'virtual:pwa-register' + +registerSW({ + onNeedRefresh() { + if (confirm('New content available. Reload?')) { + window.location.reload() + } + }, + onOfflineReady() { + console.log('App ready to work offline') + } +}) + const app = createApp(App) app.use(router) diff --git a/public/vite.config.ts b/public/vite.config.ts index 5c45e1d..bc09195 100644 --- a/public/vite.config.ts +++ b/public/vite.config.ts @@ -2,11 +2,74 @@ import { fileURLToPath, URL } from 'node:url' import { defineConfig } from 'vite' import vue from '@vitejs/plugin-vue' +import { VitePWA } from 'vite-plugin-pwa' -// https://vitejs.dev/config/ export default defineConfig({ plugins: [ vue(), + VitePWA({ + registerType: 'autoUpdate', + includeAssets: ['favicon.ico', 'minis_logo.png'], + manifest: { + name: 'Miniplan', + short_name: 'Miniplan', + description: 'Miniplan', + theme_color: '#ffffff', + background_color: '#ffffff', + display: 'standalone', + scope: '/', + start_url: '/', + screenshots: [ + { + src: 'screenshot1.png', + sizes: '505x710', + type: 'image/png', + form_factor: "narrow", + label: "Miniplan Liste" + }, + { + src: 'screenshot2.png', + sizes: '505x711', + type: 'image/png', + form_factor: "narrow", + label: "Miniplan Tabelle" + }, + { + src: "screenshot3.png", + sizes: '1003x709', + type: 'image/png', + form_factor: "wide", + label: "Miniplan Tabelle" + } + ], + icons: [ + { + src: "pwa-64x64.png", + sizes: "64x64", + type: "image/png" + }, + { + src: "pwa-192x192.png", + sizes: "192x192", + type: "image/png" + }, + { + src: "pwa-512x512.png", + sizes: "512x512", + type: "image/png" + }, + { + src: "maskable-icon-512x512.png", + sizes: "512x512", + type: "image/png", + purpose: "maskable" + } + ] + }, + devOptions: { + enabled: true + } + }) ], resolve: { alias: {