From 663ea8c82937e7390da0c902ceddb3092a2df54e Mon Sep 17 00:00:00 2001 From: Public Source Publisher Date: Thu, 1 Oct 2026 01:30:24 +0200 Subject: [PATCH] Initial curated EventLens source from 0d80d3b38dfb817285481665b9e71e4b8a0656a0 --- .dockerignore | 18 + .gitignore | 12 + Dockerfile | 45 + Makefile | 12 + PUBLIC_SOURCE_EXPORT.md | 3 + PUBLIC_SOURCE_MANIFEST.json | 421 ++ README.md | 145 + SECURITY.md | 51 + VERSION | 1 + backend/app/__init__.py | 0 backend/app/correlate.py | 362 ++ backend/app/demo.py | 12 + backend/app/main.py | 319 + backend/app/models.py | 83 + backend/app/normalize.py | 261 + backend/app/parser.py | 204 + backend/app/version.py | 25 + backend/pyproject.toml | 21 + backend/tests/fixtures/README.md | 15 + backend/tests/test_api_privacy.py | 171 + backend/tests/test_correlation.py | 27 + backend/tests/test_demo.py | 20 + backend/tests/test_evtx_fixture.py | 19 + backend/tests/test_normalize.py | 17 + backend/tests/test_post_v1_hardening.py | 267 + backend/tests/test_security_limits.py | 88 + backend/uv.lock | 1235 ++++ docker-compose.yml | 34 + docs/ARCHITECTURE.md | 40 + docs/CORRELATION.md | 29 + docs/PRIVACY.md | 37 + docs/assets/eventlens-demo-overview.png | Bin 0 -> 285470 bytes docs/assets/eventlens-redaction-export.png | Bin 0 -> 265967 bytes frontend/e2e/accessibility.spec.ts | 33 + frontend/e2e/api-contract.spec.ts | 64 + frontend/e2e/branding.spec.ts | 28 + frontend/e2e/eventlens.spec.ts | 40 + frontend/e2e/partial-and-error.spec.ts | 25 + frontend/e2e/portfolio-assets.spec.ts | 29 + frontend/e2e/real-evtx.spec.ts | 19 + frontend/e2e/responsive.spec.ts | 17 + frontend/e2e/settings-storage-failure.spec.ts | 32 + frontend/e2e/settings.spec.ts | 59 + frontend/e2e/virtualization.spec.ts | 22 + frontend/e2e/workspace.spec.ts | 77 + frontend/eslint.config.mjs | 43 + frontend/index.html | 19 + frontend/package-lock.json | 5652 +++++++++++++++++ frontend/package.json | 31 + frontend/playwright.config.ts | 30 + frontend/public/apple-touch-icon.png | Bin 0 -> 14307 bytes frontend/public/eventlens-icon-192.png | Bin 0 -> 13829 bytes frontend/public/eventlens-icon-512.png | Bin 0 -> 19587 bytes frontend/public/favicon.ico | Bin 0 -> 6050 bytes frontend/public/favicon.svg | 10 + frontend/public/site.webmanifest | 23 + frontend/src/app/App.tsx | 252 + frontend/src/app/format.ts | 68 + frontend/src/app/model.ts | 84 + frontend/src/app/validation.test.ts | 77 + frontend/src/app/validation.ts | 82 + frontend/src/components/icons.tsx | 61 + frontend/src/components/shell.tsx | 36 + frontend/src/components/states.tsx | 36 + frontend/src/components/timeline.tsx | 69 + frontend/src/export.test.ts | 60 + frontend/src/export.ts | 108 + frontend/src/filter.performance.test.ts | 27 + frontend/src/filter.test.ts | 42 + frontend/src/filter.ts | 55 + frontend/src/main.tsx | 9 + frontend/src/redact.test.ts | 95 + frontend/src/redact.ts | 177 + frontend/src/styles.css | 507 ++ frontend/src/types.ts | 55 + frontend/src/vite-env.d.ts | 1 + frontend/src/workspaces/AnalysisView.tsx | 12 + frontend/src/workspaces/HuntingView.tsx | 12 + frontend/src/workspaces/ReportsView.tsx | 13 + frontend/src/workspaces/SettingsView.tsx | 157 + frontend/src/workspaces/TimelineView.tsx | 9 + frontend/tsconfig.json | 17 + frontend/vite.config.ts | 12 + frontend/vitest.config.ts | 7 + samples/demo-events.json | 8 + 85 files changed, 12395 insertions(+) create mode 100644 .dockerignore create mode 100644 .gitignore create mode 100644 Dockerfile create mode 100644 Makefile create mode 100644 PUBLIC_SOURCE_EXPORT.md create mode 100644 PUBLIC_SOURCE_MANIFEST.json create mode 100644 README.md create mode 100644 SECURITY.md create mode 100644 VERSION create mode 100644 backend/app/__init__.py create mode 100644 backend/app/correlate.py create mode 100644 backend/app/demo.py create mode 100644 backend/app/main.py create mode 100644 backend/app/models.py create mode 100644 backend/app/normalize.py create mode 100644 backend/app/parser.py create mode 100644 backend/app/version.py create mode 100644 backend/pyproject.toml create mode 100644 backend/tests/fixtures/README.md create mode 100644 backend/tests/test_api_privacy.py create mode 100644 backend/tests/test_correlation.py create mode 100644 backend/tests/test_demo.py create mode 100644 backend/tests/test_evtx_fixture.py create mode 100644 backend/tests/test_normalize.py create mode 100644 backend/tests/test_post_v1_hardening.py create mode 100644 backend/tests/test_security_limits.py create mode 100644 backend/uv.lock create mode 100644 docker-compose.yml create mode 100644 docs/ARCHITECTURE.md create mode 100644 docs/CORRELATION.md create mode 100644 docs/PRIVACY.md create mode 100644 docs/assets/eventlens-demo-overview.png create mode 100644 docs/assets/eventlens-redaction-export.png create mode 100644 frontend/e2e/accessibility.spec.ts create mode 100644 frontend/e2e/api-contract.spec.ts create mode 100644 frontend/e2e/branding.spec.ts create mode 100644 frontend/e2e/eventlens.spec.ts create mode 100644 frontend/e2e/partial-and-error.spec.ts create mode 100644 frontend/e2e/portfolio-assets.spec.ts create mode 100644 frontend/e2e/real-evtx.spec.ts create mode 100644 frontend/e2e/responsive.spec.ts create mode 100644 frontend/e2e/settings-storage-failure.spec.ts create mode 100644 frontend/e2e/settings.spec.ts create mode 100644 frontend/e2e/virtualization.spec.ts create mode 100644 frontend/e2e/workspace.spec.ts create mode 100644 frontend/eslint.config.mjs create mode 100644 frontend/index.html create mode 100644 frontend/package-lock.json create mode 100644 frontend/package.json create mode 100644 frontend/playwright.config.ts create mode 100644 frontend/public/apple-touch-icon.png create mode 100644 frontend/public/eventlens-icon-192.png create mode 100644 frontend/public/eventlens-icon-512.png create mode 100644 frontend/public/favicon.ico create mode 100644 frontend/public/favicon.svg create mode 100644 frontend/public/site.webmanifest create mode 100644 frontend/src/app/App.tsx create mode 100644 frontend/src/app/format.ts create mode 100644 frontend/src/app/model.ts create mode 100644 frontend/src/app/validation.test.ts create mode 100644 frontend/src/app/validation.ts create mode 100644 frontend/src/components/icons.tsx create mode 100644 frontend/src/components/shell.tsx create mode 100644 frontend/src/components/states.tsx create mode 100644 frontend/src/components/timeline.tsx create mode 100644 frontend/src/export.test.ts create mode 100644 frontend/src/export.ts create mode 100644 frontend/src/filter.performance.test.ts create mode 100644 frontend/src/filter.test.ts create mode 100644 frontend/src/filter.ts create mode 100644 frontend/src/main.tsx create mode 100644 frontend/src/redact.test.ts create mode 100644 frontend/src/redact.ts create mode 100644 frontend/src/styles.css create mode 100644 frontend/src/types.ts create mode 100644 frontend/src/vite-env.d.ts create mode 100644 frontend/src/workspaces/AnalysisView.tsx create mode 100644 frontend/src/workspaces/HuntingView.tsx create mode 100644 frontend/src/workspaces/ReportsView.tsx create mode 100644 frontend/src/workspaces/SettingsView.tsx create mode 100644 frontend/src/workspaces/TimelineView.tsx create mode 100644 frontend/tsconfig.json create mode 100644 frontend/vite.config.ts create mode 100644 frontend/vitest.config.ts create mode 100644 samples/demo-events.json diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..beb5b36 --- /dev/null +++ b/.dockerignore @@ -0,0 +1,18 @@ +frontend/node_modules +frontend/dist +frontend/test-results +frontend/playwright-report +backend/.venv +**/__pycache__ +*.pyc +.git +.gitea +*.log +.env +.env.* +docs +frontend/e2e +frontend/test-results +frontend/playwright-report +backend/tests +**/*.test.ts diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..efc154b --- /dev/null +++ b/.gitignore @@ -0,0 +1,12 @@ +__pycache__/ +.pytest_cache/ +.ruff_cache/ +.venv/ +node_modules/ +dist/ +coverage/ +frontend/test-results/ +frontend/playwright-report/ +.env +*.log +.DS_Store diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..d742610 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,45 @@ +FROM node:22-alpine@sha256:c610fcdfb1d5b4740dd70c284ed3cb16bb857e0f7166196e36a5501df7a3aa32 AS frontend +WORKDIR /src/frontend +COPY VERSION /src/VERSION +COPY frontend/package.json frontend/package-lock.json ./ +RUN npm ci --include=dev +COPY frontend/ ./ +RUN npm run build + +FROM python:3.12-alpine@sha256:b64631e04e4920160c50fbe8d8df828f7f35f06f425cb44aa09bca53e708a35a AS python-deps +WORKDIR /build/backend +COPY backend/pyproject.toml backend/uv.lock ./ +ENV UV_PROJECT_ENVIRONMENT=/opt/venv +RUN python -m pip install --no-cache-dir uv==0.10.0 \ + && uv sync --locked --no-dev --no-install-project + +FROM python:3.12-alpine@sha256:b64631e04e4920160c50fbe8d8df828f7f35f06f425cb44aa09bca53e708a35a AS runtime +ARG EVENTLENS_REVISION=local +WORKDIR /app +ENV VIRTUAL_ENV=/opt/venv +ENV PATH="/opt/venv/bin:${PATH}" +ENV EVENTLENS_REVISION=${EVENTLENS_REVISION} +LABEL org.opencontainers.image.revision="${EVENTLENS_REVISION}" + +ENV PYTHONUNBUFFERED=1 +ENV PYTHONDONTWRITEBYTECODE=1 +ENV EVENTLENS_FRONTEND_DIR=/app/frontend-dist +ENV TMPDIR=/tmp + +RUN apk add --no-cache 'libuuid=2.42.3-r1' \ + && addgroup -S -g 10001 eventlens \ + && adduser -S -D -H -u 10001 -G eventlens -s /sbin/nologin eventlens + +COPY --from=python-deps --chown=eventlens:eventlens /opt/venv /opt/venv +COPY --chown=eventlens:eventlens VERSION /app/VERSION +COPY --chown=eventlens:eventlens backend/app/ /app/backend/app/ +COPY --chown=eventlens:eventlens samples/ /app/samples/ +COPY --from=frontend --chown=eventlens:eventlens /src/frontend/dist/ /app/frontend-dist/ + +USER eventlens +EXPOSE 8000 + +HEALTHCHECK --interval=30s --timeout=5s --start-period=20s --retries=3 \ + CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8000/health', timeout=3).read()" || exit 1 + +CMD ["uvicorn", "app.main:app", "--app-dir", "/app/backend", "--host", "0.0.0.0", "--port", "8000"] diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..4eb8095 --- /dev/null +++ b/Makefile @@ -0,0 +1,12 @@ +.PHONY: api web test e2e build +api: + cd backend && python -m uv run --locked --extra dev uvicorn app.main:app --reload --port 8000 +web: + cd frontend && npm run dev +test: + cd backend && python -m uv run --locked --extra dev pytest -W error::DeprecationWarning + cd frontend && npm test +e2e: + cd frontend && npm run test:e2e +build: + cd frontend && npm run build diff --git a/PUBLIC_SOURCE_EXPORT.md b/PUBLIC_SOURCE_EXPORT.md new file mode 100644 index 0000000..2d9cd19 --- /dev/null +++ b/PUBLIC_SOURCE_EXPORT.md @@ -0,0 +1,3 @@ +# Public source export + +This source snapshot was generated from the private canonical repository at revision `0d80d3b38dfb817285481665b9e71e4b8a0656a0`. It contains no private Git history or operational evidence. Changes are published from the canonical repository. diff --git a/PUBLIC_SOURCE_MANIFEST.json b/PUBLIC_SOURCE_MANIFEST.json new file mode 100644 index 0000000..6218625 --- /dev/null +++ b/PUBLIC_SOURCE_MANIFEST.json @@ -0,0 +1,421 @@ +{ + "schemaVersion": 1, + "sourceRevision": "0d80d3b38dfb817285481665b9e71e4b8a0656a0", + "files": [ + { + "path": ".dockerignore", + "sha256": "335ec52ea297e3a101ad78d4d5092859e78069c74d425bead6b28b66a11877ba", + "bytes": 262 + }, + { + "path": ".gitignore", + "sha256": "e44cadf923d745d957695d6e41c1fbbd13fe1e80995862cba23895f13b4d49cc", + "bytes": 162 + }, + { + "path": "Dockerfile", + "sha256": "1af5a5c6e247aea936a88ec48f3440bac88e8b068a457a6a20dd079fbe4b65ae", + "bytes": 1898 + }, + { + "path": "Makefile", + "sha256": "4de1e258bf059469547b882efa9b06e055b38886c98de2fe4d69550232b62a6c", + "bytes": 371 + }, + { + "path": "README.md", + "sha256": "d4c150cc0c4b5b58552e3df34c31b4c4ec5ef63fa9ecac382b2e4b841016c7ee", + "bytes": 9460 + }, + { + "path": "SECURITY.md", + "sha256": "99a573a9d5d07e37f15054273058b591d621a7e56af3600d8779ae0889efd0ab", + "bytes": 4911 + }, + { + "path": "VERSION", + "sha256": "3dd81e3d2bbe930a0c98531afa6c35bd862ee8a08458ec0d7d1b51138d7b3a3c", + "bytes": 7 + }, + { + "path": "backend/app/__init__.py", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "bytes": 0 + }, + { + "path": "backend/app/correlate.py", + "sha256": "832ab5358bac0bd1a8f8dc8e764ada8cbfd3def70c745d19b7f76c99d2b47277", + "bytes": 12832 + }, + { + "path": "backend/app/demo.py", + "sha256": "6ef93def5b21883b6d61755dedc9cded60122740bbcc032fe5039dd220bcb58f", + "bytes": 339 + }, + { + "path": "backend/app/main.py", + "sha256": "42af827ba7da473ea4e5add0d6cf68ea09b4a26d641df1ce820c80c870a3dc8c", + "bytes": 11730 + }, + { + "path": "backend/app/models.py", + "sha256": "dfdc0c5c9c34fdd41fbcd2f22f2418bbb8b2f321b50a11676bc735dfab57a37e", + "bytes": 2995 + }, + { + "path": "backend/app/normalize.py", + "sha256": "e06271964395b7d428e2ad5c698fd71a3d520c7fbb17649ef2db29887b72aa3c", + "bytes": 10740 + }, + { + "path": "backend/app/parser.py", + "sha256": "0481fb6da19753409bed633d6c5d1917a621eafe8666e30b3af4635b4134fa15", + "bytes": 8559 + }, + { + "path": "backend/app/version.py", + "sha256": "4c5bdcb3640668ddeaab9a116d10662b22a60536587f38672df1b9b7e2a4fa21", + "bytes": 698 + }, + { + "path": "backend/pyproject.toml", + "sha256": "4350e56b0e9af15cecccf04fc3fe8ce534f89a298e650828391aab54ca1e8bf8", + "bytes": 514 + }, + { + "path": "backend/tests/fixtures/README.md", + "sha256": "9208c039dd47b379fda4272b3f48ada537083897f6a53b2d25f760e059ae68b4", + "bytes": 816 + }, + { + "path": "backend/tests/test_api_privacy.py", + "sha256": "7b65e5ff28fd2750dc9eff9646ed1b0823b2a332a0119cea31df698af6499357", + "bytes": 6781 + }, + { + "path": "backend/tests/test_correlation.py", + "sha256": "bc613454bacf8ae7e24435551a1395cfaf6374b42e9fd4561226a042e84fa344", + "bytes": 1228 + }, + { + "path": "backend/tests/test_demo.py", + "sha256": "8cc6e53f45edb49328a36ac1e8dc6d2abb77edd1538b8b5f5457dc6abdbfe21b", + "bytes": 630 + }, + { + "path": "backend/tests/test_evtx_fixture.py", + "sha256": "8c6215c8b34d26e34fb592337b62bcef07aab595b17ea65a9f693a40c0513459", + "bytes": 780 + }, + { + "path": "backend/tests/test_normalize.py", + "sha256": "3765500cdf7c7d69d0adf6f879d7200ad763ef7428018f1efd9d7eaec534b503", + "bytes": 1014 + }, + { + "path": "backend/tests/test_post_v1_hardening.py", + "sha256": "7a195245dc1ee77806b7c8abae3e5733d010ebba24d85c9a4191037e890202b2", + "bytes": 11074 + }, + { + "path": "backend/tests/test_security_limits.py", + "sha256": "42f10eebf5174926838f5fe254852abd16a7836d4129c92a9a510818314e1de3", + "bytes": 3249 + }, + { + "path": "backend/uv.lock", + "sha256": "479198b6cfb74433368f5bb6e587fe6deb9657cc5ea95f291908f11079c07799", + "bytes": 236644 + }, + { + "path": "docker-compose.yml", + "sha256": "046df4d1537e40e82105f23201dec87c5cabb7bc94c1904f981b4bcfbfdca47a", + "bytes": 790 + }, + { + "path": "docs/ARCHITECTURE.md", + "sha256": "a5618036f0455405b5aad3e0b650971fc44123a1843d2234b9fe374688df6bf8", + "bytes": 3942 + }, + { + "path": "docs/CORRELATION.md", + "sha256": "a74f2321610de5f7d7babadd8999a303c56a01a1c74aa6665bc69a949f4b8048", + "bytes": 3826 + }, + { + "path": "docs/PRIVACY.md", + "sha256": "9bfdb5a72f5cc5eea14f3f586186e7d28055f7617075665ab6a5d347c487bbba", + "bytes": 3164 + }, + { + "path": "docs/assets/eventlens-demo-overview.png", + "sha256": "c24060588edb7004eac6cbd3b2164d84911d868bbc15d7c1deb7eec4faf558a5", + "bytes": 285470 + }, + { + "path": "docs/assets/eventlens-redaction-export.png", + "sha256": "5bed3e7ee9b3e1f96465a9f127a9ac18e358c02f23271478eb5734f05fdd6af0", + "bytes": 265967 + }, + { + "path": "frontend/e2e/accessibility.spec.ts", + "sha256": "43908447c69cbac930c12afc39fba189a8598061f5989dbe40de079aaf732a21", + "bytes": 2247 + }, + { + "path": "frontend/e2e/api-contract.spec.ts", + "sha256": "f920c5af3c04ad02b884a038a9799aa9a5b63e0e036269f6ffbf1c114b7de644", + "bytes": 3355 + }, + { + "path": "frontend/e2e/branding.spec.ts", + "sha256": "9f133b4f15405efcc44cba21624b1eeb08bf3eede29d784e889acb7b7b8efef1", + "bytes": 1355 + }, + { + "path": "frontend/e2e/eventlens.spec.ts", + "sha256": "d0ca700bf291787b6b2c551a2c9898c00d8af52e7c7803c1e44e7f7ce4b9cf3d", + "bytes": 2742 + }, + { + "path": "frontend/e2e/partial-and-error.spec.ts", + "sha256": "6c95dcc14fd78047127ab7b24e93b9ba641f67fb270f0df882d3e8f3a9149aee", + "bytes": 2437 + }, + { + "path": "frontend/e2e/portfolio-assets.spec.ts", + "sha256": "8e6a84162b994fc37f6cc63326ac4c9d4a405722d9ee15e9a0bce28537fb9a46", + "bytes": 1899 + }, + { + "path": "frontend/e2e/real-evtx.spec.ts", + "sha256": "6bc637105498c3e10605572cd5e23cc751f7f0484565cce771baea506b117732", + "bytes": 1149 + }, + { + "path": "frontend/e2e/responsive.spec.ts", + "sha256": "fecd2af0a7037e52f669a718484df4f9d43b126c95ee1e552b58a358fa27d722", + "bytes": 1197 + }, + { + "path": "frontend/e2e/settings-storage-failure.spec.ts", + "sha256": "a4662e7edade225558561fecede0bbb1801a2f873996a2dc712a2728e234ef8c", + "bytes": 1580 + }, + { + "path": "frontend/e2e/settings.spec.ts", + "sha256": "270d801f4ee2773ffb20e4e107f8864181acc17f44532eb4ca4f29d0e44ac761", + "bytes": 3469 + }, + { + "path": "frontend/e2e/virtualization.spec.ts", + "sha256": "f40284f9ff7a57e689c62b369b03281c7d554791889738447caa78af95ed1a03", + "bytes": 1433 + }, + { + "path": "frontend/e2e/workspace.spec.ts", + "sha256": "9ffbd7c6df504990c52b7426b84d23f8121fa4d5a61bdbdc87e7c8f251bd5f59", + "bytes": 4606 + }, + { + "path": "frontend/eslint.config.mjs", + "sha256": "a44f173c1c676000fdfdbb4a00653a350b7c79ff33905e7459af60141fa5f3d3", + "bytes": 1468 + }, + { + "path": "frontend/index.html", + "sha256": "e5c50877769b161ae8e2390b9493fb8189c8d7cab464f561b4eb695eec7177ab", + "bytes": 866 + }, + { + "path": "frontend/package-lock.json", + "sha256": "80d66b567277ebe9a8e80889879712b1d95a0cf412971f5789320fa8e4a22bf4", + "bytes": 198707 + }, + { + "path": "frontend/package.json", + "sha256": "4ecf33f663fcaeb947dfe6fc70e2206daf1653103e6f35ff50ca44ffcc455342", + "bytes": 805 + }, + { + "path": "frontend/playwright.config.ts", + "sha256": "41799d03b9057169815e739d1ba27a8663ad927a67b70be81dc757b42ebba30b", + "bytes": 867 + }, + { + "path": "frontend/public/apple-touch-icon.png", + "sha256": "94f9b61268f3df1f8eb82e0c655bada5a31e5e235a4f39af43b6af8d97187a36", + "bytes": 14307 + }, + { + "path": "frontend/public/eventlens-icon-192.png", + "sha256": "65b2a5e56748318a6521cac564fd318b1fe5d44e8043583af4851657ab06afe6", + "bytes": 13829 + }, + { + "path": "frontend/public/eventlens-icon-512.png", + "sha256": "ed72d01fbbcb1a42767a4f0ddf3753e968c6ae20d9da04e7259082de2e1f4be4", + "bytes": 19587 + }, + { + "path": "frontend/public/favicon.ico", + "sha256": "15bfcabc811d370f9c264b993082f1134cbd64110f4f88f97c0df7da961a7c02", + "bytes": 6050 + }, + { + "path": "frontend/public/favicon.svg", + "sha256": "ec7ab2dc3bbfc49f509f564306c976da51d70e15e765e51bf92dbae256a59c0f", + "bytes": 646 + }, + { + "path": "frontend/public/site.webmanifest", + "sha256": "e8ecd0422ff69eaf31da44605039816c01d69838e4243f56dc16cd28957899e5", + "bytes": 630 + }, + { + "path": "frontend/src/app/App.tsx", + "sha256": "4fdac8c7bbb3bdee747bda015de40c7991493d0fde6a0ad46a6419a2f330d116", + "bytes": 16742 + }, + { + "path": "frontend/src/app/format.ts", + "sha256": "980648a970eef09d6bf2f81d481a7bd441aaa4f6a98c37c538bda37e4f09aff6", + "bytes": 2780 + }, + { + "path": "frontend/src/app/model.ts", + "sha256": "7fa5a714f0686a9ee461f89c7a552f508cc30b2db09cec8c3dbebf36565628b8", + "bytes": 2857 + }, + { + "path": "frontend/src/app/validation.test.ts", + "sha256": "a90a4f313fa41765d259a322b45611a66f5b589cf8ad75390f958fb80f3a250b", + "bytes": 3065 + }, + { + "path": "frontend/src/app/validation.ts", + "sha256": "d6d87231ba58269a2c37ffe98923078645cd4c11bd5210a3cb84d10d8286d95b", + "bytes": 4547 + }, + { + "path": "frontend/src/components/icons.tsx", + "sha256": "f40aa04da4b58ef561c41a2af1b08119678d9362057b70612e96b0fa297dd8b6", + "bytes": 3775 + }, + { + "path": "frontend/src/components/shell.tsx", + "sha256": "12208aa1454ca175017487b3d20e038dd7e947a49db270ab9243d8d8a4c85806", + "bytes": 4613 + }, + { + "path": "frontend/src/components/states.tsx", + "sha256": "c23c32d65e58d9eba3af8033f8052209089d2d525477f17eb12155e2219dbb31", + "bytes": 4854 + }, + { + "path": "frontend/src/components/timeline.tsx", + "sha256": "21dd8ce0bcc049f5cd4a32d5dda973030f65615432da4dc449e21835dad06b5b", + "bytes": 14520 + }, + { + "path": "frontend/src/export.test.ts", + "sha256": "268c710a57c1fb860c0f6092af4433e751c75d1465bfb8d76ac43fee502ee74f", + "bytes": 3144 + }, + { + "path": "frontend/src/export.ts", + "sha256": "c0f71ab393db8263dffb679d3ef3f10d881a9ed2cb3485035a10fd44cf9302bf", + "bytes": 4831 + }, + { + "path": "frontend/src/filter.performance.test.ts", + "sha256": "720cf8994e6e898d4560ed1cf91ef019e684d3da41c2f4e34e3c7b4d3daf356d", + "bytes": 1092 + }, + { + "path": "frontend/src/filter.test.ts", + "sha256": "c0c42d1d3a78e2d956c13a528fded79b9cb7025f98124d4b70eeda2212bfd644", + "bytes": 2348 + }, + { + "path": "frontend/src/filter.ts", + "sha256": "d2e1595251138fbfa1d7b9b768b004a2ab540f1a85fd558c0b75eec3516472d0", + "bytes": 2443 + }, + { + "path": "frontend/src/main.tsx", + "sha256": "7769fc3cb8a7e6b4fda3a8c8b49e0c046f34a2d5dbc71c23093bcfab83f2bf9e", + "bytes": 341 + }, + { + "path": "frontend/src/redact.test.ts", + "sha256": "8e0715734dcd61d51bc41239db3190f046da7de78048930b162ce599024899a8", + "bytes": 4557 + }, + { + "path": "frontend/src/redact.ts", + "sha256": "0c9e30ad90bb19ada06024c8f7a91252beba8aa193899f6f084749b5afeb0cf2", + "bytes": 7930 + }, + { + "path": "frontend/src/styles.css", + "sha256": "ca14e2cca59c1a0e4f2a8f79aaefb6c3c756a4da91e943f34eda89fe12a0960f", + "bytes": 43338 + }, + { + "path": "frontend/src/types.ts", + "sha256": "13aa2a01ac49f3626da88017d6f06d4474fb9c781ed27bf4f7b0faef66e3675e", + "bytes": 1217 + }, + { + "path": "frontend/src/vite-env.d.ts", + "sha256": "424faf9241dd699dda995b367ed36665732da1e6ec1f33b2fd40394488ecac92", + "bytes": 39 + }, + { + "path": "frontend/src/workspaces/AnalysisView.tsx", + "sha256": "7b3e576fe130c02436ae1c8ab97f4054409718a382626ade0769330f08414d36", + "bytes": 2813 + }, + { + "path": "frontend/src/workspaces/HuntingView.tsx", + "sha256": "63965c7f11a7a0ffd5b345c562d985842b0546c00286f14defcd062e0deadb51", + "bytes": 6348 + }, + { + "path": "frontend/src/workspaces/ReportsView.tsx", + "sha256": "99f541f6ef4e775761c9117c1e4eb60821a80b1b490360884482ea9496a596d9", + "bytes": 5416 + }, + { + "path": "frontend/src/workspaces/SettingsView.tsx", + "sha256": "feafb35e6f54f934ad3d5214d6c79d9e8f22997efbbfc8a8e4eff2618b2ec3e2", + "bytes": 8004 + }, + { + "path": "frontend/src/workspaces/TimelineView.tsx", + "sha256": "1c0d571f57d6699c63f95a2c234fcbd5e5ae509c81cea42ef23a164c2f849cf1", + "bytes": 2601 + }, + { + "path": "frontend/tsconfig.json", + "sha256": "715065df676b49f489e9fdf3b3d9bcc7d978d8e0b696a1d59918432006fd93d4", + "bytes": 419 + }, + { + "path": "frontend/vite.config.ts", + "sha256": "789713c0deb31de7fab87deb6e3ff83294b33396d71915bfea94d8446bde6589", + "bytes": 407 + }, + { + "path": "frontend/vitest.config.ts", + "sha256": "90ea927fec7f0a4e9608f65171ec0c748f965304c50be5cca4000a8f967d7d10", + "bytes": 158 + }, + { + "path": "samples/demo-events.json", + "sha256": "55c0dab7dd2baf1d184e814cd139289c8fb5402952eb5127d54bf93865fc1e9b", + "bytes": 1688 + } + ] +} diff --git a/README.md b/README.md new file mode 100644 index 0000000..7eaa89d --- /dev/null +++ b/README.md @@ -0,0 +1,145 @@ +# EventLens-Public + +EventLens is a local/self-hosted Windows Event Log incident reconstruction tool. It turns a real `.evtx` export into normalized evidence, deterministic incident windows and a readable timeline that helps answer: **what happened, in what order, and which records are probably related?** + +![EventLens demo overview](docs/assets/eventlens-demo-overview.png) + +## What it solves + +Windows event logs are detailed but difficult to scan during an incident. EventLens provides a bounded workflow: + +```text +EVTX upload -> size/resource gate -> normalize -> deterministic correlation -> timeline/evidence inspector -> redacted export +``` + +It preserves source evidence, makes every grouping explainable, and keeps the analysis local. + +## Product boundary + +EventLens is deliberately not a SIEM, a full Windows Event Viewer replacement, a cloud platform or an AI product. It has no database, authentication, telemetry, background worker, cloud account or LLM requirement. It focuses on one compact job: reconstructing a bounded incident story from Windows event records. + +## v1.0.6 capabilities + +- Parses real EVTX in memory with the Rust-backed `evtx` engine. +- Enforces a 50 MiB file cap plus a receive-level request cap, 100,000-event cap, cooperative 8-second parse budget and bounded normalized output. +- Reports `complete`, `partial` or `failed` parser status with stable issue codes, retained/skipped metrics and export metadata. +- Normalizes System, EventData and UserData into a stable evidence contract; unreliable timestamps remain explicit and are never converted to epoch evidence. +- Correlates provider/channel-scoped startup, shutdown, service, DNS, authentication and crash patterns using stable rule IDs, incident IDs and evidence event IDs. +- Keeps unmatched warning/error evidence visible and compresses repeated signatures without deleting source events. +- Supports drag/drop, search, category/level/provider filters, informational-noise suppression, incident focus and ±1/5/15/60-minute evidence windows. +- Shows the rule, reason, time window and exact evidence IDs behind each incident. +- Exports semantically equivalent JSON and Markdown in the browser. Redaction is enabled by default and previews host, identity, e-mail, IP, path and source-name replacement counts before export. +- Uses `no-store` responses, security headers, bounded parse concurrency, sanitized source names and no intentional upload persistence. +- Virtualizes large timelines so a 100,000-event analysis does not create 100,000 DOM rows. +- Includes a deterministic demo fixture plus a pinned-hash public real-EVTX qualification fixture in CI and Playwright. +- Provides five functional workspaces over the same in-memory analysis: Analysis overview, Timeline investigation, Hunting facets, Reports/export and local-only Settings. +- Preserves workspace navigation and browser hash history without persisting event data; each workspace has an explicit empty state when no analysis is loaded. +- Uses a responsive, keyboard-accessible shell with shared event filters, a virtualized timeline and an evidence inspector that remains available from Hunting results. +- Ships one local, canonical evidence-lens mark across the top bar, browser favicon, touch/app icons and web manifest; it makes no network request and carries no tracking. +- Keeps investigation orientation visible across Analysis, Timeline, Hunting and Reports with a compact source/completeness/evidence context strip and export-readiness summary. +- Gives the existing browser-local preferences a dedicated, keyboard-accessible Settings workspace: native radio-backed option cards, a semantic export-redaction switch, explicit autosave feedback, a privacy boundary and a one-click preference reset. +- Keeps source identity in one shared context strip, promotes parser completeness/skipped-record metrics in Analysis and reserves first-use guidance for the deterministic demo. + +## Privacy and security + +Event logs can contain usernames, hostnames, IP addresses, e-mail addresses, executable paths and application-specific data. EventLens: + +- processes uploads only for the current request and closes the multipart handle; +- never renders raw XML as markup and escapes untrusted values through React rendering; +- bounds input size, parser records, fields, strings, normalized output and parse time; +- bounds request bytes independently of `Content-Length` and admits only a small number of concurrent parses; +- does not log event contents or write an application database; +- previews best-effort redaction of hosts, identities (including domain accounts, SIDs and machine accounts), e-mails, IPv4/IPv6, Windows/UNC paths and source filenames before export. + +Redaction is a privacy aid, not a formal DLP engine. Review an export before sharing it. See [SECURITY.md](SECURITY.md) and [docs/PRIVACY.md](docs/PRIVACY.md). + +## Portfolio walkthrough + +1. Open the deployed instance or start EventLens locally. +2. Select **Load demo** for a deterministic six-event walkthrough. +3. Review the source/completeness summary in **Analysis** and select an incident. +4. Investigate the linked evidence in **Timeline** with search, facets, focus and time windows. +5. Use **Hunting** for combined event-ID, provider, category, level, host and incident-membership searches. +6. Review the redaction preview and download JSON or Markdown from **Reports**. +7. Adjust UTC/local timestamps, density and default local preferences in **Settings**. + +![Redaction and export preview](docs/assets/eventlens-redaction-export.png) + +## Run locally + +Backend (locked dependencies): + +```bash +cd backend +python -m pip install uv==0.10.0 +python -m uv sync --locked --extra dev +python -m uv run --locked --extra dev uvicorn app.main:app --reload --port 8000 +``` + +Frontend: + +```bash +cd frontend +npm ci +npm test +npm run lint +npm run build +npm run dev +``` + +The development UI uses `http://127.0.0.1:8000` for the API. Set `VITE_API_BASE_URL` when the API runs elsewhere. In a production image the UI and API are same-origin. + +## Docker + +```bash +docker compose up --build +``` + +Open [http://localhost:1252](http://localhost:1252). The production image uses digest-pinned base images, `npm ci`, `backend/uv.lock`, a non-root runtime user, dropped Linux capabilities, a read-only root filesystem and a bounded `/tmp` tmpfs. The health endpoint is [http://localhost:1252/health](http://localhost:1252/health); its `revision` is the exact injected build SHA (`local` for an unlabelled development build). + +For an Unraid DockerMan-managed Compose deployment, the compose metadata publishes the WebUI URL and serves the durable canonical icon locally at `/eventlens-icon-512.png` through `net.unraid.docker.webui` and `net.unraid.docker.icon`. A broker-managed deployment must preserve those service labels for DockerMan to import them; EventLens does not claim DockerMan lifecycle ownership. + +## Validation + +The release gates are reproducible from a clean checkout: + +```bash +cd backend +python -m uv sync --locked --extra dev +python -m uv run --locked --extra dev pytest -q -W error::DeprecationWarning +python -m uv run --locked --extra dev ruff check . +python -m uv run --locked --extra dev pip-audit --strict + +cd ../frontend +npm ci +npm test +npm run lint +npm run build +npx playwright install chromium +npm run test:e2e +npm audit --audit-level=moderate +``` + +The private canonical repository maintains its own validation and deployment workflows. This public snapshot includes the application and reproducible tests; it does not include private infrastructure automation or deployment evidence. + +## Deployment and access + +Compose publishes port 1252 on all host interfaces. For local use, change the mapping to `127.0.0.1:1252:8000`. There is no built-in authentication; use network isolation and an authenticated HTTPS reverse proxy before allowing other users to upload sensitive evidence. Configure the build revision via `GITEA_COMMIT_SHA` when reproducible deployment identity is needed. + +The screenshots show the deterministic bundled demo, not a real incident or an uploaded customer log. + +## Limitations + +- Correlation describes temporal/semantic relationships supported by evidence; it does not prove causality. +- Rules are intentionally small and Windows-focused. Custom rules, hunting queries, alerting and retention are outside the product boundary. +- The EVTX parser and browser analysis are bounded for safety; partial parses surface issues instead of pretending completeness. +- Redaction is best-effort and application-specific values may still contain sensitive data. +- A real Windows EVTX file is required for parser analysis; the bundled demo intentionally bypasses only the raw parser step. + +## License + +No project-wide license file is included in this repository. Publishing the source does not grant an open-source license. Normal copyright restrictions and the applicable terms for individual third-party components remain in effect. + +## Public source distribution + +The private canonical repository remains the development source. Reviewed snapshots are synchronized automatically to `EventLens-Public` after changes reach its default branch. The public export contains application source, dependency locks, generic deployment examples and selected demo visuals; private Git history, infrastructure workflows and operational records are excluded. `PUBLIC_SOURCE_MANIFEST.json` identifies the exact source revision and file hashes. diff --git a/SECURITY.md b/SECURITY.md new file mode 100644 index 0000000..f783144 --- /dev/null +++ b/SECURITY.md @@ -0,0 +1,51 @@ +# Security and privacy policy + +EventLens is a defensive, local/self-hosted Windows Event Log analysis tool. It is designed for bounded incident reconstruction, not for centralized log retention or alerting. + +## Data handling + +- The selected `.evtx` file is processed at the request boundary and is not intentionally persisted by EventLens. +- FastAPI/Starlette may use a transient multipart spool while receiving a request; the upload handle is explicitly closed in a `finally` block and EventLens does not copy it to an application file. +- Analysis state lives in browser component memory for the current session. Only non-sensitive UI preferences are stored in the single `eventlens.preferences.v1` localStorage record; the Settings workspace exposes that boundary, saves preferences automatically and resets only that record. EventLens never stores event text, EVTX-derived values or analysis results there. There is no application database, account system, telemetry, analytics, cloud storage or third-party event upload. +- API and health responses use `Cache-Control: no-store`; API responses also use `Pragma: no-cache`. +- The API sanitizes uploaded filenames to a short basename before returning them. Export filenames are sanitized in the browser. +- Event contents are not written to application logs. Runtime logs contain request paths/statuses only. + +## Untrusted input controls + +The EVTX/XML boundary is hostile-input handling, not trusted document parsing. The current limits are: + +- 50 MiB file cap plus a 51 MiB request-envelope gate enforced while ASGI body messages are received, independent of `Content-Length`; +- 100,000 normalized-event cap; +- cooperative 8-second parser budget; +- 2 MiB per parser-record JSON cap; +- 200 normalized fields per event; +- 256-character provider/channel/computer and 512-character summary caps; +- 1,000-character normalized field-value cap, bounded field keys and a 16 MiB normalized-output budget; +- deterministic single-thread parser execution with a process-local bounded admission gate (one active parse by default, with a configurable queue capped at four waiting requests); +- generic parser errors and generic skipped-record issues without raw exception/event payloads; unexpected programmer/parser failures are logged only with stage, exception class and a non-data fingerprint and return a generic client error; +- `complete`, `partial` and `failed` parse status. Partial status means records were omitted or parser recovery/truncation occurred; timestamp-quality notes alone do not make a complete record set look partial. + +Malformed/corrupt files are rejected when no event can be recovered; partial recovery is marked in parse statistics. The Rust-backed `evtx` parser remains an external parser dependency and is isolated behind the parser module. + +## Presentation and export safety + +- Raw XML is never returned to or injected into the UI. The inspector exposes the normalized JSON contract. +- React renders event text as values, not HTML. +- Redaction works on a clone and previews host, identity, e-mail, IPv4/IPv6, Windows/UNC path and source-name replacements before export. Known structured identities are propagated into summaries, incident titles and reasons; domain accounts, SIDs and machine accounts are covered conservatively. +- Markdown exports treat every event value as untrusted text: headings, links, images, HTML, tables and code-fence delimiters are escaped or placed inside a safe dynamic code span. +- Redaction is best-effort; users must inspect reports before external sharing. +- Correlation copy explicitly describes evidence-supported relationships and does not claim causality. + +## Dependency and release controls + +- Frontend release installs use `frontend/package-lock.json` and `npm ci`. +- Python release installs use `backend/uv.lock` and `uv sync --locked`. +- Base images are pinned by manifest digest in `Dockerfile`; the maintenance task is to update the tag and digest together and rerun the full validation. +- CI runs Ruff, backend tests with deprecation warnings treated as errors, `pip-audit`, frontend lint/tests/typecheck/build, `npm audit`, deterministic Playwright journeys, Docker runtime smoke, a Trivy high/critical image scan and a CycloneDX image SBOM generation step. +- The real-EVTX CI fixture is fetched from a pinned upstream tag and accepted only when its EVTX magic and SHA-256 match the recorded value. +- The runtime container is non-root, read-only-compatible, uses a bounded `/tmp`, drops all Linux capabilities and enables `no-new-privileges`. + +## Reporting issues + +Use synthetic or already-public event samples. Never attach production logs containing credentials, personal data, confidential hostnames or internal network details to a public issue. Describe the smallest reproducible input and remove raw event payloads from screenshots and logs. diff --git a/VERSION b/VERSION new file mode 100644 index 0000000..af0b7dd --- /dev/null +++ b/VERSION @@ -0,0 +1 @@ +1.0.6 diff --git a/backend/app/__init__.py b/backend/app/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/backend/app/correlate.py b/backend/app/correlate.py new file mode 100644 index 0000000..2e92f19 --- /dev/null +++ b/backend/app/correlate.py @@ -0,0 +1,362 @@ +import hashlib +from collections.abc import Callable +from dataclasses import dataclass +from datetime import UTC, datetime, timedelta + +from .models import Category, IncidentCluster, NormalizedEvent +from .normalize import ( + is_application_error, + is_dns_client, + is_event_log, + is_kernel_general, + is_kernel_power, + is_security_audit, + is_service_control_manager, + is_windows_error_reporting, +) + +TitleBuilder = Callable[[list[NormalizedEvent]], str] +ReasonBuilder = Callable[[list[NormalizedEvent]], str] + + +@dataclass(frozen=True) +class Rule: + id: str + category: Category + severity: str + window_seconds: int + predicate: Callable[[NormalizedEvent], bool] + key: Callable[[NormalizedEvent], str | None] + title_for: TitleBuilder + reason_for: ReasonBuilder + + +def _field(event: NormalizedEvent, *names: str) -> str: + for name in names: + value = event.fields.get(name, "").strip() + if value: + return value + return "" + + +def _dimension(value: str) -> str | None: + normalized = value.strip() + if not normalized or normalized.casefold() in { + "unknown", + "unknown-account", + "unknown-host", + "unknown-process", + "unknown-service", + "n/a", + "-", + }: + return None + return normalized + + +def _host(event: NormalizedEvent) -> str | None: + return _dimension(event.computer) + + +def _process(event: NormalizedEvent) -> str | None: + return _dimension(_field(event, "process", "EventData.AppName", "EventData.Data[0]")) + + +def _service(event: NormalizedEvent) -> str | None: + return _dimension(_field(event, "service", "EventData.param1", "UserData.param1")) + + +def _account(event: NormalizedEvent) -> str | None: + return _dimension(_field(event, "EventData.TargetUserName", "TargetUserName")) + + +def _group_key(*dimensions: str | None) -> str | None: + if any(value is None for value in dimensions): + return None + return "|".join(value.casefold() for value in dimensions if value is not None) + + +def _crash(event: NormalizedEvent) -> bool: + return is_application_error(event.provider, event.channel, event.event_id) or is_windows_error_reporting( + event.provider, event.channel, event.event_id + ) + + +def _service_failure(event: NormalizedEvent) -> bool: + return is_service_control_manager(event.provider, event.channel) and event.event_id in {7023, 7024, 7031, 7034} + + +def _dns_timeout(event: NormalizedEvent) -> bool: + return is_dns_client(event.provider, event.channel) and event.event_id == 1014 + + +def _failed_logon(event: NormalizedEvent) -> bool: + return is_security_audit(event.provider, event.channel) and event.event_id == 4625 + + +def _normal_startup(event: NormalizedEvent) -> bool: + return (is_kernel_general(event.provider, event.channel) and event.event_id == 12) or ( + is_event_log(event.provider, event.channel) and event.event_id == 6005 + ) + + +def _normal_shutdown(event: NormalizedEvent) -> bool: + return (is_kernel_general(event.provider, event.channel) and event.event_id == 13) or ( + is_event_log(event.provider, event.channel) and event.event_id == 6006 + ) + + +def _unexpected_shutdown(event: NormalizedEvent) -> bool: + return (is_kernel_power(event.provider, event.channel) and event.event_id == 41) or ( + is_event_log(event.provider, event.channel) and event.event_id == 6008 + ) + + +def _crash_title(evidence: list[NormalizedEvent]) -> str: + ids = {event.event_id for event in evidence} + if {1000, 1001}.issubset(ids): + return "Application crash and reporting sequence" + if 1000 in ids: + return "Application crash recorded" + return "Crash report recorded" + + +def _crash_reason(evidence: list[NormalizedEvent]) -> str: + ids = {event.event_id for event in evidence} + if {1000, 1001}.issubset(ids): + return "Application Error and Windows Error Reporting records were temporally related; no causal claim is made." + return "A crash-related provider record was observed; a reporting sequence is not established by this evidence." + + +def _service_title(evidence: list[NormalizedEvent]) -> str: + return "Service failure window" if len(evidence) > 1 else "Service failure recorded" + + +def _service_reason(evidence: list[NormalizedEvent]) -> str: + service = _service(evidence[0]) + if service is None or _host(evidence[0]) is None: + return "Service Control Manager reported a service failure; no service/host grouping was applied because a grouping dimension was unavailable." + return "Service Control Manager reported an abnormal service termination for the same known service and host." + + +def _dns_title(evidence: list[NormalizedEvent]) -> str: + return "DNS timeout activity" if len(evidence) > 1 else "DNS timeout recorded" + + +def _dns_reason(evidence: list[NormalizedEvent]) -> str: + if _host(evidence[0]) is None: + return "DNS Client reported a timeout; no host grouping was applied because the computer identity was unavailable." + return "DNS Client timeout events were observed in the same bounded window on the same known host." + + +def _auth_title(evidence: list[NormalizedEvent]) -> str: + if len(evidence) >= 3: + return "Failed sign-in burst" + if len(evidence) == 2: + return "Repeated failed sign-ins" + return "Failed sign-in recorded" + + +def _auth_reason(evidence: list[NormalizedEvent]) -> str: + if _group_key(_host(evidence[0]), _account(evidence[0])) is None: + return "Security Auditing reported a failed sign-in; no account/host grouping was applied because a grouping dimension was unavailable." + return "Security Auditing reported failed sign-ins for the same known account and host; this is evidence of activity, not proof of cause." + + +def _startup_title(evidence: list[NormalizedEvent]) -> str: + return "Normal startup sequence" if len(evidence) > 1 else "Normal startup evidence" + + +def _startup_reason(evidence: list[NormalizedEvent]) -> str: + return "Kernel-General/EventLog startup records were temporally related; no cause is inferred." + + +def _shutdown_title(evidence: list[NormalizedEvent]) -> str: + return "Normal shutdown evidence" + + +def _shutdown_reason(evidence: list[NormalizedEvent]) -> str: + return "Kernel-General/EventLog shutdown evidence was observed; no cause is inferred." + + +def _unexpected_title(evidence: list[NormalizedEvent]) -> str: + return "Unexpected shutdown/restart evidence" + + +def _unexpected_reason(evidence: list[NormalizedEvent]) -> str: + return "Kernel-Power/EventLog records indicate an unexpected shutdown or restart; the logs do not establish why it occurred." + + +RULES = ( + Rule( + "windows.crash.application-report", + "crash", + "critical", + 120, + _crash, + lambda event: _group_key(_host(event), _process(event)), + _crash_title, + _crash_reason, + ), + Rule( + "windows.service.failure", + "service", + "warning", + 120, + _service_failure, + lambda event: _group_key(_host(event), _service(event)), + _service_title, + _service_reason, + ), + Rule( + "windows.network.dns-timeout", + "network", + "warning", + 120, + _dns_timeout, + lambda event: _group_key(_host(event)), + _dns_title, + _dns_reason, + ), + Rule( + "windows.auth.failed-logon", + "authentication", + "warning", + 120, + _failed_logon, + lambda event: _group_key(_host(event), _account(event)), + _auth_title, + _auth_reason, + ), + Rule( + "windows.system.startup", + "system", + "info", + 300, + _normal_startup, + lambda event: _group_key(_host(event)), + _startup_title, + _startup_reason, + ), + Rule( + "windows.system.shutdown.normal", + "system", + "info", + 300, + _normal_shutdown, + lambda event: _group_key(_host(event)), + _shutdown_title, + _shutdown_reason, + ), + Rule( + "windows.system.shutdown.unexpected", + "system", + "warning", + 300, + _unexpected_shutdown, + lambda event: _group_key(_host(event)), + _unexpected_title, + _unexpected_reason, + ), +) + + +def _event_sort_key(event: NormalizedEvent) -> tuple[bool, datetime, str]: + reliable_timestamp = event.timestamp is not None and event.timestamp_valid + return ( + not reliable_timestamp, + event.timestamp if reliable_timestamp else datetime.max.replace(tzinfo=UTC), + event.id, + ) + + +def _groups_for_rule(events: list[NormalizedEvent], rule: Rule) -> list[list[NormalizedEvent]]: + buckets: dict[str, list[NormalizedEvent]] = {} + isolated_number = 0 + for event in events: + if not rule.predicate(event) or event.timestamp is None or not event.timestamp_valid: + continue + key = rule.key(event) + if key is None: + isolated_number += 1 + key = f"__isolated__{isolated_number}:{event.id}" + buckets.setdefault(key, []).append(event) + groups: list[list[NormalizedEvent]] = [] + window = timedelta(seconds=rule.window_seconds) + for key in sorted(buckets): + ordered = sorted(buckets[key], key=_event_sort_key) + current: list[NormalizedEvent] = [] + for event in ordered: + if not current or event.timestamp - current[0].timestamp <= window: + current.append(event) + else: + groups.append(current) + current = [event] + if current: + groups.append(current) + return groups + + +def _incident_id(rule_id: str, evidence: list[NormalizedEvent]) -> str: + seed = f"{rule_id}|{'|'.join(event.id for event in evidence)}".encode() + return f"incident-{hashlib.sha256(seed).hexdigest()[:16]}" + + +def _build(rule: Rule, evidence: list[NormalizedEvent]) -> IncidentCluster: + signatures = {(event.provider, event.event_id, event.summary) for event in evidence} + reasons = [rule.reason_for(evidence)] + if len(evidence) > 1: + seconds = int((evidence[-1].timestamp - evidence[0].timestamp).total_seconds()) + reasons.append(f"{len(evidence)} evidence events occurred within {seconds} second(s).") + if len(signatures) < len(evidence): + reasons.append(f"Repeated signals compress from {len(evidence)} records to {len(signatures)} distinct signature(s).") + return IncidentCluster( + id=_incident_id(rule.id, evidence), + rule_id=rule.id, + start=evidence[0].timestamp, + end=evidence[-1].timestamp, + title=rule.title_for(evidence), + category=rule.category, + severity=rule.severity, + reasons=reasons, + evidence_event_ids=[event.id for event in evidence], + original_count=len(evidence), + compressed_count=max(1, len(signatures)), + ) + + +def correlate(events: list[NormalizedEvent]) -> list[IncidentCluster]: + ordered = sorted(events, key=_event_sort_key) + incidents: list[IncidentCluster] = [] + consumed: set[str] = set() + for rule in RULES: + for group in _groups_for_rule(ordered, rule): + incidents.append(_build(rule, group)) + consumed.update(event.id for event in group) + fallback_rule_id = "windows.generic.attention" + for event in ordered: + if event.id not in consumed and event.level.casefold() in {"critical", "error", "warning"}: + incidents.append( + IncidentCluster( + id=_incident_id(fallback_rule_id, [event]), + rule_id=fallback_rule_id, + start=event.timestamp if event.timestamp_valid else None, + end=event.timestamp if event.timestamp_valid else None, + title=event.summary or "Unclassified attention event", + category=event.category, + severity="warning", + reasons=["An error or warning was not matched by a more specific correlation rule."], + evidence_event_ids=[event.id], + original_count=1, + compressed_count=1, + ) + ) + return sorted( + incidents, + key=lambda incident: ( + incident.start is None, + incident.start or datetime.max.replace(tzinfo=UTC), + incident.rule_id, + incident.id, + ), + ) diff --git a/backend/app/demo.py b/backend/app/demo.py new file mode 100644 index 0000000..2714801 --- /dev/null +++ b/backend/app/demo.py @@ -0,0 +1,12 @@ +import json +from pathlib import Path + +from .models import NormalizedEvent + + +def load_demo() -> list[NormalizedEvent]: + path = Path(__file__).resolve().parents[2] / "samples" / "demo-events.json" + return [ + NormalizedEvent.model_validate(item) + for item in json.loads(path.read_text(encoding="utf-8")) + ] diff --git a/backend/app/main.py b/backend/app/main.py new file mode 100644 index 0000000..8050edb --- /dev/null +++ b/backend/app/main.py @@ -0,0 +1,319 @@ +import asyncio +import json +import logging +import os +import re +from pathlib import Path +from typing import Any + +from fastapi import FastAPI, File, HTTPException, UploadFile +from fastapi.middleware.cors import CORSMiddleware +from fastapi.staticfiles import StaticFiles +from starlette.requests import ClientDisconnect + +from .correlate import correlate +from .demo import load_demo +from .models import AnalysisResponse, ParseIssue, ParseStats +from .parser import ( + MAX_UPLOAD_BYTES, + EvtxParseError, + UnexpectedParserError, + parse_evtx_bytes, +) +from .version import VERSION, read_revision + +logger = logging.getLogger(__name__) + +app = FastAPI(title="EventLens API", version=VERSION) +cors_origins = [ + origin.strip() + for origin in os.environ.get( + "EVENTLENS_CORS_ORIGINS", + "http://localhost:5173,http://127.0.0.1:5173,http://127.0.0.1:4173", + ).split(",") + if origin.strip() +] +app.add_middleware( + CORSMiddleware, + allow_origins=cors_origins, + allow_credentials=False, + allow_methods=["GET", "POST"], + allow_headers=["Content-Type"], +) + +MAX_MULTIPART_OVERHEAD_BYTES = 1024 * 1024 +MAX_REQUEST_BYTES = MAX_UPLOAD_BYTES + MAX_MULTIPART_OVERHEAD_BYTES +CONTENT_SECURITY_POLICY = ( + "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; " + "img-src 'self' data:; connect-src 'self' http://localhost:8000 http://127.0.0.1:8000 " + "http://localhost:5173 http://127.0.0.1:5173 http://127.0.0.1:4173; " + "font-src 'self'; object-src 'none'; base-uri 'none'; frame-ancestors 'none'; form-action 'self'" +) +SECURITY_HEADERS = { + "X-Content-Type-Options": "nosniff", + "Referrer-Policy": "no-referrer", + "Permissions-Policy": "camera=(), microphone=(), geolocation=()", + "Content-Security-Policy": CONTENT_SECURITY_POLICY, + "X-Frame-Options": "DENY", +} + + +def _bounded_env_int(name: str, default: int, minimum: int, maximum: int) -> int: + try: + value = int(os.environ.get(name, str(default))) + except (TypeError, ValueError): + value = default + return min(max(value, minimum), maximum) + + +PARSE_CONCURRENCY = _bounded_env_int("EVENTLENS_PARSE_CONCURRENCY", 1, 1, 2) +PARSE_QUEUE_LIMIT = _bounded_env_int("EVENTLENS_PARSE_QUEUE", 1, 0, 4) +PARSE_QUEUE_TIMEOUT_SECONDS = 0.25 +_parse_slots = asyncio.Semaphore(PARSE_CONCURRENCY) +_parse_admission_lock = asyncio.Lock() +_parse_inflight = 0 + + +class RequestBodyLimitMiddleware: + """Bound request bytes before Starlette's multipart parser expands the upload.""" + + def __init__(self, app: Any, max_bytes: int) -> None: + self.app = app + self.max_bytes = max_bytes + + async def __call__(self, scope: dict[str, Any], receive: Any, send: Any) -> None: + if scope.get("type") != "http" or scope.get("path") != "/api/analyze" or scope.get("method") != "POST": + await self.app(scope, receive, send) + return + + headers = {key.lower(): value for key, value in scope.get("headers", [])} + content_length = headers.get(b"content-length") + if content_length is not None: + try: + declared = int(content_length) + except (TypeError, ValueError): + declared = 0 + if declared > self.max_bytes: + await self._send_too_large(send) + return + + consumed = 0 + too_large = False + response_started = False + + async def limited_receive() -> dict[str, Any]: + nonlocal consumed, too_large + message = await receive() + if message.get("type") == "http.request": + consumed += len(message.get("body", b"")) + if consumed > self.max_bytes: + too_large = True + return {"type": "http.disconnect"} + return message + + async def guarded_send(message: dict[str, Any]) -> None: + nonlocal response_started + if too_large: + if message.get("type") == "http.response.start" and not response_started: + response_started = True + await self._send_too_large(send) + return + await send(message) + + try: + await self.app(scope, limited_receive, guarded_send) + except ClientDisconnect: + if not too_large: + raise + if too_large and not response_started: + await self._send_too_large(send) + + async def _send_too_large(self, send: Any) -> None: + body = json.dumps( + {"detail": {"code": "request_body_too_large", "message": "Upload request exceeds the bounded request limit."}} + ).encode("utf-8") + headers = [ + (b"content-type", b"application/json"), + (b"content-length", str(len(body)).encode()), + (b"cache-control", b"no-store"), + (b"pragma", b"no-cache"), + ] + headers.extend((name.lower().encode("ascii"), value.encode("ascii")) for name, value in SECURITY_HEADERS.items()) + await send( + { + "type": "http.response.start", + "status": 413, + "headers": headers, + } + ) + await send({"type": "http.response.body", "body": body}) + + +app.add_middleware(RequestBodyLimitMiddleware, max_bytes=MAX_REQUEST_BYTES) + + +@app.middleware("http") +async def response_security_headers(request, call_next): + response = await call_next(request) + for name, value in SECURITY_HEADERS.items(): + response.headers[name] = value + if request.url.path.startswith("/api/") or request.url.path == "/health": + response.headers["Cache-Control"] = "no-store" + response.headers["Pragma"] = "no-cache" + return response + + +@app.get("/health") +def health(): + return { + "status": "ok", + "evtx_ingestion": True, + "version": VERSION, + "revision": read_revision(), + } + + +@app.get("/api/demo", response_model=AnalysisResponse) +def demo(): + events = load_demo() + return AnalysisResponse(source="bundled-demo", events=events, incidents=correlate(events)) + + +async def _parse_with_admission(data: bytes): + global _parse_inflight + async with _parse_admission_lock: + if _parse_inflight >= PARSE_CONCURRENCY + PARSE_QUEUE_LIMIT: + raise HTTPException( + 503, + detail={ + "code": "parse_capacity_exceeded", + "message": "EventLens is already analyzing its maximum concurrent uploads; retry shortly.", + }, + headers={"Retry-After": "1"}, + ) + _parse_inflight += 1 + acquired = False + try: + try: + await asyncio.wait_for(_parse_slots.acquire(), timeout=PARSE_QUEUE_TIMEOUT_SECONDS) + acquired = True + except TimeoutError as exc: + raise HTTPException( + 503, + detail={ + "code": "parse_capacity_exceeded", + "message": "EventLens is busy analyzing another upload; retry shortly.", + }, + headers={"Retry-After": "1"}, + ) from exc + finally: + if not acquired: + async with _parse_admission_lock: + _parse_inflight -= 1 + try: + return await asyncio.to_thread(parse_evtx_bytes, data) + finally: + if acquired: + _parse_slots.release() + async with _parse_admission_lock: + _parse_inflight -= 1 + + +def _failed_parse_stats() -> ParseStats: + return ParseStats( + status="failed", + parsed_events=0, + records_seen=0, + skipped_records=0, + issue_count=1, + truncated=False, + truncation_reason=None, + duration_ms=0, + issues=[ParseIssue(code="parser_rejected_input", message="The EVTX parser rejected the input.")], + ) + + +@app.post("/api/analyze", response_model=AnalysisResponse) +async def analyze(file: UploadFile = File(...)): # noqa: B008 + try: + source = _safe_source_name(file.filename) + if not source.lower().endswith(".evtx"): + raise HTTPException(400, "Upload an .evtx file") + data = bytearray() + while True: + chunk = await file.read(min(1024 * 1024, MAX_UPLOAD_BYTES + 1 - len(data))) + if not chunk: + break + data.extend(chunk) + if len(data) > MAX_UPLOAD_BYTES: + raise HTTPException(413, "EVTX file exceeds the 50 MiB MVP limit") + try: + parsed = await _parse_with_admission(bytes(data)) + except EvtxParseError as exc: + raise HTTPException( + 422, + detail={ + "code": "parser_rejected_input", + "message": str(exc), + "parse": _failed_parse_stats().model_dump(mode="json"), + }, + ) from exc + except UnexpectedParserError as exc: + logger.error("Unexpected EVTX parser failure reached API exception_type=%s", type(exc).__name__) + raise HTTPException( + 500, + detail={"code": "parser_internal_error", "message": "EVTX analysis failed unexpectedly; retry the request."}, + ) from exc + if not parsed.events: + raise HTTPException( + 422, + detail={ + "code": "no_readable_events", + "message": "No readable Windows events were found in this file.", + "parse": ParseStats( + status="failed", + parsed_events=0, + records_seen=parsed.records_seen, + skipped_records=parsed.skipped_records, + issue_count=len(parsed.issues), + truncated=parsed.truncated, + truncation_reason=parsed.truncation_reason, + duration_ms=parsed.duration_ms, + issues=parsed.issues, + ).model_dump(mode="json"), + }, + ) + return AnalysisResponse( + source=source, + events=parsed.events, + incidents=correlate(parsed.events), + parse=ParseStats( + status=parsed.status, + parsed_events=len(parsed.events), + records_seen=parsed.records_seen, + skipped_records=parsed.skipped_records, + issue_count=len(parsed.issues), + truncated=parsed.truncated, + truncation_reason=parsed.truncation_reason, + duration_ms=parsed.duration_ms, + issues=parsed.issues, + ), + ) + finally: + await file.close() + + +def _safe_source_name(filename: str | None) -> str: + """Return a short display/export name without path or control characters.""" + candidate = re.split(r"[\\/]", filename or "")[-1] + candidate = "".join(char for char in candidate if char.isprintable()).strip() + candidate = re.sub(r"[^A-Za-z0-9._ -]", "_", candidate) + candidate = candidate[:128] + return candidate or "upload.evtx" + + +frontend_dir = os.environ.get("EVENTLENS_FRONTEND_DIR") +if frontend_dir: + path = Path(frontend_dir) + if path.is_dir(): + app.mount("/", StaticFiles(directory=str(path), html=True), name="frontend") diff --git a/backend/app/models.py b/backend/app/models.py new file mode 100644 index 0000000..a23669b --- /dev/null +++ b/backend/app/models.py @@ -0,0 +1,83 @@ +from datetime import UTC, datetime +from typing import Literal + +from pydantic import BaseModel, Field, field_validator, model_validator + +Category = Literal["system", "service", "network", "authentication", "application", "crash", "other"] +ParseStatus = Literal["complete", "partial", "failed"] +TimestampSource = Literal["event", "record", "missing", "invalid"] + + +class NormalizedEvent(BaseModel): + id: str = Field(max_length=128) + timestamp: datetime | None = None + timestamp_source: TimestampSource = "event" + timestamp_valid: bool = True + provider: str = Field(default="", max_length=256) + event_id: int | None = Field(default=None, ge=0, le=4_294_967_295) + level: str = Field(default="information", max_length=32) + channel: str = Field(default="", max_length=256) + computer: str = Field(default="", max_length=256) + category: Category = "other" + summary: str = Field(default="", max_length=512) + fields: dict[str, str] = Field(default_factory=dict, max_length=200) + + @field_validator("timestamp") + @classmethod + def normalize_naive_timestamp(cls, value: datetime | None) -> datetime | None: + if value is not None and value.tzinfo is None: + return value.replace(tzinfo=UTC) + return value + + @model_validator(mode="after") + def validate_timestamp_metadata(self) -> "NormalizedEvent": + if self.timestamp is None: + self.timestamp_valid = False + if self.timestamp_source in {"event", "record"}: + self.timestamp_source = "missing" + elif self.timestamp_source in {"missing", "invalid"}: + self.timestamp_valid = False + else: + self.timestamp_valid = True + return self + + +class IncidentCluster(BaseModel): + id: str = Field(max_length=128) + rule_id: str = Field(max_length=128) + start: datetime | None = None + end: datetime | None = None + title: str = Field(max_length=256) + category: Category + severity: str = Field(max_length=32) + reasons: list[str] = Field(max_length=8) + evidence_event_ids: list[str] + original_count: int = Field(ge=1) + compressed_count: int = Field(ge=1) + + +class ParseIssue(BaseModel): + code: str = Field(max_length=64) + record_id: int | None = None + message: str = Field(max_length=256) + skipped_record: bool = False + + +class ParseStats(BaseModel): + parser: str = "evtx-rs" + status: ParseStatus + parsed_events: int = Field(ge=0) + records_seen: int = Field(ge=0) + skipped_records: int = Field(ge=0) + issue_count: int = Field(ge=0) + truncated: bool + truncation_reason: str | None = Field(default=None, max_length=64) + duration_ms: int = Field(ge=0) + issues: list[ParseIssue] = Field(default_factory=list) + + +class AnalysisResponse(BaseModel): + source: str + events: list[NormalizedEvent] + incidents: list[IncidentCluster] + parse: ParseStats | None = None diff --git a/backend/app/normalize.py b/backend/app/normalize.py new file mode 100644 index 0000000..e81e08d --- /dev/null +++ b/backend/app/normalize.py @@ -0,0 +1,261 @@ +import hashlib +import json +from datetime import UTC, datetime +from typing import Any + +from .models import Category, NormalizedEvent, TimestampSource + +AUTH_EVENT_IDS = {4624, 4625, 4634, 4647, 4648, 4672, 4768, 4769, 4771, 4776} +LEVELS = {0: "information", 1: "critical", 2: "error", 3: "warning", 4: "information", 5: "verbose"} +MAX_EVENT_ID = 4_294_967_295 +MAX_RECORD_ID = 9_223_372_036_854_775_807 +MAX_FIELDS = 200 +MAX_FIELD_KEY_CHARS = 256 +MAX_FIELD_VALUE_CHARS = 1000 +MAX_NESTING_DEPTH = 16 +MAX_PROVIDER_CHARS = 256 +MAX_CHANNEL_CHARS = 256 +MAX_COMPUTER_CHARS = 256 +MAX_SUMMARY_CHARS = 512 + + +def _bounded_text(value: Any, limit: int, fallback: str = "") -> str: + if value is None: + return fallback + return str(value)[:limit] + + +def _attributes(value: Any) -> dict[str, Any]: + return value.get("#attributes", {}) if isinstance(value, dict) else {} + + +def _scalar(value: Any) -> Any: + if isinstance(value, dict): + for key in ("#text", "Value", "value"): + if key in value: + return value[key] + return value + + +def _integer(value: Any, minimum: int = 0, maximum: int = MAX_RECORD_ID) -> int | None: + value = _scalar(value) + if isinstance(value, bool): + return None + try: + parsed = int(value) + except (TypeError, ValueError, OverflowError): + return None + return parsed if minimum <= parsed <= maximum else None + + +def _coerce_timestamp(value: Any) -> datetime | None: + if isinstance(value, datetime): + return value if value.tzinfo else value.replace(tzinfo=UTC) + if value is None: + return None + text = str(value).strip() + if not text: + return None + if text.endswith("Z"): + text = f"{text[:-1]}+00:00" + try: + parsed = datetime.fromisoformat(text) + except (TypeError, ValueError): + return None + return parsed if parsed.tzinfo else parsed.replace(tzinfo=UTC) + + +def _timestamp(system: dict[str, Any], fallback: Any) -> tuple[datetime | None, TimestampSource]: + event_raw = _attributes(system.get("TimeCreated")).get("SystemTime") + if event_raw is not None: + parsed = _coerce_timestamp(event_raw) + if parsed is not None: + return parsed, "event" + record_parsed = _coerce_timestamp(fallback) + return (record_parsed, "record" if record_parsed is not None else "invalid") + if fallback is not None: + record_parsed = _coerce_timestamp(fallback) + return (record_parsed, "record" if record_parsed is not None else "invalid") + return None, "missing" + + +def _provider(system: dict[str, Any]) -> str: + value = system.get("Provider") + if isinstance(value, dict): + return _bounded_text(_attributes(value).get("Name") or value.get("Name"), MAX_PROVIDER_CHARS, "Unknown provider") + return _bounded_text(value, MAX_PROVIDER_CHARS, "Unknown provider") + + +def _store_field(output: dict[str, str], key: str, value: str, limit: int) -> None: + bounded_key = _bounded_text(key or "value", MAX_FIELD_KEY_CHARS) + if bounded_key not in output: + output[bounded_key] = value + return + suffix = 2 + while len(output) < limit: + suffix_key = _bounded_text(f"{bounded_key}#{suffix}", MAX_FIELD_KEY_CHARS) + if suffix_key not in output: + output[suffix_key] = value + return + suffix += 1 + + +def _flatten( + prefix: str, + value: Any, + output: dict[str, str], + limit: int = MAX_FIELDS, + depth: int = 0, +) -> None: + if len(output) >= limit: + return + if depth > MAX_NESTING_DEPTH: + _store_field(output, prefix or "value", "[nested value truncated]", limit) + return + if isinstance(value, dict): + for key, child in value.items(): + if key == "#attributes": + continue + next_prefix = f"{prefix}.{key}" if prefix else str(key) + _flatten(next_prefix, child, output, limit, depth + 1) + if len(output) >= limit: + return + return + if isinstance(value, list): + for index, child in enumerate(value): + _flatten(f"{prefix}[{index}]", child, output, limit, depth + 1) + if len(output) >= limit: + return + return + try: + rendered = json.dumps(value, ensure_ascii=False) if not isinstance(value, str) else value + except (TypeError, ValueError): + rendered = "[unrenderable value]" + _store_field(output, prefix or "value", rendered[:MAX_FIELD_VALUE_CHARS], limit) + + +def _channel_matches(channel: str, *accepted: str) -> bool: + return channel.strip().casefold() in {value.casefold() for value in accepted} + + +def is_security_audit(provider: str, channel: str) -> bool: + return provider.strip().casefold() == "microsoft-windows-security-auditing" and _channel_matches(channel, "Security") + + +def is_service_control_manager(provider: str, channel: str) -> bool: + return provider.strip().casefold() == "service control manager" and _channel_matches(channel, "System") + + +def is_dns_client(provider: str, channel: str) -> bool: + return provider.strip().casefold() == "microsoft-windows-dns-client" and _channel_matches(channel, "System") + + +def is_application_error(provider: str, channel: str, event_id: int | None) -> bool: + return provider.casefold().strip() == "application error" and event_id == 1000 and _channel_matches(channel, "Application") + + +def is_windows_error_reporting(provider: str, channel: str, event_id: int | None) -> bool: + return provider.casefold().strip() == "windows error reporting" and event_id == 1001 and _channel_matches(channel, "Application") + + +def is_event_log(provider: str, channel: str) -> bool: + return provider.casefold().strip() in {"eventlog", "microsoft-windows-eventlog"} and _channel_matches(channel, "System") + + +def is_kernel_general(provider: str, channel: str) -> bool: + return provider.strip().casefold() == "microsoft-windows-kernel-general" and _channel_matches(channel, "System") + + +def is_kernel_power(provider: str, channel: str) -> bool: + return provider.strip().casefold() == "microsoft-windows-kernel-power" and _channel_matches(channel, "System") + + +def classify(provider: str, event_id: int | None, channel: str) -> Category: + provider_lower = provider.casefold() + channel_lower = channel.casefold() + if is_service_control_manager(provider, channel): + return "service" + if is_dns_client(provider, channel) or any( + token in provider_lower for token in ("networkprofile", "tcpip", "dhcp", "nlasvc") + ): + return "network" + if is_security_audit(provider, channel) and event_id in AUTH_EVENT_IDS: + return "authentication" + if is_application_error(provider, channel, event_id) or is_windows_error_reporting(provider, channel, event_id): + return "crash" + if ( + (is_kernel_general(provider, channel) and event_id in {12, 13}) + or (is_kernel_power(provider, channel) and event_id == 41) + or (is_event_log(provider, channel) and event_id in {6005, 6006, 6008}) + ): + return "system" + if "application" in channel_lower: + return "application" + return "other" + + +def summarize(provider: str, event_id: int | None, category: Category, fields: dict[str, str]) -> str: + if category == "service" and event_id in {7023, 7024, 7031, 7034}: + service = fields.get("EventData.param1") or fields.get("UserData.param1") or fields.get("service") + return f"{service} terminated unexpectedly" if service else "Service failure recorded" + if category == "crash" and event_id == 1000: + process = fields.get("EventData.AppName") or fields.get("EventData.Data[0]") or fields.get("process") + return f"{process} crashed" if process else "Application crash recorded" + if category == "authentication" and event_id == 4625: + account = fields.get("EventData.TargetUserName") or fields.get("TargetUserName") + return f"Failed sign-in for {account}" if account else "Failed sign-in recorded" + return f"{provider} event {event_id}" if event_id is not None else f"{provider} event" + + +def normalize_record( + payload: dict[str, Any], + record_id: Any = None, + record_timestamp: Any = None, + record_ordinal: int | None = None, +) -> NormalizedEvent: + if not isinstance(payload, dict): + raise TypeError("Record does not contain an Event object") + event = payload.get("Event", payload) + if not isinstance(event, dict): + raise TypeError("Record does not contain an Event object") + system = event.get("System") if isinstance(event.get("System"), dict) else {} + event_id = _integer(system.get("EventID"), maximum=MAX_EVENT_ID) + provider = _provider(system) + channel = _bounded_text(_scalar(system.get("Channel")), MAX_CHANNEL_CHARS) + computer = _bounded_text(_scalar(system.get("Computer")), MAX_COMPUTER_CHARS) + level_value = _integer(system.get("Level"), maximum=5) + level = LEVELS.get(level_value, str(_scalar(system.get("Level")) or "information").lower()) + fields: dict[str, str] = {} + if "EventData" in event: + _flatten("EventData", event.get("EventData"), fields) + if "UserData" in event: + _flatten("UserData", event.get("UserData"), fields) + category = classify(provider, event_id, channel) + normalized_record_id = _integer(system.get("EventRecordID")) + if normalized_record_id is None: + normalized_record_id = _integer(record_id) + if normalized_record_id is not None: + stable_id = str(normalized_record_id) + else: + canonical_event = json.dumps(event, sort_keys=True, ensure_ascii=False, separators=(",", ":"), default=str) + ordinal = "" if record_ordinal is None else str(record_ordinal) + seed = f"{provider}|{event_id}|{record_timestamp}|{ordinal}|{canonical_event}".encode( + "utf-8", errors="replace" + ) + stable_id = f"event-{hashlib.sha256(seed).hexdigest()[:16]}" + timestamp, timestamp_source = _timestamp(system, record_timestamp) + summary = summarize(provider, event_id, category, fields)[:MAX_SUMMARY_CHARS] + return NormalizedEvent( + id=stable_id, + timestamp=timestamp, + timestamp_source=timestamp_source, + timestamp_valid=timestamp is not None, + provider=provider, + event_id=event_id, + level=level[:32], + channel=channel, + computer=computer, + category=category, + summary=summary, + fields=fields, + ) diff --git a/backend/app/parser.py b/backend/app/parser.py new file mode 100644 index 0000000..d62c8a2 --- /dev/null +++ b/backend/app/parser.py @@ -0,0 +1,204 @@ +import hashlib +import io +import json +import logging +import time +from dataclasses import dataclass + +from evtx import PyEvtxParser + +from .models import NormalizedEvent, ParseIssue, ParseStatus +from .normalize import normalize_record + +logger = logging.getLogger(__name__) + +MAX_EVENTS = 100_000 +MAX_PARSE_SECONDS = 8.0 +MAX_UPLOAD_BYTES = 50 * 1024 * 1024 +MAX_RECORD_JSON_BYTES = 2 * 1024 * 1024 +MAX_NORMALIZED_CHARS = 16 * 1024 * 1024 + + +class EvtxParseError(ValueError): + pass + + +class UnexpectedParserError(RuntimeError): + pass + + +@dataclass +class ParseResult: + events: list[NormalizedEvent] + issues: list[ParseIssue] + truncated: bool + duration_ms: int + status: ParseStatus = "complete" + truncation_reason: str | None = None + records_seen: int = 0 + skipped_records: int = 0 + + +def _safe_record_id(value: object) -> int | None: + try: + parsed = int(value) if not isinstance(value, bool) else None + except (TypeError, ValueError, OverflowError): + return None + return parsed if parsed is not None and 0 <= parsed <= 9_223_372_036_854_775_807 else None + + +def _fingerprint(stage: str, exc: BaseException) -> str: + return hashlib.sha256(f"{stage}:{type(exc).__name__}".encode("ascii", errors="replace")).hexdigest()[:12] + + +def parse_evtx_bytes( + data: bytes, + max_events: int = MAX_EVENTS, + max_seconds: float = MAX_PARSE_SECONDS, +) -> ParseResult: + if len(data) > MAX_UPLOAD_BYTES: + raise EvtxParseError("EVTX file exceeds the 50 MiB MVP limit") + max_events = min(max(1, int(max_events)), MAX_EVENTS) + max_seconds = min(max(0.1, float(max_seconds)), MAX_PARSE_SECONDS) + started = time.monotonic() + events: list[NormalizedEvent] = [] + issues: list[ParseIssue] = [] + truncated = False + truncation_reason: str | None = None + records_seen = 0 + skipped_records = 0 + normalized_chars = 0 + seen_ids: set[str] = set() + + def add_issue( + code: str, + message: str, + record_id: int | None = None, + skipped_record: bool = False, + ) -> None: + nonlocal skipped_records + issues.append(ParseIssue(code=code, record_id=record_id, message=message, skipped_record=skipped_record)) + if skipped_record: + skipped_records += 1 + + try: + parser = PyEvtxParser(io.BytesIO(data), number_of_threads=1) + for ordinal, record in enumerate(parser.records_json()): + records_seen += 1 + if len(events) >= max_events: + truncated = True + truncation_reason = "event_limit_reached" + add_issue( + "event_limit_reached", + f"Event limit reached ({max_events}); this record and later records were not analyzed.", + _safe_record_id(record.get("event_record_id")) if isinstance(record, dict) else None, + skipped_record=True, + ) + break + if time.monotonic() - started > max_seconds: + truncated = True + truncation_reason = "parse_time_budget_reached" + add_issue( + "parse_time_budget_reached", + f"Parse time budget reached ({max_seconds:.1f}s); later records were not analyzed.", + _safe_record_id(record.get("event_record_id")) if isinstance(record, dict) else None, + skipped_record=True, + ) + break + if not isinstance(record, dict): + add_issue("malformed_record_skipped", "Skipped a malformed parser record.", skipped_record=True) + continue + record_id = _safe_record_id(record.get("event_record_id")) + try: + raw_data = record["data"] + if not isinstance(raw_data, str): + raise TypeError("record data was not textual") + if ( + len(raw_data) > MAX_RECORD_JSON_BYTES + or len(raw_data.encode("utf-8")) > MAX_RECORD_JSON_BYTES + ): + add_issue( + "record_json_limit_exceeded", + "Skipped a parser record that exceeded the record JSON limit.", + record_id, + skipped_record=True, + ) + continue + payload = json.loads(raw_data) + normalized = normalize_record( + payload, + record_id=record_id, + record_timestamp=record.get("timestamp"), + record_ordinal=ordinal, + ) + normalized_size = len(normalized.provider) + len(normalized.channel) + len(normalized.computer) + normalized_size += len(normalized.summary) + normalized_size += sum(len(key) + len(value) for key, value in normalized.fields.items()) + if normalized_chars + normalized_size > MAX_NORMALIZED_CHARS: + truncated = True + truncation_reason = "normalized_output_budget_reached" + add_issue( + "normalized_output_budget_reached", + "Normalized output budget reached; this record and later records were not analyzed.", + record_id, + skipped_record=True, + ) + break + if normalized.id in seen_ids: + normalized.id = f"{normalized.id}-duplicate-{ordinal}"[:128] + seen_ids.add(normalized.id) + normalized_chars += normalized_size + events.append(normalized) + if normalized.timestamp_source in {"invalid", "missing"}: + add_issue( + "invalid_timestamp" if normalized.timestamp_source == "invalid" else "missing_timestamp", + "Event timestamp is not reliable; the event remains evidence but is excluded from temporal correlation.", + record_id, + ) + except (KeyError, TypeError, ValueError, UnicodeError, json.JSONDecodeError, RecursionError): + add_issue("malformed_record_skipped", "Skipped a malformed record.", record_id, skipped_record=True) + except (OSError, ValueError, TypeError, UnicodeError, RuntimeError, EOFError, RecursionError) as exc: + if not events: + logger.warning( + "EVTX parser rejected input stage=%s exception_type=%s fingerprint=%s", + "open_or_iterate", + type(exc).__name__, + _fingerprint("open_or_iterate", exc), + ) + raise EvtxParseError("The EVTX parser rejected the file or could not read its records.") from exc + logger.warning( + "EVTX parser recovered partially stage=%s exception_type=%s fingerprint=%s", + "iterate", + type(exc).__name__, + _fingerprint("iterate", exc), + ) + add_issue("parser_partial_recovery", "Parser stopped after partial recovery.") + truncated = True + truncation_reason = "parser_partial_recovery" + except Exception as exc: + logger.error( + "Unexpected EVTX parser failure stage=%s exception_type=%s fingerprint=%s", + "iterate", + type(exc).__name__, + _fingerprint("iterate", exc), + ) + raise UnexpectedParserError("The EVTX parser encountered an unexpected internal failure.") from exc + + duration_ms = int((time.monotonic() - started) * 1000) + # A warning about an unreliable timestamp does not mean that the record was + # omitted. Only truncation/recovery or an actually skipped record makes + # the analysis partial; the issue remains visible in the parse metadata. + incomplete = truncated or skipped_records > 0 or any( + issue.code == "parser_partial_recovery" for issue in issues + ) + status: ParseStatus = "partial" if incomplete else "complete" + return ParseResult( + events=events, + issues=issues, + truncated=truncated, + duration_ms=duration_ms, + status=status, + truncation_reason=truncation_reason, + records_seen=records_seen, + skipped_records=skipped_records, + ) diff --git a/backend/app/version.py b/backend/app/version.py new file mode 100644 index 0000000..ec735e4 --- /dev/null +++ b/backend/app/version.py @@ -0,0 +1,25 @@ +import os +import re +from pathlib import Path + +_VERSION_PATTERN = re.compile(r"^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$") +_REVISION_PATTERN = re.compile(r"^[0-9a-f]{40}$") +_VERSION_FILE = Path(__file__).resolve().parents[2] / "VERSION" +LOCAL_REVISION = "local" + + +def read_version() -> str: + value = _VERSION_FILE.read_text(encoding="utf-8").strip() + if not _VERSION_PATTERN.fullmatch(value): + raise RuntimeError("Invalid EventLens VERSION file") + return value + + +def read_revision() -> str: + value = os.environ.get("EVENTLENS_REVISION", "") + if _REVISION_PATTERN.fullmatch(value): + return value + return LOCAL_REVISION + + +VERSION = read_version() diff --git a/backend/pyproject.toml b/backend/pyproject.toml new file mode 100644 index 0000000..ef512b8 --- /dev/null +++ b/backend/pyproject.toml @@ -0,0 +1,21 @@ +[project] +name = "eventlens-api" +version = "1.0.6" +description = "Local EVTX incident reconstruction API for EventLens" +requires-python = ">=3.12" +dependencies = [ + "fastapi>=0.115,<1", + "uvicorn[standard]>=0.34,<1", + "python-multipart>=0.0.20,<1", + "pydantic>=2.10,<3", + "evtx>=0.12.1,<0.13" +] + +[project.optional-dependencies] +dev = ["pytest>=9.0.3,<10", "httpx>=0.28,<1", "ruff>=0.9,<1", "pip-audit>=2.7,<3"] + +[tool.pytest.ini_options] +pythonpath = ["."] + +[tool.ruff] +line-length = 100 diff --git a/backend/tests/fixtures/README.md b/backend/tests/fixtures/README.md new file mode 100644 index 0000000..3157274 --- /dev/null +++ b/backend/tests/fixtures/README.md @@ -0,0 +1,15 @@ +# EVTX integration fixture provenance + +The binary fixture is intentionally not copied into this text-managed repository. + +CI downloads `samples/Security_short_selected.evtx` from the upstream `omerbenamram/evtx` release tag `v0.12.2` and exposes it through `EVENTLENS_EVTX_FIXTURE`. + +Expected contract: + +- EVTX `ElfFile\0` header; +- 7 records; +- event IDs `5152, 4611, 4776, 4625, 5152, 5157, 4673`; +- provider `Microsoft-Windows-Security-Auditing`; +- channel `Security`. + +The upstream EVTX project is dual-licensed MIT / Apache-2.0 and distributes this file as test data. The release tag `v0.12.2` corresponds to release commit `99a6def` (June 13, 2026). Keeping the fetch pinned to that release makes the integration contract reproducible while avoiding a binary-only write path in this repository. diff --git a/backend/tests/test_api_privacy.py b/backend/tests/test_api_privacy.py new file mode 100644 index 0000000..b1cd17c --- /dev/null +++ b/backend/tests/test_api_privacy.py @@ -0,0 +1,171 @@ +import asyncio +from datetime import UTC, datetime + +import httpx +import pytest + +from app import main +from app.models import NormalizedEvent, ParseIssue +from app.parser import ParseResult +from app.version import VERSION + + +def request(method: str, url: str, **kwargs) -> httpx.Response: + async def send() -> httpx.Response: + transport = httpx.ASGITransport(app=main.app) + async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client: + return await client.request(method, url, **kwargs) + + return asyncio.run(send()) + + +def _fake_parse(_data: bytes) -> ParseResult: + event = NormalizedEvent(id="1",timestamp=datetime(2026,9,9,tzinfo=UTC),provider="Test Provider",event_id=1000,level="error",channel="Application",computer="LAB-PC",category="crash",summary="Synthetic crash",fields={}) + return ParseResult(events=[event], issues=[], truncated=False, duration_ms=1) + + +def test_api_sets_no_store_headers(monkeypatch): + monkeypatch.setattr(main, "parse_evtx_bytes", _fake_parse) + response = request("POST", "/api/analyze", files={"file": ("sample.evtx", b"synthetic", "application/octet-stream")}) + assert response.status_code == 200 + assert response.headers["cache-control"] == "no-store" + assert response.headers["pragma"] == "no-cache" + + +def test_api_sets_response_security_headers(): + response = request("GET", "/health") + assert response.status_code == 200 + assert response.headers["x-content-type-options"] == "nosniff" + assert response.headers["referrer-policy"] == "no-referrer" + assert response.headers["x-frame-options"] == "DENY" + assert "frame-ancestors 'none'" in response.headers["content-security-policy"] + + +def test_api_exposes_semantic_partial_parse_metrics(monkeypatch): + def partial_parse(_data: bytes) -> ParseResult: + event = _fake_parse(_data).events[0] + return ParseResult( + events=[event], + issues=[ParseIssue(code="event_limit_reached", message="later records were not analyzed", skipped_record=True)], + truncated=True, + duration_ms=12, + status="partial", + truncation_reason="event_limit_reached", + records_seen=4, + skipped_records=1, + ) + + monkeypatch.setattr(main, "parse_evtx_bytes", partial_parse) + response = request("POST", "/api/analyze", files={"file": ("sample.evtx", b"synthetic", "application/octet-stream")}) + assert response.status_code == 200 + parse = response.json()["parse"] + assert parse["status"] == "partial" + assert parse["parsed_events"] == 1 + assert parse["records_seen"] == 4 + assert parse["skipped_records"] == 1 + assert parse["issue_count"] == 1 + assert parse["issues"][0]["code"] == "event_limit_reached" + + +def test_health_sets_no_store_headers(): + response = request("GET", "/health") + assert response.status_code == 200 + assert response.headers["cache-control"] == "no-store" + assert response.headers["pragma"] == "no-cache" + + +def test_health_uses_the_repository_version_source(): + response = request("GET", "/health") + assert response.json()["version"] == VERSION + + +def test_health_exposes_exact_build_revision_and_preserves_existing_fields(monkeypatch): + revision = "0123456789abcdef0123456789abcdef01234567" + monkeypatch.setenv("EVENTLENS_REVISION", revision) + + response = request("GET", "/health") + + assert response.status_code == 200 + assert response.json() == { + "status": "ok", + "evtx_ingestion": True, + "version": VERSION, + "revision": revision, + } + + +@pytest.mark.parametrize("revision", [None, "", "unknown", "A" * 40, "a" * 39, "a" * 64]) +def test_health_uses_deterministic_local_build_revision_fallback(monkeypatch, revision): + if revision is None: + monkeypatch.delenv("EVENTLENS_REVISION", raising=False) + else: + monkeypatch.setenv("EVENTLENS_REVISION", revision) + + response = request("GET", "/health") + + assert response.status_code == 200 + assert response.json()["revision"] == "local" + + +def test_analysis_does_not_persist_upload_in_working_directory(monkeypatch, tmp_path): + monkeypatch.setattr(main, "parse_evtx_bytes", _fake_parse) + monkeypatch.chdir(tmp_path) + before = list(tmp_path.iterdir()) + response = request("POST", "/api/analyze", files={"file": ("sample.evtx", b"synthetic", "application/octet-stream")}) + after = list(tmp_path.iterdir()) + assert response.status_code == 200 + assert before == after == [] + + +def test_api_sanitizes_filename_in_analysis_source(monkeypatch): + monkeypatch.setattr(main, "parse_evtx_bytes", _fake_parse) + response = request( + "POST", + "/api/analyze", + files={"file": (r"..\private\LAB-PC.evtx", b"synthetic", "application/octet-stream")}, + ) + assert response.status_code == 200 + assert response.json()["source"] == "LAB-PC.evtx" + + +def test_api_rejects_oversized_upload_before_parser(monkeypatch): + monkeypatch.setattr(main, "MAX_UPLOAD_BYTES", 8) + response = request( + "POST", "/api/analyze", files={"file": ("sample.evtx", b"123456789", "application/octet-stream")} + ) + assert response.status_code == 413 + + +def test_request_limit_response_is_uncacheable_and_nosniff(): + response = request( + "POST", + "/api/analyze", + headers={"Content-Length": str(main.MAX_REQUEST_BYTES + 1)}, + content=b"oversized", + ) + assert response.status_code == 413 + assert response.headers["cache-control"] == "no-store" + assert response.headers["pragma"] == "no-cache" + assert response.headers["x-content-type-options"] == "nosniff" + + +def test_api_rejects_when_parse_capacity_is_full(monkeypatch): + import time + + def slow_parse(_data: bytes) -> ParseResult: + time.sleep(0.35) + return _fake_parse(_data) + + async def send_two(): + transport = httpx.ASGITransport(app=main.app) + async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client: + return await asyncio.gather( + client.post("/api/analyze", files={"file": ("one.evtx", b"synthetic", "application/octet-stream")}), + client.post("/api/analyze", files={"file": ("two.evtx", b"synthetic", "application/octet-stream")}), + ) + + monkeypatch.setattr(main, "parse_evtx_bytes", slow_parse) + monkeypatch.setattr(main, "PARSE_QUEUE_LIMIT", 0) + monkeypatch.setattr(main, "_parse_inflight", 0) + responses = asyncio.run(send_two()) + assert sorted(response.status_code for response in responses) == [200, 503] diff --git a/backend/tests/test_correlation.py b/backend/tests/test_correlation.py new file mode 100644 index 0000000..a3261ec --- /dev/null +++ b/backend/tests/test_correlation.py @@ -0,0 +1,27 @@ +from datetime import UTC, datetime, timedelta + +from app.correlate import correlate +from app.demo import load_demo +from app.models import NormalizedEvent + + +def test_demo_resolves_into_named_rules(): + rule_ids={incident.rule_id for incident in correlate(load_demo())} + assert "windows.system.startup" in rule_ids + assert "windows.service.failure" in rule_ids + assert "windows.network.dns-timeout" in rule_ids + assert "windows.crash.application-report" in rule_ids + + +def test_repeated_dns_events_are_compressed_in_incident_summary(): + start=datetime(2026,9,9,8,0,tzinfo=UTC) + events=[NormalizedEvent(id=str(index),timestamp=start+timedelta(seconds=index*10),provider="Microsoft-Windows-DNS-Client",event_id=1014,level="warning",channel="System",computer="LAB-PC",category="network",summary="DNS timeout") for index in range(3)] + incident=correlate(events)[0] + assert incident.rule_id == "windows.network.dns-timeout" + assert incident.original_count == 3 + assert incident.compressed_count == 1 + + +def test_incident_ids_are_deterministic(): + events=load_demo() + assert [incident.id for incident in correlate(events)] == [incident.id for incident in correlate(events)] diff --git a/backend/tests/test_demo.py b/backend/tests/test_demo.py new file mode 100644 index 0000000..a7ecb55 --- /dev/null +++ b/backend/tests/test_demo.py @@ -0,0 +1,20 @@ +from app.correlate import correlate +from app.demo import load_demo + + +def test_demo_is_deterministic(): + events = load_demo() + incidents = correlate(events) + assert len(events) >= 6 + assert incidents + assert all(incident.evidence_event_ids for incident in incidents) + + +def test_demo_is_chronological_after_correlation(): + incidents = correlate(load_demo()) + assert incidents == sorted(incidents, key=lambda incident: incident.start) + + +def test_demo_contains_portfolio_story_events(): + ids = {event.event_id for event in load_demo()} + assert {12, 7031, 1014, 1000, 1001}.issubset(ids) diff --git a/backend/tests/test_evtx_fixture.py b/backend/tests/test_evtx_fixture.py new file mode 100644 index 0000000..d2e8850 --- /dev/null +++ b/backend/tests/test_evtx_fixture.py @@ -0,0 +1,19 @@ +import os +from pathlib import Path + +import pytest + +from app.parser import parse_evtx_bytes + +FIXTURE = os.environ.get("EVENTLENS_EVTX_FIXTURE") + + +@pytest.mark.skipif(not FIXTURE, reason="EVENTLENS_EVTX_FIXTURE is only supplied by CI/release qualification") +def test_pinned_real_evtx_fixture_end_to_end(): + data = Path(FIXTURE).read_bytes() + assert data.startswith(b"ElfFile\x00") + result = parse_evtx_bytes(data, max_events=100, max_seconds=10.0) + assert len(result.events) == 7 + assert [event.event_id for event in result.events] == [5152, 4611, 4776, 4625, 5152, 5157, 4673] + assert all(event.provider == "Microsoft-Windows-Security-Auditing" for event in result.events) + assert all(event.channel == "Security" for event in result.events) diff --git a/backend/tests/test_normalize.py b/backend/tests/test_normalize.py new file mode 100644 index 0000000..596308b --- /dev/null +++ b/backend/tests/test_normalize.py @@ -0,0 +1,17 @@ +from app.normalize import classify, normalize_record + + +def test_normalizes_rust_evtx_json_shape(): + payload = {"Event": {"System": {"Provider": {"#attributes": {"Name": "Microsoft-Windows-Security-Auditing"}},"EventID": 4625,"Level": 0,"Channel": "Security","Computer": "LAB-PC","EventRecordID": 77,"TimeCreated": {"#attributes": {"SystemTime": "2026-09-09T08:32:11.000000Z"}}},"EventData": {"TargetUserName": "jens", "Status": "0xc000006d"}}} + event = normalize_record(payload) + assert event.id == "77" + assert event.event_id == 4625 + assert event.category == "authentication" + assert event.summary == "Failed sign-in for jens" + assert event.fields["EventData.Status"] == "0xc000006d" + + +def test_classification_handles_common_windows_sources(): + assert classify("Service Control Manager", 7031, "System") == "service" + assert classify("Microsoft-Windows-DNS-Client", 1014, "System") == "network" + assert classify("Application Error", 1000, "Application") == "crash" diff --git a/backend/tests/test_post_v1_hardening.py b/backend/tests/test_post_v1_hardening.py new file mode 100644 index 0000000..4059dc6 --- /dev/null +++ b/backend/tests/test_post_v1_hardening.py @@ -0,0 +1,267 @@ +import asyncio +from datetime import UTC, datetime, timedelta + +import pytest + +from app import main, parser +from app.correlate import correlate +from app.models import NormalizedEvent +from app.normalize import normalize_record +from app.parser import UnexpectedParserError, parse_evtx_bytes + + +def normalized( + event_id: str, + timestamp: datetime | None, + *, + provider: str, + number: int, + channel: str = "Security", + computer: str = "LAB-PC", + fields: dict[str, str] | None = None, + level: str = "warning", + category: str = "authentication", + summary: str = "Synthetic event", +) -> NormalizedEvent: + return NormalizedEvent( + id=event_id, + timestamp=timestamp, + provider=provider, + event_id=number, + level=level, + channel=channel, + computer=computer, + category=category, # type: ignore[arg-type] + summary=summary, + fields=fields or {}, + ) + + +def record(provider: str, event_id: int, timestamp: str | None = "2026-09-09T08:00:00Z") -> dict: + system = {"Provider": {"#attributes": {"Name": provider}}, "EventID": event_id} + if timestamp is not None: + system["TimeCreated"] = {"#attributes": {"SystemTime": timestamp}} + return {"Event": {"System": system}} + + +def test_invalid_timestamps_are_marked_and_never_become_epoch_evidence(): + event = normalize_record(record("Microsoft-Windows-Security-Auditing", 4625, "not-a-time"), record_timestamp="also-bad") + assert event.timestamp is None + assert event.timestamp_source == "invalid" + assert event.timestamp_valid is False + incident = correlate( + [event.model_copy(update={"level": "warning", "category": "other", "channel": "Security", "computer": "LAB-PC"})] + )[0] + assert incident.start is None + assert incident.end is None + + +def test_valid_record_timestamp_is_an_explicit_fallback(): + event = normalize_record(record("Microsoft-Windows-Security-Auditing", 4625, "not-a-time"), record_timestamp="2026-09-09T08:00:00+02:00") + assert event.timestamp == datetime(2026, 9, 9, 6, 0, tzinfo=UTC) + assert event.timestamp_source == "record" + assert event.timestamp_valid is True + + +def test_invalid_record_timestamp_is_not_silent_missing_timestamp(): + event = normalize_record(record("Microsoft-Windows-Security-Auditing", 4625, timestamp=None), record_timestamp="not-a-time") + assert event.timestamp is None + assert event.timestamp_source == "invalid" + assert event.timestamp_valid is False + + +def test_unreliable_timestamp_metadata_cannot_enter_temporal_correlation(): + event = normalized( + "unreliable", + datetime(2026, 9, 9, 8, 0, tzinfo=UTC), + provider="Microsoft-Windows-Security-Auditing", + number=4625, + ).model_copy(update={"timestamp_source": "invalid", "timestamp_valid": False}) + incidents = correlate([event]) + assert incidents[0].start is None + assert incidents[0].end is None + + +@pytest.mark.parametrize( + ("provider", "event_id", "channel", "expected"), + [ + ("Other Provider", 4625, "Security", "other"), + ("Other Provider", 1014, "System", "other"), + ("Other Provider", 1000, "Application", "application"), + ("Application Error", 1000, "System", "other"), + ("Windows Error Reporting", 1001, "Application", "crash"), + ], +) +def test_event_ids_are_scoped_to_provider_and_channel(provider, event_id, channel, expected): + event = normalize_record(record(provider, event_id), record_timestamp="2026-09-09T08:00:00Z") + event.channel = channel + # Re-normalize the explicit channel because the helper record intentionally stays small. + payload = record(provider, event_id) + payload["Event"]["System"]["Channel"] = channel + normalized_event = normalize_record(payload) + assert normalized_event.category == expected + + +def test_provider_rules_do_not_match_when_channel_context_is_missing(): + payload = record("Microsoft-Windows-Security-Auditing", 4625) + normalized_event = normalize_record(payload) + assert normalized_event.category == "other" + incidents = correlate( + [normalized("1", datetime(2026, 9, 9, 8, 0, tzinfo=UTC), provider=normalized_event.provider, number=4625, channel="", fields={})] + ) + assert all(incident.rule_id != "windows.auth.failed-logon" for incident in incidents) + + +def test_unknown_dimensions_are_isolated_and_one_failure_is_not_a_burst(): + start = datetime(2026, 9, 9, 8, 0, tzinfo=UTC) + events = [ + normalized(str(index), start + timedelta(seconds=index), provider="Microsoft-Windows-Security-Auditing", number=4625, fields={}) + for index in range(2) + ] + incidents = correlate(events) + assert len(incidents) == 2 + assert all(incident.title == "Failed sign-in recorded" for incident in incidents) + assert all("same known account" not in reason for incident in incidents for reason in incident.reasons) + + +def test_known_failed_logons_use_thresholded_titles(): + start = datetime(2026, 9, 9, 8, 0, tzinfo=UTC) + make = lambda index: normalized( + str(index), + start + timedelta(seconds=index), + provider="Microsoft-Windows-Security-Auditing", + number=4625, + fields={"EventData.TargetUserName": "jens"}, + ) + assert correlate([make(0)])[0].title == "Failed sign-in recorded" + assert correlate([make(0), make(1)])[0].title == "Repeated failed sign-ins" + assert correlate([make(0), make(1), make(2)])[0].title == "Failed sign-in burst" + + +def test_startup_and_unexpected_power_are_separate_rules(): + start = datetime(2026, 9, 9, 8, 0, tzinfo=UTC) + events = [ + normalized("boot", start, provider="Microsoft-Windows-Kernel-General", number=12, channel="System", category="system", summary="OS started", level="information"), + normalized("power", start + timedelta(seconds=20), provider="Microsoft-Windows-Kernel-Power", number=41, channel="System", category="system", summary="Unexpected restart"), + ] + rules = {incident.rule_id for incident in correlate(events)} + assert rules == {"windows.system.startup", "windows.system.shutdown.unexpected"} + + +def test_parse_metrics_count_records_not_issue_messages(monkeypatch): + class FakeParser: + def __init__(self, *_args, **_kwargs): + pass + + def records_json(self): + yield {"event_record_id": 1, "timestamp": "2026-09-09T08:00:00Z", "data": '{"Event":{"System":{"Provider":"P","EventID":1}}}'} + yield {"event_record_id": 2, "timestamp": "2026-09-09T08:00:01Z", "data": "not-json"} + + monkeypatch.setattr(parser, "PyEvtxParser", FakeParser) + result = parse_evtx_bytes(b"ElfFile\x00synthetic") + assert len(result.events) == 1 + assert result.records_seen == 2 + assert result.skipped_records == 1 + assert len(result.issues) == 1 + assert result.issues[0].code == "malformed_record_skipped" + assert result.status == "partial" + + +def test_timestamp_issue_does_not_claim_records_were_omitted(monkeypatch): + class FakeParser: + def __init__(self, *_args, **_kwargs): + pass + + def records_json(self): + yield {"event_record_id": 1, "timestamp": "not-a-time", "data": '{"Event":{"System":{"Provider":"P","EventID":1}}}'} + + monkeypatch.setattr(parser, "PyEvtxParser", FakeParser) + result = parse_evtx_bytes(b"ElfFile\x00synthetic") + assert result.status == "complete" + assert result.skipped_records == 0 + assert result.issues[0].code == "invalid_timestamp" + + +def test_event_limit_reports_one_observed_record_without_inventing_remaining_count(monkeypatch): + class FakeParser: + def __init__(self, *_args, **_kwargs): + pass + + def records_json(self): + for index in range(3): + yield {"event_record_id": index + 1, "timestamp": "2026-09-09T08:00:00Z", "data": '{"Event":{"System":{"Provider":"P","EventID":1}}}'} + + monkeypatch.setattr(parser, "PyEvtxParser", FakeParser) + result = parse_evtx_bytes(b"ElfFile\x00synthetic", max_events=2) + assert len(result.events) == 2 + assert result.records_seen == 3 + assert result.skipped_records == 1 + assert result.truncation_reason == "event_limit_reached" + assert result.issues[0].code == "event_limit_reached" + + +def test_unexpected_parser_exception_is_not_disguised_as_partial(monkeypatch, caplog): + class FakeParser: + def __init__(self, *_args, **_kwargs): + pass + + def records_json(self): + raise AssertionError("secret parser details") + yield # pragma: no cover + + monkeypatch.setattr(parser, "PyEvtxParser", FakeParser) + with pytest.raises(UnexpectedParserError): + parse_evtx_bytes(b"ElfFile\x00synthetic") + assert "secret parser details" not in caplog.text + + +def run_asgi(app, messages, headers=None): + async def execute(): + sent = [] + pending = list(messages) + + async def receive(): + return pending.pop(0) if pending else {"type": "http.disconnect"} + + async def send(message): + sent.append(message) + + scope = {"type": "http", "method": "POST", "path": "/api/analyze", "headers": headers or [], "query_string": b"", "scheme": "http", "server": ("test", 80), "client": ("test", 1), "http_version": "1.1"} + await app(scope, receive, send) + return sent + + return asyncio.run(execute()) + + +def test_receive_level_body_limit_handles_chunked_like_requests(): + async def sink(scope, receive, send): + while (await receive()).get("type") != "http.disconnect": + pass + await send({"type": "http.response.start", "status": 200, "headers": []}) + await send({"type": "http.response.body", "body": b"ok"}) + + messages = [{"type": "http.request", "body": b"abc", "more_body": True}, {"type": "http.request", "body": b"d", "more_body": False}] + sent = run_asgi(main.RequestBodyLimitMiddleware(sink, 3), messages) + assert sent[0]["status"] == 413 + + +def test_receive_level_body_limit_accepts_exact_limit(): + async def sink(scope, receive, send): + message = await receive() + assert message["body"] == b"abc" + await send({"type": "http.response.start", "status": 200, "headers": []}) + await send({"type": "http.response.body", "body": b"ok"}) + + sent = run_asgi( + main.RequestBodyLimitMiddleware(sink, 3), + [{"type": "http.request", "body": b"abc", "more_body": False}], + ) + assert sent[0]["status"] == 200 + + +def test_receive_level_body_limit_handles_oversized_content_length(): + async def sink(scope, receive, send): + raise AssertionError("downstream must not receive an oversized request") + + sent = run_asgi(main.RequestBodyLimitMiddleware(sink, 3), [], headers=[(b"content-length", b"4")]) + assert sent[0]["status"] == 413 diff --git a/backend/tests/test_security_limits.py b/backend/tests/test_security_limits.py new file mode 100644 index 0000000..5c34da4 --- /dev/null +++ b/backend/tests/test_security_limits.py @@ -0,0 +1,88 @@ +from datetime import UTC, datetime, timedelta + +import pytest + +from app import parser +from app.correlate import correlate +from app.models import NormalizedEvent +from app.normalize import normalize_record +from app.parser import EvtxParseError, parse_evtx_bytes + + +def test_corrupt_evtx_has_a_generic_error_without_parser_details(): + with pytest.raises(EvtxParseError, match="rejected the file"): + parse_evtx_bytes(b"not-an-evtx") + + +def test_oversized_parser_record_is_skipped_before_json_expansion(monkeypatch): + class FakeParser: + def __init__(self, *_args, **_kwargs): + pass + + def records_json(self): + yield {"event_record_id": "9" * 5000, "data": "x" * (parser.MAX_RECORD_JSON_BYTES + 1)} + + monkeypatch.setattr(parser, "PyEvtxParser", FakeParser) + result = parse_evtx_bytes(b"ElfFile\x00synthetic") + assert result.events == [] + assert result.issues[0].code == "record_json_limit_exceeded" + assert result.issues[0].record_id is None + + +def test_normalization_bounds_nested_and_textual_values(): + payload = { + "Event": { + "System": { + "Provider": {"#attributes": {"Name": "P" * 500}}, + "EventID": 1, + "Channel": "C" * 500, + "Computer": "H" * 500, + "TimeCreated": {"#attributes": {"SystemTime": "2026-09-09T08:00:00Z"}}, + }, + "EventData": {"value": "V" * 5000}, + } + } + event = normalize_record(payload, record_ordinal=1) + assert len(event.provider) == 256 + assert len(event.channel) == 256 + assert len(event.computer) == 256 + assert len(event.fields["EventData.value"]) == 1000 + + +def test_records_without_event_record_ids_get_distinct_deterministic_ids(): + payload = { + "Event": { + "System": { + "Provider": "Synthetic", + "EventID": 1, + "TimeCreated": {"#attributes": {"SystemTime": "2026-09-09T08:00:00Z"}}, + } + } + } + first = normalize_record(payload, record_timestamp="2026-09-09T08:00:00Z", record_ordinal=0) + second = normalize_record(payload, record_timestamp="2026-09-09T08:00:00Z", record_ordinal=1) + repeat = normalize_record(payload, record_timestamp="2026-09-09T08:00:00Z", record_ordinal=0) + assert first.id != second.id + assert first.id == repeat.id + + +def test_correlation_does_not_bridge_beyond_rule_window(): + start = datetime(2026, 9, 9, 8, 0, tzinfo=UTC) + events = [ + NormalizedEvent( + id=str(index), + timestamp=start + timedelta(seconds=offset), + provider="Microsoft-Windows-DNS-Client", + event_id=1014, + level="warning", + channel="System", + computer="LAB-PC", + category="network", + summary="DNS timeout", + ) + for index, offset in enumerate((0, 119, 238)) + ] + incidents = correlate(events) + assert len(incidents) == 2 + assert [incident.original_count for incident in incidents] == [2, 1] + assert all(incident.end - incident.start <= timedelta(seconds=120) for incident in incidents) diff --git a/backend/uv.lock b/backend/uv.lock new file mode 100644 index 0000000..e900f34 --- /dev/null +++ b/backend/uv.lock @@ -0,0 +1,1235 @@ +version = 1 +revision = 3 +requires-python = ">=3.12" + +[[package]] +name = "annotated-doc" +version = "0.0.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5a/8e/38aa427ed5402449e226975b649c5dc73ccadfefeb95e6aecb8f8ea4b6b6/annotated_doc-0.0.5.tar.gz", hash = "sha256:c7e58ce09192557605d8bbd92836d7e1d520ac9580096042c0bfd197efacf1bb", size = 10758, upload-time = "2026-07-28T13:50:58.129Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3e/30/e900b21425a860e195f32e37657aa1f7c7f2b1bfb26f03ca209b90933c06/annotated_doc-0.0.5-py3-none-any.whl", hash = "sha256:117bac03a25ede5df5440e855b32d556049ca169ead221505badf432fed4b101", size = 5302, upload-time = "2026-07-28T13:50:57.239Z" }, +] + +[[package]] +name = "annotated-types" +version = "0.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5f/56/a8120250d128bed162cd73c76d45f6ef9991f3e068f62a8ee060afa3104a/annotated_types-0.8.0.tar.gz", hash = "sha256:13b2beaad985e05e2d6407ee4c4f35590b11f8d693a258a561055cac8f64cab7", size = 15893, upload-time = "2026-07-23T20:16:13.995Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/91/8acff4f5e50511b911bbccb72b8628a49c68ce14148cd9f6431094859a90/annotated_types-0.8.0-py3-none-any.whl", hash = "sha256:f072f4d804ea359e4eaf198b1af7a8b0943881a87f31bb764f8bf219bb9419e0", size = 13427, upload-time = "2026-07-23T20:16:12.938Z" }, +] + +[[package]] +name = "anyio" +version = "4.15.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "typing-extensions", marker = "python_full_version < '3.15'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a9/d2/f4d173e22df740bc37b1db102b386ba719b66e95b0f0d751f556b387e6d2/anyio-4.15.1.tar.gz", hash = "sha256:9f28306018cbd6d329e64a36d58256edff76dd996fe423bc957326e578b82a94", size = 276966, upload-time = "2026-09-05T10:42:39.44Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/b8/4bd346e22b28902df4d651910f5242c28d84e4a5c2435ca5c3f797ed7e2e/anyio-4.15.1-py3-none-any.whl", hash = "sha256:6152fdbbf9a77fdec97731721bebf7c4c44f7c29b424b0065826173efc7ed101", size = 132079, upload-time = "2026-09-05T10:42:37.923Z" }, +] + +[[package]] +name = "boolean-py" +version = "5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c4/cf/85379f13b76f3a69bca86b60237978af17d6aa0bc5998978c3b8cf05abb2/boolean_py-5.0.tar.gz", hash = "sha256:60cbc4bad079753721d32649545505362c754e121570ada4658b852a3a318d95", size = 37047, upload-time = "2025-04-03T10:39:49.734Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/ca/78d423b324b8d77900030fa59c4aa9054261ef0925631cd2501dd015b7b7/boolean_py-5.0-py3-none-any.whl", hash = "sha256:ef28a70bd43115208441b53a045d1549e2f0ec6e3d08a9d142cbc41c1938e8d9", size = 26577, upload-time = "2025-04-03T10:39:48.449Z" }, +] + +[[package]] +name = "cachecontrol" +version = "0.14.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "msgpack" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2d/f6/c972b32d80760fb79d6b9eeb0b3010a46b89c0b23cf6329417ff7886cd22/cachecontrol-0.14.4.tar.gz", hash = "sha256:e6220afafa4c22a47dd0badb319f84475d79108100d04e26e8542ef7d3ab05a1", size = 16150, upload-time = "2025-11-14T04:32:13.138Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/79/c45f2d53efe6ada1110cf6f9fca095e4ff47a0454444aefdde6ac4789179/cachecontrol-0.14.4-py3-none-any.whl", hash = "sha256:b7ac014ff72ee199b5f8af1de29d60239954f223e948196fa3d84adaffc71d2b", size = 22247, upload-time = "2025-11-14T04:32:11.733Z" }, +] + +[package.optional-dependencies] +filecache = [ + { name = "filelock" }, +] + +[[package]] +name = "certifi" +version = "2026.7.22" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a3/c2/24167ea9858356b47a87a50d39908bfdb72ceeefe0041586e704e5376b3a/certifi-2026.7.22.tar.gz", hash = "sha256:741e2c3b351ddf169a738da9f2c048608ff7f2c5cc02f1ebc6b118bb090d5d55", size = 138112, upload-time = "2026-07-22T03:35:12.644Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl", hash = "sha256:62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775", size = 136983, upload-time = "2026-07-22T03:35:11.276Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e5/3f/143b048436775b0f76ac3eec145c019e8173ccc2885c8f20319b996d5e83/charset_normalizer-3.5.1.tar.gz", hash = "sha256:6117b84ea48435e5356dc737f5121485c30920ba43375fa7b434fd753df0eac3", size = 171764, upload-time = "2026-08-15T08:20:44.807Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/30/27/78873dc8b6a56357517b74b6bb9568b80450e7bb4f6ef7e3fa9d22aa0bd7/charset_normalizer-3.5.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:5b6d1386bf0096d26d3a863dc0a487a5b4eb9aa93cf5ba69683d29dde6b9d60f", size = 344456, upload-time = "2026-08-15T08:17:10.072Z" }, + { url = "https://files.pythonhosted.org/packages/9a/4c/be49ada26b1f0232d57aa89bbebf997a5cc2332a5616b6eca26ff680044d/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4582c27e8c889d64811987b5967fbd3ae0c823fe1fd933b543d55ac20bb475fa", size = 238530, upload-time = "2026-08-15T08:17:11.563Z" }, + { url = "https://files.pythonhosted.org/packages/76/84/6f1290fa07ae6978d3960caa3eb1b8019bf9284ab7c2297b00c099ef4250/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1d1c7a53a6c2103925cdd6d7229f8c567379f211c869793df679f2e9f738c369", size = 230200, upload-time = "2026-08-15T08:17:12.919Z" }, + { url = "https://files.pythonhosted.org/packages/e7/a0/47b18adeed31c8f16ba9700f32c1b18594cfa09f47eb672a488c273c22bf/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e6621fb2a4988d6e53eedc455e5903e2679f3967b8acb3d639f1b63c14a2e893", size = 262222, upload-time = "2026-08-15T08:17:14.571Z" }, + { url = "https://files.pythonhosted.org/packages/38/fe/341861ac118dae06f3ec0eb487488af52128f2ef2faf0b11003944d22259/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7c0c10730342b0c9b35dd1d619beb8214e520bd96a1f870f452680b238aab3e0", size = 258951, upload-time = "2026-08-15T08:17:16.158Z" }, + { url = "https://files.pythonhosted.org/packages/6f/89/bb5108dc6c3651dca963f2b0a3ba19bbcb370c94e1b6d3e0e844a58e6dca/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b9af956078716df40d985fb0dfeb2c2120c5ca92ba4ff4b388acfd01cdc14d08", size = 248801, upload-time = "2026-08-15T08:17:17.683Z" }, + { url = "https://files.pythonhosted.org/packages/b1/ba/ef83ae3aca816393decfa3530976f38a79812d707b80b580ac33b83f9877/charset_normalizer-3.5.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f9f8405c2c758532c74fed975dbee57be1f31a6e865c031870c79a6ed3212ada", size = 244070, upload-time = "2026-08-15T08:17:19.191Z" }, + { url = "https://files.pythonhosted.org/packages/f6/0b/c5292a2462d69b7378ea89793bbb5b2b6fcf6f7dd6d1667f9619094ad553/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:96fef3e886d6a9874b14f27fc193fbdc69d5d8035783d86aa4e1cea594e695f9", size = 240110, upload-time = "2026-08-15T08:17:20.547Z" }, + { url = "https://files.pythonhosted.org/packages/46/22/111e5be3b740d5c2a5bfcedb3d237b6591e5c2e82ae9d6ffcb121fe0909c/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5d8531a6569d025f68e2321e7638fb7978f23db58e5f69f56913837aae03816e", size = 232836, upload-time = "2026-08-15T08:17:21.895Z" }, + { url = "https://files.pythonhosted.org/packages/f9/d2/d2aad6fe0dbb44b194bf3becb60f5a0ac48446ade999a47fe7bb41eb09a7/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:aae2ee51122d3ae968a3837d97dc24a0aeebb0dea23694422cd172bd30017cd6", size = 262712, upload-time = "2026-08-15T08:17:23.727Z" }, + { url = "https://files.pythonhosted.org/packages/35/5a/337e4663a5eae6de99db940ee8066d4145caafb61327db62deda15313cce/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:7235dc28fc6dd9d832ac7c7bce95367dedb85929f17368a0c2bee1e080b9acbf", size = 242977, upload-time = "2026-08-15T08:17:25.157Z" }, + { url = "https://files.pythonhosted.org/packages/ca/85/f82f8a92e31c7519410e2e1afdc630f28ec47490ce2c09a11c1a43cbb459/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:4abdc5f9ad448c1ecbfae2974b820535d6bc6e7eef63babbab3d81cf46968c71", size = 260207, upload-time = "2026-08-15T08:17:26.602Z" }, + { url = "https://files.pythonhosted.org/packages/b7/52/643d11ffd60e9ac2fd1fb87e167a19285b9eefeff4a40e63c87cbfbeab36/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ba501e667c17d8411f98e67a022d9604ef179aff0e459b7e292c796837c13573", size = 250562, upload-time = "2026-08-15T08:17:27.971Z" }, + { url = "https://files.pythonhosted.org/packages/62/16/46556278c2168d12df9da7fede5dc6fc70e60301b26a82bbeec238c9cfe3/charset_normalizer-3.5.1-cp312-cp312-win32.whl", hash = "sha256:cfa1c0cc3a8f9f53f1243a5a99ac36fd003880199383b37672e86ddda9cb07e2", size = 178507, upload-time = "2026-08-15T08:17:29.277Z" }, + { url = "https://files.pythonhosted.org/packages/9d/7a/4c6c298171e6b3e745633180ff59350fc0ca0db1ffd28df1e369e0579f71/charset_normalizer-3.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:3617ac3cfd8b9888f145ad89dd6e692285834b0201c6074a5eeaad3fd4d668c2", size = 200551, upload-time = "2026-08-15T08:17:30.668Z" }, + { url = "https://files.pythonhosted.org/packages/cd/d7/eb95a042f0dd22e304b0b6472b154f3546a1a039a9ee89ccb2a7f61591fc/charset_normalizer-3.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:88e85ab89cb822c1e635f51d6d32e488f94e002e70e2f492bdb8b945543f345a", size = 180700, upload-time = "2026-08-15T08:17:32.028Z" }, + { url = "https://files.pythonhosted.org/packages/bc/61/2cb6ad133dbbb449fa2d37ccae973232f4827e799af258d15e589a3d1e9e/charset_normalizer-3.5.1-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:4f298bdadb8f0b9e5672877f647d1be9373ef5320c9e2f049795e26cad28b6a9", size = 211584, upload-time = "2026-08-15T08:17:33.597Z" }, + { url = "https://files.pythonhosted.org/packages/18/57/a305c968be1ca13f3dd1b32f445877e97addf55d80b65c7cb35fac82b777/charset_normalizer-3.5.1-cp313-cp313-android_24_x86_64.whl", hash = "sha256:88ca277405c2d3b71c4e1c2ee0e7966e807bcba86a69d11e19ba199d18ae4491", size = 223359, upload-time = "2026-08-15T08:17:35.022Z" }, + { url = "https://files.pythonhosted.org/packages/09/0a/d3646670292ce8d8f8cc11ac067d44885e697a5591f57a9221128da5e7b3/charset_normalizer-3.5.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:9362dd90aa7dab48c0054a21187791ccf05473f7dba5d92b8033ae62164675e7", size = 194464, upload-time = "2026-08-15T08:17:36.452Z" }, + { url = "https://files.pythonhosted.org/packages/de/93/d51ec556e01042fed6f993ea859311bc7917b466684182fbbceb6ca24762/charset_normalizer-3.5.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:977cdbd483a9cff38179bea4fd754289a6f2195c7abd414aba85410b3e66cc5e", size = 197676, upload-time = "2026-08-15T08:17:37.819Z" }, + { url = "https://files.pythonhosted.org/packages/a4/a0/562247944386f7d4ef94467e84876600cc1e0f1b93239aaa9213d2bc3cbd/charset_normalizer-3.5.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e90251c0c7bdd54a100a0dce3c07b7e637278c93af29dbf78ebb89a58c4bac7d", size = 340473, upload-time = "2026-08-15T08:17:39.303Z" }, + { url = "https://files.pythonhosted.org/packages/31/e7/1d994be1b93d41e9502b8b0460eaa88a1dd8df335df415db87d6c3e91ab2/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:94d78ecec2605a8d0398b0f365d5f12a63248438516f5dac536a5eff7337df4a", size = 240156, upload-time = "2026-08-15T08:17:40.66Z" }, + { url = "https://files.pythonhosted.org/packages/09/53/27923ce5cc6cbccb832037b27dca98882d9c53e9b69e866bbbef4aae7fc8/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d59b75732e9b6f27388e10c14b0259cc5f2e48c78627d185e6a177b58ad3cffe", size = 228246, upload-time = "2026-08-15T08:17:42.003Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/5a97e84d63af1d55c07439cb80e56d99a8efb4295700eb4e18c0d1615d2c/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0d929fc574b4d6fd9e7c0f5c2ede8716a41911923aa7fa5fce38e0818aa4a1ac", size = 263660, upload-time = "2026-08-15T08:17:43.627Z" }, + { url = "https://files.pythonhosted.org/packages/7a/c2/071575791dcc88316c0a9a65ce38897a82e4cfe4a325f0f7fe1b1ac47bcf/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:394fea06235c8543390050ed5f529187074b029fb027213f6c46ac11ab5d950e", size = 260354, upload-time = "2026-08-15T08:17:45.094Z" }, + { url = "https://files.pythonhosted.org/packages/fb/af/63240b0c0248c075c2535a1f1bd992821d8251b9f173abc13329661d09e4/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62b55f6722735a6c472f88361cde6640608773d9443cebdbb51abf436a1fcdd3", size = 250638, upload-time = "2026-08-15T08:17:46.496Z" }, + { url = "https://files.pythonhosted.org/packages/4d/66/70dfad64f15be09c15ccfee81330a7e515895dbe296dd23114e9a231268a/charset_normalizer-3.5.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fa48b1b63d639f9483e0633e092f5851e2348c352f1f9bb6c8182f87884ef876", size = 244583, upload-time = "2026-08-15T08:17:47.963Z" }, + { url = "https://files.pythonhosted.org/packages/c0/24/ef36367d38b9ddd4bccbf72888c342e8de1f5ae506fa0b2dcf970e2732a1/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c71fb0d56c920c269cd3e2e3fe7c610e3f1fdb21a6ce60efa6430ff63676cea6", size = 242038, upload-time = "2026-08-15T08:17:49.481Z" }, + { url = "https://files.pythonhosted.org/packages/db/ab/55e683ba0fff2e43adafc10daa3001eac90fdaa419a97227d5a7067eedde/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:485a0d363cafefcd2538a73c7c838daa2035f09b2c9f9b5e3133f80c6aeb84c2", size = 233677, upload-time = "2026-08-15T08:17:50.845Z" }, + { url = "https://files.pythonhosted.org/packages/bd/67/0f40eaf8d1b6e7cf15e82382a2965efaca787fc1c2794b7021d37aaf5036/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c0ea61a470e070686aa30892fed79e297d2c8d0ab46b8bcdf027d38c51da591", size = 264491, upload-time = "2026-08-15T08:17:52.61Z" }, + { url = "https://files.pythonhosted.org/packages/5c/64/12b4c2a11ee8df4fcc518c78b0d93e3a92bd3d5253d1617ce74ff0e8c7ef/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:90b7481fb62fbe172c558bc6fd1c4c98d82004a54a7551f20e11ac9bf0b8708c", size = 245196, upload-time = "2026-08-15T08:17:54.023Z" }, + { url = "https://files.pythonhosted.org/packages/37/2e/651d910af6d0fba325eee1cda37ec5443462ed25360e666c144166eb6091/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:35fe081843b35aad20ffeccec3eeffbe637b15d14f3fb22cc1b59cd8ec17e93c", size = 261660, upload-time = "2026-08-15T08:17:55.491Z" }, + { url = "https://files.pythonhosted.org/packages/90/c6/b09e05e6db7f64338e0dc067c79577b1138da86c1e38369096851d96be88/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fd0350afdc3aabd5576f60ea109228bd5538139713c7b094c5cd27c73a98bc6f", size = 252618, upload-time = "2026-08-15T08:17:57.025Z" }, + { url = "https://files.pythonhosted.org/packages/76/4e/362d4f9fdcdf5556fb2aa3ce7d4a58ebce03ed1ff03aa1d9aca8d02f13f3/charset_normalizer-3.5.1-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:9d9a0dc7cbe9bec24c3f767c9122c41fe5a1bc43f47cd099d00d393e09769de4", size = 140362, upload-time = "2026-08-15T08:17:58.425Z" }, + { url = "https://files.pythonhosted.org/packages/b4/d4/703be739b26acce318bd29eb3b25b7209e1b1f527f9eae3d1f1f01fdde2b/charset_normalizer-3.5.1-cp313-cp313-win32.whl", hash = "sha256:d63600d620ad0064c3a748b950ac5ea38a80190e5498532efefa4b7b3f1da1f3", size = 177755, upload-time = "2026-08-15T08:18:00.037Z" }, + { url = "https://files.pythonhosted.org/packages/8a/33/56d97ade41c8db611e727168c52ae46c9224c362ec28d4b65d7e9869e8da/charset_normalizer-3.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:aea996a6aba25260827c9ea511d1addfde2da9eb686ac961838509086188b7e6", size = 199295, upload-time = "2026-08-15T08:18:01.506Z" }, + { url = "https://files.pythonhosted.org/packages/5b/75/5b20dd1e6573a01a08158fe104104fa2c8abf941745596954185726cd46c/charset_normalizer-3.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:fd0a274c0e5f9a21565cd9d3dd749b61f96b7aa1e20a93aa1ba4029518f2e5c0", size = 179856, upload-time = "2026-08-15T08:18:02.929Z" }, + { url = "https://files.pythonhosted.org/packages/29/cd/2b812ce5e888f1ce69a5350281e58aab07ae64a958ecae8912f30865718e/charset_normalizer-3.5.1-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:774d157f112367ff4abd29019f38f023c24e00e56edc7829c20e358a5a913ad8", size = 212318, upload-time = "2026-08-15T08:18:04.403Z" }, + { url = "https://files.pythonhosted.org/packages/9e/4a/a6ee107430768a5334e6d63f31f148a04a1a491ef161a1ac9415a73f2fa8/charset_normalizer-3.5.1-cp314-cp314-android_24_x86_64.whl", hash = "sha256:26422d45fd13551cf564c58932f7d72b4f58b93b0fcf18c35ba6be12b46bb102", size = 224897, upload-time = "2026-08-15T08:18:05.997Z" }, + { url = "https://files.pythonhosted.org/packages/c3/d9/35ae3f64f29d0179c35c3baefe575904df2913dde519129c7f75995a2b1d/charset_normalizer-3.5.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:09a7bba9f739468c8e78c36a75c33768e53cb1959fc638f510454c14683f00d5", size = 194848, upload-time = "2026-08-15T08:18:07.397Z" }, + { url = "https://files.pythonhosted.org/packages/74/76/f2fc7380f056cc273a53af37f50d08ad54b2c59f61078f31432edcf1c2bd/charset_normalizer-3.5.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:4c9548dc78002099910abaebc0a72ac58b7d30931869e0351c09b507dff4ece3", size = 198163, upload-time = "2026-08-15T08:18:08.989Z" }, + { url = "https://files.pythonhosted.org/packages/e9/40/095ce62fa078483cccc1fa2b36e6bc9580b85422a20ee9f925341c50e44f/charset_normalizer-3.5.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:c428c6c31eb5f4277d7f8eccaf767fbd548ddd5ce3c8b4f4cbbfab3d96b5904c", size = 341823, upload-time = "2026-08-15T08:18:10.458Z" }, + { url = "https://files.pythonhosted.org/packages/f1/5a/0e58b1c04a1596e0256f407274a92d5fb2ee21324409d1fab1da48a65b5b/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2f06b7eae9dbe77fe1d644ca244dad508de8d302870a43f3c559b521270938a0", size = 242458, upload-time = "2026-08-15T08:18:11.989Z" }, + { url = "https://files.pythonhosted.org/packages/22/95/b4618ce912e6db0b1aae89ba788e38e8a7eba0f3025cc66e8c0699f977b2/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b7430cf5728e68f6c462254009a6ef4086e1bea43cf2f57aa9c55fb4f50ff96", size = 226717, upload-time = "2026-08-15T08:18:13.401Z" }, + { url = "https://files.pythonhosted.org/packages/8a/76/c681192bbda3d55356db5dadd64381d5202b37c6b598fcda5282e88b5d3d/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab743e9bc90c1f73552ec33e10e3331315acd2c397b36065b591b0181de533cc", size = 266111, upload-time = "2026-08-15T08:18:14.961Z" }, + { url = "https://files.pythonhosted.org/packages/88/be/55127bfca72c0cff6c022488d140d7c5b04c771e3b72e9bdb4836d54979d/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6f7deae3feb4edfa2efaf7c574fe88cbf055038a6abdb40188e4fff66d5699f", size = 263128, upload-time = "2026-08-15T08:18:16.515Z" }, + { url = "https://files.pythonhosted.org/packages/e0/91/39c3af510b0aa32bbda03374259200f28430febfd1bf5e511fe765282ce5/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15f024313246a4ed976c60f440bb8d257815513a681d212ff74fd46f7d715a90", size = 251240, upload-time = "2026-08-15T08:18:18.127Z" }, + { url = "https://files.pythonhosted.org/packages/1c/a5/cbe418bbc6ecdfc3e05a0116002897c4b403a5e838d697e64c78e9f0190d/charset_normalizer-3.5.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:823f82903d189af463d7df250ef1f7f696f3cee08cc8d91deb565e8d425f6506", size = 245282, upload-time = "2026-08-15T08:18:19.625Z" }, + { url = "https://files.pythonhosted.org/packages/cc/a4/689bb42e8e7cd492f3cb64907c6bc00ad247ec9a3628cd3f8eed126e8ae1/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:01e93745f7f219b703b60ba7afead36cfc4242782be5af484673fc500df12da5", size = 244597, upload-time = "2026-08-15T08:18:21.121Z" }, + { url = "https://files.pythonhosted.org/packages/c1/ce/9962938e179cf9f699d3f1e7b3114b5d7642dee6a893745229f9dd04f274/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:329fc3ccb63ad22d867d84c2adea759a64079a37ba4a343433b02c7a2816871e", size = 231376, upload-time = "2026-08-15T08:18:22.57Z" }, + { url = "https://files.pythonhosted.org/packages/85/54/46000450ada53bd9eac5429a2c8c54cd2d9b39c0c255f229aea9af0948a5/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:bb57753e36e4855b8ca375069482250a6246372331a3e4f3407eaebb007443f5", size = 266715, upload-time = "2026-08-15T08:18:24.235Z" }, + { url = "https://files.pythonhosted.org/packages/3d/bb/618749d70f792b44252a777bf89bfb86823b9bbc1ea13fe8ce759b07f38a/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:fce8cbd4997efeb450bd298b54f755dcdff18d496f7a5ddbb4867c6d7c88fdc3", size = 245848, upload-time = "2026-08-15T08:18:25.726Z" }, + { url = "https://files.pythonhosted.org/packages/7e/3f/ffb64458527c7668031d5eb095d978de561958dc9f5b53f8e488a533e603/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:6c9cdde8becb25a7fde49924511aa2644d6f8081cc8df8e9452724303348d8e3", size = 264521, upload-time = "2026-08-15T08:18:27.193Z" }, + { url = "https://files.pythonhosted.org/packages/4f/ab/74a55fd803916a35ac461daf002708191aac19b546b80dc8cabfedc63d98/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9ac4444d8d4fd4c4bd08bf451ed3167aa9e7ec6cdb41b648794f1d1103652e36", size = 253054, upload-time = "2026-08-15T08:18:28.568Z" }, + { url = "https://files.pythonhosted.org/packages/a0/2a/6a9034b7d3c60b17499afb482df5878bf9fa20b50cc3887d5ef017a833db/charset_normalizer-3.5.1-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:f03ac127268b43ef4fe9e6ab6794a6794b49485a0cc0c1db79876d2f33f75bc7", size = 140580, upload-time = "2026-08-15T08:18:30.214Z" }, + { url = "https://files.pythonhosted.org/packages/f3/46/1d362e1a00d035d66b9869e1281eee115907f7e390a16a07824ab5737360/charset_normalizer-3.5.1-cp314-cp314-win32.whl", hash = "sha256:1f5883d77fd409a261abb5dc8ccbe335720d798b1de4abb3b1d47ccbbc76b53b", size = 180325, upload-time = "2026-08-15T08:18:31.877Z" }, + { url = "https://files.pythonhosted.org/packages/7a/7c/4938c329b6a9d446f6a59aa2092ff7118f274209b5ed0e26893d1d30a63c/charset_normalizer-3.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:c658c50ac0c98cd755a2dd50b7977d3bca7df401dcc47fbdfa87db53ef7d4e8b", size = 204175, upload-time = "2026-08-15T08:18:33.466Z" }, + { url = "https://files.pythonhosted.org/packages/ac/33/eeb384dbd8dec570661354592f4f2e1b2fcc92585624d146a000caf53841/charset_normalizer-3.5.1-cp314-cp314-win_arm64.whl", hash = "sha256:4bea7f8ebe90bbd7f0e4a2de42ca6924ba23e3e76418c408ff82f1d46fabd687", size = 184123, upload-time = "2026-08-15T08:18:34.913Z" }, + { url = "https://files.pythonhosted.org/packages/1c/6c/c73fa9d5a85f6ab05395de61c5f6984e0a9ff40bb5ff888d46dff02526c6/charset_normalizer-3.5.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:fbc597639158fd7c14d55e808718848319540f51b0e6746e3eefa59723a4a348", size = 381682, upload-time = "2026-08-15T08:18:36.349Z" }, + { url = "https://files.pythonhosted.org/packages/30/c7/63565f860921457feba93bae6c86fb7746deb4cffeed2f375cb845318146/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e71c909f353863b2b89c83de2ebed71ea6d0df8a6ef65a128193c5e650766bef", size = 240826, upload-time = "2026-08-15T08:18:37.887Z" }, + { url = "https://files.pythonhosted.org/packages/06/ae/7ae8807410dfa33f8e6f1715740adeaafa8a816cc4cb33508f54b1f7c896/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7ac76cf9afd34929d76eb7fcb63be476a4853d8a96f0dcf2d0db68a0cbdf9885", size = 227861, upload-time = "2026-08-15T08:18:39.315Z" }, + { url = "https://files.pythonhosted.org/packages/e9/a3/887c1642f0da26000b0e0652d91071113c0e72cea33952e225cf589f49a9/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a3a370082ce34d0612f421e15fe011c53bb1feff21a26d06ad4fb244dab5a375", size = 260758, upload-time = "2026-08-15T08:18:40.88Z" }, + { url = "https://files.pythonhosted.org/packages/3e/11/e6f5b9a3d0e55b0ef7505cd3765cdd48f22db89994c947b316f52f801fd8/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:256dd4d85d9e4dc595e2bc983c980e73f62ddeb3165c58b4c3dfe78c5c8548c1", size = 259950, upload-time = "2026-08-15T08:18:42.351Z" }, + { url = "https://files.pythonhosted.org/packages/1b/ee/e4e10a94d51cd1ee638aa7e00b65399e6b2a4e8376ab6d2eac9f95586671/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:58d4aa13a59c969dbfdf9e6a9560e242cbfd9e8a8f50c2747714df1a423adf65", size = 249329, upload-time = "2026-08-15T08:18:43.914Z" }, + { url = "https://files.pythonhosted.org/packages/c4/25/d5f4198819e6059735a84e8d0bfb72dc33976da67b97adcd3fb5a5e07ec6/charset_normalizer-3.5.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0c6dfb5ca6723eeed15aa8e564a014d69fcb8812f94eef11fe3631e0508199f5", size = 243137, upload-time = "2026-08-15T08:18:45.368Z" }, + { url = "https://files.pythonhosted.org/packages/a5/e9/e925ca7569cf9fb9701fd82503fee73eea5268fdb856bdd64947092d3daa/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c010f5581d9c612804cc59fcf7b524b707fbcb72828551237ab545bb5c7034af", size = 242820, upload-time = "2026-08-15T08:18:46.842Z" }, + { url = "https://files.pythonhosted.org/packages/34/17/672c251a888ed2aebcdd2fe830ad0104e25ff83c43f5c4f9c15e9fc6853c/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:52ec005752a56ae79547a05c0139ca2501a0c866390b6115008456b9f0e7cde1", size = 230504, upload-time = "2026-08-15T08:18:48.353Z" }, + { url = "https://files.pythonhosted.org/packages/3f/fc/f6a85abebd42ce4da2f1db0aa56cc6a0df1995e318b3875d14401b8381d1/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:2bced4061f000f7187254a02ad3433ae17eaf991747ceea2f478422590a5bba9", size = 263087, upload-time = "2026-08-15T08:18:49.859Z" }, + { url = "https://files.pythonhosted.org/packages/98/66/7c42677e739ba66746b297e2046918d793078094dc239e1e72768cffccc6/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:9eea3ab2597a5e65fe65296e2d6a84570845a6b55532d90333d740d48bbc850a", size = 243269, upload-time = "2026-08-15T08:18:51.601Z" }, + { url = "https://files.pythonhosted.org/packages/de/d8/a50b79237f417af10f8c2a501ce8d1ca87829a22e69117891ca4ba20a69e/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:496846868fea80e479324862fa877f02411f2fd0f83b79ccee2607aa68b2a032", size = 258766, upload-time = "2026-08-15T08:18:53.23Z" }, + { url = "https://files.pythonhosted.org/packages/2e/1d/0fc91aeaeb3c83b748f532399ce67cf84604b48297405d740000f7a9e786/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:85d5855daafc240cc045c026d7a15fd198a09b0fc8ff6f5ecbb5297b509cb11e", size = 250814, upload-time = "2026-08-15T08:18:54.768Z" }, + { url = "https://files.pythonhosted.org/packages/ae/10/3d8c777cf9024615295aa1b808324ad5b4a77855869c00824bad74ffaf8a/charset_normalizer-3.5.1-cp314-cp314t-win32.whl", hash = "sha256:58d3e12c88e0950bca850ae1f7c256055c097639c2edb9eb123af9807d8b15e4", size = 191074, upload-time = "2026-08-15T08:18:56.305Z" }, + { url = "https://files.pythonhosted.org/packages/4d/81/ae557d3c44d1a1d688696d60563413a0866a91b7ebc50f20df838be3d8c8/charset_normalizer-3.5.1-cp314-cp314t-win_amd64.whl", hash = "sha256:acaf604462bf330b0d07e7a07c1d6e4adac79e5fb13e9c5140590542cafacc00", size = 216476, upload-time = "2026-08-15T08:18:57.889Z" }, + { url = "https://files.pythonhosted.org/packages/27/e9/61c01fb8b804692569c036b3fc50495814502dcf13a60649c6055390b02c/charset_normalizer-3.5.1-cp314-cp314t-win_arm64.whl", hash = "sha256:fdb8a068947befafba9952162645dc2fecaeb400e64584829ed5e9b2fbe21a7f", size = 194115, upload-time = "2026-08-15T08:18:59.418Z" }, + { url = "https://files.pythonhosted.org/packages/4a/4e/8544831ef59d8f27ce92c80871380fdacc8076a8a56ed62f82e54f991333/charset_normalizer-3.5.1-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:9085f87b0e38a2b92b8923059b4e8789fe40d9279712d15dcc670048d77079af", size = 342048, upload-time = "2026-08-15T08:19:01.054Z" }, + { url = "https://files.pythonhosted.org/packages/7f/a6/e3b46852424246065355644f4fb6dbccc0239a42a2eee27ecfc8957f0bcd/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2679de311c7946dde5d3b6f44941844133ff5c7cb86099c0061ab1e8901c20a8", size = 242997, upload-time = "2026-08-15T08:19:02.492Z" }, + { url = "https://files.pythonhosted.org/packages/03/3b/0cc9a26777334ab2f2e3089b948bbf4e4fe72ea70b897715ef6415043ec8/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:baf3775a2635e5a11fbd5e4e64ee69c7e86875d224a5c72aca4c141064589a90", size = 237014, upload-time = "2026-08-15T08:19:03.943Z" }, + { url = "https://files.pythonhosted.org/packages/8c/c2/027335f0aa337a2a2e121bac1ad88c4f02ba6053ea0926802784f3db11af/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ac8c94b6539074e0f40899301273ac8402b9b3e01c7b7ba269ff30340aaaf20", size = 266174, upload-time = "2026-08-15T08:19:05.598Z" }, + { url = "https://files.pythonhosted.org/packages/86/d3/e367787febe4e74769dec0f406f2c3c8d1b955fce5aee1fd0f94e8367a45/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8fe532b3c966d1fb794e0698e4589d0444017ae77fc0b31edea13c0e35bcc449", size = 263361, upload-time = "2026-08-15T08:19:07.251Z" }, + { url = "https://files.pythonhosted.org/packages/af/3d/391b193eb9f3e84b02f9314088c386debdc0debee843535aaea2e2c6715d/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5c84bec0ab5ae0c64bfe73a7d2adcb5ce73b467523fc27fd6a28ab2aa6cbe35a", size = 252143, upload-time = "2026-08-15T08:19:08.816Z" }, + { url = "https://files.pythonhosted.org/packages/2e/57/de221f1745a90d418199761967e2776bfe2c275a1194220985e8c1d37833/charset_normalizer-3.5.1-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:854066be00447fa8de2ccbbe893e2ffc4b123ef16d897af794c1e18bd4a714b0", size = 252086, upload-time = "2026-08-15T08:19:10.255Z" }, + { url = "https://files.pythonhosted.org/packages/c8/e3/d119f86a01f9331e8186175f24873b1d74a7ee9e2e4b4d68f9947dae5afd/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:21b82d8082f6f5e7f456ef0bd16323d08de1266efbfeb476e64b2a91d1471a4e", size = 245231, upload-time = "2026-08-15T08:19:11.807Z" }, + { url = "https://files.pythonhosted.org/packages/26/de/d8e48c135ae480879539cdb179c8d3b50c7879497d75dd899b5763b69cee/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:838648accb3a7fd9803fd45c87bce8509648eb0c11bc34e216141300977244f2", size = 241546, upload-time = "2026-08-15T08:19:13.416Z" }, + { url = "https://files.pythonhosted.org/packages/67/c4/217755fd1abc50d326c252922cd642002758095a81ff45010337b8b3ef65/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:195ce897c6153c0700078142cf8efe3e6454ca4cf4357499e4078dfd83396626", size = 267033, upload-time = "2026-08-15T08:19:14.981Z" }, + { url = "https://files.pythonhosted.org/packages/b8/d7/34d8e404e358d2adcc5a228c2134643af00104c8fb0bf525f3688d756f05/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:978eab16f55b4ab2c2a745be9a0a840bf8f09a7f227d9c76eb30214d078865a5", size = 252045, upload-time = "2026-08-15T08:19:16.618Z" }, + { url = "https://files.pythonhosted.org/packages/5e/fa/40414471acf0aa0692ca77305aa00e434fcd8288f0941c93c30e9a5f8f2f/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:cc0329df4caaceb950d2f580b5ac716a377f7059624a0bafaeaf8a218c6ed774", size = 264866, upload-time = "2026-08-15T08:19:18.101Z" }, + { url = "https://files.pythonhosted.org/packages/32/90/fcc850bae791abd2e0c041847f13e270aa08692a79f3e00de6d2dce1cb50/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:687c9ca3035544b113bea2055e180af96fb63c0c476e22a9180f51925186e7b7", size = 253932, upload-time = "2026-08-15T08:19:19.734Z" }, + { url = "https://files.pythonhosted.org/packages/af/af/53afe99068b3c10b4cbae592a52ef72a7c92c0188440e83ee3a078fd8f75/charset_normalizer-3.5.1-cp315-cp315-win32.whl", hash = "sha256:706bfd38730a5ac7a365793269a00f4e988178cec121391f4248d84ad8c972e9", size = 180320, upload-time = "2026-08-15T08:19:21.37Z" }, + { url = "https://files.pythonhosted.org/packages/c9/bc/f46a132041b29e4a8779ed712d3df1bf112e94ca8de58b66d7ec2c0cf8b9/charset_normalizer-3.5.1-cp315-cp315-win_amd64.whl", hash = "sha256:92caef967d287a407085d61176fce4012b1dd62daed4eb6d5ceb26d3d2538712", size = 204174, upload-time = "2026-08-15T08:19:23.088Z" }, + { url = "https://files.pythonhosted.org/packages/a1/5d/9ed554480eda8e447b673648628fdc29574d23dbad01fe11837adedd1cae/charset_normalizer-3.5.1-cp315-cp315-win_arm64.whl", hash = "sha256:5fc45d653ea8c9a20479167e11d4a0f8cb2fa3470737ab6f9c827532313187b7", size = 184126, upload-time = "2026-08-15T08:19:24.471Z" }, + { url = "https://files.pythonhosted.org/packages/3b/32/9b8929bf384061ee1fe5d9c27c6f9776d3d824039ad4e14c88ec00c7808e/charset_normalizer-3.5.1-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:59171c6e45bf07d0d5cab3b0bf81d945035530f6873398b3b531c31184d46663", size = 381441, upload-time = "2026-08-15T08:19:26.038Z" }, + { url = "https://files.pythonhosted.org/packages/96/10/e9aa7923d3ddac652c99a1c5f7be494e737e151566a44abe018daf757f2c/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9dbdd9205662134957cf0c324f639bdc5031c0ca056e2369e238db75187c0f11", size = 241742, upload-time = "2026-08-15T08:19:27.532Z" }, + { url = "https://files.pythonhosted.org/packages/28/53/a2d249ebddf47b889a100c0bdcb61a2f9dbb8bc24ef325cc062e4f476877/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e4b018dc5a0eee4676e38fe84a47a427816c590b93b55d9025274ec4d6ffc2dc", size = 235298, upload-time = "2026-08-15T08:19:29.274Z" }, + { url = "https://files.pythonhosted.org/packages/7d/07/469f78af590f7d5cd48e20d8dbfa3d66deeff9ba37768c04d886b5afd45c/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ced3fdd71aaa83ce593746c2edb42b7a59cb4c19c8b5c407781c72e493aae55a", size = 262500, upload-time = "2026-08-15T08:19:30.955Z" }, + { url = "https://files.pythonhosted.org/packages/55/66/3bb56a47f7dcba014055b1a1d33c6f08bbe9c1e74dba154cfa25f90ae885/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:19a3dd5aa73cef1c99687c4fc57db016a9c17104ae1185da88ba566a5d3bebe4", size = 258888, upload-time = "2026-08-15T08:19:32.458Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c1/2adc2800903fb013210349313b710a5376856578d9e33e6b9a1d8b36714a/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cc5d36d96478aa9c60654bd932525bf32964c62a7281eafdf16d85003a8d6004", size = 250243, upload-time = "2026-08-15T08:19:33.94Z" }, + { url = "https://files.pythonhosted.org/packages/95/b5/a18d0dd1157ab655cc2cb14a545f4a4784bbad70ab3502412e36097502d9/charset_normalizer-3.5.1-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:04368edf83514385ffc3e1cfd4546e595f4f1272dd23ba437a93a9cc3741d47b", size = 249871, upload-time = "2026-08-15T08:19:35.413Z" }, + { url = "https://files.pythonhosted.org/packages/ad/c3/525f508cd1e58d0450ac55ed40ac75bc3a97482c59def5278456a5fbf03c/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:9b5db6052055d34d41230fb78d7c439c23dc536a9896f6cb039e8dd92cfc1263", size = 243580, upload-time = "2026-08-15T08:19:36.886Z" }, + { url = "https://files.pythonhosted.org/packages/7c/c1/49a91fe7e97c8140094ca5c64161ab623a70d9f636bf834eace14048acb5/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:252d099029bcbea642f2a06c4ed5046bdf8b5a8150b64afa5e027e88b106e5ee", size = 239807, upload-time = "2026-08-15T08:19:38.392Z" }, + { url = "https://files.pythonhosted.org/packages/d3/58/56a48c296601274c4689b864a8e2dfb209b81dfcb39472753ce95eea662b/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:6199d5606e2bbf2b096cf64d03f8b6790c91081d5ac866b8e7bb6422738cc60c", size = 264083, upload-time = "2026-08-15T08:19:39.856Z" }, + { url = "https://files.pythonhosted.org/packages/10/4c/dc48409274a1817ff349711d26c62aa0c597df865d4d69ef79160c859193/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:77efcff2b23071c349402ac1066667a3d011f62398d81408c9b88ad991747c9e", size = 250317, upload-time = "2026-08-15T08:19:41.53Z" }, + { url = "https://files.pythonhosted.org/packages/81/58/d325912115caec62d6bdd77bbab5e0b7da5d234a9f20affdffcbcb530d0b/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:a5cbd90ecf0fc62e64726917ad083b73001f0563657a87ec3c0b504e277dc90d", size = 258173, upload-time = "2026-08-15T08:19:43.07Z" }, + { url = "https://files.pythonhosted.org/packages/34/f7/b13b1ccae2c8ec63980d13be1890eb73f8aeabbfce02a24aabc0908788f5/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:4d26f14f041e83dd8edfd61f4cd4fa7285d31798b5bf1f28e70c367ba6c41d61", size = 251960, upload-time = "2026-08-15T08:19:44.587Z" }, + { url = "https://files.pythonhosted.org/packages/1e/25/ed3f9919c5aef8cc818be1f972f565f7610d7b2076b8ebb98839516ffc3c/charset_normalizer-3.5.1-cp315-cp315t-win32.whl", hash = "sha256:ac13b004224fb341e1e25a1ed5e19d32f57cdb2a403e01f003b46f051a550f6f", size = 191186, upload-time = "2026-08-15T08:19:46.293Z" }, + { url = "https://files.pythonhosted.org/packages/69/d5/43c2b3e9d8267092b913eb8b0603f0f71993c395632886bd37a7223f96cf/charset_normalizer-3.5.1-cp315-cp315t-win_amd64.whl", hash = "sha256:35aea775dc2bd5f54cd84a1cd2696cc3207c479cb9cf0bd346f0d343e4300ddb", size = 215947, upload-time = "2026-08-15T08:19:47.853Z" }, + { url = "https://files.pythonhosted.org/packages/a8/76/9aad3e9c8865e5e0efa9a7f6f81c37a67635a985145ecd44528a81e088ee/charset_normalizer-3.5.1-cp315-cp315t-win_arm64.whl", hash = "sha256:fb78f6e7fcd8ad785d28cd577168bc1aaee827b25bb8755638f694794ea98f0a", size = 193909, upload-time = "2026-08-15T08:19:49.383Z" }, + { url = "https://files.pythonhosted.org/packages/5b/97/fb4e82231aba271ffd775a1b4993b0defc4e3059f286ae41d9433409fe85/charset_normalizer-3.5.1-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:41876ee62a3dddf48ff1121ad8f0798032aa03f2fd35f21f34a4cab14f18d8d2", size = 331467, upload-time = "2026-08-15T08:19:50.959Z" }, + { url = "https://files.pythonhosted.org/packages/9f/2f/fe3f187327aac18e2d54e9d2b08e15d27bf9b642d9e51c219f130fc34d1a/charset_normalizer-3.5.1-cp37-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a6dac12ff6b846103483683f60c5f8fee205121adc58ffd87e90a90a3af69e99", size = 253057, upload-time = "2026-08-15T08:19:52.654Z" }, + { url = "https://files.pythonhosted.org/packages/d7/c7/9e48cee5c161fe24da823b61bf381921d77cb994a0a4de148e95018c1984/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cee5dd7c6fb5dd52a0fe2a740f9bc6e3593f5f8b1788bde49de02086f30182b2", size = 240930, upload-time = "2026-08-15T08:19:54.163Z" }, + { url = "https://files.pythonhosted.org/packages/49/e0/716601f3cc69be7b198951150c75ead1ece33c3c8036ff6ffa46029659a0/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:343fb4f2821043bd87095f7b08a1a181febc8e36ac64212143bbfd0a0e1bc235", size = 230822, upload-time = "2026-08-15T08:19:55.807Z" }, + { url = "https://files.pythonhosted.org/packages/d3/05/71bfc5caa0abcc45aea1f6a4d50ac68e59605ddc7666fe8494f4cd229665/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ae4a097991662cd4fff0ddc74e0fe7874f82e00042fa0ea00855645ed0c79598", size = 260037, upload-time = "2026-08-15T08:19:57.312Z" }, + { url = "https://files.pythonhosted.org/packages/c3/92/de7e32ed05341e7a9c4c877c318418197b7f2d66a3b68d561bf2ac57ca3e/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b599739b93b2cbeded49645ae3c8d1405c29ddfbceac1545c87a3f9580a9e96", size = 255097, upload-time = "2026-08-15T08:19:59.056Z" }, + { url = "https://files.pythonhosted.org/packages/f5/7b/ade0a122600319dfa0b1000ab0f9731c94a817904cf3c5de408c73a4ede7/charset_normalizer-3.5.1-cp37-abi3-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b39b69b347e5e47a3b5b8cfc005c68c1ba347474e3960236c4944a8ecd174962", size = 250166, upload-time = "2026-08-15T08:20:00.612Z" }, + { url = "https://files.pythonhosted.org/packages/75/9c/019fbb9f4834491a160951349b1a3714439376f66e5f7cf18b4f18f0c7aa/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:a2028475ba855475b8b4d3cfeb4994269c967aea8b9892dfba907f4263a863a3", size = 241821, upload-time = "2026-08-15T08:20:02.321Z" }, + { url = "https://files.pythonhosted.org/packages/2b/b8/11d4840bfc99330cc7fbcc2681ee5a044553a6e77655508d8f9b2bff7b34/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:36047af20e17097c3bb9476c2b7655f2f7aa51322c0ba58c07695bedf755a950", size = 232529, upload-time = "2026-08-15T08:20:04.008Z" }, + { url = "https://files.pythonhosted.org/packages/18/96/2b3a21492d9f65171ac75d872f5018260013d00bfa0ff70ec9f179148cbd/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:4c4fb141a727957c93edfe5c32a26ceb6b5f6461d67146e2d39f51e16170bea8", size = 260348, upload-time = "2026-08-15T08:20:05.877Z" }, + { url = "https://files.pythonhosted.org/packages/d6/aa/a69a2028e8bd052476c245460ab19d7de595de084dd968f2d75cd50c3e25/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:2f293479cce755c75f1697e87c409b7ae4c555c7dfecb6e988ad13abba943031", size = 247234, upload-time = "2026-08-15T08:20:07.487Z" }, + { url = "https://files.pythonhosted.org/packages/35/8a/3d130aeabcaf3d2466af76b7b141c08d9e89c9016ab4b7cdd0f7dc2d1c62/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_s390x.whl", hash = "sha256:3588e376b3ea2eea84976f67273d679f229e24c66dce7b82ae45aef04ff6e072", size = 256917, upload-time = "2026-08-15T08:20:09.142Z" }, + { url = "https://files.pythonhosted.org/packages/80/c2/a7379b840292d0c1ab9fbd17d1f3967aa81794dc95bc74be8999d7fedcf7/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e199fb99720074809a7720f1c0b4d919eea8b87e88713e0f8f602f7bef543d9d", size = 254846, upload-time = "2026-08-15T08:20:10.727Z" }, + { url = "https://files.pythonhosted.org/packages/01/65/d43b714731bb2f40d4053dfa00ecfc1c5a301f8e3316c5db3a09af59fe94/charset_normalizer-3.5.1-cp37-abi3-win32.whl", hash = "sha256:dd732602a7009217f658d5863d12d79d373a4de0eebc111094bcdd3bb8e0a6cc", size = 174216, upload-time = "2026-08-15T08:20:12.334Z" }, + { url = "https://files.pythonhosted.org/packages/35/4f/b911ed898b26a09789eba9c9200c999aff6c61b4bafaf4838e56d1a1e1a3/charset_normalizer-3.5.1-cp37-abi3-win_amd64.whl", hash = "sha256:70055ff39b97c99e7ae40ea3e393fb62aa2e44dbd9b29f8d14f42fb0025c3959", size = 199764, upload-time = "2026-08-15T08:20:13.908Z" }, + { url = "https://files.pythonhosted.org/packages/f0/a7/920baf467bfd9bf689f3b318340f37aee4572a71f162bd8db51da55ba4fa/charset_normalizer-3.5.1-cp37-abi3-win_arm64.whl", hash = "sha256:87e4f41d375c0b9be2fb5251aee4b8a689169e134535aed81bf085c3b647451e", size = 287318, upload-time = "2026-08-15T08:20:15.551Z" }, + { url = "https://files.pythonhosted.org/packages/cc/61/d01fc49b8dea277640b55a9e15960dbca9fdc8c9fde18e572d39c59f4019/charset_normalizer-3.5.1-py3-none-any.whl", hash = "sha256:6df0ec430f9a831772c23ca5a224cba36517a58a84bb32c32bb59a9fa67c47f6", size = 68658, upload-time = "2026-08-15T08:20:43.306Z" }, +] + +[[package]] +name = "click" +version = "8.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c7/0e/7fa0ef50764b67090eca4114772a2abf8b6148198475e54c660b97caeee6/click-8.5.0.tar.gz", hash = "sha256:ba0d2089de75ea0310e2dde03160e6ca10009947fb95a182f9b54021bb272e34", size = 382235, upload-time = "2026-08-26T13:33:14.56Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/50/6c0d534c5f134586a8e1ba4e330569e32f057e33372ae556463212fb4cd3/click-8.5.0-py3-none-any.whl", hash = "sha256:255bc9599cf7748b4b1a446ccc735421bd08a2ae529a8b88597d3de5664ee360", size = 125251, upload-time = "2026-08-26T13:33:12.928Z" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, +] + +[[package]] +name = "cyclonedx-python-lib" +version = "11.12.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "license-expression" }, + { name = "packageurl-python" }, + { name = "py-serializable" }, + { name = "sortedcontainers" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/17/40/6509e6cfd7f2f3255501690f46375fdd224949e21fd1e96f4f4c8a9041b1/cyclonedx_python_lib-11.12.0.tar.gz", hash = "sha256:16767c4039de90c04e9f03348f8f0ed4b8ff842eaa7eefcad3a95685f970dacf", size = 1445378, upload-time = "2026-08-13T07:52:18.675Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cf/f0/b2cb999244f2f4194df63ecff6939228178fa63a33be809c412684ca8db7/cyclonedx_python_lib-11.12.0-py3-none-any.whl", hash = "sha256:0e807521a921a5c3cb8ce1153f8a61d29eedfe76a46aac2796b7c6b573391a54", size = 529453, upload-time = "2026-08-13T07:52:16.836Z" }, +] + +[[package]] +name = "defusedxml" +version = "0.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69", size = 75520, upload-time = "2021-03-08T10:59:26.269Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61", size = 25604, upload-time = "2021-03-08T10:59:24.45Z" }, +] + +[[package]] +name = "eventlens-api" +version = "1.0.6" +source = { virtual = "." } +dependencies = [ + { name = "evtx" }, + { name = "fastapi" }, + { name = "pydantic" }, + { name = "python-multipart" }, + { name = "uvicorn", extra = ["standard"] }, +] + +[package.optional-dependencies] +dev = [ + { name = "httpx" }, + { name = "pip-audit" }, + { name = "pytest" }, + { name = "ruff" }, +] + +[package.metadata] +requires-dist = [ + { name = "evtx", specifier = ">=0.12.1,<0.13" }, + { name = "fastapi", specifier = ">=0.115,<1" }, + { name = "httpx", marker = "extra == 'dev'", specifier = ">=0.28,<1" }, + { name = "pip-audit", marker = "extra == 'dev'", specifier = ">=2.7,<3" }, + { name = "pydantic", specifier = ">=2.10,<3" }, + { name = "pytest", marker = "extra == 'dev'", specifier = ">=9.0.3,<10" }, + { name = "python-multipart", specifier = ">=0.0.20,<1" }, + { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.9,<1" }, + { name = "uvicorn", extras = ["standard"], specifier = ">=0.34,<1" }, +] +provides-extras = ["dev"] + +[[package]] +name = "evtx" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/10/8cdb3afe0f1ba5344978a550fca1d9dcbc3f9093f429bca2209552af03ee/evtx-0.12.1-cp310-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:230c7b2dd0395d6b3cdd954d66423a6ed1fabcea3bf0f151cb53cd9c3a115154", size = 2124872, upload-time = "2026-06-13T15:10:09.721Z" }, + { url = "https://files.pythonhosted.org/packages/d8/b6/fd36daccd36b740b233ececf89a76dbaa1979f39ca228f3caa4874c05fd5/evtx-0.12.1-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:6dc78b1fe6e9193e56ae00797bdd7cb79a94f10642292855ed9f696917783e31", size = 1113799, upload-time = "2026-06-13T15:10:08.62Z" }, + { url = "https://files.pythonhosted.org/packages/0d/cf/b0bb5dbbe746fca1135cca11b2b63ea1fe7d3a4c94447aebe1cab8b977b0/evtx-0.12.1-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1ee835a4eee6513956b37162f6ae96dbc475d361d91b6bcc89f215f89f5f94d4", size = 1055244, upload-time = "2026-06-13T15:10:07.641Z" }, + { url = "https://files.pythonhosted.org/packages/71/71/3989029f9c82233cde390ed39f320dc6268c03f4034c74e0f171026e60e6/evtx-0.12.1-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:826ff391772566b1fb2605b92f3c2e66e9597e5731e8176713c60dcc91ed70b1", size = 1239910, upload-time = "2026-06-13T15:10:11.171Z" }, + { url = "https://files.pythonhosted.org/packages/8c/00/9ff5286ff0c8fd52ef832dfecfabefd89b4d45a3dde7b8294646fe7a0d05/evtx-0.12.1-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:4074ae24a4f8f84aaed16c54990eb0f7d4da998a1bb3b998e14bb27d4f34eca1", size = 1054146, upload-time = "2026-06-13T15:10:06.609Z" }, + { url = "https://files.pythonhosted.org/packages/e5/05/b488927ccbd1460e44ce5d6453b6ac611b9d935ec2c6e6a25986604a67fa/evtx-0.12.1-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:c891c83c328c17ae9f2128976bddec9e0d19a2d82b49c2e2a20568ba2a014b7d", size = 1084129, upload-time = "2026-06-13T15:10:12.477Z" }, + { url = "https://files.pythonhosted.org/packages/60/52/a0a7de46fa0f71705a5d8622325855ef64ec7401f048a00f9d255f2ff03c/evtx-0.12.1-cp310-abi3-win_amd64.whl", hash = "sha256:ee0e40f0f09d10af779bafa5b058358cdd7f23e00d730afd0520dc3e4c2bfe04", size = 921736, upload-time = "2026-06-13T15:10:05.135Z" }, +] + +[[package]] +name = "fastapi" +version = "0.141.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-doc" }, + { name = "pydantic" }, + { name = "starlette" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8a/02/91e3416a8fdd715abb903a952a6bec7cdd8d14eed55d415fc8595524c319/fastapi-0.141.1.tar.gz", hash = "sha256:e8822fc40db1e1858054d7a949a888695bc9bdce70139178e33bd2871a453ca1", size = 425799, upload-time = "2026-07-29T17:18:05.568Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/03/10388a42375ee7e4ac9b94eb2c5c569c8b5795e377e701c9ac3ad63de890/fastapi-0.141.1-py3-none-any.whl", hash = "sha256:bfb91aa2d334c61cb35ba9a116fc123b3d3df31640b801cf57a7a78ec3f603b3", size = 131954, upload-time = "2026-07-29T17:18:04.364Z" }, +] + +[[package]] +name = "filelock" +version = "3.32.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/38/46/126b1831dca12060d4a8296bf9c4fe5c93c4f22197fa239cb0cc82042bba/filelock-3.32.6.tar.gz", hash = "sha256:a3f55a18af3652a94d8f47d6055df434f254ca1d02ef2524850c6d249ca2512c", size = 225172, upload-time = "2026-09-08T22:57:11.528Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cc/06/4f138f618dbea66803291274f228f01daf29f306fe8b96bc30dab765df75/filelock-3.32.6-py3-none-any.whl", hash = "sha256:3f16ecd0117feae0dfc147e8c62eb5daeccd8bd800378c3ddf416de9b4feb6b1", size = 100189, upload-time = "2026-09-08T22:57:10.182Z" }, +] + +[[package]] +name = "h11" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, +] + +[[package]] +name = "httpcore" +version = "1.0.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" }, +] + +[[package]] +name = "httptools" +version = "0.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/e5/d471fcb0e14523fe1c3f4ba58ca52480e7bd70ad7109a3846bc75892f7fb/httptools-0.8.0.tar.gz", hash = "sha256:6b2a32f18d97e16e90827d7a819ffa8dbd8cc245fc4e1fa9d1095b54ef4bd999", size = 271342, upload-time = "2026-05-25T22:17:48.841Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/14/88/1d21a36da8f5cb0fa49eafd4b169eba5608d57e75bbcf61845cbc6243216/httptools-0.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:880490234c10f70a9830743097e8958d6e4b9f5a0ffc24515023afeef984054d", size = 208247, upload-time = "2026-05-25T22:17:07.843Z" }, + { url = "https://files.pythonhosted.org/packages/a5/42/cc4feea2945cb3051038f090c9b36bd5b8a9d7f5a894a506a8983e33fd1c/httptools-0.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5931891fb7b441b8a3853cf1b85c82c903defce084dd5f6771ca46e31bf862c5", size = 113064, upload-time = "2026-05-25T22:17:09.136Z" }, + { url = "https://files.pythonhosted.org/packages/e3/a6/febbb8b8db0f58b38e44ad6cb946e6a255ae49b55f2e8543408fb7501ccd/httptools-0.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b15fc622b0f869d19207c4089a501d9bcc63ca5e071ffdd2f03f922df882dcb2", size = 523851, upload-time = "2026-05-25T22:17:10.106Z" }, + { url = "https://files.pythonhosted.org/packages/b7/e4/f90a0df0b83beff265b7e3b65f2a4cefd95792d4be0ac3e16049f2acd3c2/httptools-0.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:425f83884fd6343828d8c565f046cb72b6d19063f6924093e11bcd8e1548cd09", size = 518842, upload-time = "2026-05-25T22:17:11.218Z" }, + { url = "https://files.pythonhosted.org/packages/9e/2d/0c9ac76dd2c893841fbf6498d6acec4f2442e1b7067f6e3e316a80e494e8/httptools-0.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ef7c3c97f4311c7be57e2986629df89d49cb434dbff78eafcd48c2bff986b15a", size = 501238, upload-time = "2026-05-25T22:17:12.728Z" }, + { url = "https://files.pythonhosted.org/packages/ca/42/906adc91ae3a5fa9c59c0a2f21c139725bd7e5b41ae6acd485cd14123ebf/httptools-0.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a1afd7c9fbff0d9f5d489c4ce2768bd09c84a46ddefc7161e6aa82ae35c85745", size = 509567, upload-time = "2026-05-25T22:17:13.842Z" }, + { url = "https://files.pythonhosted.org/packages/05/0b/4240efeb672751ee5b9b380cb0e3fdc050bc05f68adc7a8aefc4fcd9a69a/httptools-0.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:cd96f29b4bab1d42fa6e3d008711c75e0f79e94e06827330160e3a304227f150", size = 90918, upload-time = "2026-05-25T22:17:15.155Z" }, + { url = "https://files.pythonhosted.org/packages/5e/e5/8cfcabc5546e8022f168be28bcdaa128a240a0befdd03b59d558b4f18bd6/httptools-0.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:614ceea8ea606848bece2338ac03b3ce5324bcb4be8dc7d377ed708012fa4db8", size = 205148, upload-time = "2026-05-25T22:17:16.333Z" }, + { url = "https://files.pythonhosted.org/packages/2a/0e/0fb14848c19a686c8062ff9067c1a48793e3224b47bc5b201535b6036fce/httptools-0.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2d689918c15a013c65ef52d9fd495d766893ab831a2c8d89f2ac5940a5df847c", size = 111368, upload-time = "2026-05-25T22:17:17.586Z" }, + { url = "https://files.pythonhosted.org/packages/2e/1b/46f1cecf06b9bbde8e4b8c88034ac7908989e5ff7a3a388ef38392949c1f/httptools-0.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:eb3028cca2fc0a6d720e52ef61d8ebb62fcbfeb1de56874546d858d3f25a26b7", size = 486447, upload-time = "2026-05-25T22:17:18.564Z" }, + { url = "https://files.pythonhosted.org/packages/77/00/258bfc0837221f81d9725c45f9b948a6a6b2994a147a4fb66e85100c668f/httptools-0.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:88bdd940f2b5d487b4d032c6afa5489a7dc4694410d43de3c38c4fb3af0dc45d", size = 482448, upload-time = "2026-05-25T22:17:19.912Z" }, + { url = "https://files.pythonhosted.org/packages/04/ab/d1cef3b5523f4d272a70f42a776c3169a2dddfe3a54de4b2ce4a36341528/httptools-0.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6a43c9dd399758ccc0531acb0a3c4a6c299ee893ee9400e9c893b7bdcfae0681", size = 464460, upload-time = "2026-05-25T22:17:20.882Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/5d1d072442277bb2b3434e0e60690b8e8c23840ef7de8b6ea54040a536d3/httptools-0.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0770728beb05094c809b98e814edff5fef69d26ad7d21185f2f6d5884a0ba683", size = 471312, upload-time = "2026-05-25T22:17:22.085Z" }, + { url = "https://files.pythonhosted.org/packages/0d/66/b96623b27e51a68199ef4efdda0613cced9233fe3062ac74e50749c5ad37/httptools-0.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:7685df791fad561384bfb139e77fde27a1ffd93134e016f95a0db424ffbf77b1", size = 90117, upload-time = "2026-05-25T22:17:23.074Z" }, + { url = "https://files.pythonhosted.org/packages/1a/12/fa3fbf5f9517b273edea2dc982aa82a8c634091e67c590792b729017bc6f/httptools-0.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:de242a49b5d18e0a8776e654e9f6bf6d89f3875a5c35b425a0e7ce940feb3fd6", size = 206183, upload-time = "2026-05-25T22:17:24.004Z" }, + { url = "https://files.pythonhosted.org/packages/30/fc/5e7c4cb443370f2090a3aba0453a07384d29ff66b7435bb90e77e1037599/httptools-0.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:159e9ab5f701ccd42e555a12f1ad8ff69702910fc1c996cf2bb66e5fcb7a231b", size = 112079, upload-time = "2026-05-25T22:17:25.216Z" }, + { url = "https://files.pythonhosted.org/packages/ba/53/771bd891eb0f236f32145d6a1775777ec85745f3cc983a1f23d1a3b8ddfe/httptools-0.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c4a9f1707e4823d54dfec6c33fa3697d302aed536ed352a7ebb5a061ddb869d0", size = 481596, upload-time = "2026-05-25T22:17:26.186Z" }, + { url = "https://files.pythonhosted.org/packages/62/42/94e15bc68ce3d423243c45d7f1b0c7561f13844f97dc52ae23182fb65628/httptools-0.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d76ad7b951387e3632c8716a9bb03ac5b45c5f16119aa409db0459520887944e", size = 480865, upload-time = "2026-05-25T22:17:27.542Z" }, + { url = "https://files.pythonhosted.org/packages/1c/7c/fe2980fc03723272e30f135b62360b075f513dfe7cc73aef36c7f04012bd/httptools-0.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a3b7387147361c3fd47a0bde763c5c91b5b4cd4dc9989b8ece84ff436c99843b", size = 463189, upload-time = "2026-05-25T22:17:28.546Z" }, + { url = "https://files.pythonhosted.org/packages/15/1b/47fc5fff68acd1bfa20b4734059c9a06cadb88119dcd5258b5b0d21d91c8/httptools-0.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f256d6ce930c52ca1cb2a960b7da03548c454e7d28b06059ad41bfe789036ce0", size = 466610, upload-time = "2026-05-25T22:17:29.816Z" }, + { url = "https://files.pythonhosted.org/packages/60/bd/07b13c93ffd9bec9546e0d43f8e19378dd696dbd278511406bc07371ef1f/httptools-0.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:19d1ee275bb59ba2643ba9a3a1e51cc0c788caf2b8df506368e03f56fdd08527", size = 92705, upload-time = "2026-05-25T22:17:31.133Z" }, + { url = "https://files.pythonhosted.org/packages/fd/c4/121648f68ce066d7bd762d6b6d97e620847642d38d54f3d90ff11d947629/httptools-0.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:de1ed58a974e75d56560acc7e7fed01a454994429456f65209789992e41f2568", size = 215023, upload-time = "2026-05-25T22:17:32.401Z" }, + { url = "https://files.pythonhosted.org/packages/b9/b0/312a062ae741ae3e8baa8c8bf20be81b2e67337b259ab4349bebc7b6142e/httptools-0.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e93c227b595c6926c1acee96891dd9da4be338cfbe82e5cd3bb9d8dd7dc4ac0b", size = 117405, upload-time = "2026-05-25T22:17:33.742Z" }, + { url = "https://files.pythonhosted.org/packages/fc/37/fccd705f795386bb05bf413012fecff2a33e5aa8c2f069096de3e9fd8702/httptools-0.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2a021c3a8e65cc125390d72f59b968afca3bdcaff25bd67965e0a055a14946ca", size = 558497, upload-time = "2026-05-25T22:17:34.732Z" }, + { url = "https://files.pythonhosted.org/packages/bd/39/f172e8003576de35f5ba77ff417cf0e34429d35dc014deef15afa337a72c/httptools-0.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48774d39cbb70e2b1f71f88852a3087ae1d3a1eb80482bb48c13067ab080c14f", size = 571585, upload-time = "2026-05-25T22:17:35.813Z" }, + { url = "https://files.pythonhosted.org/packages/3e/b9/f5564760af99f3dbbf3f9104dc00e5da27e96cf433c6bdcf77617f70bf3f/httptools-0.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:88eead8ec8680a9f146c655bc88445a325bd7921cfd8194c7337e9467282427d", size = 543297, upload-time = "2026-05-25T22:17:37.08Z" }, + { url = "https://files.pythonhosted.org/packages/99/67/8d9f2c313618e161b82f3873188e7196126da1d6e29688df40eb3997c77a/httptools-0.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:2c032fa028f46871ec7e1fc59fc15e8023eab3e6bbe6ece786a1611719a5d081", size = 539535, upload-time = "2026-05-25T22:17:38.032Z" }, + { url = "https://files.pythonhosted.org/packages/48/63/b906c01e53f50d432c0defe43ce52764a111dc1bdd028bafbeb54dcfd008/httptools-0.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:384c17174464c8e873398b7af24f0b1f44d992c820328413951a625323155d77", size = 108209, upload-time = "2026-05-25T22:17:39.473Z" }, +] + +[[package]] +name = "httpx" +version = "0.28.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" }, +] + +[[package]] +name = "idna" +version = "3.19" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5f/f7/abb373e5757eaec4b922b92f97ec8d6d7e057cf06778247604fbc4e7c3f3/idna-3.19.tar.gz", hash = "sha256:5e0811a4383b21dc5838069f801c4fb62113b7447663d2530d2bd6e77b49bf15", size = 215237, upload-time = "2026-08-18T05:14:24.27Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, +] + +[[package]] +name = "license-expression" +version = "30.4.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "boolean-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/40/71/d89bb0e71b1415453980fd32315f2a037aad9f7f70f695c7cec7035feb13/license_expression-30.4.4.tar.gz", hash = "sha256:73448f0aacd8d0808895bdc4b2c8e01a8d67646e4188f887375398c761f340fd", size = 186402, upload-time = "2025-07-22T11:13:32.17Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/af/40/791891d4c0c4dab4c5e187c17261cedc26285fd41541577f900470a45a4d/license_expression-30.4.4-py3-none-any.whl", hash = "sha256:421788fdcadb41f049d2dc934ce666626265aeccefddd25e162a26f23bcbf8a4", size = 120615, upload-time = "2025-07-22T11:13:31.217Z" }, +] + +[[package]] +name = "markdown-it-py" +version = "4.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mdurl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/ff/7841249c247aa650a76b9ee4bbaeae59370dc8bfd2f6c01f3630c35eb134/markdown_it_py-4.2.0.tar.gz", hash = "sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49", size = 82454, upload-time = "2026-05-07T12:08:28.36Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/81/4da04ced5a082363ecfa159c010d200ecbd959ae410c10c0264a38cac0f5/markdown_it_py-4.2.0-py3-none-any.whl", hash = "sha256:9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a", size = 91687, upload-time = "2026-05-07T12:08:27.182Z" }, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" }, +] + +[[package]] +name = "msgpack" +version = "1.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6d/44/ea2100ec54d30c46ee9dba10a3bfb79b655e96c6df237238a3234c75869b/msgpack-1.2.2.tar.gz", hash = "sha256:9eb0b0e602064527a045ea28c4f174ed69383587e29cebe28947e3b84106eb2a", size = 187025, upload-time = "2026-08-27T10:03:47.793Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/31/78/90c15bebb1a72667349ca62d4507e9d9369e7f8f76b95f490b823d3622e5/msgpack-1.2.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a4348705be86e029d04e741cf9ed0dfe03e942d7d3b92e838fa80d3aa2c3ebc", size = 84275, upload-time = "2026-08-27T10:02:07.106Z" }, + { url = "https://files.pythonhosted.org/packages/88/88/c2b6d8e81571da87aa232c0e34a3f3a0e618e6235892065ec82d1d81fc7a/msgpack-1.2.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0a652ceeededf71d3fa40c303a02a149d42338d310162367b91c539d4bd6e0a3", size = 83970, upload-time = "2026-08-27T10:02:08.488Z" }, + { url = "https://files.pythonhosted.org/packages/da/c0/d3ede9f5d16acb4c05a9281859f1e99ef9f877a928eb78454c37f70db001/msgpack-1.2.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:90986cc9aab9d7d1d8f38bcbf65d3f7ac83bdd90c35765db7d691b4829698cba", size = 409401, upload-time = "2026-08-27T10:02:09.877Z" }, + { url = "https://files.pythonhosted.org/packages/41/f0/29f591bea185616cf417645ac03bd3ad9b317483ad8572160e325f7fe777/msgpack-1.2.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:77c2e018417dc1d66f235e383877ee885b60ade9d29e494dd581e08af2cb1923", size = 420619, upload-time = "2026-08-27T10:02:11.526Z" }, + { url = "https://files.pythonhosted.org/packages/4e/8e/c70c8c9180c5ddf4440eb8658ebead98e22e7686fbf84f6b165031430750/msgpack-1.2.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0e91332144f69bc3018c91232fac26da580ef748fb8eaddd7914d4458001cc4f", size = 379747, upload-time = "2026-08-27T10:02:13.345Z" }, + { url = "https://files.pythonhosted.org/packages/50/9a/f10ce11fa62700c9ab87a22e65b9ca272f7f673ddd31aeb2de6ae272ad35/msgpack-1.2.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3e915d390d7068b257ca8b62f3fc59fad135c8631d1017ab03b0b924b07c5367", size = 398944, upload-time = "2026-08-27T10:02:15.006Z" }, + { url = "https://files.pythonhosted.org/packages/82/fe/d7be978456ff8552e69a8e270d882e7530e01513c096b293d83df03753ea/msgpack-1.2.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:c522420d78db2431887d45b518e304d86e27b9ad0b30f24e3806a6ad5d8bdbfc", size = 373979, upload-time = "2026-08-27T10:02:16.618Z" }, + { url = "https://files.pythonhosted.org/packages/be/af/91b0d8d3fb3063e259daee3ea8515cea6282f68f4b0e5f0b6fea25762c6e/msgpack-1.2.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4b554d8164ebb526892194f71dcd96ef1fefe0c250087498785d3ffc04a80be3", size = 417781, upload-time = "2026-08-27T10:02:18.293Z" }, + { url = "https://files.pythonhosted.org/packages/8e/3c/ce8e9efe1fd9e95c78b3705e4300ba7feba3dc6c00fb76259895db155518/msgpack-1.2.2-cp312-cp312-win32.whl", hash = "sha256:0e3315de5a4b2920ccef48d96b4448025e064a10d0f5a250f6584477d839c8d4", size = 65267, upload-time = "2026-08-27T10:02:19.869Z" }, + { url = "https://files.pythonhosted.org/packages/85/98/a33b8b4af14e3476bb0da1b8c36ef7a0f28dcf95db1c5e68ff88cb89d591/msgpack-1.2.2-cp312-cp312-win_amd64.whl", hash = "sha256:b68614fba0570349833b7dd999ff0aed4e5cc8d9eb6e3a7d4527be33c65e33d3", size = 72275, upload-time = "2026-08-27T10:02:21.141Z" }, + { url = "https://files.pythonhosted.org/packages/df/5e/2f323a33a6aba5bd4b2d8b430e4fab21d92cd91c093b49ee287bc166ee54/msgpack-1.2.2-cp312-cp312-win_arm64.whl", hash = "sha256:59d5b93efa45fd09f620d0c9ba81cde339a2c9937af3eea42ee9653094ce6640", size = 65488, upload-time = "2026-08-27T10:02:22.575Z" }, + { url = "https://files.pythonhosted.org/packages/1f/eb/42f31c5a48811787ff59a9869721f70a49654d65ab6c455f4463c39b044e/msgpack-1.2.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8b2a281b556f120a43e591ea39915741b7ad54d4727b9c4350a0a11692252533", size = 83911, upload-time = "2026-08-27T10:02:24.06Z" }, + { url = "https://files.pythonhosted.org/packages/33/54/10c6c16ddba8a5112e3680176b838e3694e4aad7284f9daa6d6d70d98817/msgpack-1.2.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1e8cdd1f3e7cc52c751092a9bf740e81e6919ab109cd376ae2d965dad0bbae34", size = 83734, upload-time = "2026-08-27T10:02:25.613Z" }, + { url = "https://files.pythonhosted.org/packages/d7/75/35823e4419df8792191b2a17ae3fe71b41d02c162b2c491c94d1a87f0caa/msgpack-1.2.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1814f92306ae7862908e9ece7cfd90e0dc87ded3e89b6ae7ffdd1175d6376fdc", size = 405635, upload-time = "2026-08-27T10:02:27.012Z" }, + { url = "https://files.pythonhosted.org/packages/6e/d3/6592e4064619b04f2dd0054c5fa13e37e3d55eb26044483d871fadb2f46b/msgpack-1.2.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d24b38a825bcca41bb956de50eb98451ef291304a8607fad99e619043d3e79b9", size = 417332, upload-time = "2026-08-27T10:02:28.776Z" }, + { url = "https://files.pythonhosted.org/packages/e3/a1/b21c6818a545e9a4a976ac954a5c250eecde9a02e0ec82f415473dab1324/msgpack-1.2.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:34e83e345194a2a51d8bd447dea9de2104f91e75b247f4735f14f04529f0746b", size = 374378, upload-time = "2026-08-27T10:02:30.678Z" }, + { url = "https://files.pythonhosted.org/packages/03/8b/7ada15c7b64151d6dbb562d1b091520efb2c37acf2403b1d4ae13797b27d/msgpack-1.2.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:682804bf31e43d46e51a9a33bd575b51e839d715ce6bd5612c055f7b28ad637b", size = 395809, upload-time = "2026-08-27T10:02:32.322Z" }, + { url = "https://files.pythonhosted.org/packages/bb/f7/96283e50f7020df4dfeacc55612b7a210c8cdf0dda48bc262f1f9b3e4c49/msgpack-1.2.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:9b659d77f8726fa5e7038967dda6b68d53cf34472c094cfa5b845454713b90d5", size = 373495, upload-time = "2026-08-27T10:02:33.832Z" }, + { url = "https://files.pythonhosted.org/packages/cc/fe/1548dede9d9ca482f2d424a2e110a9705d4e02627a16b8bc8d10ce0208a2/msgpack-1.2.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4d9a562aec0a92fe536da2e533d313b3d2a6b929157b1dec7ff623446dc0a8ab", size = 414360, upload-time = "2026-08-27T10:02:35.396Z" }, + { url = "https://files.pythonhosted.org/packages/77/9d/4419b8f86c219174b1fb8bbd7faaf84a548935f7b1916d028401b9433417/msgpack-1.2.2-cp313-cp313-win32.whl", hash = "sha256:a4161eee7799863aee237c35c90427861f7b994416dd81ae829f560b0a81bdcd", size = 65196, upload-time = "2026-08-27T10:02:37.007Z" }, + { url = "https://files.pythonhosted.org/packages/3c/f8/593f5caf0dacab41cde1564c5f0419e61af55ec9628006205e8fd5eb5e03/msgpack-1.2.2-cp313-cp313-win_amd64.whl", hash = "sha256:b07c03f0da7e5279170df7745ddc732d526c8a198208936ec1a95c11ed2b2d5f", size = 72203, upload-time = "2026-08-27T10:02:38.28Z" }, + { url = "https://files.pythonhosted.org/packages/bc/9e/c6ef92046b4a2bbb9d3aa0cb581cbf4a4051afccf6e5fb301a1bd3086f39/msgpack-1.2.2-cp313-cp313-win_arm64.whl", hash = "sha256:d13d07efbf655f9ae7a2352b630c52727b359005b21ba08a507585c9ac8c0896", size = 65435, upload-time = "2026-08-27T10:02:39.534Z" }, + { url = "https://files.pythonhosted.org/packages/5e/50/3e92c403346652cabd08cb8faceef847bae917ea3b3c81b64a5b6d09ed41/msgpack-1.2.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:e497ee34e8a3342bbde51b27c22d8db05a651df3361dd3daef5b3ab0d66f3e04", size = 84315, upload-time = "2026-08-27T10:02:41.181Z" }, + { url = "https://files.pythonhosted.org/packages/b6/dc/8efe6dd96a12ab043930cb4cffb40b6e7f061491d6ec7a3d2b75ef1fda42/msgpack-1.2.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0dd9173c5ebaf5ecc5ca86e7ae1db92934e1d57b856f3dd90698941431f4fd77", size = 84634, upload-time = "2026-08-27T10:02:42.621Z" }, + { url = "https://files.pythonhosted.org/packages/1b/89/996573095bf7b038c04dd65ddbc4f1a4d381b0f7a44ff9186f3c7b8325c2/msgpack-1.2.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8dc4487097571f7311188c3eca2a3e86cd1f1db4c37c7a017bcc3fd38486cbfe", size = 404194, upload-time = "2026-08-27T10:02:44.096Z" }, + { url = "https://files.pythonhosted.org/packages/b6/4e/46f5a5d949dbd054dab60cb15aac7ac6ae6774c134532893414689bf2f53/msgpack-1.2.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:73b0e05c32c3cfc3cd84994908e57430c0ebc6813abf905d3f18ff115d54df3f", size = 412343, upload-time = "2026-08-27T10:02:45.747Z" }, + { url = "https://files.pythonhosted.org/packages/da/e8/739a94197358a313307e6e9e7d8d22ef66add39222de911a44161aa96920/msgpack-1.2.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:aa1120c653b76d8eafa50423b5eba06b5c9737f8692c74fa3afe03e84b8978ea", size = 372620, upload-time = "2026-08-27T10:02:47.578Z" }, + { url = "https://files.pythonhosted.org/packages/03/d4/09b92e1fcdccea9466bfae45455367ac52362ae445d96a602e51b7a8df73/msgpack-1.2.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ccfd880988f8438d1c91c77d7edc58e70f4d2012e999167bc154c64c6f06ea6b", size = 394603, upload-time = "2026-08-27T10:02:49.172Z" }, + { url = "https://files.pythonhosted.org/packages/47/db/d11bd6f258a60703dcdc7a3772818ad0c2f602ee4c2acfb24088c6c3ebc3/msgpack-1.2.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:6195257a107bf25872ef84aab7295078271eea3ac6413f0506b631f6c9586ed5", size = 372666, upload-time = "2026-08-27T10:02:50.886Z" }, + { url = "https://files.pythonhosted.org/packages/71/cf/fbbbac0c6e5fbb9d51abc23e3b5fe8620f5c01e0588797cf664a623bb9e1/msgpack-1.2.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b8dd6c71d20c28d2d0eb0c51e7cccf3584afde3b1364f6629596186c9025bd54", size = 410889, upload-time = "2026-08-27T10:02:52.51Z" }, + { url = "https://files.pythonhosted.org/packages/94/60/8366558da954095e04e7fbc351f9387d87a682feaee9a235ceda966f794b/msgpack-1.2.2-cp314-cp314-win32.whl", hash = "sha256:d242f3c4ccf55b056e6cf901720dccde58f1df117898f2bbf3bcd6e38ec7c248", size = 66774, upload-time = "2026-08-27T10:02:53.984Z" }, + { url = "https://files.pythonhosted.org/packages/4b/3d/1ce873c8057c65e4fbb076ffe1c99c9ae39d90a00a2540d7b06c652a292f/msgpack-1.2.2-cp314-cp314-win_amd64.whl", hash = "sha256:1510f24612d4b983dff6935d9273e02c320cfd525727fbcb58836a75f589fdbc", size = 73424, upload-time = "2026-08-27T10:02:55.277Z" }, + { url = "https://files.pythonhosted.org/packages/d5/55/e36f2a33e38657f33850d74e0bf256838a0d45802c298cc501a32bffcc08/msgpack-1.2.2-cp314-cp314-win_arm64.whl", hash = "sha256:7826f16edc763e768404f55605ef85dfcf5857e729c1ed29e0d7c180be4fe6d8", size = 67657, upload-time = "2026-08-27T10:02:56.493Z" }, + { url = "https://files.pythonhosted.org/packages/64/58/7e764b957bae80ae281a9cb28761068c8bae8d5c6ac0873e43cc69d176c7/msgpack-1.2.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:f466049b8e1ec0854287bbe9a074316826fe0e08dcf707245f98b1ae49e92650", size = 86594, upload-time = "2026-08-27T10:02:57.796Z" }, + { url = "https://files.pythonhosted.org/packages/ae/f0/250f5985b6ee533e60d357571a808aaae03c54118294dc3db7158e27feb1/msgpack-1.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1f6b6f8deb07d49090e1808c6ef9cb7d23ca17bef3aa6ed3e5e03df16606e60c", size = 87374, upload-time = "2026-08-27T10:02:59.256Z" }, + { url = "https://files.pythonhosted.org/packages/bd/2c/126ec8f187877c5f688631c543d1d3a3d75b2e66b83fb9de3ed7c13a39b6/msgpack-1.2.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b542ffc0a5c531eedc40419f291f1bd659aa8d4223408a5b51c88a2796083fd3", size = 428157, upload-time = "2026-08-27T10:03:00.9Z" }, + { url = "https://files.pythonhosted.org/packages/95/21/d2d81d50aaedb14147d01f22094185794db3ad8a8791b60afacba0627c89/msgpack-1.2.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7d095df2627e5dd59ac7b0c5ad627a671c76e6020171e03cbe4621a61f0562c3", size = 426669, upload-time = "2026-08-27T10:03:02.457Z" }, + { url = "https://files.pythonhosted.org/packages/c6/fc/f7d484ee5b572719608e7ffad569bea22ff11309a96ca2fae85eec94226b/msgpack-1.2.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ffdd2f4950daf7815490f23087963e3420175b9609520b7ff5df64d351159c22", size = 380625, upload-time = "2026-08-27T10:03:04.244Z" }, + { url = "https://files.pythonhosted.org/packages/0a/c4/b924cbd5516676f4e612329f18602a833bd055ffbe27f808eeba0f01bfea/msgpack-1.2.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:652d1bf13d01bac8fd569def0fe76745e55bcda01e30aa6332d5947ea3788839", size = 411328, upload-time = "2026-08-27T10:03:05.869Z" }, + { url = "https://files.pythonhosted.org/packages/27/9d/0c1d9683a951a80f270c3b7dac1022c18b9307617344dd44d904135d5e12/msgpack-1.2.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:9bf452ff4d4981f25a18e9476e002bcc9263e7928024aa4d7148e25f7be3f929", size = 377892, upload-time = "2026-08-27T10:03:07.37Z" }, + { url = "https://files.pythonhosted.org/packages/06/bb/bf22338cdd22e0b40c8f28468cea5f3d9c320244c095d8303364bc012c41/msgpack-1.2.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:55faa6f8395e23b848c535ad5dcb96b3462f37f5e7f4ac500d500434f7345da7", size = 419426, upload-time = "2026-08-27T10:03:09Z" }, + { url = "https://files.pythonhosted.org/packages/7d/42/6d02c19a01abd8d7ce817c321d2ee6af1a8e24d584dca619d1b6576a83bf/msgpack-1.2.2-cp314-cp314t-win32.whl", hash = "sha256:419a45c67a5c04213172a14b1864657e014665b77d7081b107a51707923dd39e", size = 71810, upload-time = "2026-08-27T10:03:10.498Z" }, + { url = "https://files.pythonhosted.org/packages/af/df/fda3a204415dab0a8c0db5461ef7205416ea52bd8581c5cafd361be07f3b/msgpack-1.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:935b1cfad9b908b0fa845010f4271df4c2f04e1cd26e3f18acd61a45f93c9e36", size = 78919, upload-time = "2026-08-27T10:03:12.016Z" }, + { url = "https://files.pythonhosted.org/packages/63/d4/4b4b0ef25a86deca91feaf7252ca885ba4f2ada40461379120122a04fe96/msgpack-1.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:11e8c421e117d1c36728b423d0402555cccbf0c6f53e288f0e75b6b12100d70f", size = 71925, upload-time = "2026-08-27T10:03:13.332Z" }, + { url = "https://files.pythonhosted.org/packages/3b/92/4b44bc8f3243ef8cf9cb5368c17a299d45b9df858f6dfdd98a0482dbbb37/msgpack-1.2.2-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:e1b99ad34613d5f8477fa5cf99bc4eaeaf27965588007c102370cd9a78fe9de5", size = 84293, upload-time = "2026-08-27T10:03:14.718Z" }, + { url = "https://files.pythonhosted.org/packages/80/05/c992bb65744665a41b5bf531fc0e1619bae0901f57738228ded90023c151/msgpack-1.2.2-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:0fbc1bed8a535389b41882cfae66376e248cd1680eaa94fd83193c73e1d24986", size = 84490, upload-time = "2026-08-27T10:03:16.12Z" }, + { url = "https://files.pythonhosted.org/packages/d7/bf/7f53b9e6709a4df7f9b9b81dc65f9dfaa32caf65bee94986ec2cb8fa07f1/msgpack-1.2.2-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:06d95f61de7afe4f4ff908a6feebfcb070d0582ac87c9cf3cedf8551cf634516", size = 405332, upload-time = "2026-08-27T10:03:17.692Z" }, + { url = "https://files.pythonhosted.org/packages/d2/5a/305c4dca14b50d0b51fb88ef04ec125b8f0be3e2ce730dcc62dbaa651cc5/msgpack-1.2.2-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b5c696ae7cd7166b3657261adb855b461ff31f07823fdbae9de8bf80adfccc21", size = 416798, upload-time = "2026-08-27T10:03:19.389Z" }, + { url = "https://files.pythonhosted.org/packages/7a/df/a645102b4cdfd9a94201cac4e900e9c1429fc16d86aa311c06eef82528c9/msgpack-1.2.2-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0708afbf6a9587f0bfe479a9825c141d14d91e2f6a5c8103cf28bc96f4edb5d9", size = 377312, upload-time = "2026-08-27T10:03:20.928Z" }, + { url = "https://files.pythonhosted.org/packages/f4/26/c56d8d086d3fb1077bb48092b158b5ea2eee08b279e10c191275f13bc980/msgpack-1.2.2-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:226a62ffe99fe54c5c61d910ec64c3449b7766c3280bd286bf6c94838dde239a", size = 395182, upload-time = "2026-08-27T10:03:22.571Z" }, + { url = "https://files.pythonhosted.org/packages/4d/b5/3d46ba367a565e536d8d2a61eebcee71b1dc803da3ce74a22313b573d6fa/msgpack-1.2.2-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:9fd7f32e2f0fb334e7ecc5adb5cf0458785bd3a9d9d86f950e1715f101cebce5", size = 377945, upload-time = "2026-08-27T10:03:24.151Z" }, + { url = "https://files.pythonhosted.org/packages/a5/2c/d5d2df273ed5306357da25b69400fd8d7a53c4d87d8976604b677484d61c/msgpack-1.2.2-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:9db1ba1c1e6a84245a9dd866265b56b8a1e9461549cc72ed296d8cbfbd32961b", size = 413341, upload-time = "2026-08-27T10:03:25.85Z" }, + { url = "https://files.pythonhosted.org/packages/1b/fb/32613bced3cad47b40b1b73dd04d687121349d83f748efc2575929121903/msgpack-1.2.2-cp315-cp315-win32.whl", hash = "sha256:e2eb7ea0ac3911a7aac9d8aaa36d40f216d99455b3274cd3fac38181bcd910cf", size = 66730, upload-time = "2026-08-27T10:03:27.294Z" }, + { url = "https://files.pythonhosted.org/packages/74/56/d86171f7251015e9312e5a7f9fdd4cf89752fc2114b88fed453d2a040c66/msgpack-1.2.2-cp315-cp315-win_amd64.whl", hash = "sha256:9352e6cdb510a7b1a5d3ccaccec730e82e50cf3484a3af7bdaab19e23b9589ff", size = 73477, upload-time = "2026-08-27T10:03:28.615Z" }, + { url = "https://files.pythonhosted.org/packages/13/1a/56b90f6defef61700b86baca3637c15f62ac0f9b21ab0f16613ab9d1f101/msgpack-1.2.2-cp315-cp315-win_arm64.whl", hash = "sha256:29cc2d5291711a52956a79a51f41c732329df39ad727c886bd8f0b5b9237a808", size = 67660, upload-time = "2026-08-27T10:03:29.895Z" }, + { url = "https://files.pythonhosted.org/packages/cd/20/12751ca0d8ec874701b54c392c2b19f51af8dd1de40a92a10e356f0aaf58/msgpack-1.2.2-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:d886baa46b2532135e7320067e6a44edb09ba5883a6096b0f9c044533984b8a8", size = 86462, upload-time = "2026-08-27T10:03:31.348Z" }, + { url = "https://files.pythonhosted.org/packages/91/4c/cf6d12a3d709fe5f9771dd917c35e6ebcd55597a5b792287382fde056c95/msgpack-1.2.2-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:53679573c75cce5f82359e0bd4e6a97809a6b9a9b7a48fd1ba592f4a82cddc84", size = 87412, upload-time = "2026-08-27T10:03:32.74Z" }, + { url = "https://files.pythonhosted.org/packages/ca/0d/0aac5752d1708dcb458f8754db34a4999514db3df2d2b798b9381293f638/msgpack-1.2.2-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d3c247d457ae9079974c7ce3c665396754a6d2baff7eaa51332212a8a5a3f13b", size = 422057, upload-time = "2026-08-27T10:03:34.124Z" }, + { url = "https://files.pythonhosted.org/packages/81/30/70f281a3685b04aaf235a5237da11b978a02a865a5a479186205177ad676/msgpack-1.2.2-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:352ed831042549cca8be23780e1fe7c9177e65ff02bf183509c4b4d33f671782", size = 422696, upload-time = "2026-08-27T10:03:35.862Z" }, + { url = "https://files.pythonhosted.org/packages/8a/6d/f76e8425efb0aa38988cd778ae290bfa120491d80d26872d88bb52fedb3f/msgpack-1.2.2-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f80361592c13d7226b4379c8941529b63fe1a9d0e05d2de8f3306b70e522b53f", size = 376495, upload-time = "2026-08-27T10:03:37.339Z" }, + { url = "https://files.pythonhosted.org/packages/95/77/0809aa9b52b2868f7d01862dc14073708f0440421a65197b48453480034c/msgpack-1.2.2-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:68df2947921d449f6dcfeafd86cb2cdde13327a8b447534bbe4ee5aaf32a5695", size = 404683, upload-time = "2026-08-27T10:03:38.87Z" }, + { url = "https://files.pythonhosted.org/packages/02/d2/4e5ac915ba120172d210ef00165c5e6276c8a65db3a4a5cf36e946b83e23/msgpack-1.2.2-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:51dd39d23cfdea0400ed3ff2d29d1e83bd951d3aea79dc89be5b701a09edfe23", size = 375087, upload-time = "2026-08-27T10:03:40.486Z" }, + { url = "https://files.pythonhosted.org/packages/cb/e3/8051d53e5495c87c6cf27eb42fb680361017037f87f322bdaf525f71e4a2/msgpack-1.2.2-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:b13b59e66f107cca1ba708dd5307179870ca1b15b19fcee7ccf722e5308d9212", size = 414421, upload-time = "2026-08-27T10:03:42.308Z" }, + { url = "https://files.pythonhosted.org/packages/ba/4e/13783aa7c17414d7186c72c49bc718366f75e49f0ea58d4f81cb63ac3187/msgpack-1.2.2-cp315-cp315t-win32.whl", hash = "sha256:8c6321a414f8b4a8dc43976b2fa8349156434ca9adedd9a187b796f7e1d3d3fc", size = 71790, upload-time = "2026-08-27T10:03:43.715Z" }, + { url = "https://files.pythonhosted.org/packages/5e/9d/1d02994c7ae2603c98100984428ff0f67443572133bc18eca6058f732c1b/msgpack-1.2.2-cp315-cp315t-win_amd64.whl", hash = "sha256:6f53285f20d592ed309ee19e509cc4c77a3bda1db02ad67e8a0949bb227a5a6d", size = 78766, upload-time = "2026-08-27T10:03:45.036Z" }, + { url = "https://files.pythonhosted.org/packages/60/54/89ed16e6f966a050dc78b0e94a545025211b07ce9f4bdfe07dff70c03fc2/msgpack-1.2.2-cp315-cp315t-win_arm64.whl", hash = "sha256:a378e12ccc06d76efde115caf4073b7e5ff3cc18291d1341f9e65fb882e3f754", size = 71819, upload-time = "2026-08-27T10:03:46.375Z" }, +] + +[[package]] +name = "packageurl-python" +version = "0.17.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f5/d6/3b5a4e3cfaef7a53869a26ceb034d1ff5e5c27c814ce77260a96d50ab7bb/packageurl_python-0.17.6.tar.gz", hash = "sha256:1252ce3a102372ca6f86eb968e16f9014c4ba511c5c37d95a7f023e2ca6e5c25", size = 50618, upload-time = "2025-11-24T15:20:17.998Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/2f/c7277b7615a93f51b5fbc1eacfc1b75e8103370e786fd8ce2abf6e5c04ab/packageurl_python-0.17.6-py3-none-any.whl", hash = "sha256:31a85c2717bc41dd818f3c62908685ff9eebcb68588213745b14a6ee9e7df7c9", size = 36776, upload-time = "2025-11-24T15:20:16.962Z" }, +] + +[[package]] +name = "packaging" +version = "26.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" }, +] + +[[package]] +name = "pip" +version = "26.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ae/15/4500e320e6b101ec3b719ae85b697d9940b6cda672bc555bd6016fc60c6f/pip-26.2.1.tar.gz", hash = "sha256:f6ad667e89a1fe78046c8f13232b247200f5258d7828f3f7883d660878e0813f", size = 1848877, upload-time = "2026-08-04T22:51:14.148Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f3/6e/1736e5b4ae2b778ef2f81c47d797de9f891d4d8acb047a24ca37a60294dd/pip-26.2.1-py3-none-any.whl", hash = "sha256:71138adf1f4ca900cdb7d289c21b7494329f2332b6d85f0e1c42108c0384ed3e", size = 1816632, upload-time = "2026-08-04T22:51:12.472Z" }, +] + +[[package]] +name = "pip-api" +version = "0.0.35" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pip" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fc/08/47dfc28aa16ef0dbc38dd7c6e4fe24d124c3ed3a722a4a3e5021584a588c/pip_api-0.0.35.tar.gz", hash = "sha256:14dea05d7b3b68f4c7582213e3ae8932bbba8e1f754bf06b95263d5fa6ab4363", size = 123884, upload-time = "2026-09-08T19:35:12.876Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1d/2e/d424c5b5877be862dd9a2c8b7e9ddb13382bb25e132e6dd50cc09c0a7dde/pip_api-0.0.35-py3-none-any.whl", hash = "sha256:66990d0da25378555cbb538db79384bab92d4617c6350dfd7a2126ba2a3a9894", size = 123943, upload-time = "2026-09-08T19:35:11.537Z" }, +] + +[[package]] +name = "pip-audit" +version = "2.10.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cachecontrol", extra = ["filecache"] }, + { name = "cyclonedx-python-lib" }, + { name = "packaging" }, + { name = "pip-api" }, + { name = "pip-requirements-parser" }, + { name = "platformdirs" }, + { name = "requests" }, + { name = "rich" }, + { name = "tomli" }, + { name = "tomli-w" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/a4/f21d5f0a0edabcbce31560b73c7c5a6f72ae87af4236fd1069c8f59a353d/pip_audit-2.10.1.tar.gz", hash = "sha256:1eb4565d19ebe5d48996f4b770b4d2b32887e12cb12cfa637f1a064011b55ffc", size = 54275, upload-time = "2026-06-10T22:17:01.744Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a3/a7/b0c504148114047bd1bc9d97447453c6850ca176bb2f3c0038835994e8b7/pip_audit-2.10.1-py3-none-any.whl", hash = "sha256:99ef3f600a317c1945f1e89e227ef26e1c2d618429b8bd3fa6f4f7c440c4611a", size = 62023, upload-time = "2026-06-10T22:17:00.309Z" }, +] + +[[package]] +name = "pip-requirements-parser" +version = "32.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging" }, + { name = "pyparsing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5e/2a/63b574101850e7f7b306ddbdb02cb294380d37948140eecd468fae392b54/pip-requirements-parser-32.0.1.tar.gz", hash = "sha256:b4fa3a7a0be38243123cf9d1f3518da10c51bdb165a2b2985566247f9155a7d3", size = 209359, upload-time = "2022-12-21T15:25:22.732Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/d0/d04f1d1e064ac901439699ee097f58688caadea42498ec9c4b4ad2ef84ab/pip_requirements_parser-32.0.1-py3-none-any.whl", hash = "sha256:4659bc2a667783e7a15d190f6fccf8b2486685b6dba4c19c3876314769c57526", size = 35648, upload-time = "2022-12-21T15:25:21.046Z" }, +] + +[[package]] +name = "platformdirs" +version = "4.11.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/53/18/f3bb8ef0d3b930692343da8aa4d3cbcd6749477c053959395ac81965a6e9/platformdirs-4.11.8.tar.gz", hash = "sha256:f23abafea7dd4276d1f29104b83598d7dcc567cafd07c9c951e66665645437fc", size = 37182, upload-time = "2026-09-08T22:20:42.866Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/e1/5b7b8bbb55084d1425bcb9bc823ff519e1b2be05f6ebb0089e2eacc38413/platformdirs-4.11.8-py3-none-any.whl", hash = "sha256:52f2f181bbfde907966932cc8312d967d02976422d66d537ea16092b8e291081", size = 24027, upload-time = "2026-09-08T22:20:41.537Z" }, +] + +[[package]] +name = "pluggy" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, +] + +[[package]] +name = "py-serializable" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "defusedxml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/73/21/d250cfca8ff30c2e5a7447bc13861541126ce9bd4426cd5d0c9f08b5547d/py_serializable-2.1.0.tar.gz", hash = "sha256:9d5db56154a867a9b897c0163b33a793c804c80cee984116d02d49e4578fc103", size = 52368, upload-time = "2025-07-21T09:56:48.07Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9b/bf/7595e817906a29453ba4d99394e781b6fabe55d21f3c15d240f85dd06bb1/py_serializable-2.1.0-py3-none-any.whl", hash = "sha256:b56d5d686b5a03ba4f4db5e769dc32336e142fc3bd4d68a8c25579ebb0a67304", size = 23045, upload-time = "2025-07-21T09:56:46.848Z" }, +] + +[[package]] +name = "pydantic" +version = "2.13.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-types" }, + { name = "pydantic-core" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/53/ef/fc4f868f4e2cee79f863883abffceff107875f569b848507319842d2a681/pydantic-2.13.5.tar.gz", hash = "sha256:51a9c5f7b2f8e636f04c6cada605d9b6a3bf1348fdf945a3d8869b19bba0ee08", size = 845750, upload-time = "2026-08-28T14:04:00.916Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/47/c95ffc2009878c7aac0c5e08528022dcb885933252a88b5f170058014464/pydantic-2.13.5-py3-none-any.whl", hash = "sha256:346a034f080da3755d8e9cb5e00e8b07de1d39e4f6e2c87d8ab7cafa0b269a73", size = 472589, upload-time = "2026-08-28T14:03:59.136Z" }, +] + +[[package]] +name = "pydantic-core" +version = "2.46.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/af/f9/8a06bea35ef8daf588f707784c973a7046e0034c8d8cfb08828eeffb8b75/pydantic_core-2.46.5.tar.gz", hash = "sha256:10416c15b8839ecc4ef4d0885da76da6fd0f67333a0eb8aff6d93c4b8f2910fc", size = 472262, upload-time = "2026-08-28T10:01:31.677Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/3f/76358795aa7a8c6d4f36e2cb828ad1c90ee118e1393a9281664f5aade9d4/pydantic_core-2.46.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:b9fe6fb92520e3fd61f2e49000b6911b188824f089b75973ea06d6267f0b476d", size = 2076516, upload-time = "2026-08-28T09:58:21.576Z" }, + { url = "https://files.pythonhosted.org/packages/db/50/26b091836076ce4cb2fac264186936acc069e0595772cfd02a563bc4761a/pydantic_core-2.46.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a39ac25a9a2fa4072efdb429833c4a4c8009a51ff9eea3eeae131713cd27991e", size = 1922874, upload-time = "2026-08-28T09:58:23.766Z" }, + { url = "https://files.pythonhosted.org/packages/09/f0/2a8ce3849e299d44e2d2c196b6082643a3235565a735cb51db7a6261f614/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4fdc8b93a41521988916eeaa271173fcca7fa0803d62f87675aac8dcec1c8e29", size = 1951772, upload-time = "2026-08-28T09:58:25.435Z" }, + { url = "https://files.pythonhosted.org/packages/87/46/ac0dc8bdd9e6048183a14eb127764e7ad9240021c17513074a4711b0e31e/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b98134087d9de723658d17a42c7d0da8d6e2ef08015dee7dc93889047315f5e4", size = 2031832, upload-time = "2026-08-28T09:58:27.102Z" }, + { url = "https://files.pythonhosted.org/packages/c4/c2/339de5bef7be36301a2231eaa52e62163742c2281f11b5f4892bc79785cd/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e652ab17569c94bff5475520f907b7148b8c24036a8ebbe5cf7cf7493d28579a", size = 2208645, upload-time = "2026-08-28T09:58:28.948Z" }, + { url = "https://files.pythonhosted.org/packages/7b/a0/9ff22b797724262da14427abaed4dd1d864a139693fc5e7809114376a716/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d925f3d9afd05a8c0fb3a1031463a8d59ebe5e2afad297e29c78be19e13b4e62", size = 2265935, upload-time = "2026-08-28T09:58:30.625Z" }, + { url = "https://files.pythonhosted.org/packages/c0/a4/eb9409ec0736e50aa70a412f16c204ed149516846912f7e6724d4c73ee53/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0fc5be0abd4a407e200d844b404e33639a554e7bd0d448e7b9ae181be4789ac2", size = 2066284, upload-time = "2026-08-28T09:58:32.289Z" }, + { url = "https://files.pythonhosted.org/packages/c0/02/7f6156ffc926857f1c37c07d9a388682865a81830ab6a1b637082c25e399/pydantic_core-2.46.5-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:816ff0a6550ffc06c098ccd2e0698600f9aa7da192a79eaa6f9af504a35db869", size = 2105889, upload-time = "2026-08-28T09:58:33.986Z" }, + { url = "https://files.pythonhosted.org/packages/92/b1/e781d357ebe09fc929f995700f1b3503e8897f1cece183ecb1300d4d67e9/pydantic_core-2.46.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c7ea57fc63aa7da93a1bd2d644e6577befae10c52c4e36377635eea1056a74f5", size = 2158006, upload-time = "2026-08-28T09:58:35.647Z" }, + { url = "https://files.pythonhosted.org/packages/70/0a/644597d84ab400e50609c192120b85c9681c22d3a20461b9060a79be0a7a/pydantic_core-2.46.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:efd62a42486f1bda5d24cb4f63d15a3c7768375fe83d36f9417b4ad7a2fb20b3", size = 2158408, upload-time = "2026-08-28T09:58:37.38Z" }, + { url = "https://files.pythonhosted.org/packages/1e/ee/ca3b7b3a4b3769ffe9ce9432a7c9be755de9593a46d3b0d54d0409323e44/pydantic_core-2.46.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:2bc9419666990c06d7397831f2126a1ecc3594aaa3ff7de5bf2d066802f4e07b", size = 2309609, upload-time = "2026-08-28T09:58:39.22Z" }, + { url = "https://files.pythonhosted.org/packages/ce/52/39fa1f451486019524ca685020390e7ca351832fd874530ba30c8628e6dc/pydantic_core-2.46.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:18a09e1e1011b462f2e32774f25859ef1223d5c2b0546a633cf56654710721e0", size = 2342618, upload-time = "2026-08-28T09:58:40.89Z" }, + { url = "https://files.pythonhosted.org/packages/81/5e/468fc630568c61dcef3cd47ad32ffbeed9af643f49208d1ea86ab4f890c4/pydantic_core-2.46.5-cp312-cp312-win32.whl", hash = "sha256:5cb482e9e84c851f4e623fe4acc1ced89168cf1fe18f7089db4548c8f5bbb65b", size = 1939475, upload-time = "2026-08-28T09:58:42.591Z" }, + { url = "https://files.pythonhosted.org/packages/cf/c9/4c19f41b84cf6b622a72fbeed7665b25d47a187d68d47d0d430c07f23268/pydantic_core-2.46.5-cp312-cp312-win_amd64.whl", hash = "sha256:5e81740c09e310f5aa5cbd3e434a01c154d4bef93241c7877b39f211d2b78ba8", size = 2043140, upload-time = "2026-08-28T09:58:44.272Z" }, + { url = "https://files.pythonhosted.org/packages/af/dd/0c1a050299147c746e5256db16d645ab5efd4f78c59937d581a0524e74a2/pydantic_core-2.46.5-cp312-cp312-win_arm64.whl", hash = "sha256:f7b0ec93a2893de856652154d73b7ba622f26fa97726487dcac373de5f4c6084", size = 1997729, upload-time = "2026-08-28T09:58:46.13Z" }, + { url = "https://files.pythonhosted.org/packages/f5/37/5abe39a8372a61d3dc3c1338fc504281c01b32fdb3169cd7187153b56d3e/pydantic_core-2.46.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:b7ca9034437b6022f941f4857459562ee00a560b97e7cce8a0ec5a74fc6766e0", size = 2075885, upload-time = "2026-08-28T09:58:47.856Z" }, + { url = "https://files.pythonhosted.org/packages/21/43/6323b1f8b217780454c61304bcd2b38ae4762f50754414124603ccc90bb2/pydantic_core-2.46.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f332f0e72a5a0400141f830744e141bf9f97917878dbe968669e8a7fefea78ff", size = 1922768, upload-time = "2026-08-28T09:58:49.58Z" }, + { url = "https://files.pythonhosted.org/packages/0f/a3/c05ca796e1197618a774b01e596aeedfefc2f7d8c01ae3054e910b120e8a/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:193375f3548919d3f0b60936ca113ada3e38f264f91b9b8e0508efaad57be931", size = 1951241, upload-time = "2026-08-28T09:58:51.511Z" }, + { url = "https://files.pythonhosted.org/packages/68/32/33bc39ac705c52cffc908e8389f9754fdb208aea5c69cceddf4eb3ce99af/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:79bdfa52f843137045b2d081cc05c120ba6665d29b7559c2c47690906f39279f", size = 2031975, upload-time = "2026-08-28T09:58:53.166Z" }, + { url = "https://files.pythonhosted.org/packages/b0/70/2333e885c0f6a67bc105c5916965dac9b57f2718ee20d81d1a06a4ebdc13/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:24922243639cbdac66c75fcb6fd6495a9cb52b213d62f9a0d16f0310b1ff8038", size = 2208542, upload-time = "2026-08-28T09:58:55.017Z" }, + { url = "https://files.pythonhosted.org/packages/f7/ea/296debfb4264207bbda5936133892e027c0a58875ad53ebd512fba8ec3a2/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c76fe65e607be28c7fd4d56fc3c42b1583aa058ce3408b7ad0fd540171d31f9f", size = 2264692, upload-time = "2026-08-28T09:58:56.767Z" }, + { url = "https://files.pythonhosted.org/packages/d3/f2/9e4de77a6271e07a76d2d58b11c091a979c191ed2939bf80067568b369d2/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6f7b393a8b3da82f5c1fc0751e6d01ac6c55b93c18226a60bdfba4a724efafd1", size = 2066633, upload-time = "2026-08-28T09:58:58.531Z" }, + { url = "https://files.pythonhosted.org/packages/8d/db/f9e9d0c97445987b2084823d5c240de88087338f04fc2cfaa2df186b8049/pydantic_core-2.46.5-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:7ac031912d54f3d83ef3b3eb98dfabc1608802e2202263d25957eeed40b94761", size = 2105235, upload-time = "2026-08-28T09:59:00.421Z" }, + { url = "https://files.pythonhosted.org/packages/07/c5/79169b047b3b2c3e99e04bc76372af9637e0bf6db638274fa927df96369e/pydantic_core-2.46.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:837b396ca3d7b74091ca623f6cbd8351bd42d670a79c2683e79fb089f06a2de5", size = 2157367, upload-time = "2026-08-28T09:59:02.442Z" }, + { url = "https://files.pythonhosted.org/packages/26/b5/ba6057afb7c291bd449f51b867f95aef2072941c4ce4e5c31d6ffd132d3b/pydantic_core-2.46.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:5ee239d575f80b08eca11f6e20f90c4c695de7825c67eefe6091fbf20dda648e", size = 2158420, upload-time = "2026-08-28T09:59:04.2Z" }, + { url = "https://files.pythonhosted.org/packages/6e/28/2057abecaafdc22912afa819603a51f0a62d40643b7c4871c51721fea9be/pydantic_core-2.46.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:e80675d75ae2cd14372cb65cad5400d9347a3d3f6c13000183f22dfd027283ed", size = 2309588, upload-time = "2026-08-28T09:59:06.048Z" }, + { url = "https://files.pythonhosted.org/packages/71/9d/881156dc404e27479c4246128d73538464cab4a239bec61995e227644c30/pydantic_core-2.46.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:9c4b71f10dd532fb7a5cbc8f58707779e64f03a258c2bf8bfbaecfcd9970b519", size = 2341866, upload-time = "2026-08-28T09:59:08.539Z" }, + { url = "https://files.pythonhosted.org/packages/5a/38/d66f443a259f84d13babdceae568e572b0ed26da17ca5d0a649ebb110a67/pydantic_core-2.46.5-cp313-cp313-win32.whl", hash = "sha256:97bf8de4d541598c94a59344eeb988a94c08ff76b5723c41f6567ec18c7892ea", size = 1938580, upload-time = "2026-08-28T09:59:10.402Z" }, + { url = "https://files.pythonhosted.org/packages/2c/1e/1d5371213f4cc9a7ed70c0bfcc7911de22311ee99a662a56077d7292d2ac/pydantic_core-2.46.5-cp313-cp313-win_amd64.whl", hash = "sha256:15f4a94963c95accac15b7b657bb177d3ad82bb90b0d0526d9a9b85079925db5", size = 2041980, upload-time = "2026-08-28T09:59:12.396Z" }, + { url = "https://files.pythonhosted.org/packages/5a/48/4222d90b1c67568bace4dec6dca6271449c66de3595d72b6d098f5fde597/pydantic_core-2.46.5-cp313-cp313-win_arm64.whl", hash = "sha256:d22a945598fb91236b4dd793a6e42e4f3dd7740bb5aace5ebd7d4c08d13bb575", size = 1997213, upload-time = "2026-08-28T09:59:14.245Z" }, + { url = "https://files.pythonhosted.org/packages/8e/8a/14596f2a8367da50cf7cbac48169ee5d9c8e11d486a3b527082384630c72/pydantic_core-2.46.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:c1c43ad4339643d70ebb8124e1305a7dab423001eff58bb41a0f731adbc98355", size = 2074081, upload-time = "2026-08-28T09:59:16.141Z" }, + { url = "https://files.pythonhosted.org/packages/ae/d5/d8a4eb6d6c7f66b91dd37c576d76e9e60fba900caf5372c17bcf949febc2/pydantic_core-2.46.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1a353f84de772f423b5ffb11d7ae352fbbef0f446f3c0b0af0f8236d7233606e", size = 1920497, upload-time = "2026-08-28T09:59:18.065Z" }, + { url = "https://files.pythonhosted.org/packages/8e/26/092079428f86e927e030b2c0ced87df69dbb1c875cdeaa67bf42ea2be746/pydantic_core-2.46.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5086029a57366b8cf81b130a43908738095c270c21a8d7f0e8bdfdb89718e2f3", size = 1952130, upload-time = "2026-08-28T09:59:20.476Z" }, + { url = "https://files.pythonhosted.org/packages/08/c3/8ec0e290a9ebaebd64047bf5fda94be835c6b1551b02437e4b76778fbcd7/pydantic_core-2.46.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:46c25dda9d092a06c08db76ffe0a197107904d0dfac653f7d5306bbcd6d6119c", size = 2026371, upload-time = "2026-08-28T09:59:22.227Z" }, + { url = "https://files.pythonhosted.org/packages/01/72/4fd20ad520fb8da0157f95b27a7eb05a72790ef08138e7701ac972c342ea/pydantic_core-2.46.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:37ea7b83c935e5b0d68c9449b82651accf78a10828b2c02b2f2d9e9496446c21", size = 2202822, upload-time = "2026-08-28T09:59:24.277Z" }, + { url = "https://files.pythonhosted.org/packages/31/b0/d16e0771206b29314f0d52198b720be21e8a99ab2bf11e3bc0d7c9cebdff/pydantic_core-2.46.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e64e88d5585bea9ce95861079de72006c7fa6d3df4e3a3b65ba31eb979c15c9f", size = 2262756, upload-time = "2026-08-28T09:59:26.608Z" }, + { url = "https://files.pythonhosted.org/packages/2c/9b/59634b7ac631c63b2a37760eb6943af3e29573d6b59a4abc5e7f019d4cee/pydantic_core-2.46.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:54d510bac3ee52247af28ed4bb18a1e799f040ac60fd2bf5ccd4c92f1fbe786f", size = 2068352, upload-time = "2026-08-28T09:59:29.044Z" }, + { url = "https://files.pythonhosted.org/packages/08/7c/570abb1ad2155348dc754ea91be22e5aaa18eb6d69a6068f7c6f2679a6ed/pydantic_core-2.46.5-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:a2a5e1d0ff29adddc9f6d6821a66302e4493f8ca898b715b6b1182c2c201ea0a", size = 2104777, upload-time = "2026-08-28T09:59:30.95Z" }, + { url = "https://files.pythonhosted.org/packages/8e/25/5bf74adc65a1ac5b7be3f6cb0bcb5433615c1598a801c19d830d84c98ded/pydantic_core-2.46.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:03b9666e41e35d8909852ba191a0607520f81b74eaf12ccf8737005dbb313821", size = 2156312, upload-time = "2026-08-28T09:59:32.604Z" }, + { url = "https://files.pythonhosted.org/packages/90/6a/2ef38830675e050121040618135564ed56b860b45433b02d9b4ebece46f3/pydantic_core-2.46.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:a91c17edf6eea2402cb5457b4c89e99bc5ed1004aa34c4adf1d4258c1a5c22c2", size = 2150067, upload-time = "2026-08-28T09:59:34.453Z" }, + { url = "https://files.pythonhosted.org/packages/90/ef/a7dbb03a14a64c2a4621f989c615ed9a892535a6cad938fc27079f919d80/pydantic_core-2.46.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:b49924c73a235e969511bf2aabdff3beebf9820931f646c80274d5d780010c47", size = 2304516, upload-time = "2026-08-28T09:59:36.194Z" }, + { url = "https://files.pythonhosted.org/packages/68/f8/6bb4c4b80e8a6fde1904c64a51c62a1d04fcdfa3ea521a66b2ddefa1d885/pydantic_core-2.46.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:2cbd9a5eff05e51c447c34dfa4632145b26b09120cf04bd0c871e44c1a5e1c9a", size = 2335223, upload-time = "2026-08-28T09:59:37.931Z" }, + { url = "https://files.pythonhosted.org/packages/2a/80/f46b8c681195190b2c1f1c7c0a81abce60663e987613e09ef64d433dd96b/pydantic_core-2.46.5-cp314-cp314-win32.whl", hash = "sha256:2d5d76654becf5efd62c9e51c3756c67b49498b0c9a40884934c40807adbd074", size = 1934827, upload-time = "2026-08-28T09:59:39.836Z" }, + { url = "https://files.pythonhosted.org/packages/f7/3c/60674207246bc0a4009d2391b7c7251c7159f279c8d2ab8aae8ef46f3dee/pydantic_core-2.46.5-cp314-cp314-win_amd64.whl", hash = "sha256:fa10ef4112775900e7a0661068635eb67b2ab824fbde764de6e0e21982a93db0", size = 2042648, upload-time = "2026-08-28T09:59:41.792Z" }, + { url = "https://files.pythonhosted.org/packages/69/0c/117c562c7c1babdf44576b72a5e496906506c93690387ecfbca7c729ae2e/pydantic_core-2.46.5-cp314-cp314-win_arm64.whl", hash = "sha256:045ab3b6d308439e32b81cc173bba5b9018bc6ed896afd0c65b3b009b1699af5", size = 1989652, upload-time = "2026-08-28T09:59:43.702Z" }, + { url = "https://files.pythonhosted.org/packages/e8/66/9336ae58f9eb68c41d121894e52c4c89eccb07eb8f602a04ee9c3f37736a/pydantic_core-2.46.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8816f3d218beb4b787de5c9759c259b8fa61f9dec42dc7811f320a33771778b7", size = 2065829, upload-time = "2026-08-28T09:59:45.364Z" }, + { url = "https://files.pythonhosted.org/packages/c5/02/bc19b47a96c2d3109760711acf22369e56bd7e405ca52f7ade164d2ead57/pydantic_core-2.46.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:bce57638e08ac148e5778cce7feb968307a727d66f8e2274a543d0cf0c9ad6a3", size = 1905716, upload-time = "2026-08-28T09:59:47.18Z" }, + { url = "https://files.pythonhosted.org/packages/52/a4/70b47c0509923dd98ccfed04fb3e32ea3849c82a0ff2205bb41009b43c00/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:976e1128455aa595ea04c79ccfedff1aaeab96ee013fcc916bed120c4f0ad94f", size = 1934216, upload-time = "2026-08-28T09:59:49.241Z" }, + { url = "https://files.pythonhosted.org/packages/52/ab/aa03b65f7bb198585edf806b906c3223ecf1795543e39e23aec4cce27ad2/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b891faeedeafba41b2983e5001a81b6a915b69544c7e7570d1989ce1c36ac7", size = 2010635, upload-time = "2026-08-28T09:59:51.692Z" }, + { url = "https://files.pythonhosted.org/packages/3c/8b/0da06343f30b84ec549aafd309c6456223d5dc8bd36af504c573faad561d/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5f194189415698233dd1114a093a9b56e61e2c57e11b469be3b0506f46f0771c", size = 2209369, upload-time = "2026-08-28T09:59:53.582Z" }, + { url = "https://files.pythonhosted.org/packages/d6/5b/844c4defaa34a3df66eb9257087d121d70c201298b96abdf9f492fc2f1bf/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:82a36973cf8a2ef5406f4fe2edbf8ed0c99629535d959e0b100c76a32535a111", size = 2253238, upload-time = "2026-08-28T09:59:55.484Z" }, + { url = "https://files.pythonhosted.org/packages/f4/64/a4e536cb16d7f61a7fd3120b46c577fc7fa7325992f69c4f52bc786d77d8/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cdbb78909f52b981d3b2d56b97328d71eb0b974c36bd77c920123a7ebb192829", size = 2065740, upload-time = "2026-08-28T09:59:58.038Z" }, + { url = "https://files.pythonhosted.org/packages/5f/75/aaa38c6bc2d085f6605b34eabdc6a8a4e0b2e61fc9c8e6e52b28e97b3125/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:52e24eacdb536cade636aa90fb851835222becff8484b7001fdc78cb0290f2aa", size = 2087425, upload-time = "2026-08-28T09:59:59.898Z" }, + { url = "https://files.pythonhosted.org/packages/55/ae/fcab4cfc39aba3689e1d20c8b5250ad280957022c09af2ed9cd585602a5e/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:37ae34309d7bd8c0d61ab839668058f2a7962ea1fc51d105d2db228fe0618034", size = 2139306, upload-time = "2026-08-28T10:00:03.057Z" }, + { url = "https://files.pythonhosted.org/packages/2d/f4/f1d03a4bc9d9acbc62f4d742b8a319af52f71885079868b2ff8e48a651ee/pydantic_core-2.46.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:0cdbada856a1c69a7624a64d3d9aefe79300bd6ef827b43a4f265010b9b55184", size = 2144589, upload-time = "2026-08-28T10:00:05.645Z" }, + { url = "https://files.pythonhosted.org/packages/83/f3/7a53bb1356de514a4cd295f25b6ac39237895620c0462d2592b76c16e114/pydantic_core-2.46.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:545f26c504b27c3758439a5e6d9349931f0a04f855668d5fe323c89e82300a38", size = 2288882, upload-time = "2026-08-28T10:00:07.931Z" }, + { url = "https://files.pythonhosted.org/packages/cd/94/5a81583660c175c59d49ffb09f4b3a44debeaf86a19fca664ae1cdd9ee32/pydantic_core-2.46.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:ff218293c9c806138dca139765e3b067621be52bcd93cdc14c7711be7ddc90a9", size = 2335210, upload-time = "2026-08-28T10:00:10.177Z" }, + { url = "https://files.pythonhosted.org/packages/5a/9f/5d685c2693b972d1a59c998586e8823712b66603aeff47ee60a4bdaafd37/pydantic_core-2.46.5-cp314-cp314t-win32.whl", hash = "sha256:97cf3eb53a8cccacf9d46686a0926186c9bfb5574f2ed66d3639d5fe117cd3a9", size = 1921180, upload-time = "2026-08-28T10:00:12.35Z" }, + { url = "https://files.pythonhosted.org/packages/70/12/5c94ee16d65a37a15f9e869f5e6256df111154491173801a4c5e800ab548/pydantic_core-2.46.5-cp314-cp314t-win_amd64.whl", hash = "sha256:d2f9fc07a8042a8f95925b35c4f04f469707c981fc33245b6ca187cf5d2dd290", size = 2020515, upload-time = "2026-08-28T10:00:14.774Z" }, + { url = "https://files.pythonhosted.org/packages/63/19/67830dda664e6bdf9285ee2e40f355d0d7d6b92aa0c42e8d217bb8d33d36/pydantic_core-2.46.5-cp314-cp314t-win_arm64.whl", hash = "sha256:acf8a67ba51f4ca9ddbd0e6b3000a65ac51ab734661778b3e7ba64d99a710f2f", size = 1989276, upload-time = "2026-08-28T10:00:16.984Z" }, + { url = "https://files.pythonhosted.org/packages/df/dd/053c2e4303f791f3b8f8a14ab0b22008e8eb21d868c0c90b4f9be705b76a/pydantic_core-2.46.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:013d6f3483d81e02e7c328831808f336c8596ee33b4bd4026b9ffb1e960b8942", size = 2062540, upload-time = "2026-08-28T10:01:00.318Z" }, + { url = "https://files.pythonhosted.org/packages/d7/dd/a18df751a5e37dd51bfad7f68e766999125bebe68c9e1d10a493ad01bd63/pydantic_core-2.46.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:e9c134bb666dd54b778b9fc0d2b50cbb7f979b9e3716f26a88c9ab3b6fc1dd0f", size = 1902040, upload-time = "2026-08-28T10:01:02.529Z" }, + { url = "https://files.pythonhosted.org/packages/b7/13/01d40f9d07ce8a779fd6e0bd8ad4fba91309500dd67b869e2e219d261a6d/pydantic_core-2.46.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:347ec774390c87326a2e4929d58d3f7e8763a104d5d35f4cd595a4c952366433", size = 1967479, upload-time = "2026-08-28T10:01:05.004Z" }, + { url = "https://files.pythonhosted.org/packages/fa/04/c81d4841331c2178b6fb09ae225425e110ed72d990c9fe556c4ec03d1013/pydantic_core-2.46.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e24d8f05fa2d28513d94e877e9c75ad66175376209b3977f916e240e623193c", size = 2111034, upload-time = "2026-08-28T10:01:07.345Z" }, +] + +[[package]] +name = "pygments" +version = "2.21.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" }, +] + +[[package]] +name = "pyparsing" +version = "3.3.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f3/91/9c6ee907786a473bf81c5f53cf703ba0957b23ab84c264080fb5a450416f/pyparsing-3.3.2.tar.gz", hash = "sha256:c777f4d763f140633dcb6d8a3eda953bf7a214dc4eff598413c070bcdc117cbc", size = 6851574, upload-time = "2026-01-21T03:57:59.36Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/10/bd/c038d7cc38edc1aa5bf91ab8068b63d4308c66c4c8bb3cbba7dfbc049f9c/pyparsing-3.3.2-py3-none-any.whl", hash = "sha256:850ba148bd908d7e2411587e247a1e4f0327839c40e2e5e6d05a007ecc69911d", size = 122781, upload-time = "2026-01-21T03:57:55.912Z" }, +] + +[[package]] +name = "pytest" +version = "9.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" }, +] + +[[package]] +name = "python-dotenv" +version = "1.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6a/53/ed9d74092561d4b01a2ef1349d52cdbc135e526c245f366b089cfca6de49/python_dotenv-1.2.3.tar.gz", hash = "sha256:a20a594dabeaa385725aa239d5244871c143ecb356add8a20fcf23773a6c3a35", size = 58945, upload-time = "2026-08-16T16:54:54.067Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0d/17/c5c6b53ddc18f297992099b3d9ec16c855c0ccc83263a21fe4d1c625ec6c/python_dotenv-1.2.3-py3-none-any.whl", hash = "sha256:904552145e8bfed22162c09dab1c2b9b54fefa7b23ba780f4f26ca0316b0f0d9", size = 22780, upload-time = "2026-08-16T16:54:52.473Z" }, +] + +[[package]] +name = "python-multipart" +version = "0.0.32" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5b/42/55c32bb9b12693c092ad250a0e82edb5b31ddeda6eb772de5f308b3804ad/python_multipart-0.0.32.tar.gz", hash = "sha256:be54b7f3fa167bb83e4fcd936b887b708f4e57fe75911c02aebf53efaf8d938e", size = 46881, upload-time = "2026-06-04T16:18:58.647Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e1/04/e8135ebd1ad02c56ec633277529b2602ff99ff634be76cdba5744cf554fd/python_multipart-0.0.32-py3-none-any.whl", hash = "sha256:ff6d3f776f16878c894e52e107296ffc890e913c611b1a4ec6c44e2821fe2e23", size = 30042, upload-time = "2026-06-04T16:18:57.319Z" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, + { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, + { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" }, + { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" }, + { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" }, + { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" }, + { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" }, + { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" }, + { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" }, + { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" }, + { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" }, + { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" }, + { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" }, + { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" }, + { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" }, + { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, + { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, + { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, + { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, + { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, + { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, + { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, +] + +[[package]] +name = "requests" +version = "2.34.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0", size = 73075, upload-time = "2026-05-14T19:25:26.443Z" }, +] + +[[package]] +name = "rich" +version = "15.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c0/8f/0722ca900cc807c13a6a0c696dacf35430f72e0ec571c4275d2371fca3e9/rich-15.0.0.tar.gz", hash = "sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36", size = 230680, upload-time = "2026-04-12T08:24:00.75Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl", hash = "sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb", size = 310654, upload-time = "2026-04-12T08:24:02.83Z" }, +] + +[[package]] +name = "ruff" +version = "0.16.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/82/bb/5a449b9162e49b139d72f61672bd3ac1d790221f796d3304e2241fff4c58/ruff-0.16.7.tar.gz", hash = "sha256:5f71d004ac1263b22fa39462ac5ae618a4b77d58981af2cc79bf79a29c12b1a6", size = 4924184, upload-time = "2026-09-10T18:04:06.336Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e3/b2/c80aeeb7f9e469c0d63a85d2f1ab6e1ebfbe10ea7a8d2438b7e09e3ff09e/ruff-0.16.7-py3-none-linux_armv6l.whl", hash = "sha256:727307773e7c7f9181d3ed3a2484186e56c1fa1874255911c74585eb2c7c19f9", size = 10048917, upload-time = "2026-09-10T18:03:30.28Z" }, + { url = "https://files.pythonhosted.org/packages/7b/96/20bb7bcae008004df52afcb7ac83432d4a467f2c17b672fe46d26be231c5/ruff-0.16.7-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:9d61c258deabf58f34c67bd4bb4d939c7f2e6b5f0e59c1cdd1cf771b11cde929", size = 10242929, upload-time = "2026-09-10T18:03:32.706Z" }, + { url = "https://files.pythonhosted.org/packages/90/b2/f184b0d5abec02db69cfd7e49b688ae0237554528ca777136c613bf36bee/ruff-0.16.7-py3-none-macosx_11_0_arm64.whl", hash = "sha256:7ab81118df8945e0193d0240712aa4496573595b75185c3636ed825592a0f728", size = 9847245, upload-time = "2026-09-10T18:03:34.509Z" }, + { url = "https://files.pythonhosted.org/packages/eb/2d/db1633a641866ed801e34cc6b60ef236c5e16f9b2124ab1d49cc24a5fe4f/ruff-0.16.7-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4c196c968874fc8019da8e7163de7a1a370f111e2309b4b7dfea0fce950198d0", size = 9961780, upload-time = "2026-09-10T18:03:36.618Z" }, + { url = "https://files.pythonhosted.org/packages/4d/98/edea21e1a3e38dbbc3bf6bb068b863b3b06184cf8533a4c7dbbe208a89d5/ruff-0.16.7-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac8c3bd0a7e10ad31e6ce51e7a99f3cb772e69aecdd6b9ea7e99b362f62a62c0", size = 9866337, upload-time = "2026-09-10T18:03:38.805Z" }, + { url = "https://files.pythonhosted.org/packages/0b/11/a15e60d4c87b214646f116ca9d204475bf993ee1047459bc9a360fd4d6d1/ruff-0.16.7-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:398d3988edde000b5c75dc1b3f584708da9bc990de069c18909142580fec1af9", size = 10562512, upload-time = "2026-09-10T18:03:40.71Z" }, + { url = "https://files.pythonhosted.org/packages/29/42/eaff4c9b6d0c7cdf56df313a17e89ae854f5bbc0b0c8f9cce19be0ab7a8f/ruff-0.16.7-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ce05b62b770a8217c4646a9c4139fca00efe8fe5d71f87df2b243ff20d4584d1", size = 11302938, upload-time = "2026-09-10T18:03:42.607Z" }, + { url = "https://files.pythonhosted.org/packages/5d/43/c75aa59a4ec181fe2ec06cab30e198c1c6d107229a9f008ae3a7c16cabd8/ruff-0.16.7-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:af1b576fddb9d9ef2ececfb5fadcd6a624b25070ed85e3cfcfe449fc3ff6a7b9", size = 10840857, upload-time = "2026-09-10T18:03:44.604Z" }, + { url = "https://files.pythonhosted.org/packages/21/33/81f3da371942ea031105ba679d8d6e28ec1660ccd690a45f42d381161356/ruff-0.16.7-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ce7f8f22df67c93ed96c717f9128eadb797144ac2bad475cf536f31d6100c55", size = 10370001, upload-time = "2026-09-10T18:03:46.706Z" }, + { url = "https://files.pythonhosted.org/packages/fa/0b/6345fb4dbf6dd0ed1cfe5d18391dc9c3f59cc81622a7b0a65b84b3e730ba/ruff-0.16.7-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:06d0e93d04f392996435ebd600c153f65b47d73fbec2415aa99c5ee5756b3a5f", size = 10548735, upload-time = "2026-09-10T18:03:48.658Z" }, + { url = "https://files.pythonhosted.org/packages/3f/4d/c5576adf511f92a328e5569dda190ecdd430da51f1a649f3a4a2fd73e21e/ruff-0.16.7-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:142151a5e7b93c1b11111337142f89dd2fbfee92161225c99a97222f22e32656", size = 10108496, upload-time = "2026-09-10T18:03:50.563Z" }, + { url = "https://files.pythonhosted.org/packages/ff/8c/667d83c16199a17a56adc6b0bd4c3beb5b767a2babcd16a56f76f9be7fd6/ruff-0.16.7-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:e6651f97a342d8b35d54d8991544ca22169b86dc54111cb604666940c431b750", size = 9860136, upload-time = "2026-09-10T18:03:52.621Z" }, + { url = "https://files.pythonhosted.org/packages/99/75/78d401106731999a1dd20cc5a6961e37e1eb9397a3b589f73f3a5ce146a3/ruff-0.16.7-py3-none-musllinux_1_2_i686.whl", hash = "sha256:ef140c6eb935fa9a84c9c607dfb2cb1b85843c192e79265b0c54f35f557ea8e5", size = 10286290, upload-time = "2026-09-10T18:03:55.207Z" }, + { url = "https://files.pythonhosted.org/packages/68/49/56f9c3a8b755df93a0ad318b2147bf4ef5dae9a7e5ec61c460109c67957f/ruff-0.16.7-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:53e39506a730fadeee0d998ed5946f30671f0db240c6c7c73bdabbe33604bb6f", size = 10745048, upload-time = "2026-09-10T18:03:57.299Z" }, + { url = "https://files.pythonhosted.org/packages/5f/ea/7f9b938a63ece4bec677ad7f9f7fa02df3383db1949ed93a382441c09a87/ruff-0.16.7-py3-none-win32.whl", hash = "sha256:2ea3470fcebcbc5df2fb0c6f3b90333fa9084c534e0111c038fa4a6ab9f1c4b7", size = 10059082, upload-time = "2026-09-10T18:03:59.632Z" }, + { url = "https://files.pythonhosted.org/packages/39/11/480a6973a927aa653e1cead6a6416008640e03a99d05b34c0434b8c6c366/ruff-0.16.7-py3-none-win_amd64.whl", hash = "sha256:7ac26aca826e9e21d0f1cb25b54ac660760a9fdd094d3e4df9848232be98cfc6", size = 10593368, upload-time = "2026-09-10T18:04:01.999Z" }, + { url = "https://files.pythonhosted.org/packages/8b/4b/51327018d056f0dad2c2238f26d1fb0f53707a9d91b75dea6d1b3039f136/ruff-0.16.7-py3-none-win_arm64.whl", hash = "sha256:aab7f39e2c9df6c596216070f98eef1207b94f8516cca20c808826974971855b", size = 10412401, upload-time = "2026-09-10T18:04:04.098Z" }, +] + +[[package]] +name = "sortedcontainers" +version = "2.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e8/c4/ba2f8066cceb6f23394729afe52f3bf7adec04bf9ed2c820b39e19299111/sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88", size = 30594, upload-time = "2021-05-16T22:03:42.897Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575, upload-time = "2021-05-16T22:03:41.177Z" }, +] + +[[package]] +name = "starlette" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b5/b4/205b0d5241d934e8add0c38aa924c4f9fb7330834ff11e5444db964ec3f9/starlette-1.6.0.tar.gz", hash = "sha256:d4e3ac5e546444960c710297a3c9fc3f7ebae1b7e963f3d36173b49da535be9b", size = 2716969, upload-time = "2026-08-08T18:27:57.512Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c8/cb/6a6a47d5b464bd08695d254f3da6e7986cc70c9fa5d778eda57538edfe56/starlette-1.6.0-py3-none-any.whl", hash = "sha256:a86dd39d14bb45f85a3d18525215a9ef0cfd1f192ac793220e72598c90335f0c", size = 75969, upload-time = "2026-08-08T18:27:56.196Z" }, +] + +[[package]] +name = "tomli" +version = "2.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/22/de/48c59722572767841493b26183a0d1cc411d54fd759c5607c4590b6563a6/tomli-2.4.1.tar.gz", hash = "sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f", size = 17543, upload-time = "2026-03-25T20:22:03.828Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/ba/42f134a3fe2b370f555f44b1d72feebb94debcab01676bf918d0cb70e9aa/tomli-2.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c742f741d58a28940ce01d58f0ab2ea3ced8b12402f162f4d534dfe18ba1cd6a", size = 155924, upload-time = "2026-03-25T20:21:21.626Z" }, + { url = "https://files.pythonhosted.org/packages/dc/c7/62d7a17c26487ade21c5422b646110f2162f1fcc95980ef7f63e73c68f14/tomli-2.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7f86fd587c4ed9dd76f318225e7d9b29cfc5a9d43de44e5754db8d1128487085", size = 150018, upload-time = "2026-03-25T20:21:23.002Z" }, + { url = "https://files.pythonhosted.org/packages/5c/05/79d13d7c15f13bdef410bdd49a6485b1c37d28968314eabee452c22a7fda/tomli-2.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff18e6a727ee0ab0388507b89d1bc6a22b138d1e2fa56d1ad494586d61d2eae9", size = 244948, upload-time = "2026-03-25T20:21:24.04Z" }, + { url = "https://files.pythonhosted.org/packages/10/90/d62ce007a1c80d0b2c93e02cab211224756240884751b94ca72df8a875ca/tomli-2.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:136443dbd7e1dee43c68ac2694fde36b2849865fa258d39bf822c10e8068eac5", size = 253341, upload-time = "2026-03-25T20:21:25.177Z" }, + { url = "https://files.pythonhosted.org/packages/1a/7e/caf6496d60152ad4ed09282c1885cca4eea150bfd007da84aea07bcc0a3e/tomli-2.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5e262d41726bc187e69af7825504c933b6794dc3fbd5945e41a79bb14c31f585", size = 248159, upload-time = "2026-03-25T20:21:26.364Z" }, + { url = "https://files.pythonhosted.org/packages/99/e7/c6f69c3120de34bbd882c6fba7975f3d7a746e9218e56ab46a1bc4b42552/tomli-2.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5cb41aa38891e073ee49d55fbc7839cfdb2bc0e600add13874d048c94aadddd1", size = 253290, upload-time = "2026-03-25T20:21:27.46Z" }, + { url = "https://files.pythonhosted.org/packages/d6/2f/4a3c322f22c5c66c4b836ec58211641a4067364f5dcdd7b974b4c5da300c/tomli-2.4.1-cp312-cp312-win32.whl", hash = "sha256:da25dc3563bff5965356133435b757a795a17b17d01dbc0f42fb32447ddfd917", size = 98141, upload-time = "2026-03-25T20:21:28.492Z" }, + { url = "https://files.pythonhosted.org/packages/24/22/4daacd05391b92c55759d55eaee21e1dfaea86ce5c571f10083360adf534/tomli-2.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:52c8ef851d9a240f11a88c003eacb03c31fc1c9c4ec64a99a0f922b93874fda9", size = 108847, upload-time = "2026-03-25T20:21:29.386Z" }, + { url = "https://files.pythonhosted.org/packages/68/fd/70e768887666ddd9e9f5d85129e84910f2db2796f9096aa02b721a53098d/tomli-2.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:f758f1b9299d059cc3f6546ae2af89670cb1c4d48ea29c3cacc4fe7de3058257", size = 95088, upload-time = "2026-03-25T20:21:30.677Z" }, + { url = "https://files.pythonhosted.org/packages/07/06/b823a7e818c756d9a7123ba2cda7d07bc2dd32835648d1a7b7b7a05d848d/tomli-2.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:36d2bd2ad5fb9eaddba5226aa02c8ec3fa4f192631e347b3ed28186d43be6b54", size = 155866, upload-time = "2026-03-25T20:21:31.65Z" }, + { url = "https://files.pythonhosted.org/packages/14/6f/12645cf7f08e1a20c7eb8c297c6f11d31c1b50f316a7e7e1e1de6e2e7b7e/tomli-2.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:eb0dc4e38e6a1fd579e5d50369aa2e10acfc9cace504579b2faabb478e76941a", size = 149887, upload-time = "2026-03-25T20:21:33.028Z" }, + { url = "https://files.pythonhosted.org/packages/5c/e0/90637574e5e7212c09099c67ad349b04ec4d6020324539297b634a0192b0/tomli-2.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c7f2c7f2b9ca6bdeef8f0fa897f8e05085923eb091721675170254cbc5b02897", size = 243704, upload-time = "2026-03-25T20:21:34.51Z" }, + { url = "https://files.pythonhosted.org/packages/10/8f/d3ddb16c5a4befdf31a23307f72828686ab2096f068eaf56631e136c1fdd/tomli-2.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f3c6818a1a86dd6dca7ddcaaf76947d5ba31aecc28cb1b67009a5877c9a64f3f", size = 251628, upload-time = "2026-03-25T20:21:36.012Z" }, + { url = "https://files.pythonhosted.org/packages/e3/f1/dbeeb9116715abee2485bf0a12d07a8f31af94d71608c171c45f64c0469d/tomli-2.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d312ef37c91508b0ab2cee7da26ec0b3ed2f03ce12bd87a588d771ae15dcf82d", size = 247180, upload-time = "2026-03-25T20:21:37.136Z" }, + { url = "https://files.pythonhosted.org/packages/d3/74/16336ffd19ed4da28a70959f92f506233bd7cfc2332b20bdb01591e8b1d1/tomli-2.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51529d40e3ca50046d7606fa99ce3956a617f9b36380da3b7f0dd3dd28e68cb5", size = 251674, upload-time = "2026-03-25T20:21:38.298Z" }, + { url = "https://files.pythonhosted.org/packages/16/f9/229fa3434c590ddf6c0aa9af64d3af4b752540686cace29e6281e3458469/tomli-2.4.1-cp313-cp313-win32.whl", hash = "sha256:2190f2e9dd7508d2a90ded5ed369255980a1bcdd58e52f7fe24b8162bf9fedbd", size = 97976, upload-time = "2026-03-25T20:21:39.316Z" }, + { url = "https://files.pythonhosted.org/packages/6a/1e/71dfd96bcc1c775420cb8befe7a9d35f2e5b1309798f009dca17b7708c1e/tomli-2.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:8d65a2fbf9d2f8352685bc1364177ee3923d6baf5e7f43ea4959d7d8bc326a36", size = 108755, upload-time = "2026-03-25T20:21:40.248Z" }, + { url = "https://files.pythonhosted.org/packages/83/7a/d34f422a021d62420b78f5c538e5b102f62bea616d1d75a13f0a88acb04a/tomli-2.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:4b605484e43cdc43f0954ddae319fb75f04cc10dd80d830540060ee7cd0243cd", size = 95265, upload-time = "2026-03-25T20:21:41.219Z" }, + { url = "https://files.pythonhosted.org/packages/3c/fb/9a5c8d27dbab540869f7c1f8eb0abb3244189ce780ba9cd73f3770662072/tomli-2.4.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fd0409a3653af6c147209d267a0e4243f0ae46b011aa978b1080359fddc9b6cf", size = 155726, upload-time = "2026-03-25T20:21:42.23Z" }, + { url = "https://files.pythonhosted.org/packages/62/05/d2f816630cc771ad836af54f5001f47a6f611d2d39535364f148b6a92d6b/tomli-2.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a120733b01c45e9a0c34aeef92bf0cf1d56cfe81ed9d47d562f9ed591a9828ac", size = 149859, upload-time = "2026-03-25T20:21:43.386Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/66341bdb858ad9bd0ceab5a86f90eddab127cf8b046418009f2125630ecb/tomli-2.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:559db847dc486944896521f68d8190be1c9e719fced785720d2216fe7022b662", size = 244713, upload-time = "2026-03-25T20:21:44.474Z" }, + { url = "https://files.pythonhosted.org/packages/df/6d/c5fad00d82b3c7a3ab6189bd4b10e60466f22cfe8a08a9394185c8a8111c/tomli-2.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01f520d4f53ef97964a240a035ec2a869fe1a37dde002b57ebc4417a27ccd853", size = 252084, upload-time = "2026-03-25T20:21:45.62Z" }, + { url = "https://files.pythonhosted.org/packages/00/71/3a69e86f3eafe8c7a59d008d245888051005bd657760e96d5fbfb0b740c2/tomli-2.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7f94b27a62cfad8496c8d2513e1a222dd446f095fca8987fceef261225538a15", size = 247973, upload-time = "2026-03-25T20:21:46.937Z" }, + { url = "https://files.pythonhosted.org/packages/67/50/361e986652847fec4bd5e4a0208752fbe64689c603c7ae5ea7cb16b1c0ca/tomli-2.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ede3e6487c5ef5d28634ba3f31f989030ad6af71edfb0055cbbd14189ff240ba", size = 256223, upload-time = "2026-03-25T20:21:48.467Z" }, + { url = "https://files.pythonhosted.org/packages/8c/9a/b4173689a9203472e5467217e0154b00e260621caa227b6fa01feab16998/tomli-2.4.1-cp314-cp314-win32.whl", hash = "sha256:3d48a93ee1c9b79c04bb38772ee1b64dcf18ff43085896ea460ca8dec96f35f6", size = 98973, upload-time = "2026-03-25T20:21:49.526Z" }, + { url = "https://files.pythonhosted.org/packages/14/58/640ac93bf230cd27d002462c9af0d837779f8773bc03dee06b5835208214/tomli-2.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:88dceee75c2c63af144e456745e10101eb67361050196b0b6af5d717254dddf7", size = 109082, upload-time = "2026-03-25T20:21:50.506Z" }, + { url = "https://files.pythonhosted.org/packages/d5/2f/702d5e05b227401c1068f0d386d79a589bb12bf64c3d2c72ce0631e3bc49/tomli-2.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:b8c198f8c1805dc42708689ed6864951fd2494f924149d3e4bce7710f8eb5232", size = 96490, upload-time = "2026-03-25T20:21:51.474Z" }, + { url = "https://files.pythonhosted.org/packages/45/4b/b877b05c8ba62927d9865dd980e34a755de541eb65fffba52b4cc495d4d2/tomli-2.4.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:d4d8fe59808a54658fcc0160ecfb1b30f9089906c50b23bcb4c69eddc19ec2b4", size = 164263, upload-time = "2026-03-25T20:21:52.543Z" }, + { url = "https://files.pythonhosted.org/packages/24/79/6ab420d37a270b89f7195dec5448f79400d9e9c1826df982f3f8e97b24fd/tomli-2.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7008df2e7655c495dd12d2a4ad038ff878d4ca4b81fccaf82b714e07eae4402c", size = 160736, upload-time = "2026-03-25T20:21:53.674Z" }, + { url = "https://files.pythonhosted.org/packages/02/e0/3630057d8eb170310785723ed5adcdfb7d50cb7e6455f85ba8a3deed642b/tomli-2.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1d8591993e228b0c930c4bb0db464bdad97b3289fb981255d6c9a41aedc84b2d", size = 270717, upload-time = "2026-03-25T20:21:55.129Z" }, + { url = "https://files.pythonhosted.org/packages/7a/b4/1613716072e544d1a7891f548d8f9ec6ce2faf42ca65acae01d76ea06bb0/tomli-2.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:734e20b57ba95624ecf1841e72b53f6e186355e216e5412de414e3c51e5e3c41", size = 278461, upload-time = "2026-03-25T20:21:56.228Z" }, + { url = "https://files.pythonhosted.org/packages/05/38/30f541baf6a3f6df77b3df16b01ba319221389e2da59427e221ef417ac0c/tomli-2.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8a650c2dbafa08d42e51ba0b62740dae4ecb9338eefa093aa5c78ceb546fcd5c", size = 274855, upload-time = "2026-03-25T20:21:57.653Z" }, + { url = "https://files.pythonhosted.org/packages/77/a3/ec9dd4fd2c38e98de34223b995a3b34813e6bdadf86c75314c928350ed14/tomli-2.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:504aa796fe0569bb43171066009ead363de03675276d2d121ac1a4572397870f", size = 283144, upload-time = "2026-03-25T20:21:59.089Z" }, + { url = "https://files.pythonhosted.org/packages/ef/be/605a6261cac79fba2ec0c9827e986e00323a1945700969b8ee0b30d85453/tomli-2.4.1-cp314-cp314t-win32.whl", hash = "sha256:b1d22e6e9387bf4739fbe23bfa80e93f6b0373a7f1b96c6227c32bef95a4d7a8", size = 108683, upload-time = "2026-03-25T20:22:00.214Z" }, + { url = "https://files.pythonhosted.org/packages/12/64/da524626d3b9cc40c168a13da8335fe1c51be12c0a63685cc6db7308daae/tomli-2.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:2c1c351919aca02858f740c6d33adea0c5deea37f9ecca1cc1ef9e884a619d26", size = 121196, upload-time = "2026-03-25T20:22:01.169Z" }, + { url = "https://files.pythonhosted.org/packages/5a/cd/e80b62269fc78fc36c9af5a6b89c835baa8af28ff5ad28c7028d60860320/tomli-2.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:eab21f45c7f66c13f2a9e0e1535309cee140182a9cdae1e041d02e47291e8396", size = 100393, upload-time = "2026-03-25T20:22:02.137Z" }, + { url = "https://files.pythonhosted.org/packages/7b/61/cceae43728b7de99d9b847560c262873a1f6c98202171fd5ed62640b494b/tomli-2.4.1-py3-none-any.whl", hash = "sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe", size = 14583, upload-time = "2026-03-25T20:22:03.012Z" }, +] + +[[package]] +name = "tomli-w" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/19/75/241269d1da26b624c0d5e110e8149093c759b7a286138f4efd61a60e75fe/tomli_w-1.2.0.tar.gz", hash = "sha256:2dd14fac5a47c27be9cd4c976af5a12d87fb1f0b4512f81d69cce3b35ae25021", size = 7184, upload-time = "2025-01-15T12:07:24.262Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c7/18/c86eb8e0202e32dd3df50d43d7ff9854f8e0603945ff398974c1d91ac1ef/tomli_w-1.2.0-py3-none-any.whl", hash = "sha256:188306098d013b691fcadc011abd66727d3c414c571bb01b1a174ba8c983cf90", size = 6675, upload-time = "2025-01-15T12:07:22.074Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" }, +] + +[[package]] +name = "typing-inspection" +version = "0.4.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/26/b09b8010994eccc3c09092e6b34058f36a460eea2d4c3e8b910c695975a0/typing_inspection-0.4.4.tar.gz", hash = "sha256:547274fa6b0a561ccf549cc9524b999a578e737d015d8709d021f9d0d13bea47", size = 76928, upload-time = "2026-08-12T12:37:25.997Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/67/81/4add07e5172b7ac40d8ed5ff580409a7801a4fe26d529bdd915401dabfbe/typing_inspection-0.4.4-py3-none-any.whl", hash = "sha256:65b8397ba37ccbce054456aaccddfc91e6e3083c92824df348d96ca832f3f147", size = 14750, upload-time = "2026-08-12T12:37:24.648Z" }, +] + +[[package]] +name = "urllib3" +version = "2.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" }, +] + +[[package]] +name = "uvicorn" +version = "0.52.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f2/0f/3f86e61397dd33bf2ccf28188c40db6a740658aeebbbf6e7dbc101a1f487/uvicorn-0.52.4.tar.gz", hash = "sha256:73acfee47a0b133c5de13d219492d62d8a31e935f4fe6e41a232451a15379f86", size = 100627, upload-time = "2026-08-19T06:27:41.821Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/79/4a20b54ab0491485ccd8c077db2d39187c7f12b3e15485d38a7be37c81b4/uvicorn-0.52.4-py3-none-any.whl", hash = "sha256:f86e41a149d7d05a9969337e3946a9c171c06a5d42680896daaba624aeac8da1", size = 79871, upload-time = "2026-08-19T06:27:40.36Z" }, +] + +[package.optional-dependencies] +standard = [ + { name = "httptools" }, + { name = "python-dotenv" }, + { name = "pyyaml" }, + { name = "uvloop", marker = "platform_python_implementation != 'PyPy' and sys_platform != 'cygwin' and sys_platform != 'win32'" }, + { name = "watchfiles" }, + { name = "websockets" }, +] + +[[package]] +name = "uvloop" +version = "0.22.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", hash = "sha256:6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f", size = 2443250, upload-time = "2025-10-16T22:17:19.342Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3d/ff/7f72e8170be527b4977b033239a83a68d5c881cc4775fca255c677f7ac5d/uvloop-0.22.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fe94b4564e865d968414598eea1a6de60adba0c040ba4ed05ac1300de402cd42", size = 1359936, upload-time = "2025-10-16T22:16:29.436Z" }, + { url = "https://files.pythonhosted.org/packages/c3/c6/e5d433f88fd54d81ef4be58b2b7b0cea13c442454a1db703a1eea0db1a59/uvloop-0.22.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:51eb9bd88391483410daad430813d982010f9c9c89512321f5b60e2cddbdddd6", size = 752769, upload-time = "2025-10-16T22:16:30.493Z" }, + { url = "https://files.pythonhosted.org/packages/24/68/a6ac446820273e71aa762fa21cdcc09861edd3536ff47c5cd3b7afb10eeb/uvloop-0.22.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:700e674a166ca5778255e0e1dc4e9d79ab2acc57b9171b79e65feba7184b3370", size = 4317413, upload-time = "2025-10-16T22:16:31.644Z" }, + { url = "https://files.pythonhosted.org/packages/5f/6f/e62b4dfc7ad6518e7eff2516f680d02a0f6eb62c0c212e152ca708a0085e/uvloop-0.22.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b5b1ac819a3f946d3b2ee07f09149578ae76066d70b44df3fa990add49a82e4", size = 4426307, upload-time = "2025-10-16T22:16:32.917Z" }, + { url = "https://files.pythonhosted.org/packages/90/60/97362554ac21e20e81bcef1150cb2a7e4ffdaf8ea1e5b2e8bf7a053caa18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e047cc068570bac9866237739607d1313b9253c3051ad84738cbb095be0537b2", size = 4131970, upload-time = "2025-10-16T22:16:34.015Z" }, + { url = "https://files.pythonhosted.org/packages/99/39/6b3f7d234ba3964c428a6e40006340f53ba37993f46ed6e111c6e9141d18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:512fec6815e2dd45161054592441ef76c830eddaad55c8aa30952e6fe1ed07c0", size = 4296343, upload-time = "2025-10-16T22:16:35.149Z" }, + { url = "https://files.pythonhosted.org/packages/89/8c/182a2a593195bfd39842ea68ebc084e20c850806117213f5a299dfc513d9/uvloop-0.22.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:561577354eb94200d75aca23fbde86ee11be36b00e52a4eaf8f50fb0c86b7705", size = 1358611, upload-time = "2025-10-16T22:16:36.833Z" }, + { url = "https://files.pythonhosted.org/packages/d2/14/e301ee96a6dc95224b6f1162cd3312f6d1217be3907b79173b06785f2fe7/uvloop-0.22.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cdf5192ab3e674ca26da2eada35b288d2fa49fdd0f357a19f0e7c4e7d5077c8", size = 751811, upload-time = "2025-10-16T22:16:38.275Z" }, + { url = "https://files.pythonhosted.org/packages/b7/02/654426ce265ac19e2980bfd9ea6590ca96a56f10c76e63801a2df01c0486/uvloop-0.22.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2ea3d6190a2968f4a14a23019d3b16870dd2190cd69c8180f7c632d21de68d", size = 4288562, upload-time = "2025-10-16T22:16:39.375Z" }, + { url = "https://files.pythonhosted.org/packages/15/c0/0be24758891ef825f2065cd5db8741aaddabe3e248ee6acc5e8a80f04005/uvloop-0.22.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0530a5fbad9c9e4ee3f2b33b148c6a64d47bbad8000ea63704fa8260f4cf728e", size = 4366890, upload-time = "2025-10-16T22:16:40.547Z" }, + { url = "https://files.pythonhosted.org/packages/d2/53/8369e5219a5855869bcee5f4d317f6da0e2c669aecf0ef7d371e3d084449/uvloop-0.22.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bc5ef13bbc10b5335792360623cc378d52d7e62c2de64660616478c32cd0598e", size = 4119472, upload-time = "2025-10-16T22:16:41.694Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ba/d69adbe699b768f6b29a5eec7b47dd610bd17a69de51b251126a801369ea/uvloop-0.22.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1f38ec5e3f18c8a10ded09742f7fb8de0108796eb673f30ce7762ce1b8550cad", size = 4239051, upload-time = "2025-10-16T22:16:43.224Z" }, + { url = "https://files.pythonhosted.org/packages/90/cd/b62bdeaa429758aee8de8b00ac0dd26593a9de93d302bff3d21439e9791d/uvloop-0.22.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3879b88423ec7e97cd4eba2a443aa26ed4e59b45e6b76aabf13fe2f27023a142", size = 1362067, upload-time = "2025-10-16T22:16:44.503Z" }, + { url = "https://files.pythonhosted.org/packages/0d/f8/a132124dfda0777e489ca86732e85e69afcd1ff7686647000050ba670689/uvloop-0.22.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4baa86acedf1d62115c1dc6ad1e17134476688f08c6efd8a2ab076e815665c74", size = 752423, upload-time = "2025-10-16T22:16:45.968Z" }, + { url = "https://files.pythonhosted.org/packages/a3/94/94af78c156f88da4b3a733773ad5ba0b164393e357cc4bd0ab2e2677a7d6/uvloop-0.22.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:297c27d8003520596236bdb2335e6b3f649480bd09e00d1e3a99144b691d2a35", size = 4272437, upload-time = "2025-10-16T22:16:47.451Z" }, + { url = "https://files.pythonhosted.org/packages/b5/35/60249e9fd07b32c665192cec7af29e06c7cd96fa1d08b84f012a56a0b38e/uvloop-0.22.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c1955d5a1dd43198244d47664a5858082a3239766a839b2102a269aaff7a4e25", size = 4292101, upload-time = "2025-10-16T22:16:49.318Z" }, + { url = "https://files.pythonhosted.org/packages/02/62/67d382dfcb25d0a98ce73c11ed1a6fba5037a1a1d533dcbb7cab033a2636/uvloop-0.22.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b31dc2fccbd42adc73bc4e7cdbae4fc5086cf378979e53ca5d0301838c5682c6", size = 4114158, upload-time = "2025-10-16T22:16:50.517Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/f1171b4a882a5d13c8b7576f348acfe6074d72eaf52cccef752f748d4a9f/uvloop-0.22.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:93f617675b2d03af4e72a5333ef89450dfaa5321303ede6e67ba9c9d26878079", size = 4177360, upload-time = "2025-10-16T22:16:52.646Z" }, + { url = "https://files.pythonhosted.org/packages/79/7b/b01414f31546caf0919da80ad57cbfe24c56b151d12af68cee1b04922ca8/uvloop-0.22.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:37554f70528f60cad66945b885eb01f1bb514f132d92b6eeed1c90fd54ed6289", size = 1454790, upload-time = "2025-10-16T22:16:54.355Z" }, + { url = "https://files.pythonhosted.org/packages/d4/31/0bb232318dd838cad3fa8fb0c68c8b40e1145b32025581975e18b11fab40/uvloop-0.22.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:b76324e2dc033a0b2f435f33eb88ff9913c156ef78e153fb210e03c13da746b3", size = 796783, upload-time = "2025-10-16T22:16:55.906Z" }, + { url = "https://files.pythonhosted.org/packages/42/38/c9b09f3271a7a723a5de69f8e237ab8e7803183131bc57c890db0b6bb872/uvloop-0.22.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:badb4d8e58ee08dad957002027830d5c3b06aea446a6a3744483c2b3b745345c", size = 4647548, upload-time = "2025-10-16T22:16:57.008Z" }, + { url = "https://files.pythonhosted.org/packages/c1/37/945b4ca0ac27e3dc4952642d4c900edd030b3da6c9634875af6e13ae80e5/uvloop-0.22.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b91328c72635f6f9e0282e4a57da7470c7350ab1c9f48546c0f2866205349d21", size = 4467065, upload-time = "2025-10-16T22:16:58.206Z" }, + { url = "https://files.pythonhosted.org/packages/97/cc/48d232f33d60e2e2e0b42f4e73455b146b76ebe216487e862700457fbf3c/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:daf620c2995d193449393d6c62131b3fbd40a63bf7b307a1527856ace637fe88", size = 4328384, upload-time = "2025-10-16T22:16:59.36Z" }, + { url = "https://files.pythonhosted.org/packages/e4/16/c1fd27e9549f3c4baf1dc9c20c456cd2f822dbf8de9f463824b0c0357e06/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6cde23eeda1a25c75b2e07d39970f3374105d5eafbaab2a4482be82f272d5a5e", size = 4296730, upload-time = "2025-10-16T22:17:00.744Z" }, +] + +[[package]] +name = "watchfiles" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cd/41/5e1a4bb12aac5f1493fa1bdc11154eca3b258ca4eba65d39c473fe19d8e9/watchfiles-1.2.0.tar.gz", hash = "sha256:c995fba777f1ea992f090f9236e9284cf7a5d1a0130dd5a3d82c598cacd76838", size = 108252, upload-time = "2026-05-18T04:32:04.251Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b8/2f/e42c992d2afda3108ea1c02acecc991b9f31d05c14adc2a7cee9ee211fc4/watchfiles-1.2.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:bc13eb17538be00c874699dc0abe4ee2bc8d50bb1166a6b9e175ef3fd7eb8f26", size = 400115, upload-time = "2026-05-18T04:32:02.06Z" }, + { url = "https://files.pythonhosted.org/packages/5f/8f/6af2ea19065c91d8b0ea3516fdfc8c0d349f407e8e9fbf4e5a17360de8ad/watchfiles-1.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2d95ddc1eb6914154253d239089900813f6a767e174b8e6a50e7fdacb7e4236c", size = 393659, upload-time = "2026-05-18T04:30:50.951Z" }, + { url = "https://files.pythonhosted.org/packages/13/01/b32a967c56fb3e3e5be3db52c3d3b87fa4513aa367d8ed1ad96d42952e5f/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8f70d8b291ef6e88d19b1f297a6905ddb978888d9272b0d05e6f53309856bcfc", size = 453207, upload-time = "2026-05-18T04:31:04.231Z" }, + { url = "https://files.pythonhosted.org/packages/04/98/97557a812180338cb1abd32e1cffcc4588f59b5f23e0cb006b2ba95ba64a/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:56d8641cf834c2836922899105bd3ce3d0dfc69291d52edf0b4d0436829b34c0", size = 459273, upload-time = "2026-05-18T04:31:50.377Z" }, + { url = "https://files.pythonhosted.org/packages/e8/a8/b4b08dcb7653b8087c6586f7ce649505900e866bbcfe40dc9587af02e686/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2581a94056e55d7d0a31a823ea92bf73749c489ca2285bfdc0fbe6b2bb49d50c", size = 489927, upload-time = "2026-05-18T04:31:42.485Z" }, + { url = "https://files.pythonhosted.org/packages/50/94/3dceea03545d2e5ddfd839f0ddd5e1cecbf1697b5a428d5ba11cef6af95d/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:41bc1199f7523b3f82843c88cbb979180c949caef0342cf90968f178e5d49b01", size = 570476, upload-time = "2026-05-18T04:31:03.071Z" }, + { url = "https://files.pythonhosted.org/packages/cc/f2/d39a5450c3532092b91f81d274360e613c2371bc874a89c7a1a3c5e8d138/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7571e4464cb6e434958f867f7f730b8ab0b75e3f8e5eac0499168486ab3c33a8", size = 465650, upload-time = "2026-05-18T04:30:12.701Z" }, + { url = "https://files.pythonhosted.org/packages/22/24/ed72f68cbc1333ca9b9f2200aa048bb6658ae41709bc1caad4310f4bdffd/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e53a384f76b631c3ae5334ce6a52f0baa3a911eb94a4eac7f160079868b716d5", size = 456398, upload-time = "2026-05-18T04:30:13.784Z" }, + { url = "https://files.pythonhosted.org/packages/0d/64/982ef4a4e5bab5b6e5b6becc8cd5e732f6130a78b855f0abec6439a9a135/watchfiles-1.2.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:d20029a60a71a052a24c4db7673bc4de39ab89adbaccbfb5d67987c5d73f424d", size = 465140, upload-time = "2026-05-18T04:31:52.111Z" }, + { url = "https://files.pythonhosted.org/packages/a0/0c/95282abf4ed680b6096010bcfc30c5fa7a041fc5aa5a2ad17a2cc6c75bba/watchfiles-1.2.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:2cb93af48550faf1cea04c303107c8b75833de7013e57ce27d3b8d21d8d0f58c", size = 630259, upload-time = "2026-05-18T04:31:25.676Z" }, + { url = "https://files.pythonhosted.org/packages/30/45/607c1de1530c4bdcf2cf1d1ecc2505ddba5d96bd43ba9f2b0e79876f850f/watchfiles-1.2.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2995c176de7692b86a2e4c58d9ec718f753150a979cb4a754e2b4ffa38e70906", size = 659859, upload-time = "2026-05-18T04:30:24.333Z" }, + { url = "https://files.pythonhosted.org/packages/fa/08/d9e2e0f9e8e6791d33aefc694ad7eefa7f901f63caff84a81ded38692f9c/watchfiles-1.2.0-cp312-cp312-win32.whl", hash = "sha256:7a2cffd17d27d2ecbb310c2b1d8174f222a5495b1a721894afa88ec11e25b898", size = 275480, upload-time = "2026-05-18T04:30:31.307Z" }, + { url = "https://files.pythonhosted.org/packages/1c/e6/9d42569c0102645cc8cea5d8c7d8a1e9d4ada2cb7f05f75e554b8aa2202a/watchfiles-1.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:f155b3a1b2a5fc89cdc70d47ee5d54e3b75e88efa34982028a35daef9ba00379", size = 288718, upload-time = "2026-05-18T04:32:10.745Z" }, + { url = "https://files.pythonhosted.org/packages/0a/26/88e0dc6ee3898169d7fa22bb6a69cabf2502d2ee25cb8c876d1262d204f8/watchfiles-1.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:8fa585ede612ee9f9e91b18bebf9ba11b9ae29a4e3a0d0cf6fca3e382133f0d5", size = 281026, upload-time = "2026-05-18T04:30:22.23Z" }, + { url = "https://files.pythonhosted.org/packages/d1/4d/70a7feced9f87e2ff26dba42667290f41694fc64646c67261fbb8cab5d5c/watchfiles-1.2.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:01ea8d66f0693b9b60a6541c8d10263091ca9a9060d242f3c1f3143f9aad2c98", size = 399730, upload-time = "2026-05-18T04:31:38.162Z" }, + { url = "https://files.pythonhosted.org/packages/31/3a/0da302f2307aee316922806ebd5726c542cbd787c938271cf14a074c7daf/watchfiles-1.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7ba0480b9a74af058f43b337e937a451e109295c420916d68ad24e3dc02f5e44", size = 392842, upload-time = "2026-05-18T04:30:27.051Z" }, + { url = "https://files.pythonhosted.org/packages/db/ef/d5bdb705c224dbc256aa0c1ec47bf4e61ec52558f2afb44a71a1fe4d7015/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4f34e26a19f91f710c08e0183429f0d1d15df734e6bc78c31e77b9ea9c433658", size = 452989, upload-time = "2026-05-18T04:31:11.945Z" }, + { url = "https://files.pythonhosted.org/packages/71/29/5495f2c1661949ef7a35e4d71111d129cfe7606414a26887a919d0a55406/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b4e77f6a55f858504069abd35d336a637555c09bca453dde1ee1e5ada8a6a1fb", size = 458978, upload-time = "2026-05-18T04:30:52.606Z" }, + { url = "https://files.pythonhosted.org/packages/d5/8c/7f9c07c433811c2fffd93e13fdfb7135de9aab5f2ae41be08960fa0047dc/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0cb4d80e212f116474a545c21c912b445f16bb0cef9e6a73a498164223e14e2f", size = 490248, upload-time = "2026-05-18T04:31:36.003Z" }, + { url = "https://files.pythonhosted.org/packages/3c/11/d93632febc52fbc21be90231bb7c17fd5387f46c9076fd40a5f9c2ae6910/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b974946a10af379d425e2eef5b62f5c6ebeaccf91d45eaad6f5b27ecd4f91aa0", size = 571847, upload-time = "2026-05-18T04:31:10.862Z" }, + { url = "https://files.pythonhosted.org/packages/55/b4/383173e73aabb07ad1d9c7aa859d95437ac46a6d6a1e11005facda0c9d19/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:86bc13c25a8d1fcd70b51d0ce7c9b65e90de5666fcbfd3e34957cc73ee19aeb5", size = 465974, upload-time = "2026-05-18T04:30:17.006Z" }, + { url = "https://files.pythonhosted.org/packages/a7/6c/89b1a230a78f57c52dd8893adb1f92f94411721b6ec12596c56d98c74356/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ca148d73dea36c9763aaa351e4d7a51780ec1584217c45276f4fe8239c768b71", size = 454782, upload-time = "2026-05-18T04:30:35.656Z" }, + { url = "https://files.pythonhosted.org/packages/24/62/1732118367cfff0a9fce3bf62ff4bfded09ef5df21d9d446b858b3f70a96/watchfiles-1.2.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:c525543d91961c6955b2636b308569e84a1d1c5f5f2932041ab9ef46422f43e3", size = 465182, upload-time = "2026-05-18T04:30:20.846Z" }, + { url = "https://files.pythonhosted.org/packages/28/96/716f7e5f51339bf22963f3345f9f27d7f3b30e2eadc597e257c881dd3c53/watchfiles-1.2.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:a204794696ffb8f9b10fba6f7cb5216d42f3b2b71860ccac6b6e42f5f10973b0", size = 629841, upload-time = "2026-05-18T04:31:05.397Z" }, + { url = "https://files.pythonhosted.org/packages/4c/fe/c40783950fd771ccf66ab3ec2722d188a9af1c7f96c6e811f36e40c6e03f/watchfiles-1.2.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:10d86db20695afe7997ac9e1717637d6714a8d0220458c33f3d2061f54cec427", size = 658028, upload-time = "2026-05-18T04:31:48.22Z" }, + { url = "https://files.pythonhosted.org/packages/71/72/4508db1856d1d87fcbb3b63f4839bab1b5682cb0e8d224d122263c09654a/watchfiles-1.2.0-cp313-cp313-win32.whl", hash = "sha256:eb283ee99e21ad6443c8cdb06ac5b34b1308c329cbdf03fa02b445363714c799", size = 275183, upload-time = "2026-05-18T04:30:59.57Z" }, + { url = "https://files.pythonhosted.org/packages/f9/36/14b76ca57652e5cc5fd1c11f32a261292c08a0d19a00351013c2549cbfb2/watchfiles-1.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:a0f27f01bee51861392bb6b7c4fdb290b27d1eb194e9e28788d68102a0e898d9", size = 288059, upload-time = "2026-05-18T04:32:07.937Z" }, + { url = "https://files.pythonhosted.org/packages/1b/8d/0a85e395398d8d20fadfe5c5d32c726eee17a519e78fb356f2cf7531bffe/watchfiles-1.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:3651aa7058595e9cfb75d35dd5ada2bf9f48a5b8a0f3562821d3e210c507e077", size = 280186, upload-time = "2026-05-18T04:31:54.484Z" }, + { url = "https://files.pythonhosted.org/packages/37/68/36db056f1fdcc5f07302f56e631774d6835bcd6fa3ace402304621d5f9e5/watchfiles-1.2.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:faea288b6f0ab1902ef08f4ca6de005dccf856c4e0c4f21b8c5fce02d90a1b08", size = 399031, upload-time = "2026-05-18T04:30:44.576Z" }, + { url = "https://files.pythonhosted.org/packages/c1/64/01a9d6f66a82a5c101ce939274106cc72759d62427e153f01edd2b9f87c2/watchfiles-1.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:01859b11fd9fbca670f4d5da00fbac282cfea9bd67a2125d8b2833a3b5617ea9", size = 391205, upload-time = "2026-05-18T04:30:25.413Z" }, + { url = "https://files.pythonhosted.org/packages/84/2c/0a44fe058cb4bb7b8ede6b6670698bbb7c0400740e378d00022189b7b31d/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fff610d7bb2256a317bb1e96f0d7862c7aa8076733ee5df0fd41bbe76a24a4f4", size = 451892, upload-time = "2026-05-18T04:32:14.005Z" }, + { url = "https://files.pythonhosted.org/packages/67/a1/351e0d56cd35e6488b5c8b4fb11a809a5bc923e8fe8fed9faf8920be0c89/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b141a4891c995a039cd89e9a49e62df1dc8a559a5d1a6e4c7106d16c12777a55", size = 458867, upload-time = "2026-05-18T04:31:22.279Z" }, + { url = "https://files.pythonhosted.org/packages/d5/7d/9d09605187f1b838998624049fcf8bf47b73c1a3b76901fcac1782f62277/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f22943b7770483f6ea0721c6b11d022947a98eb0acae14694de034f4d0d38925", size = 490217, upload-time = "2026-05-18T04:31:43.657Z" }, + { url = "https://files.pythonhosted.org/packages/60/5d/a17a16eccb182f04188cd308ec24b1a71a9b5c4e7098269cf35d9fa56d02/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1bc6195825b7dcd217968bb1f801a60fd4c16e8eeab5bedc7fe917d7d5995ab4", size = 571458, upload-time = "2026-05-18T04:32:11.875Z" }, + { url = "https://files.pythonhosted.org/packages/d3/3d/4dd457062083ab1938e5dfd45032eb425cee2ac817287ca8ff4356183e5d/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d4a4b147f5dca2a5d325a06a832fb43f345751adfbc63204aec30e0d9ca965a2", size = 464707, upload-time = "2026-05-18T04:30:43.492Z" }, + { url = "https://files.pythonhosted.org/packages/c6/71/ea8c57b128f5383de74d0c7d2d9c57ad7c9a65a930c451bd25d524b295b7/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4543579a9bdb0c9560039b4ffddbdb39545707659fbc430ce4c10f3f68d557f9", size = 454663, upload-time = "2026-05-18T04:30:16.061Z" }, + { url = "https://files.pythonhosted.org/packages/53/fd/2e812bf938406d7db351f0703ddd3fc6c061cf30d96153a77bc79a943a44/watchfiles-1.2.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:20aa0e708b920bde876a4aa82dc7dd6ebea228a63a67cda6632c2fc87b787efa", size = 463537, upload-time = "2026-05-18T04:31:44.9Z" }, + { url = "https://files.pythonhosted.org/packages/86/56/d17a7f1dd1bc3035f1072694a551301272f1739c2d8e319c927cb9e29b38/watchfiles-1.2.0-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:d413349d565dab74297f2a63e84a097936be69bf8f3b3801f27f380e32040f44", size = 629194, upload-time = "2026-05-18T04:31:14.141Z" }, + { url = "https://files.pythonhosted.org/packages/be/06/f1ff66bf5cae50aa4062779a0ecd0bbaf15e466195719074078947d9a17d/watchfiles-1.2.0-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:f28b2725eb8cce327b9b3ab02415c853011dc55c95832fe90de6bc56f5315f72", size = 656194, upload-time = "2026-05-18T04:31:47.14Z" }, + { url = "https://files.pythonhosted.org/packages/e7/54/a9c7ea9a82a4ac65e7004c0a03920b5cdd2f9c3b678757d9cd425aa51d53/watchfiles-1.2.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:b8c8358484d5fa12ef34f05b7f4168eaf1932f408725ff6d023c33ec17bd79d4", size = 400205, upload-time = "2026-05-18T04:32:05.153Z" }, + { url = "https://files.pythonhosted.org/packages/aa/5d/c9ab3534374a4a67450696905d6ef16a04405448b8dc52bd752ae50423d4/watchfiles-1.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9f04b092229ad2c50126dd3c922c8822e51e605993764a33058d4a791ab42281", size = 392508, upload-time = "2026-05-18T04:30:54.849Z" }, + { url = "https://files.pythonhosted.org/packages/26/ca/1ad30103535cf0cecd7b993e8d50edc5351b1820e38f2d22e3df58962feb/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7a7ce236284f002a156f70add88efe5c70879cccbb658be0822c54b1306fc09d", size = 452448, upload-time = "2026-05-18T04:30:53.727Z" }, + { url = "https://files.pythonhosted.org/packages/37/a1/ceee2cdf2afbd715fa07758d39c9859513eae411b23196f7fd039e5feedd/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b9909cc2b48468b575eefa944919e1fe8a36c5849d5c7c168f80a8c1db69398e", size = 459605, upload-time = "2026-05-18T04:30:23.312Z" }, + { url = "https://files.pythonhosted.org/packages/e8/f6/421e30fd1cb3907a84ed92ab3f1983e37ba2dca015e9a894a048418417a2/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0a37faaed405c67e28e6be45a1fa4f206ef5a2860f27c237db9fa30704c38242", size = 490757, upload-time = "2026-05-18T04:30:47.358Z" }, + { url = "https://files.pythonhosted.org/packages/41/b0/55ed1b97ed08be7bba6f9a541cac15f2a858e1d74d2b07b6da70a82aab00/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9649193aa27bd9ff2e80ff29bfaa93085496c7a3a377592823cc58b77ee88add", size = 568672, upload-time = "2026-05-18T04:30:38.915Z" }, + { url = "https://files.pythonhosted.org/packages/d1/cf/d8ae8a80dd7bafab395ea7681c10237311bbf34d37704a8c744e7cf31fc7/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e4ff8e37f99cf1da89e255e07c9c4b37c214038c4283707bdec308cb1b0ea1f", size = 464197, upload-time = "2026-05-18T04:30:09.914Z" }, + { url = "https://files.pythonhosted.org/packages/7c/8a/3076c496ca8dafe0e8cd03fcebdfc47be4b1174b4e5b24ff6e396e6b3af2/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:054dc20fd2e3132b4c3883b4a00d72fd6e1f56fdaf89fccd12e8057d74cd74d7", size = 453181, upload-time = "2026-05-18T04:30:14.829Z" }, + { url = "https://files.pythonhosted.org/packages/e5/10/9745e17c98e7b8a86454df0a3c7b5686bd650383f1e9f26e4ebcbd6cc0c0/watchfiles-1.2.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:e140ed30ebde76796b686e67c182cff10ea2fbab186fafd1560f74bb5a473a6e", size = 465109, upload-time = "2026-05-18T04:30:28.123Z" }, + { url = "https://files.pythonhosted.org/packages/8f/95/8ef4a95481d3e0cb52d62a06fa6e972e81424be2d9698b91a2fecca9904c/watchfiles-1.2.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:bb7e52ecf68ba46d22df23467b87cffeb2146908aa523ebfe803019618cfda06", size = 630653, upload-time = "2026-05-18T04:31:49.304Z" }, + { url = "https://files.pythonhosted.org/packages/fd/e4/3b3bf36b0f829b50c6ebcb8d031583863c59f923d6a6af3d485e470d0fac/watchfiles-1.2.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:23282a321c8baf9b3a3c4afff673f9fe65eb7fdc2338d765ccad9d3d1916a5ba", size = 657838, upload-time = "2026-05-18T04:31:06.497Z" }, + { url = "https://files.pythonhosted.org/packages/21/b1/6cbbb50c1f3002ab568777d44aa21206dfb8807a840990c4037523b51812/watchfiles-1.2.0-cp314-cp314-win32.whl", hash = "sha256:c0db965c5f79aa49fe672d297cf1febc5ad149b658594944f49a54a2b96270a7", size = 275108, upload-time = "2026-05-18T04:30:06.891Z" }, + { url = "https://files.pythonhosted.org/packages/92/45/190ce6db8dcb4536682cf75d3889ff1a27182a58cb519d343cb6d9ea63d8/watchfiles-1.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:71283b39fd17e5408eb123bd37aeecfd9d54c81fc184421943208aadb879d103", size = 288441, upload-time = "2026-05-18T04:32:12.901Z" }, + { url = "https://files.pythonhosted.org/packages/74/0d/3eae1c2313ab08378431d907c3f8095ecca00f3eda33111cf4f0f2591799/watchfiles-1.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:c5c19526f4e54a00f2666a6c0e9e40d582c09e865055ea7378bf0009aab857b3", size = 280684, upload-time = "2026-05-18T04:31:26.902Z" }, + { url = "https://files.pythonhosted.org/packages/b1/75/fb64e6c25d6b5ca636d03df34ffb1c6e9873303e76d27967e045f8df088f/watchfiles-1.2.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:d73a585accffa5ae39c17264c36ec3166d2fad7000c780f5ef83b2722afb9dd2", size = 398857, upload-time = "2026-05-18T04:32:17.108Z" }, + { url = "https://files.pythonhosted.org/packages/73/4e/9f7adf01754cbf81843722ccfec169d8f26c69778281a302855cecd2ee08/watchfiles-1.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ae99b14c5f21e026e0e9d96f40e07d8570ebee6cafd9d8fc318354606daa7a28", size = 392413, upload-time = "2026-05-18T04:31:07.911Z" }, + { url = "https://files.pythonhosted.org/packages/47/c8/bec626bcc2d69f44b9acb24ce7d60ed7b16b73628eea747fcbd169d8edda/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4429f3b105524a10b72c3a819b091c495d2811d419c1e1e8df773a5a5974f831", size = 452409, upload-time = "2026-05-18T04:31:20.142Z" }, + { url = "https://files.pythonhosted.org/packages/00/b7/b6362068e81e7c556d155a34c35d40ac3ef42d747b06d7f6e5bf58e359c2/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:43d818978d06062d9b22c4fab2ebe44cf5213d42dc8e62bda8c2760cfa2eeb33", size = 458827, upload-time = "2026-05-18T04:32:06.219Z" }, + { url = "https://files.pythonhosted.org/packages/67/f8/9a813fa42afb1e0b4625e75f0479826644d3ee8dc287e093799bc01f390c/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b9f732dc58b2dbe69e464ccf8fff7a03b0dd0be439da4c0720d3558527d3d6b4", size = 490104, upload-time = "2026-05-18T04:31:56.034Z" }, + { url = "https://files.pythonhosted.org/packages/2f/bf/27dfb6094ca4c9aad21298b5525b6c53cb36121ee454331d05161e58d130/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8f200104103feb097de4cab8fe4f5dd18a2026934c7dea98c55a2f5fd6d5a33b", size = 571360, upload-time = "2026-05-18T04:31:57.133Z" }, + { url = "https://files.pythonhosted.org/packages/fb/39/44a096d67270ea93df91d33877dbe91fbda3aa4f8ec2edf799d93eda8736/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:63ac26eefbf4af1741247d6fb68b11c49a25b2f7413fbd318a83a12aaa9cf666", size = 464644, upload-time = "2026-05-18T04:30:57.33Z" }, + { url = "https://files.pythonhosted.org/packages/0e/80/c7472203bad6268e3ef1ad260739704847898938ad7ea8b63a5131f46b50/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c4997d4e4a55f0d02b6cde327322daf3a0400e5df6c6b15948994bf72497925", size = 454771, upload-time = "2026-05-18T04:30:48.736Z" }, + { url = "https://files.pythonhosted.org/packages/51/cf/3b10b268b4b7f0fc26e9debb5eef1998b515887840f444cd3ec80c688755/watchfiles-1.2.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:4c887eba18b7945ac73067a8b4a66f21cd46c2539b2bc68588f7be6c7eb6d26b", size = 463494, upload-time = "2026-05-18T04:31:33.826Z" }, + { url = "https://files.pythonhosted.org/packages/3d/3e/a4302545cd589262a0dc7d140e86f7688eba3f9c72776c27f7e23b8864c4/watchfiles-1.2.0-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:3416ff151bb6b5a8d8d11664974fbef4d9305b9b2957839ab5a270468fd8df30", size = 629383, upload-time = "2026-05-18T04:31:15.596Z" }, + { url = "https://files.pythonhosted.org/packages/db/99/d5649df0a9a410d45b7c882304d0b790903ac9b6e8f2cfd12114e0c6b9f2/watchfiles-1.2.0-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:0e831a271c035d89789cffc386b6aa1375f39f1cd25eb7ca0997e4970d152fc5", size = 656093, upload-time = "2026-05-18T04:31:58.707Z" }, + { url = "https://files.pythonhosted.org/packages/92/b9/362702539275019a54dd2e94511b31a9b89c5f9e6a21966de7eb692549fc/watchfiles-1.2.0-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:37a6721cdf3f65dbb13aa9503510ccb4451603ac837e44d265d7992a597e1374", size = 400109, upload-time = "2026-05-18T04:31:16.879Z" }, + { url = "https://files.pythonhosted.org/packages/8f/75/71d5ba62db781e5587bded1d944c675374bc4aa37ff33d5018d98e8b6538/watchfiles-1.2.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:2b37d10b5a63bd4d87e18472d80fa525bd670586fae62e5dd580452764879b65", size = 392167, upload-time = "2026-05-18T04:31:28.058Z" }, + { url = "https://files.pythonhosted.org/packages/3c/01/c66dd95d0423fe30d31820e2d1d5bda773764131bbb6ac0cb1cf303ac328/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a105bc2283f67e8fbec74253ec2d94925de92ed72c0393f1206bf326b7b7b69", size = 452372, upload-time = "2026-05-18T04:31:00.836Z" }, + { url = "https://files.pythonhosted.org/packages/91/15/2fe99557e72f85627c6a8eed50d889e8d101623e060a22ad75b875cb932d/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5327989a465505f05cfe06f04fa9d0c2fd5432bb243e10e6f012b1bdca3c8579", size = 459596, upload-time = "2026-05-18T04:31:34.96Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/d4acfa0023367428ed48351b3b9b267893037b6cadae55620c61c24bcfd4/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ecb47f183a8025b2aa18b546725c3657e542112ae9c0613a2af79b4fa8d04ad7", size = 490869, upload-time = "2026-05-18T04:31:59.923Z" }, + { url = "https://files.pythonhosted.org/packages/a4/5f/3164cbdce06c9fb95c4f7b9e2f9760b5e2797af43a9ecc317ef42a23a278/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8520a4ab0e37f770afc34459c4f8f7019e153f9124dc101c15538365875d1ab2", size = 571641, upload-time = "2026-05-18T04:32:00.948Z" }, + { url = "https://files.pythonhosted.org/packages/41/e6/85d3731c55e65cd7690f3f803d24c139588aaf863e4bf2148fe7a7fa1a19/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:71cd71740ed2c15211ebb237ced4e39a1cdf6f80566e5fe95428da1626f4fde6", size = 464444, upload-time = "2026-05-18T04:30:34.298Z" }, + { url = "https://files.pythonhosted.org/packages/f4/7d/562641012b8b09872742c3b8adf9629ec479fd78f8d68ae4a0c13da8add6/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f88af53d6ddaf72179ef613ddc905e6f4785f712b49b80b3bef9f3525e6194b4", size = 453593, upload-time = "2026-05-18T04:31:23.464Z" }, + { url = "https://files.pythonhosted.org/packages/56/fe/cb8ef3d6f929d14158fdaaad9925985b7310abc9384dcd4d82dd0016fb59/watchfiles-1.2.0-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:cee9d5efd929efdac5f7e58f72b3376f676b64050a91c5b99a7094c5b2317488", size = 465096, upload-time = "2026-05-18T04:31:30.384Z" }, + { url = "https://files.pythonhosted.org/packages/25/91/80908e835e100527a9267147b08c0eee1fa6ab0ffec15edc04d1d44885f7/watchfiles-1.2.0-cp315-cp315-musllinux_1_1_aarch64.whl", hash = "sha256:b718bf356bbc15e559bd8ef41782b573b8ae0e3f177ab244b440568d7ea02cfb", size = 630638, upload-time = "2026-05-18T04:30:49.89Z" }, + { url = "https://files.pythonhosted.org/packages/46/4b/95ab2f256bb4af3cb2eb23b9317bda984ee6e0f11733a5c004a6c95b06e3/watchfiles-1.2.0-cp315-cp315-musllinux_1_1_x86_64.whl", hash = "sha256:922c0e019fe68b3ae392965a766b02a71ba1168c932cebc3733cd52c5fe5b377", size = 657684, upload-time = "2026-05-18T04:31:32.027Z" }, +] + +[[package]] +name = "websockets" +version = "17.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/18/72/fba934cb3dff7a85d811820efffcd141ddd52b5a2a01637f64551373ff4d/websockets-17.1.tar.gz", hash = "sha256:acfea4c20bf54384883ea33b1240fc1db4f52e190823a4e2b334bc3e8bfca96a", size = 187520, upload-time = "2026-08-26T17:25:33.063Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a6/0d/098f23c4c858e5de9459ffc554fa07d5493fbcfca7f040b5800cf1cecc35/websockets-17.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:76dd004f59115087c7b700474cb18f01325e37250032e19396c08ae41448e4b3", size = 217015, upload-time = "2026-08-26T14:55:45.194Z" }, + { url = "https://files.pythonhosted.org/packages/13/86/bc1317b1a4d8c4688e2a7e564b5e004dab44c2534d7ca05de6ae9a863fca/websockets-17.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:581fa678ef46f4277cc8491312468e582f8ad609dbab907ba6096a08c6a0ff98", size = 214692, upload-time = "2026-08-26T14:55:46.366Z" }, + { url = "https://files.pythonhosted.org/packages/8f/e7/df821761772beaa48c211ee0e234930b35c1473778470773823f56d3911b/websockets-17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:87f0d5e77548b0c40c8464cdb6108792e7e53f487c6400028a4ec28a8afbe5ab", size = 214959, upload-time = "2026-08-26T14:55:47.885Z" }, + { url = "https://files.pythonhosted.org/packages/3e/92/c3fb72f11764812fc648bf3838d224972427b348e8b3989d9e0a9df87da3/websockets-17.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:882af300d2c6a092b93767d5de03c7bb56dfb06314140c8e872d3f48e09f7b74", size = 224278, upload-time = "2026-08-26T14:55:49.241Z" }, + { url = "https://files.pythonhosted.org/packages/fb/05/9f82d090c8d2d861604147ef6dfb938a90b039f9358d5193f1df62558593/websockets-17.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0c863507ada5805517ca6dff1c524dcd42942efe6304dacf06700878398d21a6", size = 224557, upload-time = "2026-08-26T14:55:50.348Z" }, + { url = "https://files.pythonhosted.org/packages/8a/50/5cbf677b865290fe36819ff00615826e7edc1df38786f770123ff39a933d/websockets-17.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d41ef69d5416fbc1d98cf96c37be6192d10fd101c3e0f8b3ddc36e09432b3c08", size = 225791, upload-time = "2026-08-26T14:55:51.75Z" }, + { url = "https://files.pythonhosted.org/packages/c1/1c/eb8a032285243381b09a221ae384c972d5000453ad136add4d1595cec798/websockets-17.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5aefe78e6a3077fe22b5e64b04666a85a3eb8b934d40e8595a693adcbceb6f11", size = 228574, upload-time = "2026-08-26T14:55:52.922Z" }, + { url = "https://files.pythonhosted.org/packages/69/85/413736251cb3ac04ce84cbd90e893d9a36a9698d4820b323aff3aa187e50/websockets-17.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f64e001bb7fa89b9f32cfa600bf8e9ac8ca26759d9b92ae01453ee303d9cd7b4", size = 226428, upload-time = "2026-08-26T14:55:54.263Z" }, + { url = "https://files.pythonhosted.org/packages/d2/2b/a08bcc7fa1ca81a10f84ba32b6e6edd73a913f4b0c2640eed1fd626efacd/websockets-17.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:677014a073bcb1fbaa7e21144786864f16c08f856d66834f611eceb9006cbab8", size = 225184, upload-time = "2026-08-26T14:55:55.943Z" }, + { url = "https://files.pythonhosted.org/packages/e5/8a/3bd2d0cf6b148c8c866d5d9fdcde30c04bfd81fdfac86813e69377eb4448/websockets-17.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0de501b7f2db11e83739ac20e2d33d46da4604b829f506c24be80e7def069391", size = 222430, upload-time = "2026-08-26T14:55:57.103Z" }, + { url = "https://files.pythonhosted.org/packages/3b/c9/8e891ae342668735eabbbc669895e15195e4b45f24a4beeb58af76f414c7/websockets-17.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f62114a54117e4948a1e414e89521f7fe1e3c2f83f2a571a06a4fc6718b0900a", size = 225227, upload-time = "2026-08-26T14:55:58.375Z" }, + { url = "https://files.pythonhosted.org/packages/e1/6f/c816f332dca11425e9bda7c07f7573eb5c5f8a735849d02b0d81e8ee20fa/websockets-17.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:eec113a5b41d124ef42ff56b0d74a6da3fd986400038eab9e58ee42a4024e837", size = 223831, upload-time = "2026-08-26T14:55:59.664Z" }, + { url = "https://files.pythonhosted.org/packages/53/67/5e91d5308ce24fc1ec74f56536c12f4888bad45ff5ea50f3180f8c518c57/websockets-17.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5f051f8030a51815dc00e24bd2e5f1435af095c1cc111d747ac6e2a3620d7641", size = 224600, upload-time = "2026-08-26T14:56:00.873Z" }, + { url = "https://files.pythonhosted.org/packages/bb/96/faa298ecf2570d35b0eb37caddf4992178d907e108ed74bfffb6bc092c29/websockets-17.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:655a8e28010f09fd6fa317e857afab3af7647f33e41dee88fa421e92086d1090", size = 225707, upload-time = "2026-08-26T14:56:02.001Z" }, + { url = "https://files.pythonhosted.org/packages/0b/12/5710d2482ca5061c1eec5eb46f6313837c760d4115b1795c85b6c08be4e3/websockets-17.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:dc2b79afc074d2f3e64b26539350f697fe1b85ea1c49ea24eb588f247b053ce1", size = 223263, upload-time = "2026-08-26T14:56:03.092Z" }, + { url = "https://files.pythonhosted.org/packages/27/47/0c30f4eebfd1d93fae779d268f678d48847fb98516f5200849574eee8820/websockets-17.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:e4bd7eacb87d8cf3ed70d6392c770a0d92441f05d7d2a3efafb5bc171d5e3067", size = 224244, upload-time = "2026-08-26T14:56:04.321Z" }, + { url = "https://files.pythonhosted.org/packages/41/33/46c256195a1255079ae23d1b1267b2e1843dc5f46a67f973cdf2a3523dff/websockets-17.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ccbf3f4a9890d50b3a08ee04029fde30a03bfdeffaa19977628bf17251764e60", size = 224520, upload-time = "2026-08-26T14:56:05.521Z" }, + { url = "https://files.pythonhosted.org/packages/06/9a/aef0792731df4352e5f417369b532b3325fe434765ca90c193f594ae1e67/websockets-17.1-cp312-cp312-win32.whl", hash = "sha256:7e724f843fa6a0614aece65a7c73e51d0f4412ca41dccac13c3caf98e69536bb", size = 217485, upload-time = "2026-08-26T14:56:06.715Z" }, + { url = "https://files.pythonhosted.org/packages/50/23/493ecfdaf32898e5ea24dc900e33e5e317f9662d5d9ab2d44b2e111b4e1c/websockets-17.1-cp312-cp312-win_amd64.whl", hash = "sha256:617243e19a0992095956f406ee9cd3bc4ba92862d83cb1d83bb59ce574412bec", size = 217786, upload-time = "2026-08-26T14:56:08.055Z" }, + { url = "https://files.pythonhosted.org/packages/97/3d/91954e2f7876f74ce1213e9b92c65a63b559cc4b942a931ebeb351cd9932/websockets-17.1-cp312-cp312-win_arm64.whl", hash = "sha256:9f4a08ff7cb68c27b18e09223cc6304e01d0f82d5a240d251266dfd2e6e44729", size = 217711, upload-time = "2026-08-26T14:56:09.267Z" }, + { url = "https://files.pythonhosted.org/packages/1d/31/5f6450a7879f4f063ef08897cc385ea3ce3f1fe17f08b11e3fd959abdf27/websockets-17.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2a0162a6372110a5601cb5c9fd826635cedf69f3e110c545dd19774e040b970e", size = 217006, upload-time = "2026-08-26T14:56:10.509Z" }, + { url = "https://files.pythonhosted.org/packages/d0/2a/c1b006fc861695d2aa4e35327b842015ce1d98cf8f99241829b3d6460bfc/websockets-17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:829dba1bc049779de9b332088c1a6a9858e96bd67e50b6b644a95e02b67836bc", size = 214690, upload-time = "2026-08-26T14:56:11.681Z" }, + { url = "https://files.pythonhosted.org/packages/46/69/66e5b7d01445e0eeb1d4ab419c30315f2c90cf7a8a8cd4ecc47f894dba54/websockets-17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fd8f47dbf2e8adb15c847215f83436de3fdb120b51fdae0fbbdf69fd97a3ad80", size = 214947, upload-time = "2026-08-26T14:56:12.923Z" }, + { url = "https://files.pythonhosted.org/packages/07/ce/033cafe2d2538562efa876b9149a2c7a0f7787870a4b1bb6e28adc9ceb6b/websockets-17.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:9f4c0377a83e163a303514fdfab501dbe379bdc13e5b9312a91d112658b29dce", size = 224329, upload-time = "2026-08-26T14:56:14.212Z" }, + { url = "https://files.pythonhosted.org/packages/34/c7/e1c2e8a67f6cc0aa43abe0046fb3b7a020980649e6a843751dc7ce9eb170/websockets-17.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c3241d684a76eaaef8b2dc789afde4343cd3aad55ea81e4e8ab3605b529bae51", size = 224611, upload-time = "2026-08-26T14:56:15.702Z" }, + { url = "https://files.pythonhosted.org/packages/be/de/07c6d48eb3d2069709410c851e7de10ab83d752c4bd09862899627c2729b/websockets-17.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e5f5c7a893507d0e83a80b88aefd6522f7e882cd53f9722c6f23f5a020c9557c", size = 225848, upload-time = "2026-08-26T14:56:16.962Z" }, + { url = "https://files.pythonhosted.org/packages/f3/dd/3c68572d20509648cc2fb6f50ccf3deeb4b87270f2c8966e99476e278ea3/websockets-17.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:00bf34b64501e3477e81fc281532ff3cbf4da26633c10b63979d5085d46602d3", size = 227290, upload-time = "2026-08-26T14:56:18.204Z" }, + { url = "https://files.pythonhosted.org/packages/0a/4a/8f6651c8a22093539c9215af0c5bbf217b87b382c99d2112039b92d593c2/websockets-17.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ce0305b702b20d1e1d60a9aaace6bc89970e1753565543f310d549eab22c2435", size = 226476, upload-time = "2026-08-26T14:56:19.459Z" }, + { url = "https://files.pythonhosted.org/packages/f5/be/f6fc33cea86b1127fd1297b18c107e81580ab55a73a39f9a934441ef321f/websockets-17.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29176d8b429cfa0fa443c473878d37a5c06cfd0cb36b71ba4314accc71e05906", size = 225233, upload-time = "2026-08-26T14:56:20.939Z" }, + { url = "https://files.pythonhosted.org/packages/cb/83/65edaf05f7c9b1dea82f4d252fdc37706a84571646f06119a27b0a16fe19/websockets-17.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3709a1ab30b4b922027d22f68d2b61a0656a91680ac894a537624e6be7dd7f7c", size = 222488, upload-time = "2026-08-26T14:56:22.208Z" }, + { url = "https://files.pythonhosted.org/packages/07/42/d1169c2f7f1f0032b0d4b0c00f0711a070cd7c735de37bfeb876bc0f9606/websockets-17.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:43bd0c1ceb924d67f5c1a5254d8361dd9d94246e6331a726064dfa2917880780", size = 225295, upload-time = "2026-08-26T14:56:23.445Z" }, + { url = "https://files.pythonhosted.org/packages/a6/f4/64e2a386c3899b917c2933225c9b47887874229d159797f3bf1a11c20d51/websockets-17.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:1fce0f43e0d41422e0b2cad6561e1970df22f212f4c7e884967df7cf591b031c", size = 223891, upload-time = "2026-08-26T14:56:24.647Z" }, + { url = "https://files.pythonhosted.org/packages/26/b3/dfb5c482f7e310a3432fdbb045ddfe6d34114680e89a233d4ff900a32961/websockets-17.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:4031152769179ab8dcdeafc7b0e58052a49117560a28671700b47b2c7b717aad", size = 224661, upload-time = "2026-08-26T14:56:26.027Z" }, + { url = "https://files.pythonhosted.org/packages/a4/cf/94865130a336029f46412adc127c4fbe380f46172b90ce251369e35c4302/websockets-17.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:a06f3b5085176763182449559e20391d7ce616a8972a9f7a33deda87ea6d4f3c", size = 225766, upload-time = "2026-08-26T14:56:27.455Z" }, + { url = "https://files.pythonhosted.org/packages/96/34/eb8c658f86dfe562ed49a887a27424bfe9e618c26ea6f865b093d075d3a6/websockets-17.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:77b37cceca17291897c3c73bd30a7c7c7909593554b5da574ec852af83c1742a", size = 223323, upload-time = "2026-08-26T14:56:28.807Z" }, + { url = "https://files.pythonhosted.org/packages/1b/7e/2629609652ece5ca0c7ac235927dd4511b08131e3a5d53439b798fddf002/websockets-17.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:d8e83333385cac6030a5167fd18bf96cc6c58b914c308e683f05b0cf94bc8dd0", size = 224276, upload-time = "2026-08-26T14:56:29.991Z" }, + { url = "https://files.pythonhosted.org/packages/a1/6b/8525737fe840b38e5f40956c198fb586a4fac1e07144d41a5b949b989cf8/websockets-17.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:073c5c3f7e127041fa9d34a9e29ceefee8c3cafbd267ed2927318f425144380d", size = 224558, upload-time = "2026-08-26T14:56:31.184Z" }, + { url = "https://files.pythonhosted.org/packages/74/ab/3a958c6cbcf74b118f601c20a80ac8bd5e8dfec0bcf7345116feaeefb121/websockets-17.1-cp313-cp313-win32.whl", hash = "sha256:2afb58c7ba48b329d56769f8dfd89f394efe587b65ef806bae810a484d6d3608", size = 217475, upload-time = "2026-08-26T14:56:32.431Z" }, + { url = "https://files.pythonhosted.org/packages/22/36/fb521f0f2994c25509651f169efe5582dddd8713d57a0757ba87859372ef/websockets-17.1-cp313-cp313-win_amd64.whl", hash = "sha256:0340bbef6bfbe16da888b3983d666a4db4954ac3253c38f13bc7aba0c7db5a2f", size = 217784, upload-time = "2026-08-26T14:56:33.608Z" }, + { url = "https://files.pythonhosted.org/packages/68/92/9b8419584681a12a7534b746dfb2737c466efe2455483e2fbf8b941a04ec/websockets-17.1-cp313-cp313-win_arm64.whl", hash = "sha256:7a72efa3bf4fa3a6669a54420a472ad056da3973d827f10e3a536da463f926c2", size = 217715, upload-time = "2026-08-26T14:56:34.865Z" }, + { url = "https://files.pythonhosted.org/packages/90/0d/500cf5daea09d4669dff3a7d67159094a0bd6c4ef130381404f6edd3eb5f/websockets-17.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:0c9982938980e086da59f70d05f9418cd143401a601a0faac10fa48f7bb1cd3e", size = 217048, upload-time = "2026-08-26T14:56:36.03Z" }, + { url = "https://files.pythonhosted.org/packages/97/12/5b12c6168aa269cffbfd24d177cd492b130120403a418c7e89462e27b4ac/websockets-17.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:57b39dc8541cf7ed3f639da82bf7451060483967f9e733da1f8173e4095f0642", size = 214737, upload-time = "2026-08-26T14:56:37.43Z" }, + { url = "https://files.pythonhosted.org/packages/0c/36/e453e5106e4e2416f008ac222837c2f1637a063b08008afcd1088889b631/websockets-17.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:96abdecbaae746851b87c3a36cb4a661df93ca3d92f114270f79228bf1d00de6", size = 214955, upload-time = "2026-08-26T14:56:38.71Z" }, + { url = "https://files.pythonhosted.org/packages/dd/30/0204bb86176db02cdfc678ce65ed808a66fab87d250ce61a8790800a60b0/websockets-17.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d9fc873e239c5abeb150bc24dbd1a7af23a9254526383ce0a077f5e20adbeb19", size = 224331, upload-time = "2026-08-26T14:56:39.924Z" }, + { url = "https://files.pythonhosted.org/packages/46/c8/d8372256e00c4e3cab1115c45075d1eeedb642a3f2b42bd70c4deae03f06/websockets-17.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6f42912fa9eb4cb7c7ec9fde9b3332ba339eb8a8811981043d4029599f3d950b", size = 224685, upload-time = "2026-08-26T14:56:41.169Z" }, + { url = "https://files.pythonhosted.org/packages/12/7d/650355b8f67f908ff99603351d4458d1a0b787d627950a47c38db7e25308/websockets-17.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f98bf378d7a5be047a044a1a27c987a8f355e10e3b5754617dbe756248cbc5ce", size = 225927, upload-time = "2026-08-26T14:56:42.359Z" }, + { url = "https://files.pythonhosted.org/packages/34/6c/a9ffa5b903579eed76017870f055d75ecc73988d9d0c9b65a92ba0bf2a27/websockets-17.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d334d11398086bb5559606cb42d51c013ea7c061c7db701521392373d3c087f5", size = 227300, upload-time = "2026-08-26T14:56:43.538Z" }, + { url = "https://files.pythonhosted.org/packages/9b/5d/4551c2269066af7481ee44605a0813770961615b5b5da3e87a8f5cb859ea/websockets-17.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5c27336b1a0ac56569493e858497870347854372395f50483725f8cdacc5a45c", size = 226533, upload-time = "2026-08-26T14:56:44.669Z" }, + { url = "https://files.pythonhosted.org/packages/3c/43/237a99233e5c445759a613831b3a92e91905afc064dc3bd0ad33c35fd1e2/websockets-17.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:67258b00302a5aaf0b267771c7014b13429abd7ea17eebc4c55bd935ff101555", size = 225280, upload-time = "2026-08-26T14:56:45.83Z" }, + { url = "https://files.pythonhosted.org/packages/d3/b5/e9407a91613d1d1cd932414143a1012096b26674a782fc55a0bd23217ee4/websockets-17.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:455ffeea0879d313205df1e745e5883e1feb7f31ecd26be882f5f0babd3db04f", size = 222540, upload-time = "2026-08-26T14:56:47.053Z" }, + { url = "https://files.pythonhosted.org/packages/db/d2/db76628db0577b783205d9779f64d8e373416b04c62d1546be4b75dc8540/websockets-17.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f7233eaf441a345a5943a929fd4b5ea3278f11aed35a9ed0f3106b8cb3ca846a", size = 225354, upload-time = "2026-08-26T14:56:48.32Z" }, + { url = "https://files.pythonhosted.org/packages/a9/4c/2174181c067b89a74ae18e2650c2ac29959f4b796afe876ab3f4d30d642c/websockets-17.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:c65da239a5ad553619804c1f9d65c1a0b3005381c6158ee14da2c7444cbd0c78", size = 223867, upload-time = "2026-08-26T14:56:49.579Z" }, + { url = "https://files.pythonhosted.org/packages/df/75/274decb9a8253561b5be3261e02a6676fc8ecdf31e95b722e53d5bfb8fd2/websockets-17.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:9fa1ffa08c81a4f809cdab6129f8e55bee4650b9d6d3461019dda73aacd146b6", size = 224652, upload-time = "2026-08-26T14:56:50.885Z" }, + { url = "https://files.pythonhosted.org/packages/9f/e6/49824f1fb4db7656d2f7492b1d8be16147b759d909490e32f4776843ee64/websockets-17.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:406b8107943a43ef4649b1e0cb0cdc052bbf08fe1c8905a623c4af9586e5cebb", size = 225822, upload-time = "2026-08-26T14:56:52.356Z" }, + { url = "https://files.pythonhosted.org/packages/b8/6a/5dc43838c0b02a95f42c47a0de33c5ddd7767a9feeb4d0d8777ac1cfefe4/websockets-17.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:4e8ffcb486c8490a34a4cef5e4409d8da5a1cb1681e5bf7d786ce5e84aa8540d", size = 223379, upload-time = "2026-08-26T14:56:53.699Z" }, + { url = "https://files.pythonhosted.org/packages/c2/62/585637cf06d6b321232f79c55dc14d65518d12cf87c94c44f5864068810e/websockets-17.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:fb88076df585b69c5761c387c0081aa87d7b9eb1b205a6535ca4777e25650d81", size = 224330, upload-time = "2026-08-26T14:56:55.184Z" }, + { url = "https://files.pythonhosted.org/packages/de/68/c3b234a6a1366b6ab5bbfaa4434a1b946e1dc4e8ddd6824bfd93a8835b7f/websockets-17.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5d4724255fb8398acd9e583b97eb2279cec20e0bd0f9a94bf75f6056ef9f13da", size = 224622, upload-time = "2026-08-26T14:56:56.393Z" }, + { url = "https://files.pythonhosted.org/packages/6a/d4/84cf3d1376f5d8207f55f43c1c818babd6b89447f5dcd01f18a6d5526796/websockets-17.1-cp314-cp314-win32.whl", hash = "sha256:be3f0129c5654517b2abf07dcb75bb1d9479759a4ccfb569e8293579e9fc029a", size = 217036, upload-time = "2026-08-26T14:56:57.652Z" }, + { url = "https://files.pythonhosted.org/packages/d0/0f/9e7ac63c5d7cb642952200814f584318e65146df008b7d375d5d9c6b2c97/websockets-17.1-cp314-cp314-win_amd64.whl", hash = "sha256:2a4dc6ef83f4559e0d05f313a375cb38f63c986096a9da99fe94fdd779d313e5", size = 217382, upload-time = "2026-08-26T14:56:59.065Z" }, + { url = "https://files.pythonhosted.org/packages/54/bb/1ae6b91f7f3ac05f5c9f14a72dc2181c115ff370bcd8a7f10f02c174adfd/websockets-17.1-cp314-cp314-win_arm64.whl", hash = "sha256:46c0331c9eaaf73a559f3a9e388466be0df96eb83d40f06f1ca6ab6613b35c82", size = 217268, upload-time = "2026-08-26T14:57:00.654Z" }, + { url = "https://files.pythonhosted.org/packages/b3/f0/f65644d0e0b2b90918a8c41503841cc4072a58f2bf76c09bc36e751fc0dd/websockets-17.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:d411ea5ca18ac1b12c0c94be88b60c18ca641ac43bcdfdf1c9f79d46cdbe1603", size = 217379, upload-time = "2026-08-26T14:57:02.181Z" }, + { url = "https://files.pythonhosted.org/packages/ff/35/4c46d1f620ac1a30f92b6eae78ee40a772a93f568647ca7ccdc5ea283cf8/websockets-17.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:07fa3e7c30e2c577928d359b56bf872a3e0cbcc15553eaa0907c1ee86344b56f", size = 214911, upload-time = "2026-08-26T14:57:03.478Z" }, + { url = "https://files.pythonhosted.org/packages/04/6e/4587e8406d7c1188e97b9cf466c081e93399380d447f885bfce81626cd37/websockets-17.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6de9acef07e3a78e9567fcd26c29011a4da8f050b13004bbf880a0fd82a6eea5", size = 215115, upload-time = "2026-08-26T14:57:04.692Z" }, + { url = "https://files.pythonhosted.org/packages/ec/06/1381c8fff525041025909eb80ace32489194a00ba22a0a8d428030afcc84/websockets-17.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:ea0ed9373b880115911d9d39634bccc95b8ce590c9c42e8589f5cacc3ef3cee2", size = 224696, upload-time = "2026-08-26T14:57:05.899Z" }, + { url = "https://files.pythonhosted.org/packages/36/9d/9034e867dc85340be058619751742b895f722326e83100d110063461ca07/websockets-17.1-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:50903d335bfda026c2fa11dd9aed09d8cbee0c451e3a85122a9acb041b7dc69b", size = 224975, upload-time = "2026-08-26T14:57:07.262Z" }, + { url = "https://files.pythonhosted.org/packages/40/eb/ed03aa3cae748ebf6397e5d44028f433f746bad09dc568ff754fda3a3c9b/websockets-17.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5a74531ce81af587f906ab42f194032388fcff8fc7938402e5917c9147a39441", size = 226151, upload-time = "2026-08-26T14:57:08.524Z" }, + { url = "https://files.pythonhosted.org/packages/b1/c9/cc1964a096d16f3b73cb1ee5f14f277f5a3bcac07c6e8f9a1dcded99f4c8/websockets-17.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8fbf28e639544503b7d1c96452a5e5e043e4108d89b1f3fa02910603622d19db", size = 228292, upload-time = "2026-08-26T14:57:09.846Z" }, + { url = "https://files.pythonhosted.org/packages/1a/26/46da6dd0363c2db2e4876fd59a40fd40c1943a82d7018d0a33afbce47d52/websockets-17.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f612dc57f00c07cf4aa2673f7cbceabd654ad2457b7e639f061b794d6e11f9fd", size = 226722, upload-time = "2026-08-26T14:57:11.118Z" }, + { url = "https://files.pythonhosted.org/packages/78/98/ecd8f5e1c5d0e54c08ebc5c66852271112166db68107cb0e17ca1bf25009/websockets-17.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1c7ac77401227212dc6e849182feee50d57cf456ec6329ffd6979c94bb136c5c", size = 225451, upload-time = "2026-08-26T14:57:12.601Z" }, + { url = "https://files.pythonhosted.org/packages/65/4d/da8d2760db53e17aae763738b6ba834b1fcf16813d3632f3edb6951e1ec8/websockets-17.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:32a2a68d989d6e5b74a9d5095415c51189ebae29fceb7cf2b64a1c0318a81256", size = 223003, upload-time = "2026-08-26T14:57:13.875Z" }, + { url = "https://files.pythonhosted.org/packages/a4/40/ea401c141a79c5b1d0021a0dab9d0df2051c108f1620fbb39a6e7c714c3b/websockets-17.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:aec00f018d34c67500ff0438dc314b40277be4a1b983cbacbf53ccf7db63e257", size = 225704, upload-time = "2026-08-26T14:57:15.091Z" }, + { url = "https://files.pythonhosted.org/packages/e1/8e/07ab3f44215d89840d5385fdcaaab1fed8caeffa67c6899e15062957c12c/websockets-17.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:0014eaff8ad5b3b43feda2279f9d34bf2eaae040720b9fbbb55944b10f40b14d", size = 224192, upload-time = "2026-08-26T14:57:16.3Z" }, + { url = "https://files.pythonhosted.org/packages/58/93/ccf1af0a23e5748d4e22292a377d78d15cf294d7e707bbb11a8990ae6bd5/websockets-17.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:db9d7ee47f3ba531e278be539af39e2c7c7d28fb94897b6cd1120d63b0ef5922", size = 225082, upload-time = "2026-08-26T14:57:17.531Z" }, + { url = "https://files.pythonhosted.org/packages/e2/db/e32200f99ce282e728d2929f2c429db353cf3282db7d0eba99eb32c9fec1/websockets-17.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:ff3e2ba7a9f0a110b0555452e9b5a03a34e11662544e01beea15f144b48ba7b7", size = 226101, upload-time = "2026-08-26T14:57:18.802Z" }, + { url = "https://files.pythonhosted.org/packages/28/3d/e7a6e9777b29433620167c98f3caaff0d6b08b1239a273ef7f7fd1393349/websockets-17.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:6da17fc94bd270f5987b10bee113461ac36a36a98b0481ddcc98056e5a90001a", size = 223794, upload-time = "2026-08-26T14:57:20.313Z" }, + { url = "https://files.pythonhosted.org/packages/48/05/ac569090726dedd6656f3ee28b0c02dfb1ba76e898dceaccc2987a237cef/websockets-17.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:e8dc3fa6d6b7ead3f9de57895f41b116a28787548e066365d9d90f7356bcaad2", size = 224567, upload-time = "2026-08-26T14:57:21.634Z" }, + { url = "https://files.pythonhosted.org/packages/14/50/4ef62941111db6b31193f4fabbb65f845a5177579040cb8fe0d774d25034/websockets-17.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b65d5fe48219dc2d5e158de9e6514e75600f379cc7e37108d35f31764c155566", size = 224993, upload-time = "2026-08-26T14:57:22.86Z" }, + { url = "https://files.pythonhosted.org/packages/28/42/2b95ada4ea19bf3a2072b68669ce4f4afb212690b727d31640576287fd68/websockets-17.1-cp314-cp314t-win32.whl", hash = "sha256:2cce251f3e2469b99b6802b55435bcdd07123b41870f54c87b336183af9d7e68", size = 217168, upload-time = "2026-08-26T14:57:24.466Z" }, + { url = "https://files.pythonhosted.org/packages/32/0a/67d5ee08dd8060a37d612fd40a625b5376ad19ae48fe1c8ad428c278b817/websockets-17.1-cp314-cp314t-win_amd64.whl", hash = "sha256:8f6c38cdcaf98a911d7acc25577f2f9e710f3a2fc2bde1563556784320196b51", size = 217508, upload-time = "2026-08-26T14:57:25.983Z" }, + { url = "https://files.pythonhosted.org/packages/76/a3/822005d0c674451d2411027b878cdc128a2b7ea5a30d337d9e279da22eba/websockets-17.1-cp314-cp314t-win_arm64.whl", hash = "sha256:d1e2f5fa2b6d01f0d85b4f223fea7ed1d504be282a02a81bd2be4817ef7a2f03", size = 217425, upload-time = "2026-08-26T14:57:27.324Z" }, + { url = "https://files.pythonhosted.org/packages/de/d5/99a6c6a1eb5d5ae9f45f59a3c97f4e3b21f310eb404a547fb3e7d2fc054c/websockets-17.1-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:88381602e379165b66244b2ebc29f9b23ea0851fbe63ae157f91ca324f072d6f", size = 216970, upload-time = "2026-08-26T14:57:28.575Z" }, + { url = "https://files.pythonhosted.org/packages/a6/0e/1e7f6e833728193958d3ed3d67b5d57c3c7cfa948abf94d4bc553257c954/websockets-17.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:88bc5138e53903a85c354e59df7ba73ce306f7b09724cef74dba121e60a88ce2", size = 214699, upload-time = "2026-08-26T14:57:29.862Z" }, + { url = "https://files.pythonhosted.org/packages/07/00/95d39549f86e34425a0412bcbe61708dd1fc46af654e2134a6c4389102ad/websockets-17.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:3546ef55b3a074494106508bc6505c73825970d2d9505f7bf53882b3e88b0d1e", size = 214927, upload-time = "2026-08-26T14:57:31.148Z" }, + { url = "https://files.pythonhosted.org/packages/4c/ff/b442415fc4f7f9943b0fc8e8eebaa13923ca73361e167c439ba634eecbd9/websockets-17.1-cp315-cp315-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:9ae55d24241fc055f22aea3ac924559069848bd0ad4ea065fdd72d2194685fe8", size = 224373, upload-time = "2026-08-26T14:57:32.833Z" }, + { url = "https://files.pythonhosted.org/packages/a8/dd/b83537aae4cf61615b9d8b2dbb235c0030ba85457a6d934798273814600f/websockets-17.1-cp315-cp315-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:d7b349265fad6244013eecd99df8d83c12bf3013943e431f4fadd5bffc37db42", size = 224801, upload-time = "2026-08-26T14:57:34.041Z" }, + { url = "https://files.pythonhosted.org/packages/76/83/5ab0abed58454909e8dbab45086ac68ee4556d7a8ada26735addc909b903/websockets-17.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dc5789e5ea182b77a38881383ada5347202a6c66f4857d054e075290e80b604b", size = 225967, upload-time = "2026-08-26T14:57:35.292Z" }, + { url = "https://files.pythonhosted.org/packages/4b/26/e2412f2b998a8c1dfc00c0709ff6ee0c634dd0b0b4f92bdfe9667876b71c/websockets-17.1-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:ce13c7d233239e739600a57d4a73c1192ad8259e655a4d55aa1a454242bc809d", size = 227664, upload-time = "2026-08-26T14:57:36.493Z" }, + { url = "https://files.pythonhosted.org/packages/ec/25/0dd4495df3c0e02f6db705312ba85ab9b2dd42257dc23eb0da10066e4844/websockets-17.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1036189bd34b0bc1b10a4679321e2c7968af317efe6e8e4c1c5141c4254fb5bb", size = 226447, upload-time = "2026-08-26T14:57:37.781Z" }, + { url = "https://files.pythonhosted.org/packages/be/67/6df3f63ffc48f08126ed0cd2fd2a41092967c3e364f8ec100deae90b6d77/websockets-17.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e78fd4b7b2c5086a38671c9c882c1e643385eccea360b5b1fda4a105e590087e", size = 225343, upload-time = "2026-08-26T14:57:39.133Z" }, + { url = "https://files.pythonhosted.org/packages/b1/8d/a8479bbb09ff054907d141123d8f52fb6ae5ac39c6dbe39e6a02a8408309/websockets-17.1-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:46e7a10bf04318c7b0c0273791925ae5e1cbe4a11e34aa934d2ef27862058a80", size = 222748, upload-time = "2026-08-26T14:57:40.478Z" }, + { url = "https://files.pythonhosted.org/packages/40/fb/4c3d2a3269cde3f3087916de9c3d9fc5d7196b46846d8c3a9ae59ad0a884/websockets-17.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:33e45c7ea38428e740a7f233555d71df0b875cef7fc080acebc9654475e35335", size = 225453, upload-time = "2026-08-26T14:57:41.859Z" }, + { url = "https://files.pythonhosted.org/packages/7f/1c/6467b401d19408f34e1c7389c222c2c7e1dfdf08c551190269b5eabc726c/websockets-17.1-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:6e63c01803be425ff062b7f7fc201a74def1d49fc94a2410dd17375df75936e9", size = 224112, upload-time = "2026-08-26T14:57:43.136Z" }, + { url = "https://files.pythonhosted.org/packages/c5/5f/744e032ac80e11039a7447657ebabb46e9b5c2dbcec83be571335212932f/websockets-17.1-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:722ec21717eec6477bce582147a28acdfe034e604239466a6a95daedb863e774", size = 224646, upload-time = "2026-08-26T14:57:44.871Z" }, + { url = "https://files.pythonhosted.org/packages/9f/47/bcb9128d9afc4d0934d9192e2a24897ca2f7a63df2654904915349c6c46d/websockets-17.1-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:e74e41f0ad12ff1e8983e349daef79d37cc8280c743ce9d134d6c74c18dab5d6", size = 225797, upload-time = "2026-08-26T14:57:46.338Z" }, + { url = "https://files.pythonhosted.org/packages/c7/e0/b058047b7cf565e1105b10ef6b6b24a6ebe3575678c7dc75a645334705a7/websockets-17.1-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:12fe8984a32dbfd084e0603f1a8d740c0180cb85b3174585c54a80d2455a8394", size = 223605, upload-time = "2026-08-26T14:57:48.175Z" }, + { url = "https://files.pythonhosted.org/packages/b9/69/fc1555bff884de363f1bf9eebf2836dbeb29fa7e4f957debb7bbcf43abba/websockets-17.1-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:01dcb47deebc40b38fd4a493b9b9f4d0a704b7bec6f35e4d34085b329abce71a", size = 224508, upload-time = "2026-08-26T14:57:49.407Z" }, + { url = "https://files.pythonhosted.org/packages/e7/f9/648d4e68621688b19093b06f7b497d520952e68cdea1c1b54371fe9491de/websockets-17.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:f4c45ee2512d3757b5e6c67c5a34e435143f2ecb7df3324f9fd888688c45c0f4", size = 224767, upload-time = "2026-08-26T14:57:50.799Z" }, + { url = "https://files.pythonhosted.org/packages/58/93/f8342b55864f71df13eb8e9ef7dce691b87a87f04f75bb8a1385b3336e7c/websockets-17.1-cp315-cp315-win32.whl", hash = "sha256:0f4f50dfe2cc810fc4e2de979b35e83bf8bb4bccdc6fe472d93762ea7b1d5927", size = 217003, upload-time = "2026-08-26T14:57:52.122Z" }, + { url = "https://files.pythonhosted.org/packages/ea/f0/7b5fdb774c245e0b6217009e2a24d2105c1a64923949f33be41aa7959302/websockets-17.1-cp315-cp315-win_amd64.whl", hash = "sha256:4af784f3e436f65b355c117c6497320f2b5cf6a559295cb1c4c7338e335d45cc", size = 217300, upload-time = "2026-08-26T14:57:53.492Z" }, + { url = "https://files.pythonhosted.org/packages/76/33/1fe6ed1b5087516115ca451b2c240314b010647071f8fc3bd78a21e4dddb/websockets-17.1-cp315-cp315-win_arm64.whl", hash = "sha256:d58159af7835fde09c462394293c0d7aaf8fb4557d8f8e5699f5e722ccae013d", size = 217214, upload-time = "2026-08-26T14:57:54.88Z" }, + { url = "https://files.pythonhosted.org/packages/94/ca/ed02e75996a266d76c5fcb5dd9b930db4cf2b388ca5fa3d2a72086f81568/websockets-17.1-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:1a5cf4e7bbe3ca499e6a289206cb4fcb7444b09919e129bd517f57d5fa192c13", size = 217282, upload-time = "2026-08-26T14:57:56.108Z" }, + { url = "https://files.pythonhosted.org/packages/bd/7d/d536f5bc89ea5b52fd1c1727c59fabafee6bc41f5ce92c3bd2f83047908c/websockets-17.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:416b4bc8789a1865a3ff643ec4ee073a5f52402d0dbeafd27b1798d5dd6b6a51", size = 214863, upload-time = "2026-08-26T14:57:57.355Z" }, + { url = "https://files.pythonhosted.org/packages/37/37/944cf17bad668e9be1247e6314f88a48b9faf7c250e383410db8b38af0b9/websockets-17.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:259f45358c76d3b18489e3e80636cdbe807e05ecf1b10fdf1a779106d23d0c8e", size = 215073, upload-time = "2026-08-26T14:57:58.719Z" }, + { url = "https://files.pythonhosted.org/packages/74/bf/3267966cc1bbc2b8fa62fd329651b0af502df1f5d1c0eed027ff339d6aa8/websockets-17.1-cp315-cp315t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d9d01e8ede41fea4f5a847dad9d628355f74905f437a5b6856d67aa66d193800", size = 225229, upload-time = "2026-08-26T14:58:00.235Z" }, + { url = "https://files.pythonhosted.org/packages/7f/d8/85ea722f483510abb39fc71aafb4465d17cf9051a275ab036874ff3c300c/websockets-17.1-cp315-cp315t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a7b35181a14cbfcae163b4de545d22abfd07d06c2c41ca69cfcd99251d6888ab", size = 225500, upload-time = "2026-08-26T14:58:01.994Z" }, + { url = "https://files.pythonhosted.org/packages/50/ce/64c7d00005bd0d15ecb5c5fcb7fb2597b6b92ddd16c4fa6bbc3d2835ad63/websockets-17.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6a8e768a048c2220697477ce2e67e4345dc9f693d0ee6af53945b5e30227c6a7", size = 226829, upload-time = "2026-08-26T14:58:03.327Z" }, + { url = "https://files.pythonhosted.org/packages/b4/dc/096c67940fb957e667ca3c542818150434eb0388c6fdc90b3a502f3c3e96/websockets-17.1-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:880069d21cc33a558dcf180924a546d1ecf8ada5be3e4e70acee87019d706a24", size = 228457, upload-time = "2026-08-26T14:58:04.78Z" }, + { url = "https://files.pythonhosted.org/packages/51/fe/f2331b6b7ccc67589891da354fa46a5cb79e95f83b9fd0e734d77f1f2140/websockets-17.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cec1bb8f22abccc8d20f8ca63df9be41600c26c190f4b97ee86c675fd4a863a6", size = 227265, upload-time = "2026-08-26T14:58:06.102Z" }, + { url = "https://files.pythonhosted.org/packages/47/a5/fb1642302f8ec77ca922203074f155a9831a5128ad75e725059a476d1227/websockets-17.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f3a1d577e081667dda7f8e5b4796e6e32f9713c93e2a3d930669519840a3c623", size = 226143, upload-time = "2026-08-26T14:58:07.464Z" }, + { url = "https://files.pythonhosted.org/packages/d7/41/7133fcfb63f5562750b269d6a845c689dde6a2c6407286da395beea19ddd/websockets-17.1-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dc053f9e95a76213c5eb7ed95779f7daf0d2bf0e4e03073629ebfa43a033f151", size = 223501, upload-time = "2026-08-26T14:58:08.766Z" }, + { url = "https://files.pythonhosted.org/packages/64/b1/82b36bfabc79ff2d383a1fc043cee6a13f794ef4f6bf1b4810ad6988cf6f/websockets-17.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:bb0efe019480a1c93e168ce96479273aaebd672fc8c350d5eed1e507ababb1b8", size = 226330, upload-time = "2026-08-26T14:58:09.987Z" }, + { url = "https://files.pythonhosted.org/packages/41/7d/5b511b9bf6e9ad331e6ff902fcbcc71c3794d10ef3b5efe80ccb8f0a7861/websockets-17.1-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:615746b12b26a3fd4077bc6fbeb277a1c192a45dd57b531d07ad9ed5c52a9a7a", size = 224980, upload-time = "2026-08-26T14:58:11.303Z" }, + { url = "https://files.pythonhosted.org/packages/e0/50/aed08f25301f8eef23be903ff9319fcf35630ca2bdec9d226f7d804dd5b3/websockets-17.1-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:1a20136d61f9ca3a31493732762661fafc2c20e8861930214e21afc6a8a692a2", size = 225478, upload-time = "2026-08-26T14:58:12.543Z" }, + { url = "https://files.pythonhosted.org/packages/3e/47/0d63d4168536b4682c9d19b7399443b1176f25dbb68878374fa716670230/websockets-17.1-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:2786cbd273ab69c22612db8a41229ddf2c158060b17b5928884bf388d07887f3", size = 226588, upload-time = "2026-08-26T14:58:14.457Z" }, + { url = "https://files.pythonhosted.org/packages/b3/dd/844bd0b6386fc81ed6a55f4b6dd26f01c6987eda205afa10175ea12b2164/websockets-17.1-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:b1c323fc3be1dc3f87f6c59458cb7d9e13dcbbf971d6c3f3e2bbaf58d3bfcdfe", size = 224336, upload-time = "2026-08-26T14:58:15.778Z" }, + { url = "https://files.pythonhosted.org/packages/96/18/03709c84bc88ec4dcea68d4be4ccd07d611073dec111203a5bf45af8809d/websockets-17.1-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:12c8e2b25df59755954a04dfa09c990b96691025aaf7eafd19ed6da24b09c18d", size = 225197, upload-time = "2026-08-26T14:58:17.141Z" }, + { url = "https://files.pythonhosted.org/packages/27/cf/0d1c694b6466c89e875b85b32b51312c472cf6708eee91914866f5087dde/websockets-17.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:f58f58b4b29bbea2a3635e2c56eff4a3adab011fe383802a9e542e31b97085fc", size = 225493, upload-time = "2026-08-26T14:58:18.521Z" }, + { url = "https://files.pythonhosted.org/packages/4e/f5/99857c3dd9676749f33e3668665a34ad6099505fb8d75eb084f49f7807a9/websockets-17.1-cp315-cp315t-win32.whl", hash = "sha256:f78a3ffb1994304db2c0c4588e4d1a518079b557054fa3bb985a6f5e50ff49a3", size = 217130, upload-time = "2026-08-26T14:58:20.037Z" }, + { url = "https://files.pythonhosted.org/packages/2c/84/77599922ab441bfe61508f97dab2c71f8e114d31793993ea54011db16199/websockets-17.1-cp315-cp315t-win_amd64.whl", hash = "sha256:ad68c28a27246fed109a4409393d677b7e1388345cbbd2f5aee5c182d8506110", size = 217448, upload-time = "2026-08-26T14:58:21.382Z" }, + { url = "https://files.pythonhosted.org/packages/ce/3c/8b9a225b523f06a9389be81f1b0ab07c49bec6014742e6aa359c1f920f1f/websockets-17.1-cp315-cp315t-win_arm64.whl", hash = "sha256:e552e0037230ac16e5f568de7012041344d1b18c9feed30ec2891b8eba55af81", size = 217372, upload-time = "2026-08-26T14:58:22.807Z" }, + { url = "https://files.pythonhosted.org/packages/41/63/23572870e01836a98346075b9e17a8bc24a6ddd9800a3204ceee58677f3c/websockets-17.1-py3-none-any.whl", hash = "sha256:f221081107b8c48184d99f7019604486376e7ef826037e70aad6b02540732c23", size = 211134, upload-time = "2026-08-26T17:25:31.397Z" }, +] diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..21b9220 --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,34 @@ +name: eventlens + +x-itworx-deployment: + purpose: broker-retry + requested-at: "2026-09-10T12:07:00+02:00" + +services: + app: + build: + context: . + dockerfile: Dockerfile + args: + EVENTLENS_REVISION: ${GITEA_COMMIT_SHA:-local} + container_name: eventlens + restart: unless-stopped + ports: + - "1252:8000" + labels: + net.unraid.docker.webui: "http://localhost:1252" + net.unraid.docker.icon: "http://localhost:1252/eventlens-icon-512.png" + security_opt: + - no-new-privileges:true + cap_drop: + - ALL + read_only: true + tmpfs: + - /tmp:rw,noexec,nosuid,size=64m + mem_limit: 1g + cpus: 2.0 + logging: + driver: json-file + options: + max-size: "20m" + max-file: "3" diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md new file mode 100644 index 0000000..35bc17f --- /dev/null +++ b/docs/ARCHITECTURE.md @@ -0,0 +1,40 @@ +# Architecture + +```text +Browser .evtx + | + v +ASGI request/body + filename gates -> bounded in-memory bytes + | + v +bounded parse admission -> Rust-backed evtx parser (single thread, time/event/record limits) + | + v +normalized events (bounded strings/fields, explicit timestamp validity/source, stable IDs) + | + v +deterministic correlation rules -> incidents + reasons + evidence IDs + | + v +React workspace shell (Analysis/Timeline/Hunting/Reports/Settings) -> virtualized timeline/filter/inspector -> cloned redacted JSON/Markdown export +``` + +## Boundaries + +- `backend/app/main.py` owns HTTP, CORS, receive-level request limits, bounded parse admission, privacy headers, upload reading and response contracts. +- `backend/app/parser.py` owns the untrusted EVTX boundary and never emits raw XML to presentation code. +- `backend/app/normalize.py` maps parser-native JSON into `NormalizedEvent` values, with bounded fields, UTC timestamps and explicit `event`/`record`/`missing`/`invalid` timestamp metadata. +- `backend/app/correlate.py` consumes normalized events only. It never parses raw EVTX, requires provider/channel context for provider-scoped IDs, avoids unknown grouping keys and attaches stable rule/incident/evidence identifiers. +- `backend/app/models.py` defines the API contract. +- `frontend/src/filter.ts`, `redact.ts` and `export.ts` are pure browser-side workflow functions. +- `frontend/src/main.tsx` is only the React bootstrap. `frontend/src/app/App.tsx` owns explicit workspace state (active hash workspace, selection, filters, settings and loading/error state); reusable shell/state components live in `frontend/src/components/`, and Analysis, Timeline, Hunting, Reports and Settings live in `frontend/src/workspaces/` over the same in-memory `Analysis` object. The browser UI does not implement parser or correlation rules. + +## Resource and privacy model + +Uploads are bounded while ASGI body messages are received, then read in bounded chunks and parsed from bytes in a worker thread so the FastAPI event loop remains responsive. Each parser record is checked before JSON expansion. Normalized output has a global character budget in addition to per-event limits. The multipart handle is closed after the request and no upload path is retained. + +API and health responses are non-cacheable and carry defensive browser headers. The production container runs as an unprivileged user with a read-only root filesystem, dropped capabilities and a bounded temporary filesystem. The browser keeps only the current normalized analysis in memory; large timelines are virtualized and search documents are cached per event. + +The deployment broker passes the validated main commit as `GITEA_COMMIT_SHA` into the Compose build. Docker embeds that exact SHA as `EVENTLENS_REVISION`; `/health` exposes it with the product version without running Git in the container. An unlabelled local build reports `local`. + +The browser stores only one validated local-preferences record in `localStorage` (`eventlens.preferences.v1`); it never stores events, analysis results or EVTX-derived values. Settings writes that record automatically, exposes an accessible save confirmation and can reset it to validated defaults. A configured default workspace is used only when no URL hash is present, so a hash/deep link always wins. Workspace navigation uses a lightweight URL hash so browser back/forward works without a routing dependency. The static browser-brand package (SVG/ICO/PNG/manifest) is bundled locally, has no service worker and does not add a cache or network dependency. The bundled JSON demo exercises the same normalized, correlation and presentation contracts while deliberately skipping only raw EVTX parsing. The real parser is qualified in CI against a public, hash-verified seven-record EVTX fixture without committing that fixture or its event data to the repository. diff --git a/docs/CORRELATION.md b/docs/CORRELATION.md new file mode 100644 index 0000000..e433b0f --- /dev/null +++ b/docs/CORRELATION.md @@ -0,0 +1,29 @@ +# Correlation design + +Correlation is deterministic and explainable. EventLens says records are temporally or semantically related; it does not invent causality. + +Every incident carries a stable `rule_id`, bounded total time window, explicit predicate, grouping key, human-readable reason and exact evidence event IDs. Incident IDs are SHA-256-derived from the rule and ordered evidence IDs, so repeated analysis of identical normalized evidence yields the same identifiers. + +## Ordering and identity + +- Parser timestamps are normalized to timezone-aware UTC values. A valid event timestamp wins; a valid parser-record timestamp is an explicit fallback. Invalid or missing timestamps remain `null` with `timestamp_source`/`timestamp_valid` metadata and are excluded from temporal correlation, so no synthetic 1970 evidence is created. +- Correlation sorts by `(timestamp, event.id)` before grouping and returns incidents by `(start, rule_id, id)`. +- EVTX record IDs are retained as stable event IDs. When a parser record has no record ID, the parser ordinal plus canonical event content produces a deterministic hash; duplicate records at the same timestamp do not silently share an ID. +- Evidence IDs are copied exactly into every incident. Repeated signatures remain in the evidence timeline and are represented by `original_count` versus `compressed_count` in incident metadata. + +## Rules and boundaries + +- `windows.crash.application-report` — Application Error 1000 and/or Windows Error Reporting 1001 from the exact Application provider/channel within 120 seconds, grouped by known host/process. The word “sequence” is reserved for evidence containing both records. +- `windows.service.failure` — abnormal Service Control Manager 7023/7024/7031/7034 events from the System channel within 120 seconds, grouped by known host/service. +- `windows.network.dns-timeout` — DNS Client 1014 events from the System channel in a bounded 120-second window per known host. +- `windows.auth.failed-logon` — Security Auditing 4625 events from the Security channel in a bounded 120-second window per known host/account. One event is recorded evidence; two are repeated failures; three or more are called a burst. +- `windows.system.startup` — Kernel-General 12 or EventLog 6005 startup signals in a bounded 300-second window per known host. +- `windows.system.shutdown.normal` — Kernel-General 13 or EventLog 6006 normal-shutdown evidence in a bounded 300-second window per known host. +- `windows.system.shutdown.unexpected` — Kernel-Power 41 or EventLog 6008 unexpected-shutdown/restart evidence in a bounded 300-second window per known host. The reason describes evidence, not a cause. +- `windows.generic.attention` — preserves unmatched warning/error evidence rather than hiding it. + +A rule requires its provider and channel context; a coincidental Event ID from another provider is not classified as that rule. Missing/placeholder host, process, service or account values create an event-isolated group and the reason says that grouping was unavailable; they never become a shared `unknown-*` key. Events without a reliable timestamp remain evidence but do not enter temporal groups. + +A group is split when adding the next event would make the total span from the first event exceed the rule window. Equality at the boundary is included; one millisecond beyond it is split. This prevents a long chain of near-adjacent records from creating an unbounded incident. + +Repeated identical provider/event/summary signatures remain in the evidence timeline but are compressed in the incident summary; source records and evidence IDs are never removed. Events may support more than one specifically matching rule when their predicates independently match; no rule is treated as proof of root cause. diff --git a/docs/PRIVACY.md b/docs/PRIVACY.md new file mode 100644 index 0000000..3926bb8 --- /dev/null +++ b/docs/PRIVACY.md @@ -0,0 +1,37 @@ +# Privacy model + +Windows Event Logs frequently contain usernames, hostnames, IP addresses, e-mail addresses, executable paths and application-specific fields. + +## In-memory workflow + +1. The browser sends the selected `.evtx` to the self-hosted API. +2. A receive-level request gate rejects oversized body streams before multipart parsing; the API then reads bounded chunks, parses bytes off the event loop and returns normalized JSON. +3. EventLens does not create an application-level upload file or database record. +4. The multipart parser may transiently spool request data as part of the web framework; the upload handle is closed after every request and the app does not retain that path. +5. The browser keeps the normalized analysis in component memory for the current session; switching workspaces does not create another copy or upload it elsewhere. +6. Only display preferences (timestamp mode, defaults, density and preferred workspace) may be stored in the single `eventlens.preferences.v1` localStorage record; event text, EVTX-derived values and analysis results are never stored there. The Settings workspace labels this boundary directly, exposes its technical key only on request and can reset the record to defaults. +7. Export is generated locally in the browser. +8. The favicon, touch icons and web manifest are static files bundled with EventLens. They make no third-party request, do not enable a service worker and do not persist investigation data. + +## Redaction before export + +Redaction is enabled by default and operates on a cloned analysis object. It masks or replaces: + +- computer/host values; +- username/account/e-mail identity fields, including domain-qualified accounts, SIDs and machine accounts; +- e-mail addresses in free text; +- IPv4 and IPv6 addresses in free text or IP-address fields; +- Windows and UNC paths (including spaces/parentheses) and path-like fields; +- source-name fields and source values propagated into free-form text; +- known structured identities propagated into summaries, incident titles and reasons; +- the source filename in the exported report. + +The UI previews replacement counts by type before export. The original in-memory analysis is never modified by the redaction function. The source name is replaced with `[REDACTED_SOURCE].evtx` when redaction is enabled. JSON and Markdown carry the same redacted normalized analysis and parse-completeness metadata. + +Redaction can be disabled when a raw forensic export is explicitly required, but that is an explicit user choice and the warning remains visible. + +## Limits + +The API enforces a 50 MiB file limit, a bounded request body independent of `Content-Length`, parser event/time budgets, bounded normalized strings/fields/output and bounded parse concurrency. These controls reduce accidental resource exhaustion; they are not a guarantee against every parser implementation vulnerability. + +Redaction is a best-effort privacy layer, not a formal DLP engine. Application-specific free-form values may contain sensitive data that cannot be inferred safely. Review exports before sharing them outside the intended context. diff --git a/docs/assets/eventlens-demo-overview.png b/docs/assets/eventlens-demo-overview.png new file mode 100644 index 0000000000000000000000000000000000000000..d15767b0162fde53377ca232dbe32bb8f3cfaaf3 GIT binary patch literal 285470 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 z

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 Z1+D6yZ`pHK7T{kfv^Dh}mOZcz{Xe$MI*$MV literal 0 HcmV?d00001 diff --git a/docs/assets/eventlens-redaction-export.png b/docs/assets/eventlens-redaction-export.png new file mode 100644 index 0000000000000000000000000000000000000000..9917eb2330c546b02d195c506fb18a2853a14b21 GIT binary patch literal 265967 zcmZs?XH-*B*EI^FA}UQq6oe?Kpa@7u0z{0J_7>>!!tD%{ebVg=FDWSo_%P6;9kD}>C+cvE8oxZI=_s%BTDa;<%C*dvF>G=9)7LeDu$~MqRxjuWp?UJupq#(Xf(zZhJX=}SOOEC z)ZqyxVet0$4)*>Y7^KU1wYO!|xijyhqC~HA1qWRG8Wp84?SfzwI92I%cIF?cfF;QX&vWpL9yOi>5 zIpo^^s}oL6vop(Q<^QV_0h?cs7Z^0v)Sh-j6Jq||>lhRTI(38dYux5)ZWQm||L!iT z?9_i|rK{APned-(r_>+NG}P4ex&HrV>wOEU5*yY3B=+0?c5+tz4S4N;#fV6TmsS$@pXop3m^uG{=WKTOKlAO>=n4MY82z8c6?1srkB*8eW~BcjZX@}> z3!Z(zk?O{2#*_!$P`xmFvKQl0p|tixJmLZXEN?d{(f8PPg?q-L>&}}7_eCu29Z3sL zmHDrSM_g5ajjVUsIQnH+ zVOr_9pOj!YYQ|v3JYVPGKdh_C_h>uH8isB2nX4X)RlX`9kijv#9r4(DukOVezW*8R ziu%H1O;=gR>1Oqsl#!Cg?HHx@CH>PxCc~=n>fa~@L5I0bfY>Rw!i;Zezqnlz>)HyY-!dUqoHCKK| zWZ@YUsv*a4zpa*i>#)M82KEOL<7Y#Gv1dxcJyodW#i6!ox3gYO$s}4V$_#H z@r&9U-_+jV8rWoB5#xBX+_lNC1-0lt(9 z?>3sVO|T}#Eu@;q?2ly1q3kxYDw=VT7q~^k&+nmY#+0!O9y7jA9}IMFF8n;;){zHq z+yZ7nmelnM!M77!r(1|JAj%vYf_)uQt*1@JrOK6B((<8Haw?4wb2%OqAAOtM9Z|1U zVbMC@;KIzwdA{ls?>`WzYPyL53(B&8F&xQEm22Sh+ijarCp94IFMFU0Jv8wZ6BeOD zi-*gD3CebTu5TK?mLoQ|3V+Hgiu?`TK%j!qM>9G~2O_^$$KP@Nl{Hu3J3_duV*ERR zSf!A8e`G5OdjXj(j5;cVKHA6^f`;ONsNj_pm~5Hl7;j`Kiis^`wW?3fePOmxD>D%u zvYg8dco0lSk2Mu${&s)(rPd(4BKeDIu5i3EuHOT^;^Ha-bDAjRwhSUh<%7JDXSheR zfT^L~vP&D#U@_%@-+oLD0L60+m3-L#uY#b1^nA8Q$2Z$ZS<->HR2`rjeZ-TVIJr=1 zxA_y+om>Aey64G$DOeOE9VWvpqwy4=FYh=?zWSamwv`}>2WnksZD2%VNgH)L<8cR< zX(tszZIn=KgOZ-Yel|prTK8glT6}|55bm!HLn`H{>A7KkunxfyAY@zJreZ{uZQoKbRy5c)Qq;KeZ!ik} z-A%7AmT%~M|EqFE!sgt{q!c^|=j1S)DVG2sE=B5{up_NWS^gvB*X3iO__T6!n4~?X zB~XsCZB&XRZNh1k!PzRZ7YtJ!6ViEo@XiiR@#qR-flAKUNtqH~iSy-CxQK8g)Vs~& zKt|Q-vomK z75tP}--cTlIn6Z@{>Wt;A5o3z0Qs9k?l)&9d&Zq#d9tkv@*tEwBEI+QJuAf1dSVDM z*+`pyNL@V!0yO#(AO}Dcb$YocM!fkjm|UQJwr$_K59;+NRfpWk0*4*3bA+j1;6_)C zy{ng5^z7q{2jUNcu}uzGWGgoKFBSz~J`ZMq3v=g8(&FUa2Z)`djfH%&OhSL79{ujB zXv5D>fru=K%T*)jHbISt62@Hb=+VI*c=pc8AtrR`PO7_{6$6m)-6M3TBNFh*Isg6r zc2#Zi4TtFp(*rmF#nE^%o4Ok#MNN&J{yTPKy42Ujkt6oH)FJWu)2kW_hw!!ODzYM*>L|hPFNIzD#%xl(~(tI?boIOgEahdMNI{|b^ zh*0(i=JnEBHCmbG{>U|E6l`}1LJnQ+=j7mAdMvZu?&(>5v{Y=XftB@Pj}rdO*2RXE zI6{HAlKD`FtP@8SpRj?OdR+z}Px4#q;R@NLCxNZho)xIC2Q zcdlwM)z0)~$r)&fB!nt7Wc0ves+kM1>{SINk3m*VTnR(l-tguvjg^J%yj%C%9~805 zzlDtIK&S=D2i%{aq)|Thy+57@hN8?jq;V?_ROY(Ai7}8reh#%cS)~_qRrC`pUp<)8 zoFZ!W#A!mF@{ya?K*%0=9*?%C`JqCM-W*+qMYel*m2=c=3_l`-W804Kz*pxW$14Cp z;BJ+7n=gJT5-{3Q7I?5;TG_I~2K?^3p1#uCdY04de48(|Cm7SJb0Xo`eXuV;pLr1C zqyf_d&M`j-46RqJHvN0&jbYJRkG1f5!}YZ(^J!khrUfw(`d24VCT+^sgEHV|v;+8P zg=`6Id~1F|y8CQnxd&D@tJ~kQ^$47;XFU+9Cs%5Y$a_OVw;{AyYZxt>Y}PVY`moIh zqaztIJ2Mri!fI3%ZtDU~#60xRD!Wm+=>X7f_h+q$lsOgIc%A$!x>LQmcV64&6ZYt!5oA)b+F zW(cwSvS$1>@FJ^R{BY==UtV#>q)$LEv&H`E`Ihiqc=U9 zG;@-a0c}rh_!C>b)fyBB2-8Osp#A%tXcIn z*hn<5CEvkdH;YGBNUsqVzEM77DVmJ}NuA76*yK0YX|VEg)yNBCFmgIgnbUptQ+Hab zr6Vf0D_RJOACCkmlTfq=rhCsSkf8+NUJjq%4X=qKBfSjDo0mnS=3->znyqCZ5uN}N z;1!20mwddyy?E4TmMi(j5MRa1Gu9VwW#ZJsY-={{i@;RFl$+O+d=Cl>zt5MN_o<{J zrwUQ=^iYs)STO40(S`a|GuaQ)K+^Yv243laOh2@;c}oB-g3bP(`_Z-mE^O^+h;~du z{qXN>!Q^4hku^qu-U>4qCL8D>ezhzvyIYpMyUe9~Ix_CpjGTx0edQ4{=|j2TiSKNi z2-T;jwx@DIc1D@gj!{scn2GJz5m{b-iZ^ z*%}O>Z+?2aYr;rL2dK6AJRJWv=ay_cnsk^%7P{<({8i{fkJbp+bx#)m;#-5C7+BLT zUOHg$V_%`eGe2Q_$JHCrq_>f+)O_GkZdw~4fik9&Ksw+f5eE#=Mm`B*uo-?ZW=DI= zK2fL>Y4tK~5A&I;EXn@o|8fD*dWXAn2RaRuT(T(+-TYyr3S!(T1P%J^Hjb$C=(Dju zRt`pmZa~+Ha3Xb*p6y@~<#-U#MjlMldpEl?mPL~o>q9J~N7%y;1jmEZwl0*l%#aaj$;FuBx z3LqalMDhnt9_Ub*d9G4O?8kV2@xVPk?BMx#H{$R{^lPsXW(|F!mOQ3f! zep|_9efZ9c$q5HnLx;@Oq)hSQXM0+A{Dfi_x1TpH5C$7;F%MAj)*IjrSgNA%jR)?b zyyrdH`Kp?%1s5CbRb%Q!w?1iknB%*1Dt4#r0^rk&h%)n9=K+_RLdu%fw1tB6$XUN1 zH4%E+Cz6nF>F_|98@#O)qi~S_vqilvYbd^nRzY}7oUyPB*uR6{sBmxo>LxrLZMk%h z!Q$Dv;!cX20isJ*i|7~YtO^+UdXGTwf=L$_rdKDsha#Up7 zl@d3GW*+>ifTl0-Z%Vk%_$f7OL8x}k*0wd%Wz2C3jvcVXZHE+R3O(C8y3st;H`ZF4 z+j5!o_DMCP`wR>yePvdRuwzNuRu0B4=BeA{$)SRF%KVY*WKlRx6-9@?BlHEXl`Ix4 zrm>6dxGz9zfAE^&V7|}||L;j!s88d}<@>ix&SJ6A zTGhNrJG5a@_Q1;UiPKDO*9tr6_@g+q^LaPXz*c|s$Xt*N8y9~fcuakl_RyH|IN8+ksD$(~`mEgb zyI9qxc1Vx-onfs9%mH(<#+VOwF`mP1%=~X_D@}9A+xHBklZ$?kd&Pkl3EoR~sn?nN zE1D$B9SKfDdcJh87SPpP_uXkRm*NM!*i0?~lx{67jkp&?=E0lEmU zvRgpVaW$hSgE{DW7jv+3$kDcplmi`0K~x$0H@^?YL<~#6EBR~F+(->>h_gd9dUXAO z{MxhI{yja;F%Kao7(ZK0XrP`%L}T0bcJ(w9lx0`D%|Ef3HH8p&R(dNH_S{totGrfJ z{evF_BqA8~6^-zJ%75hn9+kWbmH3h2eniFl0P z&}UIl5dxL9tA6mf;P91Rt@C1r!B`6TYqPZ*hYjgdT3L;DLW1 zyPo&E=v_ZCq>QigfD)Qk;CsJlFwF5~o%JGM!bYkUfREPmr)*Paeawz|($^6s?7LFW zSXN$ zKB+^6wL$ktXlEc;(YE=9mshH)&U~%kk!(byXy{S2HVK>}gYg-;JcI%OSJplH^>~iQ zciQM@uP~GZCqD|zb53a03?a2(!Od@(hk{<3uhGoWoYPvpr zyf)^lxTr;ZCkc6-(SywnW{0d5Y_Q93K3uo5q~Qbe6KI_yH2*~wJLZ*VvFel$4afy- zyXq{X{6#zHpN@dp>Q2d>lm-+zX6HEOniN>t90gHY8|EllnC zz=0DL5I0)$p9pqPC-r)qtINMEDO|N5@Z>&*wgDnmh&+cVGS>$1S=Eb5x11$hWA*IOY5y5JuwfjZTDK7r{8RYL*X~&}o*BH|1v0P4ymCKv@C5IOl^~l!cqM2$s z$uXu7R~G%kZwC}+5{))zW}C+_b3?~u<6<4Ap9YqHE9)uJA*CI)qaNE+_RLt8l=QiG zrpwKnYyykKvK&T_uQm8@|FP>J|89`IHhVP*`{d45u{TNJ^Kw1@gN0Tki~0mRUfcSH zj)cb!{9~J6H38my-s|a70i@k@fNDg(FFflkZ4bPFTQcZV(XOPpRa_P~QC?E7=UjuK zJ|--5;u~TC0pkFpm-6qp5c*7q#|!@URB9&|wsiqK!$hKINWL-lQrT{HKsHbijvXX2 zW-jM{AH`c!CW#Qzfl>8)#ra54A*VC4kk*?Wmz35&F!5y4bv0T(m#f@ z*%i3Y?!HhqDNafcocccQh>1Y`_>nzEC8QxrbFI$K!AcReOg+X8?Fs(2wLAfUPxC~$ zl|=3~?--<7b_UeDty@QtRwah`V(S`qelIa|XN}=oBX59jyMB#wIgTphcZI;LiOpI& zvNA4nv9&h~ocDUQe3%w%!4rjbyiduD1M~kPy%^AU0V0uCZnvo``-ggriYEV`YE>8s z8tOE%tg~}MK>N419Z5N$j-GD~MUwa)=9NR>k-aVWmFopUc{-3K6)@%-dyxvA@9sG! zbg`>wUj#HkHp&-|ncm0pd(9T}`SA!q!@=uto#6)%R@}ju^2l?TudlBwQwYMtV;zcH znfqku9yV80`ewjye8mDBO&O52-_@b&Vv&@bmXq2G;w>+meYT2d!I9(EUN=+iN52r`7$>TCYE9c*x_*-7z^gckW#mm|5*%+#hk{O4j=bt_DDmFp6P})<=hJjhW$$VFUu(D2EU|xFnW8WI^+YY}MFj z-OHE*;J~iZE{pZP1h=_;5hUa~&v{-s_hVu*X!dMq?usmW9A8zZ^sVFd zs`NtxC#QU^c>mIr2-2>B#iJNGOs-)4>B?42VI9Y~m17j^-pQH>cj&_c#Atz0L1YN= zKo1&{;y$}Kp18dezvD0(2w9K7jm^38lAq(G6cG?i|5dkd(AF#|yq4qV91f2$HR-_b zdj)#&Ckq>?VkTb1o((Q~Ts@%RzcqL@y!s=$^p7Rey5;o|sDnkrG&%1~Q_LqEwzDeh zAz}_mj&U*JJZAT&a)BC$I)3Hv=Hv3iW~w7{CEgu>)vOACm_N11@Zy0*N$y0>&9DlF&i$5hl33BhqJU zx)r?j+Hu~BblLD@=0ocmh{Olbz;H=p=_y6G6IiC9n9Gzyuwm2Un$b3iPQhcNHtPAr^ z=%)CJ5ZSir#GNSTew$7KeM260MJ6cs$k8iPJS{u-gjxtQkdNP|3cdR{xkDokUKEX) z9wKkkZxH@K=k&?n?!>H*WwH}Hb|MQ>y#Oz^JxXs5-)}wsY0pGwiP#$V=b@E@4}rTt zRBN|UP1;*??3Q--}Ob{0jbvcFDsfOVBuMLVx32CVt^1D7GW0SlY34~%{3snHNbYoM@;Yde~>FP1Fn^ff4O{tpW;S(f!+4p zB_3d58E7k_OY<>9uqvW?=5akUveE0Fc}=xJ1Nb=q=qN@C{wxOl9tH9MQ2V7xH68f& z$asa4P!is4zLwAT&_PH$pvVY{>Jji4~Yn7m`USRfn=ywaB0C{oB)f&~qH3X+K)p3#bzi%Gzjnm508o~~OLw91? z5ND^v;@fa7U9zE*cA-umDboPV`@)#CaKVg+!ah658og98?~UQPTBj8@RX+);@6I%n zV+MPTg4-{{GL)wJL*k_h>=i>UYvw()1hCW`#)g*|1Cb8nRXx4H5hek8-o!>*&WZ=5c>IfkyblY?nKJUJGx1aiJQmrQu|Xu8ybG6SUf zOcBJ|{$@H*4nGg^hwcG95+LY!ggd3ze-yY`sr!m?eI&E1WR9G^x1yt%PJ8E4*DeQw zvGNU)9L&CgDGd?5?ad!+kRbnxXb0>dO#)0=Zu)ZB6|O*o%K6>^`;g4p-%vYdWf7Rk zwJ(Y2uI3v-mryJ!z*#BagL!6{v-^MAPjya%iUQ3DD-+-(|>MH`nT%cW4!@*lp`9S@#NZxHz& zXD1o|Oo6Af8$1c6NUmGKns3Ciw8KAA69c{HL~lnu~TG!x3(Fk)oYXZ#e$Yf0YH z>RSlnbDAy<{FTy2rgDo@j|+(_C_EpM?&%`RYYi%+1T*-e(T^~eG?~v#l7YU@DA27-;=_@m-YA9D_M)K0OC(nw|$`P-E0)pd? zvp4EoX8wYR`HMTUZ)s0LKQKy5 z_QG8vO_|#NJGV#^)YTHjEoSWOyt5*jT0dJI}1(?mLDYBrOr zLZk%_CyMYMCzJ#vyQ*w?WP71@uR`o*)|rkh1QR)uOU}(@MS2u5gzy zGf!-XoOK$wz%IQ?YSwl&ZM{+d{I7Tt@|12}na6^vrfXf)sO1@H{WFcR(FAIZL8PB5 z{PhXng(v-DLICU?%{EwSENEu06Z1y%chb!|j<6RI8Kt;v(d1*MmWZpStsT1RMt1%Gl4tPVV+c#KEZ7oVypHJHH zOqwl>UeEmd89Rve(^hFPf*ylso{44%iEo#pDz^?Zk%8OjPr(VoLUg%@%`bK3jSWkV zR(Faib*JOw30vJXRcvYJS2V%6&3Zo z%0vOOBZ~-GI;?;LsddpFt)CI>kDL#GhdxL7?2!`_mJ^Qm7lRH>>%4m47~;yGJ5#6= zna;Cmxo!<&f?|rnFkNO6o3S!BamKwZbUJ1wem)=3ntIV?PGFA7W43XtmUo3;ULfyh z?(=K_ld#PT&C4hTIX>6AgvTBOQ7G~aPThO5AR5YTERf8a8*20#(x|Jc#wS}5e4`O@@Wu*(5Tq~>><-5m-zv3jtqh26D9hSTVT>udn@Q3 z#>6StZg!=l$uWVh?kT&jwMaA3P1SAlw<9lqyg)4EKDa^R^IH9GB4w{l;ur)Xe~r}YuUw2Gj0*S5@1;aCQ3{j}j$79P4$1R~+Sd#-Rp_LjDL zpvwTe^fs%b9leySht)!mtIZ}-UJGqXNNCk^SD^YXt`$K2q1vad2YNvH@$Mf#P8*nV zn|JM^-Dty7H!N|Kdw>>N*@4&sy`+rdrv(KW?H;};Z*(3hnWB5OOKx1END}+Cy$FD% zIoxM!;gJgH@L!*^DF>w<*)h{-f-gi?o5#&f`J2Am=X%E2*8B+z6`SuQAx&6mcqW9`oRl=M{ z2f1lTSv0iEb4;1CT7+O*XbT>*AOZXi!IAt^MX0c6mr&Z2r9HO|^gQeZ#%wEwTg-8;Sq9~amUSJ|QBFq`S%RoSh-)=yiT_bDsYxp? zpB19xV`tpRUC`)vSzj31e;0-hi}ol`N+xdQo%x1cr~^_R_rr-H8;ZVvNUwOMH^*)o zME&7EZk7YI*i^`tWz>Moq&@I+t-)mCmPwOBI&SGlzA_=ukQ7RplJNEAvji^@nb?(L zDFgF!y=iUl=tZBpHHu+_K#O|9)w!2l%`ME zHFOacX|WZdzYKN^m-{u1?Y{YTrY(^$gpY~Z6iS81+cU_Tw!qPrCT}E!fTq`V@x`SBrsBb|ZdD>Q;r^}B};@LhtQu9Z0 zw0Pg@fbsBr<;*vSah|s6uS<)E>g)-3<;O}D93!)?9c-tirr$~4^GEv4a%y_ISj`n` zr9aU5F5|t9B*niq{1(Tl#l7#)BOp-E-yMp*8f#3Aiz+@PD@21Tt>kA#Vmh|lJ=#t_ zQ=E##7UPMX_jHs4P`HzmR=iS}K`e=VzN*~Y$nPoya-1dCi*6&F^Sg#%A^>VbPsExZ z$`;YhX?Ea+Ce4)$FQ2Vhkrm~BU`|RfTBkD|BZ!kamlt)YKyR4O&dL5HJ7Lj-Mz{Mt zouVYmvnh@R(eY(jDE@Lglv@kV=RL&BcDMmjNY8+*HaQxl~?z4 zXQ;P_5m2qP91elGeowi@PzYrr9OwNT=#R;Q~YRvtg#hOP-J}L^4Pj};-!=z$= zt>G`_JB%soDB?L#bJa{~w_kxfjz5TJ4T~L)c#lGr-R2V@@9u%p_@uU_plj9ptRMsm zr@cO!Ju+%1RL#1bG>}N(ufjrUduH{Q*M-VW>%!fFJer6avSMADm`L%#Zdo;(tcQbl zzJBQh7`B#=qYo_aNlSP%EccnK5{b7$A|^{1$kyddCABlADu<7_FXTp3-} z37GBmrISJ;sp2naSAWrcTQlX0`6zsu$8Ya4J5mUcVm}O9u>`IlxFx`yytc%Kw+4Kf zb7#}6$(loWxa+P1VQYV{k$Ch=_Az*GCM=jv?7tmfPM0b=0A2q_WwCZ?mcOYYQ-d)! z7k{0tF?TeNRH!$|{>QQ95Anw70NEI^C=j;G&4Q zI5Ra>^`cTq7MPtZX2O_=1!W1FpCEAsC{fGi^7x~HAXz{7#ohdWSXmf@lLDBPNZkTUTthE6lsTm;5)nbY3QpaOs*P{{&1fVcOo zSoJ9$K!qAzOKDvid_A({T``88)m%st_~kdV2#MiSLRnM;KSGD$Y0F7Evs#T{rsp!( zempT2B%T@CfQEi{t0W3y>{yDV)+c&mn*DYdIqRPMbDnB%Z@I?_c-?G%q1L_rArcFl zaQq5)>c%$^C|eDqU8@qV9NChU=?W zEQjiSPYO9BKrSQr_e0w|mVx`kL><~TQV{Q8w^RTH58_+N*PRR>_p ztA7cGWx3@-yu0cGpaU-BXZGla+_N=fDqyC}%*fJmRqnoVT}tZD^Z+_E&F@{_*;c4^ zp8Aabe#=Jc@j??_4jRBgkThdi?i!<~l3HAuBdJyfoJT`DbJQ{;sB-B8mgTAqJQ}#i z9X8RSJ?Gg!NBsVh{zb!| z_Myu=+H|HIw#;Iwa2+6MXNy=FHHYmBm1kK^H=byw*4&!4F3Jk&dtgx;=GzHeMa_?l z+7y`k0T^F*TydCkx`(jVywRi4A-t>UsvRW)rLz@G`sA2d9u8&&0f9Ug+nQ1aqjU9q zHkoAKRw`*N?C@^~FF!G%`AmklrJA+YLJ?Lep9WYu< z+94Ljzx&)5k(UDFeh}zzH7M>mEjKpjPh(OEN#*+Ro-59TLi`N1aQNQuH=h7HtdMHM zm(erXXb8(y5Ap#PGIYL-JZ?u_GZ=NB(@sX4$BB2~%(=UbES5$CV-!EpFGEz|BFiPV z75u(g>hzQhRwVEuetM^l_d#^QEGg9oja9DLLEv{;J4ufg$~3Baf~X#-Ysv!IaO>oG zK_!z==I`d#$PfM8$!k-DHa1o{;hKbTs%gq&_x;mDE^I8}1} zoWu_S0a?NBqO1n(Zk2?nVo94V>V1b@@bDD%#8&A)d}t*cddx?Hm={eLv-&Yv6I z;-Y5HbI3jT_bX>6%d+6_I@LF9YHIJgnR5jN>K(h=W9je}H55?7r+8voO?J2G_N=Kt5v*JybYdgw8E<3DQis-|0FU;eMy@%%02 zQ+%A9;}4_8#5C1h>!bX$1b9x3kI^sSp{v&4=yh{J)YRNKY()g}3ZsBuqaLdnMMo90 z*f>sc{9p0<`yhSM$^Yd7IA+ZM4a#XIwha9L718H)aO^z)&lMac>60s`=^w`*M=Qam5iWajev9brZK($WI^R@eqA>;=;zsO6;uB$_7AU~v)p>@6c_L^6m3vQ z_J4AKo3DsDITr8}1IZTOzHJA*iR6I3$~n!!<(I#{uK`p4YIrBZx5e(PPd#FuMTE_B zFwD0~dgKlyLrXDbHHh(O(}t&CMxkD;Sux!-jk~sYW>*ODoP0ulGqhN3dwS~{#y7XR z>15y$X1cD?<_YSH;@@i~1;IV|itN7i+8RAC>&r%GWzU@AS-mBniu<*f$O-*pC#H45 zSQW53-2Xg59snb0XOQjhgg8-Rz&6Hmb?4wp^=y#HW|P2?MJUc-)U z#`cm`sqjT~xRQx|bV#;G)K#17a2+1i0?~u1;j}x?3TF!9_5JMM#U{Oo>8vD(f5fZF zS{e+BenDD1!jh6|G4m+clh;Vw1DS%heT2#!TswZ+O`z#*{Z59FCTS0(m<{! zvBwI2xEW+WfWNqtm~^>w)syd9NQ$qQ33tQ$MVO!^jcXu+G_F37e?gg1$RX8&jol}~ z>a)m({!8CgIUg~;2{zqSN&JT|LVZrb4=Z9;|0p$hki5X7%3apY@qGLleDX18*q06x z!UZoK=ph{}_$O>A`cK_}S8|k9w;(sK%_j{x1BVYiX9!=C=M)bn6{$IZip8V7 z?d4fHuYmGYAupyif782b93xVp!NJh?2La}P_cK{{(|SYVgdNOVXv-tQpz@c#*&Buc zOFYSRKWE>nmdTlYxhmD6PW7vw+a@3Sw#mfhjv=7;P1VS-oPw37=|U{xlJO-aaiXmY>m5Vx3K&K13-S5K@JA+O%DNIYPWpaLGb%^P8{cf&E3 z99zMiOa`&9BEoxwQcfo^-@I--{A+JYV5rX}$+YEK>Vo3igKl?b9pE#Und2vtyv=$g zW_O1^nSPmDc_NeT*djBnkW5wmLX#(-CuSmq?lBgDm>8;*03W|beO-O56n}}o$MjOd z0E=PmV2s&#oGoBg$3PH;3lmCly-K`){TF*|GwVzRdbZ?gc8RW^5*MkvQ==7 zE+Qu^CGIKpL%6ZYKz|-XA=%k7XG7ugQ;By0`GGIT{gOJvc+hOwJm~V!8=t?B6{PdF5M`dL4H- zrAUU)hJG>Q*8{r*NUik=oU?$~+%f=XyS3sPeI-s$fu_6vXzgx|hL#M%o!uF1dHxhn z>H}mv7y?JopWK(<6gdkLV(!FV zP54JF@XSx(*!lpK1f~KwXF`%bPCIpMTuCh9yR!Uo&0J%oD2Bihn&!=#EO{E`b8~V3Z=-sS zyH4Ts4YgbPniXx64vnRWKUJ?sGARfujSL%$-;kM`mNWW$uXpb_L+*!<&a_vOUn9qd zl3<0&UuTwof>IW5EsZ&Yhm6Y;G4G?}oqL(3mcNkw`0L+RMk+4s@LZ6VF)|p|b1svM z<-nmuY655`&(6pPv!gdU#g&!c`W>t-#ep4qy%HYAj^?f;hX-BC1PP@P+UjOX>6 zs*mYAe-KO6bJUFU3X)=cZ~IJ9oR_?@;pT zGx?I`*X}WV@n7(b3H$PV=G1Cz^0jATt&>WwfisrzS5yem9p@#(^OKjOek;!56h31d z^a7z~J*OC5&*tg*0{BptMfQC1Rmpu!(QEG?_iRR#GM$Ty`o;EgghBm?d5Ot=>~v`H z+L{cXiqrY%cm_j0=$oSo2u?l!Ws-cz~Yc%Kh5YnGW-jQ3|bZJw)}4otu55^4nsb> z{P>Ah@GuA%_UoU+U_k1h9uTz#`!39N+sVZd5W$nqm z`w%JUn>X-H{?s>^qRfhVeEvmt(dl9pb%KCBXTq}SFG_f$W?0~@j1tJa;T;9`AOo$! z5R(gMq~NziINNm-Y8d&!dHenE0;W0ra(E1gH(t^Wt5}#pRG@agV$x_+c=y4^o1`w5 zO#^w3><0mgnyJ+)GPf2d5*SR zFPMTB&yx#h^)7I|{zM2D(R4z_C_%0GU2Z8E5?*HYnLcH%Z5_wGbj$eDs%s{9$%+3h z=PgimG{0v?P4Q9FSC6&*{#E)v534@STxUyVnp|GvD6AFCF04&#Q5>1V%nIEFXVz5= zFPlTX*c*_HDR=*bKe??gSE2WO5q;*~)&6xky-iM+Upt`e9O5SqQ76IA-Y(&jn4@GB zHe##u7N9vnNZ3Mem3{B*VUy7(1|nbNY2OV+lhMP!CO#&Ux}49aiodvy8d#-i#B)lA zjOD+m$MgbvO>Z-kv%d%pwlD{tNN*zxmh^X4h* zlRX?_segKQ!we((FAp|}c}Eo^5aW{9iqWqgt@#AG?m1nj76L>AGWdEjQHIQeYOCIqw_!}pWmJyz?$s7ZmXrv|Ove16}@ z@AyqU4oqb0x_kPoc7F0jHWLbIP*myI-hUUqZFIVL{a_IGxakrP|7v*9l}%1Yd4b){ zoLR;*Iv0^9%=N;vNv~Tmj9z>6e->Q{IsAGZcVMOI8ARXc9NIF@7I+O`<>siL&S3P5 z!#D0GzopD_Jt%Bc(9(;Pi2xCI^M!bRbL$JAe|s`vqqZwMRl+m_R#}Og)ekg#orKUu z&wRc7J&?)nT6?l|^2el}hfrgdJIYBr?Yi7D3*qN8Ir0!{P|L|1AJ9355vKM`l`e4M z{r>bP_WG+;&ROj}&m?c>obdiJn&AxQatTaWUh&S4-i-=fkdLi?b!Gx(CafiaUMH(_Lk;z{(Ww&AvU&DEe&oeEk8- z8Hr^9>*yn)lgIa?zw5^Gd{+D2svBQ@_*mk#)yQr@!DmIoS8MMj1zFf%Ub@&}A#~O( zw&I;$cjoUaLp=^?e@D9(7x?=6Gfre{#fLCI27-3|Zev{_^R)xXBI6dEQ86p3R^|6M zy`UB`WfiKJUns+tuhpxA51X$Iu4wIW!{hnge2(vOrt?K^*@FAH%zk?tG! z?e@F*IE4SH(rBliUg3z|n$LyR#!48J0rhUPe8!=>r`weI^*tQp_&qJm*L3@HGAwWH zO)2fMiM2~C=%#DKEk6#_FpS^cy`G*9kUmyM7Mx6v2BX(&YKk>VVmAP==hh@%Hui0$ z(<0Gkl0m&iM7wHRDb5e3RWB(D#}&_~%yn~mA4JDym{km``WW?BM~n$4Z8wvcpYM51 zKlKv)W6rImkoxVxV{NpJbWv(htX-u$-%sTkSg-kI&6vA(kr(H_aELJ#WZB696=dt4 zKKdRuPq`Z&@WCtLCM(O}pvHnY{O{K`uYxRlt8M;!krz8~ax6a*{B9wu0MfXoEX2V9 zl|N%29!gqw-qRPoR2CYttUMihs+bL%_a&8iYWc5suHyD~FLyH`e^FB$P=pD(#L-j{ zQdrD%c{D%m_NK+XlI#J;Zch!B*sq4nXVp7onRMHJUC8)xde!vHLg*9b>4EM4B0O1P``D3#49dpxjk%Lc4Kg6EvhJSlgy?z#UDR1sf_hxb3P57AR zxlMw9!JNJuW84*W9w)}r1EYFK4{eR>hYFRr*G`U$JNh`ksrMf(>_k5>pSp$>e8&Ex z@x`O%-a*4+?Ei8Bi+UU@*SmDib~VW)X>n+EUef%`3AegX z^y&GU-)?;Tg2=A@{#;}jF=#{ z;DA13wY<+(>S9x6;)QQrw|GxJO-#UvAW*R~pVAFqIj2~Zy$s8Hyk>Dl#tLWOJrJ`~ z^^BoMd_3@GKxuVqklSMP|r2V z75U@GNsBG$=`enfkW1Ck12bPs*LHVVP&74Ao%(r6AO@v)Ya*rsion^?S@o!E2 zTGaUpvr8pw&z~lC-zqnXaXs=eKR24mm~9>U&FcyO&zF~(FJ4lZDrMq5TkojRdL{h9 zjk8_m;W{sPRlc^hPwGyHNYBYHDga(-g7Y1qyfy~t*NzLfe&BbGnExN5&N8UYHrV^P z7jG$E+zLU91b25U4yCxeyF10*3GVI`cZUMSp=b#1^5!`+=RNt7FPX{QJNI6@``iES z_2w@{$`fzVzBtVjSt=ziSRXYY?fJmPj?z&^3& zp=X5{Pm@fJM9flm_*<05JDr+B=XO$09h@l)riLHFSf21UqR84-Ov%gt`!OHDb|zW< z7+P9}L!ZBu1m7&DGA#cMRxls6P(UM5iP7{rJ2&sK;Mt>BQr&Q(Kz--aIF(ZK%Yp+{ zuLJ_*Lim^2HjK>QD|^^kX7ekJ5)VSt(vJiX0_p?zfP%lkLrX^c^S#P(x*)o)+U_b) ze0YqTFj%>m)CbIx4-_~NOsM*O`NGnP?`|dW`e7wd`z2TI{8>C z8BU1~?BY}>az_YbqSTmD1dGtpRx~|%Ej@Loo}=3EWEOvtESg@YxL^AgwmZ$-hHP@- zY#sX6H+WI{G>c*cI8Pys6Uq*%QKqKO#u`3W=%izSbJ=IW%}Y#&zx-fX`8IZQPY5G( z9dgB?!(fgg%#?mab~61uqIdqhTx{Eou&}F2#Yx{hJae}xb8>*r2W;Unq%8%ywO5_} zq|CTcj`Gi%=mLnJX=|m%DL(G~&A9@EChiIP7ha+PtJENwRl9rp9@me{J{f_(XgscAVF; zh35Z>U{-*91ko!MVT#>o*-zr{>ScsGfZgw)o7G1s?FdK-6e=V6^(Uin4WQhWJbR7X z`g!hJ`!{^eD{b(X`Qmd^8N7!0bg9A5QA>y|k;RgCNS$}lzoHg5asf@_#LAp20U{;L zBAX&eDKjNKCOuSZ4KiM}HB?u41*Fp803)S^7m=eO?^z$=%2!H*BZ+Ddqp%nCzj~HY z(nNzVknBPcH7caxvwVD4t73i;&4B({=?S?-oe9_qv*3XrQ=SOQF}em7u{=YXbFLyq zVTHKLV6C{eWO599aWd(HuS%Q{#OGspLdieywvQ^Gt^E!~XM2LfS{DM`teSuxA8`U+ z#v_tXEJeSPJqrqJvbxMce9XO3=ehfGGsvxxE5y1^2w%|*YT={( zUf|4PGHH3@1m%=RL!1W}6kQD_b^;sZ1~927iL1pa;|MCj@ zmf0X~X3^(U-9XlRGmni1kiG!#vDGt^r^nMN!2j|5veHU+!N`+dImqyNYh&yILWq0j{nCfUb; zg{i1PF*^4<(APF3P2cV`9PVZ_rLiIN6QxYNF`}WT(d4*?)j-x}cTMMR0fi32y)+*;7;c zgFJ4EU9H=4h{#Zn9o`x7Rc`nBK3Xl)x(0F%j458TDcoRc#5HFUf zU9|ZWCoKjaR((c1@hD{HI z_!h4#Xm%BrMoUn{b5a78K%P1V?heJ!%1Hdh$wAh89=b#y7SN;qa@3f`#z&t=Z{Mog zcIOk7Tbpp}0M?rDW}J`ZkHjVU?5Z+Fgxc)fyr@r3PYu^9RMVoOexG`cf~#;Orvgsf z9Vaez`b1@c@`1EoM1;3e|5?JhGPB@U`?`zd4%TQbemp3DUylm6IszX5I}E#lgB#6s z#H?atxS=NyMPK>P7@^3t;1>uOEjC1@9;@>2uaoXkIXnYhCOEc@p$mEJsGWec;M5o* zWd%RsT-1o6J*oH_$~z92HAwdTMG`GzwZ>Wb;%Be}l{uMa zC(qT+j(dzM+PmX2W)>1Yl?DnB(Y(8_$VCD~WfJK}1$M)*REW95q z7h-aK?UWIAy4iQc|E{OwRz>pW8@brH4wVvj@*RUWovS#{}k67NogW)yT< zjg(1vckr|5tGeE+t>-Rfe=WLbh-y|`Kznaw< zY{E0u$^2%TQQ_rRwyv`&L$0AwSF|LZ!#Q6%VkA3lfB93C#w{HCNU6+u!s=2-!7k|X zfMhCZ^PQ?Xh?G^7uv8u>C_Q(EvjT{goRW?`s_;n;rkXw-&*GgI_`O0Vzws;!9LnEu zEG5%Vm;$>8C>Z?RgI&aw^kyN$AcI@ezt^%cfT`Yi^cBQ*e;yo#mO6oaTuCf;{|#=Cx~L{dAVvQj&AFn_2*SyU;;=vp^mw$>NURmGeL z6#j@?8lU+!SCnVVnd(Pdi+p4zXC#rOg(_;J({sgU%L;_?DoH%G*xArTij+*{*c-l_ zmPn&xb7p`;B*jCkD^|)u+f96RXgG@cDnC5943whl73Bfqm!}d5G7(o|lv1-*5tO70 zU5Q5B$#fG4!RHNoKu>5=fK2usZCsAj)hM zk^(Ko7pnV~nw+SuRD;_kRK)H0s;5b1xyPkO*Xox?gKRO3aZjDmYdn z05k#;h#OhLqsSx|{y`FTYdQyQS=W99d&USZJT~jD)=$xFy4ypG#Xq}4apQdm*A>6b zR{T_cv%1iEk!nv8iD#*WAgUjHfT^VqNiOaA-O1@Y^w<2TtV`m!>=6}8Bs~iV0y0Dr2XeeO#WP`PQ{TA9AI+j{(hSvM)ZyKi-^K+L`d zyV?&BRGFbt87z7ze)6H>bJD`UEl|5kaKW>pGv(AJxFEGVqD*BHKlr|zXt+0LNZ8TV zHRlC4& zewY!d1>}${%}$-{5bob3v(nwb{Eb|u!=0X3d7pcN^_SL!7Dg{Pi2vWEHd6Lpf@?() z@k*ESw$4(}aVCRL1787Ap12fIUfKK?p9p?@@6H0P4$@f%4RXu+^Y3yzm~00w6KDLq z&z!D3q-ru%D(#Y>tG8xS(5jY%r|?;!C&;7tV*7!5YI(w1rh?{FZy+8+yxb1?9R@A8 z(A>Bzlc}7`ohO@fi|2%(lme+)@y?^PC_{&dWrDnm&k83~0C$|hIU}UhGvc73<yq7#gC;(U$L;VDjtMG%}_4{uLRVvA~)8XZl!EJf!f(HC4uvdx&M==!} zwckDAVLbCb-WYwwN-Jv&{0#JY$C@pW^^0l}=I+GRpDpBW&y$+-#yNQ-mvC>uJH)@r z@7!J-tx(sKJt{ou8zU0kY?N3}fCGt>M$1=G!NVphe_mFv zJdtiJC(8NEpmz_ia(LLah_WONtCn!j)xQ&v*`A19YS1Bri-mAQ4Y%D{kW8cxcO{9v z8FAnD#pg>Sro01qMFaU;4t^6K5`n~&K-dToMS(nq8x*JmEVvw4DOF;D7P%NF=T0W( z)hzoL(!$M##>ghifv76W!u&_-*FI5IA@upruaPNbOvATFeT9|Ma~{n2`t55qsKHaj zDrT3zuZV7!I7sgZl|&*i3Z27%gpJ0nml8`2Kb}%ir1psxf68l`-{=s{*gshb z=1?~|)YJ{G`WMn4ul(zAS)%yKD09pW_DBT>vTxvRl0MU~!rquD8tcMS1k#)ZfLt*y z-+n_+_=0l5GM3h5vvF}nt~{daDsbH>d0pH%d4%B9E>}R$w*+e>f$`#Zm@7gK)nduD zF(-syj`{R-rxel(6`a4A@TMY#A2>>K*8uF_By^O|x-D+{cVZTAwDW5)s6m*`ZW;zr z*1dx$C{kd8n>9edL9Ddj$&GN3)OZ}ve&CSE2EPQALCnnb60gUJ&B}dPz(e7)0s-Wm z^TIuV4d638wUXR{7{m-KE*@G^^X_4f7`aVdtFhkDxuS%bF!KL9=sXCA3q~_2X>{t0 z3xoY)KV2xU%V#D(DZJ$wk6MkIq2YUIRy4n6dI>BDH24vO`>=+{b+d*X6MHZWRnoDl zxnSkbbE}i`Xs5}8(X5D;75<4lir0RONU!dnj#Y@asxceedKh&{%!W;P*3rODE!0OI zH$vRi0>{CC%d876!#*(8sm{Z$NgRHbm(BjhNwSL12x?l};WQUF^(;TNNJ--G6ga8c5H3;Dill7k^qhZ|3|Fz5=)lL6vnNMkuKwIXWXZ3I z=!cb)zL%;&+TXFTlN+^;X*i(d!ABJdxk~upwju@+G?+?-P<0rcCAmy82+OR1maM5e zXEo+m`dngG#A1T74uJpz8YEc-Y)~z}_q60bJ>bDN*ACUv2O!a*?2T2jij_=6BT@Ef?Zc-cA ztRDM4UI@o?rrO#c=$5*129;@2rMg@kOfCjj;^?I}YZAZxtXT49eyleL>mkc(JBvKS z;L8&`v3_Pf0$k6jZiWo1A;(NU+JIouW#(CN8P_Eq^Y`Zgck<=z(8V=7er&rA^HGMTN=odU&;Dom0Zg9v zqSZhP=kU6K(I#<=3XK4fnWfQFXe1^vKZ-aM=ZYWY#h(F{#^wL}$tD#%J~mkM%1GYF zm#LxFml36-VkVBK@=w$Hqhrvl#0rXMPfBZOD^+a*8Kzx0yLGSCuu@EH#j4e?c=J{W z0ab)v_@5reL)xfrb%u&N#NQm35o$Sf^GP4Liz6NbK=hQLB4TX>GC5)fXV52uN z=wI(+U^jOn1uZ+v3OipUp`+)L7sltS5kQa`ep~+g^onqNz)?0wGmo7{UW>~ZSP(`uS#7CfG9J;qU2uDx$t=bk za67*SE>PHOMpF{@mhjp8;@cHdkIC1CK%VEeK|&XtE9#P~!xrkyeyg8VJVs$IfVLZ# zE-SJ6JIIym9o1mq2v4bRNI7p@IQit;7@2m|Ii@lf-P(2jKzZVZ&y$xch?i=JDY zOHA@ZM@M|gQXoa78@7D~H9TS=S=rXY!FOSeq=b2KWq}Flg1N4^17w#Or42be)j%g5 z)qjzG=4^@KFv`huLIKq#{CaLV9j?zksW^ck&$r0|G)c2-E0r!=YH(ITvd9KkdB4(E@WL@0$NP}22v)fK1Wy2z?`%!PmI zY~aYlb2xPSr9HIWA18u69Y;!jDc<~y=w zWciu3R=_f-!d&MzvXCScv5*MBQgu1{7oS&bUcsbfkd|jl=MfnpUi?dd6A*{@!%AQ1 zxi)7(bGp?28=COGfzpA3DTWDV-M5iQnAzKpd~l8`FhxBIb9ynZ$vwu)et4)U2AbeB z+O@zgH5i!rXj5A1@wVN6BBD#E9vHAUhhLH6L%Oe9Uj)n9$sD)_B z@$m6NEKtc^B`;pJ;y5b_e<6(9lb?|C-Ct(1WEzNfP8?n04(bxn5~7(ureF7MH&!Jb zM2(O+L|bvqWAvj>{BzII^RlGNhgRDc$=i6q(t|GGX&> zH({ut>1z{!$o!jGjG_s77JL=mntt&T?rcGP zqu3kA6ukU~wW>yQJXMum`pA`W+;273L|%cN^R z1f3s5fBx(qVg@Sylw7fdThhen^DGFj+hU9LpWgHTK9BW&w^0Yqf-GHhx4vs|LO+D} z72?M|TAp8Bo~R?}QT7C75jVCwNgq2n&;N2^``n{nGV^QDp!<@y87Ew4wp0|m?JmE- z6;Mj&!f%zRA#>62Hd2jNY8%~qdeSx5W=<1CCH^gy0XB=KP-fCPwSSR9$#V;g!KS03o6^5;TsWR%7!lW|od?h_VK3CKGseDdz~m|CU}{vMfPwHw+$=)TwtUD^PelOzw*?pT)ihznxpT%i>38I}>7xZ*9+h9Ipzc@hDuI-W4(;lMWCpGX`UL|EEp;kwfBN?6rfuC z;fiFC<=9pD8(aXC2`1Skyz0dr=^siyB4X%HvjsqGUlGmr+oe~Nz4K}>N{ zkv^cZ`O|_{+^&ahvw26jBlluz@|<<;>l&=dXcL7ih!*OR!*?CY1Aj=Km^dHeY*5uA z45t!IfaepTC0t$d!EvEbKg=D{qb@7OYg+VZnRz(jN&x#qAZ*#v={2>qtXd3FOn+3C z0*U1aB_&QLB+O~JY#7-04njkG4;hJz!16gv58)fmWR4>t1CfDY4q8HYa*L=F#p&0F-p>ztfA?Oji zm}<__F|AsC+9=~PPO*A1urRakN9_68rj+F^eTYOzIBr&W2ndNeEBMbXpB?SWS`Jp5 zH>o^_2BUm|36w%v$6|Z__9U9k6}8oJjxF*Mm-lB8_BQAPb0GMi#@zX~$YPV{DLDkp zj*b@_UHV1cpG4v#jF|}97slXgK66>v2HMzQ2_ep!(ps_y53NWmhU1{4?!@F%?)}=t zDIVQJze)C^VC5TJaEln(^8LB!CsSJJ`KbOd2|h0GlWy+_B*_sKnWBWbf~q5IDXKnA zb5{-l`><6I80NA*(lLl=HBHDWmiGHd{`-hW537g#saMW;F|ghAjn6?Asp1RzVUubo zRSLlPi3O$%@yaa|iz10Jf_RAE8=L;DA!Qu3+=()?YK6`4ZD9YF&%x~8^HCm+OpsM_ zJh{*B?U_CvEEL_k8ul+Z~m#3(Rh65!U3i>RqgPofl`^ zO>5L-$IH1=PRSga=E+NS>S`J}b+QP$B`-pbgPLI&E&d;d|tp3JqW*!Wuy+{1y2e`_+arYG) zs?8N81n=-aYyn`#K#PhTi2uC<2!%*WUF^Yz|1u{~w?CFCr){6$!re?IEVw%fI{q#P zQpV6hesQJi#RuM54-ZzCRl5v{*~+06&|(rYjGp3u{NNcv{4-5<%e&*g`i;~MeG6~i z47l$}&Qr+agGaO+GP%gZhFG(=U499a@f_akC0(&5zNT_m6s7T=-yNNuFONR{g_h_@Oz_DjFi0uiN zvHb0Qh_iN&WRzuG>ZaZGtTeco-DXNx7klPHY;+O% zLcezkStbI7~3nuHn2l;2psJ>Axw|xgw2}LvRf@3-kw&EO{8{FSO z`u?szTdG=bh|*AtB#5#?R;ZMECR{6evse+PKMVm9+`fw;NYAbOAt;Eqbj46n$hc(3 zdYD&~#xz<9d=v>Gui(Sf@BeW^K*tSz>X`p`|v41z%tV^rd@)TQy5sEHh{Ha*nFH^ic-NAYFA&F7N1H9%T?dQ>Tv zQ$fEH`P5=A94Uo&u__-8?|!5-;#+Qc!oA;R&(dr8A*s=15*)ucejrEW?jt^eVOiE+ zj#z-eeo{EnHD-mm0X9o%Hx>pIJ*UN_;{rX)=&1-;-TTTD80~P14TTHWR(YM%71YM= z2c>^c#LGZUqHMOCk^%bOuM0U&5t?1OxkA{aDfpgN5#sLUC#|<1N%|}>DUKFos?v3r z%ewEYr0pE_o3@MvFc;zDddp7V=IQ%2Vk~%nVPtKOZd10_bB4ZFXNf~tgskaL>*no8 zbDmtLeoxwMI8;`sMVRb{A+NtEMNK75MnCiN-FljYK`jxeo4rVi^I(RkV-33opH|%O zx-A;4XK}G0#nB8BmKr51XB@*zj2hpB9cG3p?}d-?)Cq~F#{~NIr95A`C*j6$YDtCe z*L%6#otGZ!oEb)NPmcr)WB7r}E*aJC*&J1B@KZ{VMF!f@)jVO~y_UI^Ava7-l= zqW|Py&GPwc)cXU?z%zuFOJ|ys~}|!|ch)&shxM`kqNl z&W|d6d*p|QigE)c`2BqfaJQkV;IJ0Z74@VeK++nW8k@^QJuuKHgIIdaC6Mum$0sI; z&&kWAj7Kv5n3I`u^4G`M!=#_!fpq)V z7sBS`@>9Y+0qh!+BY2UQS@_V51pfbJ(U*sQ8Uc$N}1 z%A^R#a-^KIxv?~jQhx8xec5pPKHTZWS07cS53ZGo6dzsrw_efzLHf}QW{o(w>H?#P zSenR*Cbgt(z4_=JRhyz4bI)!!;Tf+|?IS!Z6e(&GIdyKjx8(ol^iH*#hrH^{mqx0J zj9~LiHYX>vd0`Zs|Dh=8eXXQ7RjYf*uA>RHVbZWIuAo*DN9p1+xVSRzh0o^kNW2g1 zuRjcnkX0$6myLHuQIc3ngvN5rlM47O2s}KG9|&{4bj<~Re{v3SQoq04lcc}F@fMJv zi!i#lqODXEY%v#6mIK`li0m^)M;?#Vh*{;4K!+{Szq_DG=jZ6827NxYU*mKQT3`X= zNwxdu0V5uj+&dqnib;pZC#A#a6XGXDz(3L-;z3)Gls6cbJO;aOs>EpJU5ca-l%smc zI2L2LgIE|Ub>O28?DrfU7719G6+fB1G5LOqMy2Ez(c(5ELEnYW0O3^&Msj>0{`GPu zBe>N+B{`)Fo&;lEvs@sQM^qv=LoGMLsJQ$7bPv@FZm7O8)QrB;?7Uj$3s!6p2PB)- za`%R=CaePH)@=_D52Qro{GO3A&d$Wc7iC?KVD2+Y% zy)|eFHCu|d{H?Q}0pIHP^WC-Q7G5duCf+bVo2L!tE*l;yC*du1@){xMeup1XaqV)h ziLQ;mx1L48y?2UG+Y9K4cJc)u?Q+|Kdv`6)mq|$3#h-%BA=Tkm(9jCnXjE3ecW>Av zh2-QyH`pyf%P>z%lx0;KY8*AFGe7x$fci$|oi%2|HpL`ND3Z`mPJ!@sP?!rIqn@HC zWsu4$un#6qpSh`zixV5FTH3n!G+%RxlL9BD^7L09I(?vDnzL*-I=cMoX2aod-|`x6 zqu1QEp*T=rX>_o^l4Y;f>h%xVx>QMz!~5!Fto9>ESp0oHoU@kaB4cvnx6x`+k?%42 zoi-onoe{61n}ZmH7;0UDEge@ZeshK+J`kR}z59feTWql_eCJ&P|5%^;sbuqBcX_3J zhNYWs3I8>~Imq%bJ8h7+qGeW3>R|u(6?b~m(np$Z4wPQ$+n-64`%8u@Bdr3UStPeV zqAiRhlU%>(C`o9<%+3TB?yKG8&bMHf*HL+_hj3DYP8KsXuU%li?_|uCv=-R{9tKKX zt&i3;tj&6$!^}n2hl-(@{b_8Zy{KRJp=-3BznvMrL$7S;HD6INpYA!}7u#@wzN*NA z3m`p;Q}sjXP+rl1?8oj(+}W>IQDUS`fj_5{x5&RQG7Cj8CMduLZGE6^A1a4~Ml~$v zhupeHVEtPrb*V@%2Z_lz600K%5hb0e+J<1u2K7OUYgeOfoLt-`Vzg3G3uG?fuHy4& zCpD_n^5ETU;a~mI76yTRyVi)NmPL2O^g?aa_Ar)}OlUG-!4U}`QW4|Th+cP;7=~Z3 zoA$@jDzITMY;d3Q)OzuqLAeOfkZArOdLx0(`F_BDc44FwY$$pxC$anjPrQ+rH2^ux5Zgn-8n{caq5t#8ez;kllWSS5LWoH4|OQeRGs zS)&rnMzG~i=7-0s%YY=vondPJER|=eue%gc_4?tF?aV7U8(5>wc6o4<1TQgxO}J&a zXvYcKNYR7tDO^uV;(i;5J7Yad$a%kcJJapeegC%*h=j7Ec8lI43eB?zE<6F6#QV!D zhRAMf)8&oUUv5Oa%=V`I+`MrvKFW9CWCg z%~V~k@tt(1Tj^A`-3|3*kn_|!Nh38ot8)cjGj=$*fw`N%{-I|#CuUQ+Z>JCUEI%1F zv)0v~#4R~uIGU`eeL+fnfj1b%VXV{MQK?Mi$LTM#P&#>Rl7Z$=G*cZUzMA)YfQ0uB z()SI)ttT4WIozv4yE!#6H)0R)>8&#NRTr=~)$z<3KK$%%#xjQ3Z_Tv?d=zSP4+I-8 zKQykKkkTc)_u6a$9Y$~WPK+;5<2OgYEgjaAeqC3;j_z>W!-H-}`&M~27%udy`d|al z0v7w5_`gaGKuLO zhsG(4l2<`K?OU#u4-1-S6%qUCZ18pcV+A}2#d4S09r6o9Y*wT=a_p-|m($YLf%B5j zBm^054lYQkT^&bosC~YuXsxRjiQc+5olf~oz?d8$pU|J=LY4`W$7tRXx8qi{1G(R= zmm{^#vsVvyS1n_N6b|2eM}8i;%)Qutjy23=Xo8l1O9*qG#y^Vgm^9<1&DQo!r$5mv z-5=YT>&Y7McNYC^NK_Yeufo9xSSd&ZmNkEhfK~GF?W3^iL+2Gm{3IvToUf*CjzBf9 z;-Z8WM_N+`W8Dicj{{h<#1W*^xhGqEPA0$Od4s!wyi7ln0xx!f`JT~w`u$C)Y3yG2 zjgZDE3;h*+)%a>d&d9lYf|R@Jjpy9AW))!l?-MDA-q>5$UdGs+-QBQp$r@xEk5(~n z(7JBp>Gdu`|Kujxsjm8}II_gQwqD_3$-CkDgic6^s9Dv!rZcRDuOr#wkZ zRzo%DcQ_wp?PxLP_3N!F%c_GgC9b?kk%GjV9uo5+oBGc#XkdU{ji@vvcOAj+U-Wxk z(a@)l&MNmscL$+`yC~Hij~|9D%NrCQ^h%{vurpfnWoo#dYbu%Wb2`^qR|p^ zfsSXZHt%Us&pD2XB_m{7=C3)e3o0~(<4Z<9?Nq-Go9w&R@B6;B9LCEc?yG7|QiI63 zLi8bftt`j@)p=v-{m!!<@MCYD^T@}gSU22BI{YnbbzVLyHKs^z+iZ8p%yaHFF@0t& z{8gLU9jh}aPsd{Mg_T7!2bF@{$-BJ1M+$jvIEh!oZ+C9!m6}mG2br}ON7jJa+fYR9 zkqF8RnTp)>+2+P-#6;(JcO$2Qhs1Dl@h!p`Z<6}g`E=YyTZjWr<1pGr5Yd!zCs&gH zD=k}Qke4Vuwe+&;u`C>3;23^*KUf9n_+(^0elq{DDStI)=$s*jkqPq7?DgI~qt{o2 zj4^b77ARHYD7^rq{{Zh-G9^pM(YG<+@51kP$vMs z?H&S?R--ZY+^5Vtj=stwmEGdD13hTT<_@h_kn?zt24(Q%w$wDc#RHuypj@xV`jY!VWKtpD`N7Jt0N*oG^K(Nl?lvFcV}>KUD)2a!EZ`^=;5DSU zeg3|g?@} zhUfkllOlP_-)@vqTZ+>A8+<>;f6(M$ddS?)-evW)ZNamM;KAfMuIJ$;u^XfHkNwS% zxsBlhMlP>wR)<>OYFK_S(WURU`eQlWE?&x@ zbx2&&L}fEP3(L#D?T_~m;#vXP>wZG-ws#j9FxUnZ$7aPNgnGFyKZA7$JCwgKF=?{- zamDPcC_BN=SU9cq5xOpczuBp3asVdZHkaf|jA|UCCNUgZDtEY!dX%%|{~7Bs@G%iJ zA|Z4|>{?mcd>*o9w(ZNo5A(hKn{9&8V^rs^Q^&?%YSereMYC+f zZFD*ryNhgDJRH{p$1bfmpQd8G-%uZoZ@oPWZ^WIJz;ecW@s;NiJ|;iC9p?9^q0E|} z?QzFV&2z15uIITNB*LS1?^@z-YY#5 zrm4<2P>Cn2u$vEWa``eJ}&@RBDqu#CxAmZK}3 zXg3eMc3Cy+tFboo+lK7Q`DF2(?sANG?oR;oV26a6Pb@&FG<9NGd;v5ko5fz_pZi26 zK($#MCAWPWJ{9O4TY&?q0wZ9z><)f_; z;K8a+N|HAHKC+O06hLxYj2K5&iG{=W;!a0ENnx-tKwFiy9uc-XDMLL34UUQZ&T8UU zhXpsuf|c_(=z6Q|VRcN4MTc{ibK%;4P;_rd#C}%CsW8zTWDn@P%c3t5-0S)Oy%UX8kf1;)A&2XG_ZH7Kk>i zUiRADqhE0IvsGx9RPQOJ_T&9hXD=Q<($q zjkl~wZ#%w<0ye$`wY6WZDt9i+`rVf2>YtG+MMQy@HZoV`_lM)kU#X{p-5?ib=uKM! z9y6E+duf0+uydZGqR#Rnz+O$u%8%d%yA*_<$`;KYelHq|7F{Aru>wxsdIbC z4}L=LRd>OUuXkNxB-x;c%wtkf==gR{sYh=5;XZ%giNnm$>7Q)n-NfUPbE(VU_cjdp zoAXu6<%XKAw%xM%Wv8Jm|K|_2vy1~6uj9N@cg$=PoA2v+v}ZT5Nu9lJ%m6<(BG-Nk zkC#pJ(&G{S27Jl59@7ySr2&;7#PRrZb_u#}8<$kFvb{|X2Fxc(7y=B_ zA}=xUe)P@}Kv<8{?&T5Jjw7y>NSAv|x7{}l8G)o;!@NZyl>UA$ma1pIu#%)YzucD5 zTiYpQMa1{QQ0v}QDu;9*$llE74?l#+9B#;LEbC2P4E?8;zg78O z$O!R!tIc=np~Ck$ISo_o39LaQ~# zhc*wlM+cCT<9yCjk%#M2Rm0Z}JkKNU-=27U{5bjVM#59kcFxlq9~jGseSUZ1J-wM6 zX`O3`UXMEvLd)A{oU}YB87f)9I6XZ*IXM|o(B^k4D{;IT4*QcL_1PIC$MeYX3wU){0J{cAMnO?<}A2l0?E#U77zm`eN$mOESquO8koT(kH!+?d?n(9yl`cM@avn$PCeZQqH} zrV%0E0N;__z-iZ~hw`gUUZHB1L+%jmRxpc=lJ}{?%I4EeL${#24_y`U`YPsQ-OZfB z%A2j1e+#utB?G8_NEoj??~paAGSVvnzXWbf^!FKgnD+kJ=b zyI{>i*-p-;=k{_|P3JA`r8uVoaWlBrl!E z|8X%GB;;@k_`c_Quu*>Ga+CpT=-{>we|z-=+1z(7BMxQA^OQ4;ms)mLh<7zG*D(w`vwok|MQHi@pys^ zVTB%_GJPlp{LJ5hkJ|NBz0X|L!ofh9Xp)Za=VdWvu4Z{R4`i7st(wSM-jWOr)@L-4 z1)5Be276`Gb}`k!OQhj{?a};*peg4BHji>&it*!u11+nKL}WyzxBqI-PUp*H$6)LRx7QEgg%Oh+#L znVYxR%NI6DCw%KR0P9n!m_1Laps_i+%jQoQJWeArRR_a|W;Q?*Q~UI%zNPmZM2_5^ zr%x@A=2$0aZdrT90M%*TgZwYf8&^_7nIL|vJ?{TQ62klG_!-IgYjhvJTJvx31Kx9* z2l9;%0IQ_KEe^Lyxni|qSKTb@{@TE7R|qHNd5>OL4<#XI;+Napr{JCVFXW=o=9YPq zXOF0*d>6dl8*t{io5Dx@R^*Gt2jvnwep2qOQn6FP_1YZZlKq~9;O=q>KodN zipUaK`;h@-hR4p{5tPIHWMUXoSj=m&-B2aGf~z;$4N zp?oGEBtMyIw#9|_=yK})c3VN;iwopZbi7kSrF*wp@IA{dqoUF3Q0`!gIOk$#lFI!I ztxnx%tzJs%&t07}3-8zVm#W+g`Qvo3@!8_0SZl5S>!#fNyC6Ko63Lk0xR*JVv zdB%>HzH=bF56q+T(^wX+9m%({s!{O*=|=*GCQ$k5mj6EknnsqL*bStVmV^6=2Iog} zYbe!m;0W8+N|(#E{<*l&mR`j;E6iUHtWpGRJ)D5?DJqHkAy#^BTKV&^a#y8GUT z7rV3MN7yjPQsY9y&u9|zSv&o;0Z|_|77DffK<~Vq)F1MPLS7I6IoM^;^HA@v;0=yN zI1kH7df$IZgD-%Ah+zqCs_-pT?9X#wdQddn6jemLJu4daxK?oKicqV%)u}GS2l7s& z{DkpCkfc0s5rB93a?`#Pl|9q~g=ZwmP80Gf8X)}91%r2_J{6j9##1bUV?xv#@1nQf zm}OF-zMc9@4W)$a=4{z2nXWt5B*i2>Z$OJd5JltDZ2?=?trPUmhCEl0+U6m!tr?KFRm3 z>d*qYQN|`^jiVVO!`CxZWfDn!0;e-2U*KQSUih;;iXDnV%{no{sQvpJoAa}V$=Wv$ zldK-#6W^M{j9dv>TgUwWvH)^^#a!*ux`kTrJV%rA6LiwGWWxh`tzh%7-k74Z6_7}o z?pD8(tFbGucfGecrvO#Lc9*3A{|&+o%^#0mKOdc3sT98+oRj)5J)$I!XdnURG;QdF zd653BDOq{gSZo2rBJxaY^0Mnc3ZLq zgZK;!)!zL!wl)L7?xg!{--Imx?s2D(sj~Z-FOYPaN63q67#0{uBd3S3s$HrfQ62E z5P7Kl&jRIUO**W9jhcVFyv&&zUjRAKQq%B}ngfXmXMoIPhx2T^`_av#fBtD+Y#Nq| zDdo)fH=%jnEGol$b0>NCJI3^Tm-=SNP$MJ|3V2g%sFdD3ADb2+z0Zenf)Ky+SFbW+ zHXny$VAG8)c*9v%iE9^>7Mpr{ek1tD$8767K|S96IJM=u`-ft=(OkFvv5M7JqG)1e zD5aKnr?X619_9fbv-O|jvUxTr5Gz*y=XdIKFX2w8fg6*SU(ysDPyhN$t^Cz)SYAgP z;LWs>dL1zSwHU$;e+Sxr#MjYQk^r4mqYBSHLlsI)>I@U%`z{XD%$l%vov&nXaWz@) zmy29N?ZSe2UH_`nw%a)bPo5$DMTS+x9}d=R%AMBX8s^Mq(B1wfm|3PDj8LkD$ZR{ z?DN8P5uklHo9aeyeNrq}TQx2`bX~*Vp%U^;eKACX$ zQ#)OL>czW2`Ae{7LPy^Cx9;bkdhrhuMf??AwtqfqRQXG=UhjA+|I)0|&U_r?Mc^t# z@vb^BKZy88xMASb#lJG9fcYZt23s{@_ho&8AZOl-}CfW&OPnQy~~Hxzx}s+ zp0VHIDt9}1_R&WsUxK9sP0ZAFM_w_p)N{G4sdx_B*Q z`U&C@>-yJ!2KS!)yCWuCF}&PchORd9z4xo_VH20NJ_XXMOMjB}%yi!N&VzURbo!)l z#rSU>P5I$5>*h=e|7fd(kBBW~UKz{%~P(d<7;cq-O=a)?T>k$XN>%b%m_=fg4u-9J*v{hgL1tyNC{2 z9Y2pW(k+qFd~Z|hF}PX1@yp>6A}xP5DJ^OyN|nd1I&$*kDiqM9HGccIGDoQ33RN4s z0$oQ`ADssd`E=^L74A>%mI{9dm3H+L^dNi}2V6Ukvc z8r(q@2B88uYk?r$U3K8(c3+lrH;nwC%MZE6(a;O1q-Gr$Q-CTx0ZUT(nonumsom$k zRCVMe{vN}r8M9{XmpZ=x89;vjv!W16D?p~jXy~a$y9twuG`#C?jX*WtpnYgS3$Fkt zp*d=YTnY^gf?|w7#%iHT-B?|=-{bIZpZWUi+b(f+T1cK$(Q=54?@em= zEVa8neZO_nqJQ7UirDg z+lx1k>v7f@Ljd~s`}C>5E!y|sZp-=&==k1WZ+~YH#1=EitmrTxx+*DY$$!UUMEMFY)uo;jD9y>IeK?g{MC%$*^SU-h1>DU5S2{ zF&Q50#wDD`Ys*mjp>S1R){b1tBs{(RQ{du?{38GYgZZ*-c7Rp4B9V)PMLn7Chn&MaL5Z*Yd8J|hhm5zK< z<^w55t@%`B%I@#ad1?isGzbEO4%Dl0kRn`dF6DHGf*sWyK5w>L)O)|B4^-_JKwCRC z(%@I%b~W+d2K2fJgwi9>AHA!s;!Iu~n#1*>h3{?2kmstseB)s0l!@6ttz6e}*fA7`f=9PxD z(~$!{ed_9a-r>W`zhrID$j=X$QaYggg?OJoVbbjnl_h!YmK*QtH0r|7A3131)6;S+ zRm#J=;;pA)(}o>?@yy(Nf4btG7s?k3J~=1s#FarkZvxltc|^~XFQ4_hbCcSy`8|gP z>%hJc%c)->yHzM?k#VTu1!^WvlYAezpe|_?zl&(rgo9|c1c@}#rb%FP=!ubu%m_$&7`$_@3&&7sNf0}jam)liKrGzX3nt>O{e@w z?H%B}?*p4W6nzJ{I_T65{{*%N^&h_@o?D(hsr;~Xw=V4m?D3;>lP|ZOU#72?ORt|S zTDDWhC3|$5F)7)>PMtJ+zaE2Ofw)BPUY$GcdfH|DH@jDi?+uF>eX(@#(gjPQBOh_B%wkQ5W#B)HMl5O>7D1_|HjVSp8LD@yX?Pd z?W#4iKU_O!%Gxqa^sU{rT`_?EEr^<| zDF#S2OkO<=4f5EH=INlKLCAZt+9O09G1c?zq*Kz!@9=`wf>y(hfAefrZk-|}?n@oXmcqC^32P&Z#O6$2@++*iv=(r2X%C;FWQ=Up)@?8~x1_7TwNOn!gA}4CxK! z3h=NUVA&++PluC$x!j;-%(~^gZFbnFb^jr42kzc!|Km5UUeRu+;m|a&a`NlV+qPdl z^Mf_hC$5?K!Ro1R`kr@C`(emY2j-}RN62|Kf>LgQvGWKKfSO;Rh&UOdRro$|Ep@Tw z&(Ot9L*ED1b@WudcsKDq;Yc@k>hNJ6(b@0!hP~^XgQmxOt-vpj`7*Who>}H=BJcfr zo&|;9yiR%2gY|D#;U3Rq)k&p?822_qBJp>AwT) zYd3fTP2qQd=RJ7Oy!%n8#l|>)gwJRAS5T?wZ}=S9#|p+hZoo zly99SG+4m9JOC7*0NQV6jJ$Gf#^K7a-IG}jB2LE^=bh5 z9l}8oA&AANyEugC?v&X!qT^&zh$nvW-KwB94}M-0tlBSk1VBy!o``emQ^+YQ80D&s zU`VF{@uKgx}?{|Q;N-vl#P3m`mBPxI|&~YBAMmM2dR;{DTdoO2saJ~JVtIxDyy6ip@jc;4wV-r_xOsg+vmE$6`_KPaOg|sR(5*663qEV|*s)&Zb7X3TG5ye3T zH6jxP&Dl+*UHXMd#w`E<5CBO;K~y>d7tIZthe~G@E=(b14ghfOexWD@i_fE3e$(d~ z!HNbU^D?yZ3sfXdwty5+1{0JhS|u|TL2eg!Q^)&?<yL`fXt z2!$LZm-PZpg#sg(eu2!uh^RTJ%v$05Q*F@f9WFFOnLXEgzdoMmE*Vifq-PBp8lNfM zfZk1xJd)l~#>qx6d3k5v2jQNMIxs+Ey$>9sNA_rjj35nDARh|2OD&Px4z4;d|F}`! z2L?-iAMeyl@Y+Hb>~|N)87$-Z7fM25@^fNyJv{jFH-$oGDU{@yPIFWqW z<;m(D^3DWQ+}*Tmzh)gck>A z5pKRLu^I`~MU8r|;0X!R5gJRc^uefDAdjhv+QHWm6p)$v`%R~58NhhPEm`f9qd>kP z3G(UavaBS{0Jc6Aj7PflAiM8CXUXR{HTJ-WV6g2Z+f?$brPqNm4+ihs+hW?h#Wo#5 zfBg;bo73BUe2Z<`Z`!z_BymLJAb$o)?}k>`C292BLD0OSNrUc&>Tk$|PKC9fA*y7( z5M`={#vgGnNXS~pNNrG4V^s%U7Y}w~zKlU(cj}187;yYQ6UxJWiQo zO|nm|tQ%LSKG||~6j2qh?d1B^t8%{gi`&8TDKu}AwAD_P*8CA}YY;lgynl|nhw2Slr@G`cPrxfVy6qfcD#25avL=Y2Pr zKSR+}-V+WnOtso;O=}^4!}H*6&-5$Z5AAxd9>qze*X#NDO(TK%h5)sADm2A>*n7W_ zIwTDQBcnP8red+E|57CNQY56)^p0|iY4n~hzMJ>F_pALfD#*1^S=NSo?-x9JK&bUX zoTcC(_*?`UJ}@HMb?>`k{!E#{T>DMP*thyyNb9csy}?@v1!&Q(Q>zXgS1p_i5e*GH z3pbrEYam-83A7gbiJ)u;ZxmEXiUw7tX;{vQ+ymT%bqPU=rlAToPE6P_YqvYsP_$_K zmP#wJPqA^SDgrgDpqrYBUSp&xP_e-p3U*4WnQ&De_r`P}r`1eqKKZP^_M4*#I6?*1 zt4S1Z#_3?oK)W7&*Dm{X!>VOrE}ol)zXOcedTtyV`tqJ{7ds=W`)DGB^d;1s!i6oUCwT?<){RMt%%XQ`UZwLrKX zM3zGW5}l$$Y4r_P96_${(HBaTU>@?n8!W6r_-P&5Q^zw;Ri@u^53lGL6GjAlOJGUaKA@Yrg>wu)@S*s4S4 zP6KvYyKKpZRrNfBnf2Zr?*oI?lJFH&fH_QFM55wJ>rP!;v}xa>b({FjSP>Bs5fKp) z5fKp)5fK=hHmu*UcFl&hE7yLyu=KaNuN24Gyl;Q%r=(Sv{?6}(<6jC?ti9oROnvQD zrt)rUE*|tdwIpRQ3xf}=lGgLx_l82{Z$|)&rX276MnQhAar4E0yf&tQ-*k65taC&X zRveNdm5?n^7u#Y=8mE=Atu5|9@i%aM+L`7vMl)?>b6P&bD;(C#d9H87%hJ*0T|UEw z^Ti{wiDAM_ug=sW%tM@4Deh_M*Gjn|DeYM-6Q;}-=z%$>=D5K*IG2xCPm|zbyeF;;FaG?zMXd*jk!dJh5uU zsXL$A3j|vxjQy2m2LJJV1+TR_0>N7G2U(Li_ItT>!6$f{Q$9%R*NB!-AF@6Vx_GFB zPC@gXt966clqF5gp-831TF|fqq^eb1X3O~sb`#=7c(U``#OwL_@{Td4+N@R;q{_n8 zOF6I#7EZT8WgrkFzl-9PoXJD7p2)}ByEWe~E`NI{pDw3cU*EFaqPESek3bRLwYy|S| zh-^r_jlUly&MB{xAUR%qcWXJz0Cn$vsmMg~cXT0n=OmF^EU?Qw5j43^Ba@b}zhMU9 zGXQv_AoNOPLwc!;X}TnQ`FKTz)&%|Hk>frqXjG=hBnbFD0-=$jK&eiJ36O&b&jj5Y z3CIyAM79X+%9O~}2Bqd3n8JL9j>-6fxMv}}Ld+t9N^>eo5(*&a5(;u{EqsG(4Kma? zO-7Jnea+|tDm|QFo?r!B6CFjKZ0WAL)N}_>9-jD*@FGcR!sAOJJ0w(}iIL|kUarQ3 zUdm^P;Hk=)JR%g8ab#tu#C9rFh!!=VqDIaA!atRdN%fG&>cg+)3QS$^SPDA}uXgbO zs^$aI{+K6f@UzM}zM9pt+_w?}JoKrFnb(kj$`h z{*`MF-N6%Hc#FB7L0%zO0&1W{Y$Br*WOSt+jxRly(K-#>kz#5mA_4%AM#$+Bjll4H zYTUaQJc=4n>sXaT2=Z_OMy`-vZAOIV$$&=IXvGRUygm6NxSa;HQ={F%Q=>h7A4GuG zhR@#j$*8Y{2a5;ar=)e4{^ild$N8xo)|7U|6ERLz=TWvbcr1hrbeC{Nc?@5B(*sc} z31t&qe1hWDsx4^U2p2+`muPpR?d~nt$d)HX8PyXZSZGf_PG{9xv37#jW{zx)L{CCH z-cIqHkyk>n50Sj;C;MFERHUz*pD01uK^c{TE;&}Hff%A!Ir+S?ekGNYc51(Rrr(Qlm{TIsy>Im5ikDxzKnl?dmlS?bjKGd4~ zM08}2daBGB?vvu0`XQDAmX4afmSkf03wW%7D@Y2c9n5yf-Hv#0w1e|gycH5*VyuOZb{&`qdnUT;;b>+F8EZtl zTM3xY@MJYVQH?;cR>A-P5CBO;K~yIoV=ytH@FAj8r-x&kfZ(yC2|wZ9WqCdk^R!+8 z77;=8h@dzk%9fG-gCa{r2jblnKuaX@*#rR4>RMb4T=l~0As+DXORE~Lj~o_xrW$@A zPF~%Whg2R>;-ttalyZ)C#1jWkRn)6dCfX>wj-iGpG!7pkr;2*4Z>Fuh_Qdu##|11t zb*z;?NclbfBWRi*DqqDuta#ho6E*DGFN&Z9`Xuj)L`Te`SXMDE<6TeZiQHQDkZX56 z+W-M$#GPt^E2rtTUqwN${U&D9tV*@#Zc<&xhO$*M-??lh<_kMdf;P9xyo%>vT<-;A zsO8GXp8G^}s5t^Os%BL**O@!9PKlMaX4Bx6P&q;Ht`|qtcLlmX?Br$ zf{@ENG;?^JXIYZxrC-Ui>~~nh^W9O9op(~kx44dlEI^1E5}C9r*Uh$5ZD3zKRZOBb@=dipM6ZTG z<|yYE$aam4?y*0o$WS55y}9#JauF5dVcze_D*7?{=zBfEkh2oYn-?x>D|-}DoAonO zZIWpp?PB>QH%2zQn*e`H@m}#q4#(H;;NyYvNRY$y{&U0N9}=TSy?1NGjX^L6B>BI) z_UjeD60dH`NcSCIdxaFIJYTzgYQ7X%39aGp0K3|0YI}*g?g!v@>TNH`gT{lwLp69v z;US>ib$`ficYvTfSnB?k_V!NVYy>zJcgRXM!gXMvTD^s;9j`{6)i97%FLB>R@RaH_ zkxGni#sKTByiy1bKz5e_~20s`FE-v{Unns5}S{0bB^HMS)E3 z{wE`JTPdnXim;MR6T4|V=n*8ePpqn33fF{_cmzEBrYo3nXIPseYb##(p78cG9;7ED z9$moZWkj1iaq@^N)d^79P8{tj<5kj5a<=Ecu1|h2c!N?eZ`w9vEcCHU8EdfWy(#`< z`kTim5jFi8dAss_91$u;^hwx^FN@kUnxsk3D#k_ZDMd&zW#2oW_T&|6M$-jJNkY`s&NwULg;Vy}y%DpV^+mLn`n6wCcYD zjCmp)zoxwOSBno8v?#wBLD&sIpLoURx?1?28A0o2)Qg(_R1Qj#8xdW)tAeHljgH(0 zd34c*b~IZTGd?g*GPD!C{w__nZ;5#>$*1}SNQOCF2L%`aM?{#HYNJf#yhRDh6n^m& zAxwSoh`WN-lO;lB))mkO3A-TbKd2+8K{d}eE@j(?g1id=!nRf&I6ERNyCoM^ycsEo zFAh5ntf5NrwF9Ar{3?L)0Oj)qx5 zmqM*D1I?M@vQ{%O>_A=ftlxj|`h@B_@=3!jtVhDYSj*>8)S5n1HS&!()ilza5$UxR z)P8Bs`7tN&*iV(Id(Q=_DX&_*U*!C>g}9G`D;ox{QF;F+rCsuMy|(S#XS+5XI<;us z1|n*J4Qtn|S-$ksIUg@yFxz_&S~v6Y>d>oS=icRUY1JAcYJ&~y)~;DuzjW@56^rNF z_hJ!sMUWAu=4}Sh5eOjul#Ac zI5i5=EA1I+uM)Y&D0SRT_iE*Rm zz`0(VI2}zpCa1@`-8Y%zls6U|yEHk2Ega-;wpTdD-JvOn(C1sEyrU2p1)i}E^^mNQ zg{=L25CZm=#rOuH*kgU|jmu-|Yxj6gEq@2N*Dm{zmaSLSFI~5K)y56$A)*Fo-lAoz zw(Z(=?6h(1>Q5%UnRR$+V0!Jm4{6bI)$(O=TxyE)&}`GLW9Lol)-ISjQGH-UiW>n3 zrR*^RF5u}>JO^v<1hRwP+OOIYcttBNv#x-VsS9`Mkq1qPc#8C2*0bXcOQIZVNZmRj zT1^DV80Hogk3z6Ky3HV>YOrk^NNap44#ihVh71XvD^U@slvbjUx%vm+p2v}YY(c9u zBF;Tek&fK*1c)hYsOA@kOe4(S-SrYkwH3V<8EH?CBhs z0BQ7y@JxNC9J2Q7mn|inwj5B;oR~i+<)ZF=yU38)e8bUV?*L<-IQd??45!UnES@uC z_3~wLmsLA3+pb=|bkXeTq(!S{dzzrKJk+yQ)+qhZ0JZ=)5-nB_9w;wM{M&aVPksYl1FNJ~heg1kQaa(B8Bhg1z)zI><#4oV{U&u9~0d^`W8Oj4N8euqW5sw4~yddzrjYn_3Q`Q^3463eu^G#S5QIq5$(Wiw8hY$|a+w z^CYbu0@@Q^dV+C`)?O_>=XEtX)AVxK!NFsD<`@e(b}3^GravG*@%R#=D5E<3GdWHA zwwet!&zHHEi-2>E6;mkIjOatLDX&OSEIVRc@_J5?xk95d-|Dx#D9S}(Py%Ki(?`VQ zRhrOvLLA!;urr3_LCsmpo-(%^6y&N>P&8i{^N5*Cb(;WD^Aw)BH2X+v$hi+3)U*T9 z?I7n|5dBbmG6+}J=5Y}bfaiMYy_)XIlf`^04<~v+PzP0&E|7Pzm3BDxrH&$Ixj$&J zsV*jBlQ=#=L4#K^XeLUuQ#Cp*QotHRsh zfCt)4YGw@kn4;|zwHwhC!V|O-AgS%7nmlpx5X>jTnZ-juyK++Jr~cmo25_{?;ZA7> zsO!0H`*A8^ijhxRYL0N;y#ggDf@5$MS_tt@_EvEfJB2iHgwH8+wph4y|I&#{O z5H(d9mon@ldXaZAz^Ls&s%WWpBVtt{R$%h^y5t0p?)l*L5ha&j?F!EIFjpr5qEr73_7nXk;UVuLa3c9z^OFOIWiY1os&LA zLmq2r!pRGlPxo9bxKo_;X=bxHlUj2Mg-i!Yny59G(O~hB6lmPT9L?#<9+MEm4r%&2 zddG7y)pfLn%OiM}gysphQQd9D;Od5}=;BDa@joJf-f{ zBW^b%qSm}$WJ^r9dwLv}{|+$N`{{DKwPV)q*b#R-kWPKJTUq}pL^Lc`)qmQh-yr|z zq;uavaauJbv4z-g{sZK4+`y5>OKjstbDc4bxmey|8ApzAlM5lIp2G7SD zEJ{*&Qsee?dAu}DU$=d*J+&GU^^6N1FUS~clh^&kplSYQ`KR(*2~lf8O)B?-Cq^7G zh2qYLM>A#-k7HcpiCyV3^M-h?1gM?fP%Z+Lw}GOZMy<@2^u{eu09+A@EsXOj$h9AU z3RY=RklLY%O|SQ29?u16j!<(4(Q3bd<{Gbq$T`cN%gVZwqz8~*BB`1s@!VldTId9- zo$PdLilPIV#Gtyqgy^~h0ip*=VqrNiMFyY2Pu9OQT@z>XmKU*EupWF%qwM^3XAx3MzAfd5Ck>C}&du`-vk- z9GDr(HBVrE4&(Ntg00agy_ZsZWcXEHgn612pSRZ~L&2i2!aoGZ(nq179j zeO=VB2H2FK$pZ0IvyWygqEpbH=p*)!0(#C(@rK=ew7lAIQ)yY9a(fVDV#S-YW-7JZ zMXexxl)DJ##cJ4S0XatYG3Z_l0Dd3L(Vjv1C?_powS$|dHEst;lLtI9r&70luswx^ zY38`7cH~$zlOhkn{uAJ7rhjUFi~U(!+-k|dh>oigAo5RAc~xdC=|{ zQgxS2?xK-@W2=!l@Qw0JgH<#SiImxma0gvf-{$d;g} zM`S>=m2MM#rjvHSRLzoT?f`vO1>~{%$xgS%bGoLluDe(p;Ca)SRdJvYjiTMYq+p2b z%@1Z=eP$^eL#q|TlVRt#MgFBUJox0 zV(}=^c-sSblG$(MAU6O25CBO;K~zrdBZ=9rMWyYIMcS#e9b|htk12|jp#7$&9U!eG z5wr4lfH9wVRg2bb;`^ly4`%Zgt@yWXJEE8QXp2^@Z5bR#I~D{3hQAC$waU0r}N6JriI14OOe}|yf6W^97U&qd2MtEAZI7RyzpTWHPzq& zTs2a`18D2NhT`#ceexLc7qkPiC$@9wxS(aV86mM*T{OQICb6@F#CJ?&pil=Tj{DSreA3V~@fNP59m`TX9J4Bz zt+>0OSP(ubm3QL*(28YGwrhHNOIy zfj};k)Ow{Xv*-uV3J;96otV{R=27c8@qwm0G7zo59!LhCxKV@fA@UU0*JDFva~eD@ zXdKb_0vdOZZ^#Vk^efxq0hQaOO}Hq!9k912766S`22I>u&C&Keo|p$jT~z8WeJmMMKzBj` zkY6SK19t6K_>a^Vu)YLvsHr>DpzXbpb~t8L3}Q{~dw<9iC;*yqfT;LQixdm zD!^h^1xSekg7pFwLCD(y?Xq-lhxBzaar4B@lY;Fe4^MORBoD7vVm=;f#zP*SJEo5p zEnxD^WCj70P2^lEb*N@HSrQq%Mg8%lqsK} z6$}B#JOlt56%vA)UjcwBUakuvNtIMB668FTtYfq}Nv&Nd$Q2BlSe5SL?jS|Fixz2z zWQH>#mbA(a8m~>Bay4d}Gg*0qx{C}{=Y>tw9caKc8MU?}pw@OtO_->4k46DiJU~(~ zdAZs%ZAj2vc4AkqxDD+VHw8t(pr{TEM*U6kiSm{SJUn1G0<;2CLLkTY@`*EHUW}uR zh)f=QJgP7Vs<#7b2WNX;9=z=?d9a-6y7=v2*$wpe;IS~r&Kh4Zc)y>3ieie=oX$Ia zRrll+pC`s$KMJazhGPnJ9>t@IO*>|dxK^unwC9oe!D$RdQqq66Ew<5FJgOmanN91GgdaAMoG1J>TJh# zT{jOk$NyRNj5b%^q^LpCZ9zUmjd0rfac=C#}jSzRotM83OMSql~7MV9(k~w>ALvs z0O{=%xkC1c*yAY2nreIoRUYN`J#gL2128?=>Fw?qL0JeiN;MwEql!%yN1$U;>GaD%0h&bcI;G$rIAcxR%H30Qd=}@kFf~LhlQLo78ZiQhJOaUBJ z&4y@R(1wql@mgE640KJb1c5PzXP1KLqyX-rBNMGHHg^@%|H~-J=8VD;HN6Y z9Wpt4@q^H0LXsE+F#~C{5ujO?pUY<>E*`;@uMW$9p_;HZ*CrG#5(FjMDp0Ozh?<`W z(dQ?nJ3&*eyxXVNG>A_Ogr8YboY>nZMxj=AR`>YTtc=YmY(g|1*#we1&1kg;#=adW z%C=NdqT7m^RMm*Uwf>_r(F%Jet0EwRr@{jA?z=$&^WdY2RW)9jRpU*|6TurEi+Ew0 zWUUFN8&S)#XUbz}8X%yW+!OjfQo?5QfY-sW-|D!x+-3O%TKA`4AV%|}|3tHcnnOYMgHM*m)$Ub^NK~GQv=+QL%e*U1!MN86SYLPT7vGfz;h%{F z+*<%su?7(LqZ1{hrZ|>CPKQ=JnsKLcuXfL!V(kFjcizS5C)ycvqKXbNENF(sdO2&q zYJ9=t?P6q|z)FIpulUQ|PQ%-2KsyCT#OXXW+VKwG=1Hx1vzF`Qli)APLoo0CRDTB; z1)R6tRFL%q#fw=MP#qYEssn>QKdG6CX!`1PV0kB4uK(1^24xrm<{d<|<|9P2aH0&w zyt0GAi&-$S12U(u3Dx+75@{bm)dm8VeL&6J;<6xj`|2(LrMlhJy?O1vxU?I9vK#g* zig}9cY4C}Jpw)!It_der)p%uAjW;b%b)GnQx#9%1D8_C?5HDs;Zb^b?H8g6tT?PjY z=Bc|~j(ZNCG*Y`u7p*<7O++kc$;M@WH7=RssJA=(!S)|LqCw};A385Gs_<=)p09a3 z+B-So#S>qS7z9+e#5|5=Ez*@Sa85AuhS~$*Y?JtaaW@du>PzJ=ebfX`(V9}vjTS}G z4cZ>t%)?r)M%2#jAosM`ZrU87-S5+Czkqf`K!`av$^1;w{3UIKsSr-H367w|0-*8Y zWEm0!B^`6V77>J2$YSmzLSMNO06;rB6nw;0`vp07Abp9_mw@me;f*41U><3wcmU9I zGFY)`#vMVLDpyY81@lG(fsCNUi==iUDnZ`K(jo%YehI4m65;t2c|JAt(!8C}ls$`Q z{jBeqiMySIx08T&6lFf11hi-J#wrU%v}$*+$|~mpLTbhOelvh~eOh)G-|qlxeuLUI zs@g$skJxf?>}QT-{~#hi%2`&OGh*bwcO zJj8A~nGzDs5C|YR(MHM^7CeHJHYt1po zJ7%+*@BjX4u;!BtU&goATyu;$nmOlK>o3+-VrZlj@6+5wwO^kk0o6~;dXDsyBq6%N zbX0Z~PhP2($$8w!9_>x?Ak}`6I-H!#wA7JZ*)tuUM!T2R^94&$ul?GXj6|1e7Bydk zvu`0G_!Q}mJV@@1(ur4c(k73f+OH=sP|rd#eDWaal=pr!HD6)->>3JH@LhbL(UkAT zVn2$nby}t{d{^Ypjx|cu_%8BMD>t%NPc@C~i<7u+UxdFK27U;bDA z!yo(aejXieYYT7BSh4Sa`>*d@{`5U3^ZxP^Ui$wz>o0Eqmpibn4Q`T$LiY9bY?N*d z?71=}WTG*4q!$)ftG#a}HB?tND6Mk5|g2UB}~A9FBetaL31RPz>PKEzd^v+KXS zSz!t^-3jZuN7X4*y7VQQ@60KJ!(}N3HkE|cgVCGOp|cc9eZ<)sF~v4k%W4BP8rBC1 zMUh4e7iwz-MO?|sb&3olH#^XJZX89;u`<)F@!>ZQf5^g^(n>12Lp{Y-V8@y_8B&DASx!t4WD6(IY|`a@NcF? z)`$W70tKoxYMW*tp893fMr^y16diKRm)%Yp`1Zg`2HChKn3|pIW9*XpkD7&qtChnLAv1b{Y5lx^Gme&t&MH7`*XSd=2M>X-gmzB{J;9-WXF5rYv1tl)86+by0=g%azcmgN8d5CBO;K~%6g$umt-kDQP}^F1gB0K5VQ`8*sgBIukuC>65iZl9@6%}e!^w~{= zwhdNw8%(p%dVye{VO^^cMuy|+Z3smT^NiQ{I{PxH0v~SkVCTx?86ejH{ZuIHKlp4i zUxZP_Yy%}bG4=zCedP38DesX|JJ*$r@sYTkDf?8>2XjAlTFc^!7GmH5#ew=s9~f&K zZnbA)QDT`vK{VsEiZz3pME6ie09eJKuGeWp0Zc8>Y>yg+q`toG|kZ&6oH>Yq$w z&O(7kJp@egA5Og~s6=t1T+O+fi^*ccLpY03W*1*DwO^@Mi}U6A)MtBO6l&eA+w5 zV_JOtaWDFRzwg~+?mqcbmtDT ze`4cfkF9@nAL>|pPNp^Wgj~hb8E+b;=%!w`<^dN zZQ#OBoq{c-#hhg7!0@IHJoWZNU-Z`h?ew?2`*m-9_mrM^s03=sOl>Ap3>O_;(hFk9 zjoBBHpP)-HPZ_SwQjnXJ`ckfN^w#W64+aLgM{*gIK4 z%50`so(|B7epnHjRc6q(!K!Y9X%o7bP6y z0J4}6V}(yET@r_pocftqRGfWN`}Ns_4K*Gr+D78(UUHD5IBcVIqEAP$9gcNq@}TNa zaz~z1T8U!bp|b|GbE-KD1uBCxI-x)*`hmfjay92_E*6Uoh62(9D8Hjv`xP8?9rmqelXIBiC9U~m{6<$XWrxxJxHu5dWv(I zcc^qUfs zLkB{m9tngn1+%m$&{OHTw36uzw+1C|d3~03Aal)Y$!o=oDJBpKCk0{aHT@*QmQm~B z1su27f?W(98wQ2!|0_cVbv<4c03QDK5W_MY$bg)3V;2#d0eg7I(OSlXyh&V$dMj%C~#ZslT8dmwH<5fF6qdeZzq zM#)^eYK8>ebXC*f_6!G04>4iB)Y3E>2huV?p$f z4gQ;Rhsa{4u>bCwKSow&!wSxPtQFe>$PN-@t`o(|i05A^IOg4;{j-aq3W3YT;D9A_ z+@i$t3@&8Hd^FQ7OaggMEKD?&x`4x*JlB4~5v8W~Z0En0ux*B8xknKPt-#65nO}(k zNHpvq9vnQ8k~>8_Ewdzi#!T9lTwjVP^DD=+T8`g9&2Dc|NLsSZJEXHl*SZ189U>2c;lm-+eA%K@%3XU zS2<%X!`hoRsXr>FIXC`&jHdf@X7+;z>hp{5WhsTc0u5-|qC~OsR#s-!sJPFcY5JPa z#_u}CUd}hr#dKqIjny}N74kk=76me(i}|cnbCcI@D)Syp~R${ z!F%>Sz;08HTF}14@qOFyc(!el_{8&1eNP^1X}bvJF51m&MuN9;E77MZ%DTIMIiJ`- zaVF6MDAu#K%562Z`dOb>Y(VEiVYLq6m_kIaTap483je6Ql6#n#gDSe z7SC>)NtOlG2-QI~6$y?O;X|#>2_93F2=TnWm)K4zPh`w%-n}GIQhrXkc^;ehf<(i; z@gsd?(=r>AK*_=5_FfjvOn{Dlh|9rGcM~!@=JKV0+uDL9kAJd zAlU!s1}V5d_`yQK$(H(r-mC2w-0fgV6)Z{Dh^)Jc@JBZid)TOg7-m8?&|rvr9xW>L zl-*h_&Fl!kvYf_#cFDLRkpJ1#lBgkK5RV=Pqves)n}pgE;0ALOX}kvZ0snqRbQI zFPK8ml`V<#j!vDj?$i1JX~JA$$iW~9W-Uz&xA5ulW+xJR6#dMD5A7smWDly02;({u zVV9iz;DZ>Z<-t1zdOnhJZP8k}B@4E#O3_U@N;E9T!Vg4o; z0}8SM9rDK&QH!|IEuh2vsE%rO&?;F7H}+!GU9Ki@Z=>3jL`>e}n3^6XUx!CQMKFtLq1V{2STUE@3vm}*%)b4SKcIc} zv#BExC{!X=Y47Mh)9SsF#s|GDSsyh;X3F=D+^M+`J4sm7v39SZ6DoTptem(9l_M3!M3JSt({t}r<=EkYX|KZoaDwSf(;^y z0UO75B2Tev*!xCd=-5gAcK#+&3vHs!oF`i5tW+X9v|S9z;n_h!1>DBSU==D4PAd83 zFA>hQd!RKbY)gu1<&luQUtrUIei{rnwI$#bb=*A&ocf5Uu|e^6=31N-Iw`2Kk%(K} zsxHQ7-QM6?!Z{8e(A;eAg{J9+leh;vxwwF&t(LRX9MVP!n-M$YbR5{+O~PU&vIBSi z`LW}IkqZ`$qyx(bnfEU9EJ%xX6aA|4jeZ>p``T#95CVN8+S^6sM#sfV!+OCEs2 z=?{JljVr+uyI_FNe+r;*!+YMkdi^YlIR z2R{;56JvA*OfF`GLYG(jTlo(&=dnX+7U!iLIhcea%ix^L%9iy=hZf?krUD3;m<(hm zJ}q>=B+cCKASvb5u?75uY?;gYCySA}AA^P8zh+#CKWraW(kPKAdHQEZ$Gt`&&k08< zADg*$=%4%Q(7ssiq&N+DZ&L0kU&a-%e~=h}*g^)cFgqNdY3BOw4tRlO6GuaKV#^Xu zG3AN5_*{NlZ%v+R0u2~`^pE?^myIakE}d2b>PMiKJAB`U2~OeWz$s{%zlB=q5?$R? z1@rb!VHYXWLa?+fJTepghm1zK__Mmy`7zGilW7vEzzD-uM?N?$&a3 z?td7J=N-jg-bOcI#Cq8p_D~@X!`_y4q{^~GI0_$bwC_1O4+aJ=!Iw9LFh*fJc^o;5 z9(&hquWJ{0v*4wK-u=*CZc7-~a}zZC6)0A)eK4^-)iTosQSC2zk714%is}dC$>7KD z$scWi2wUL@b3e_;W58ek&jQQ_f#fxRR6ef$*LviLq`D710Vz(oL?YZP= zL(A%J>EekefxysvRFXS&4je6~4Q1k5esFwcju+2Ixz#$GT=-r$Lc6||ns^8sRk(5e zOsJ=kgn?1;4uvNKuKgHv$InZ*Y3atMv4$9X4^CWXwXLGrVV4|kPNGt}!{KGE7=L1_ zPi|+L(|*OTB+GktPJ+DmVcH|CpC9XY}S_7a9TR&y`Y}7f|zw z{cP*C#BQ3PaC*bt&emx2Ym&utKh4Ybm0G}Eh0Z@Q110O!EDF-+k$yY1&Vn(LS(YN` zjGS|;XCF*&X$={*x+Wx(L-#$DjMSHTf3yk=Gh=m zDYln%iqMgLf)ZW#d&Yv?W5i1Dx*?)v2dxE{1H=zL4{v6|u$1F|i|bP66hV;Ndg%CB z-g?Uv{HK=24W>12^Bwk5Hpv~0O$kRX&>P9ZJj1BgoELze!<4LW_HSVwYB`g!j@%C{ zyk+EMtmKsD$o>&Hjgz$Oe=$N9J_P0r>^*HLV!^_spJ-VYF{q{m6wEw!E~0acD~e8z z{7UZp3~uxBNC3lwwG_cOBO=TNSNPbb*7_(PwfvbQ$Om<+j(*nQRb?j;ClleMAu!m@ zACAA;j&(qKpns8Io7B_gl6Q?lPKS0%pG99LrYDem-7Tf&IC3w1_i->12GW^mUhP*C}Xjq?QMFyR;mY-Ihy<-$M(i>JzdsDEMx5KhLU( zYL0+J-PNes0!*i+cT%SkyZHN$B5C+c6Dzm!D^|!HpDw$-PHU(&7$;#7DlG363Covz zLB)ZfD^MWrx-WjW=a*b^bA=s~e(s+Bo(wyVwG26Q7nI!abvLoPz|9t7H`1nAa@I0b zbx8lsn1Cd}U;qi7H7wCP*%`Zj>33K&GqP5ft|inqxyD1kH0yez_tw$1F&QP<@x*6uD$vhn0LtR+Likkic> zyto-5Cm0*hgTW4np^VSkPVaqv(GS|8)l9sy1ONx2I>5mqDwq$*{G&uG{$Ibn*Ti^* z0>q&|LFU=0HT0m)wnjf>%gH@#YsWoo zO9FQC`ns|MSU|(-%$Z$a7p90sh4JY^1=vaTfxpEn5VHoY9wkDrk#R6e4&4$O4_t1L z;qhQpm^+ofB%obqiKQvR=%xq$S4Tv{93xU^roA5m3AOEI~uS|maevmfmBy@;q9Ih>y&7X?4bTD5W;0D`RKxq5-vjBY% zHVXj%<-5)U>1T?qc@|Pj>X-4(=xmD}Kl27TtmJjZSc@kHnDX&BIVX2s5cwot?!5Dd zB>rIcclm5^XMCBssGQIO*z1LX+CocPC6<~zmXSQ^F8XVA#V4Sqk@8NHO4V^f__LKZ;Msvj#OJKY?P zT_PZ-Cm}w@#bO#VyB}KYdB;9hyic;ek$UD_ml1a##aJcSZ>Q|YxT7YO(4a)wKC5+Q z&1Ba)T2E%KUM6oas`h$(Y)JO<0Simjl<=l6eDGXwK7T*$c9eO90A|fiLq%C~UtL4e zusQ^iMj8AX+B--uG(cIMgv3U`4Ak&>|AiMDljVz#+!pxf69*;FmlSufADV=X!^SL@ zxFt;#Iddt$04NHm-U%y=JiSMAaz}P2=4C{*%-?`Fk6nfHGrLde+N9=RN>Q}V`Fw~| z(PN9>v-nB==S^ZvlgFI=j@j5##oL02B(riPB&I`*5p82KM1Hm<54XEkix7}pUyLX>nPAG zuI{AAp!!KLICHh$nJ0D>TA6n!^3|YGhXaC-fRo7JEw)Q%!Lz>Bjzth|-7vqg%k znb(RBZy+3^<}?Xn^;^cANtjF1fSQR({Vg*4-ff5NZlF-{ zm$?|6{8ivX;M_C3K+8!(J)IEnzfvUADQ{@yCDz|_J1I)+yz16(g`i$noan%;bxlv^2>x;!AwTit z;q!l5XJglu;>X~E_9WGdajagLZxp^ubc35WP={@*xUL76u8L12ohM#XBPAoFtM#PB zPx$_r)3JLD_OlnuNisZkD}_&HI&qC~>m%qp>OF)7nNEGSz=^F*X(*5OC>s zlAMDrd-(L%AKs1jGC>j_b$P{mblpNVXn%&zPdk3TF0pQ7^_riH)xvC{Ob2Q3tHf($ zP)h=%D{_rb>Lo%PFu-HbLBqnKf8I%Xzm~PF^B{}`VSyN6+N^YPYOeQb8DVRDo#-D5 zdX;4vKx#pEi0oiDg$i1lUT4lc4?FGaNjt26u7x|GcFq2S{rv<5gf=oseZp1yt3gj?7$Z|GrsvuKM8 z9?(H4;9;h`cH^i#x|nCF#g77&I$0_S$Vel$DmodkvDb;eTbAs`*Z$w<=?=07Np>v2 zkb@`t{`0L+R@fxgKWyt=5?7C7d*agN_5F2W>CaSnr_FoumaW}Upli;{rg%hjzNrkQ zvwTmI*9OIt$y>;P6GVvts>wEb?*x+@4K_=9ljt_luWpBN3pzdLux z^_VY;hMnlAxtWpf_FipGW& z;MY0J`yn=?;sRz)L7{tZDscDD zm>K9H-&S*q=_o{b)~mm9-s{cyB9${1o?+kmwpLyL<%y!N&R=3Pa^bo^!Uv%Dm*7>` zcvMJ`vb+WJ+GB-&?O;!o~QJv)?rcqfj$2*oG% zw%!sQw?Ezk%jsFatsyWVto#x0J5v;Lsi>jOoKQY;&h;3r=^M3e^228)JizNb?w%R` zjxSHpdiQFBo90$ zkG|TROL;FC)j=`i9zaLk9?`9yWV2;w9JUyR3^UueTT={%)LTQ5ne+2e;#OOD#CwsQ zUvQU3yIGHgAYs+5L*Vu}w+wpIBTwq3$Km|KVMzbV=sYPBe?^90fu@-~#NZeJCuq;*mFRaoM1Pq}&TN8y%eduZwB6!w?dimFGraosij4Dv5*& z^X+=b(Oh8y*S3_UBCU?R;J{BFRiN!0x(9h!#&<|{-Nr5&?<#iwmo05fuyRcPsOFrvJnv%S&Xup@i0hHDG5#nIxLQOC*++#D^`qE* zZk*(W_IWmx9as`TJK(?t5;|`RKpo5u6o6j z{qgUOMv{Mz3DXP@i_;+k{y=u}kkJ(zL#K|JX5D;#Q#^^_6xD(?h;o5pOr3r7C(h>q z?8x)e!fU6?L#$@PRgN4wXUY~tswP;Z9H8pZ#j5pMT`nzaHN}Y)?j8Gr6o<7+7*W0y zF%nI!m|tl7|CAUu4^k&f8apO9s;%oBZv+Ic$-{A1q2giwHNt)g2#OR(kE2)}2++euV8Kb*Z%jaeRbPW{tUM$^Jn^^k8d-lu z747l#Dx4nm$Qj84jkfso!g(I=dL*!0y_9lI7_X=6_{S%E^i`GJ)Ta{}4qS_c*Dp-u(piL>^Y4eO4=kZu2o&-&N$dL|Yr9|zpWa*{ z_kXR{XU!`R$`L3QDTkG-V%{%uTfBb_o2lE_6oT3gASZe*A?x|2eE9u^>^pL&;W8d$ zlzH&1a_#DsmG}jYqu{~%`wlN&M|3C(L#lPM+WD+i>orVA1*{dg{1jhrc7d1kZF+8m zO|j@@Z)XrYS1YI1x1|1`1q8Bc1di%A2%7H%&57;YXCiC#OJK^6P{cnfFlj+p)pAk; zer@DUZS*+||KmSQ8~c=SOE}ElQ?a^-x#Po5O#N^~fqYg0vy6Vh$r0VZKxt`^W*I+> z`kto@nDDu7>l`dyBv2}S`hjHI@;zI5&;_k$o{_>fL2b(zHI^vB_Kxl#Y5TcZ(Z8GE zFlB0s!wqx3Q>_f!t+Tg!_~|A0YAk=lZ5t!uaITq_ocl#Hk8zq+41CmlYB6k4n zVKlGa`7jdZ15z66E#IR7R|R#2P9C5tk+7(%ZChFxHea=R&5gg! z6@oYSBdCtb244bEW)5Ne6f$UvBlN{?bN;A^f-iBp+ZkpcdXy5yzI47MlzUN{7*f^j z`F<2a%nfMaUmv!LAEpBC*hX>4ApjDiIA@QzEA`{R9e0ifm&8;&Ud9cY2F_c(mQ#;b zs6#!aHxomSt_)ac9GF>|->c<>ZQ!p3l%+T<4DBj9iCR9BKvi3#Zy9N!fUSEC(<`ix z%H$;uNbZNTq(l@Bwq!kHjx#^+c5+8`d2+~yZM?@8OBSz3KJZ*bjh^)s*zw ztwVrwyU=wV#p2#ve{z@zzht4%B8BMcg=-_Z#o^-aT$TaH2%XFiY^674SHY~`;Xz^q z79Dge@oZQXRt>!1GG(-cVC%RH-GE&_5@86$M1?P2wMyRmbb1v2`LZ#M2Y+;Obh+cu z$s4x1UTeP)l_hdF>U%w~b@P&hhnAtRB?|Ie`W*067ScHhKRBwea_?}-J#=!=0#hJF zARy$uN1934$viAB`EPMW%tFTJ7$gT?pH8FRp`v+jY9n}K+INzN;vpC~V=I_@F)?V= zGIixO!!4mhievVb*#yUiUdilPTn%kBEW}HMSzm3<1+}tx$Cj9z`--ujo))4ohlN?r z*F%j4w=6>QTH((pp@$PfsH=IS9O8`4{IQu=yS6JJ(RFc0**(z68{$35&A2Gw6c~hp zkUS^7ErQ$>tP91POn#+2d^O5m4(Z>ECa7vCSQ9hMPy3)DXyIftEZ zCkb^;Gk#yhwiWSQ4WuAL`s9p&8%doOO+Ld$hd$KhrY*;(DWsznIAmK#KJCuwl!DsQ z7zOcS)mcaWpva$f;(qI98KWis%l7(jbYCbgg`dr~ zbJn&iL^{!Nzbw?Jb{SsY1cz?yKJ??X0p+s)k-6BpfzG2V2FM;)P@w#$14;f@VwD1f z9MTa^0*;{u1l!1va5|JDr*5-8q-Fxgq0btkB#mTs5XogIUxWQh4m@y{$q8CzK|N9N z+qv-PGzo1Og^=);EqB2I7fxVf@16KTox4EMJ*4wU^RzYRbjvL66^MPjs*&O0^Vq zL-y|Z$ehcmmBUNN=(4v7ADsNoFnrt1U&brizt0QN4USMGe1`Y!<`p&iA;ayJ6yg@X zel+ivV{ts7LTW~wLHIIvSM>1Tcfb1H99OJD{z+-#dT2v_5I{3>ceO^=P)V`JGj$#u zK11x?(pBuLNR ze;piQRi#?qa?r~HkUNYc7y<=DZiOsb>evb@^fB^MYzjO;hy3& z?z*S}U|vlr@Q@T5%$$qt%$(O8cv)KB6ylaYJ z!zI%un1{OIA0BxM0R;~wNv&6x{i&qWrA~nSN*8zHqQ_>?*u8N&a5`(4Ld_}^gp@U z&-B)91Rq>91FkMoa!KRB(hbwghx1{QPQL-FDzZK|M zi5*8KAdaYstVXVdUdvF?eN_8>Z6X6=eW%fB<+ww^NgR0qgdJ(3KO@V`{RuLH*$>Vy zCKcwN0}GvN8~Yh><$$owWMI=O0CiG1NIG0RSoCWocpQ`=j~aj`{=D|i*NXEvBSxzm zj%D?IvtkB6fv$f`%swW9`cc*;@U{O10S3&4O@OX{bIBs0pL0M~daw4C(Vrc#V&dm! z1QTw`cXk+cIi#&D1YL6`h30sL)$D!)gp3C5oeJ-PTec_gv{gm3KhMG2S>@O^1@r6KrArDXgvLBGWt*N~I;0|o3O2MQp&0Pp*^RKi>zCbV?sHgS z7(+qYDS*2QAHw$a_ev5W8>T>C&2!(&v`Sd0rQnz8L03&HA5XrV9C4io4pq?O=3fx??XN;n!*X+P1mG- z-*dEF<92Z3=&P;h3*Dm_sS-qTckgs)`Bz5IrUnkEF;Go-_1J3!fGOnYMDM{l5`PLK z05uVPK7zptnT+th+Ptxl(B$|EI>3FO1OV#I&y#*EToj85%ov{5kDV(jo zz~q8*)!j=-$%qB#-5`FHSsZ6Zn92zL%LSWFu;+Q9izLm+{r^5h%}FITJ{n{0U8Z5E z)2%P4q2g_5xoT2~b*BPDuZFGxMDJ*Cuue|vXa4NzhaU+Dhc#_?;8IjBe@JFQeIVu z2p+stN?T+(uD2xJO(3=HxVw`q_Ajp)@Ziys`(^n~R)4^u_aP+AAUAOa>CtKKPK~y5 zH}l_8sZOz?wvDDG9!QueG@o~_topKWQ+#LhT5#}Qt=fl5G@$75XVlBhV7$i%;u)^* zMceu%9)UjZb#)&`ty;*L+8#!W>+goGl?EFzQq@j`TVMw2QBW#V<5<$>unRP;qM#yR z}VRf`~JsLmPJv>z?r~F z7La_0h0&al($VraTgxCcu&rgf1lPd7HsNQbCMhfhF3&q{SfX-nWuQu3z$n*>Tk!kb z6{*qp0enV1>e+5++Dw46pLa-5g73eOm}>cgAOzn-fF3%_7Hs3X~mvfm1_AKNz60b%>d2;UbB^Y!Qo1gnH3DBXLs@@ zx5auuk39P+6mP4AisSagKSDlh_1Q$9qF&DTSH1O>YQCE^@mybPa_*F2a^G=iYC6Y( z_3|__@_e!9bD61e=$mO++p)H@Oo2pKqXXH1JW_<}GJi^~T6$AbO(9q28{ZPww0ba2 z=|kaqd*->U@`oUXGO2`h8HlP%=_eT zgkJ)$+66D=%YF9kICH9R_hXXD^ueCZpr7i^&-G(R%zBYsEF?9%M8smSH57lA`e&{e zckBFz(eEmuAVDixel#w6@!mWsWzW8-6sS~v zw>NGoluOKT95{tMo{o!7-*LM0#n?LGqMkmodOHdezZ67HU@Cu^cG%Kh(A{MCcFMG^ zsPRjuqQH#UZJ&O|8C##v%O@${tKR!IS_F<{uAh-9|_Wr^x;(;x3HnxP@>(dk>$kmeOWD83eCtamh4MD z+;~o{@nyuTc#|?(r=Y%9^O1i=Ogy`iyD(f6iCbqgq!xBhZt4Cp{knf-xO^We9)&zI=I|4Hsprn$~5yKukr0_^TV$*w*jMXw0CxCVrrf7A}NS7K4Kj0@mE(b|`HrxB+7phU9v2r<6z=!#JM%BrO(S(aP;aRNWeO5DG^#&fuNr5q@`w4q7{&_XuuR7l^ z%!3^U<+x?`?4s(O>!0CXPS<+>c^^pjDNKOkoBCXX<^Qt)jCWa!OkswH}o3kcHOxJDMJ=u^FB*AHbw*eOu@!4Wz;iPDQ+~xP{nv?7CN| zYj)kBZ|?Q~*JW;Jru2YqtB=O;%;faXZp(LvP6q(9V3g-r)j%x_-TQWP-Q1AN6 zc_SNfNdK-(uTRRek8=g~Z}|3II&G!ssmpS?MnSY*r+SsyO`Q>`Vi9{@hiUB0uON4) z$IbJzQ!0W<=B3nhS_kaYQQoV1+LAv$Sojtg8_ZZm=qC$|de&23q(KoCXgc|B34g5|l!tR-k zC$?GqzIYn=_tFLI4-#(Iic?biKoRlMpv>c*n?{mbE4(;& z*WK{1bvfVR60v>N&aPw%m3* z^FO>qb>|VAfr2?YT{)Z#ySudJMyD!t?S)7p)npZ#F(=g2veAN^3mZ%@my z?$wiJRYWOz|6T64Z-qSU!mZ73{8In!liOVPed=P&o}R4gv~mpKl;t^51{cwj87Da_ zjD^F-^3i$Mlgp?-w34aB)&5DB;p%B<2xJMyzn24=W|oeFl(Y)p5nj+Wf`$nKv*|Y#ZS6Txlx^me4-Y-TYk9(>7$6IWJ>d? za0zFVu_uF8S&J>3$~`L-fR`slk^qY}0|lLCb)AAc=0yb(W&9?SX;bJ233b!#6((7r ziOiw>gLjbc+P0NN)*PcWagq8DN)5R|kH@t-=BJt?gnqM*+`Jv!r`0bNU4B#ecjN_U zxpQwd-Oj#(U{%tf2+;Z$?j=E_`=rb{vWvYu$7j~SE$T<;?|rF8zZj9y#98I1_z%0G zH!ezQnQBOMS}QY=E3)$Gsh09jp+Rmk8%)a8Wsgu=59nfi{BEAj#Ra6#@&||gG<+v4 z`yZg-dGNCou0LDJ6~+;!!;h#S1uMJvExb)Wq;4hH-sI!`T&Xms-t^O`c}$WPLuKbs zOj~o@FW}WykH2e|v7{EbJK`!W>so!CkG6ayha&O_gj&JM4z$D$JUL2pO#U(;!5I)&=o zZu}?LZj$roKU%+MGM54O@201gU0GGXOsFlH0oYE{i>Bz$AM0uHnwJiks}qpRZhwI`&8KEx&5c7y(%IyR8Nd5HeZ!^N5QaV z)k`MXTi?=!Gy;{*Hks1A^tEn`wPX*m`O}^J+3b>a_mY2@R&-&6smblW`&+iMd1yU! zLUAaO6O6bc_Np>PuE92fPw2aOD&kIHOVUUBXL>310kr&&LZmb*@TOcZazdY878++t zfY@hh)udI~yNG4%>$G6u-1jnX&npSh{5BF)P_mHrN^1Q0Ys?KGfaD#aSJZqre7N3vo^7l1+#B zHHnL4XSfL)(|W@OrPxz75BiB&aj#KdJ=;V;#NeR`+p{i>Ts z1N1a9-9<#7mzlET_A=cyxnH&)LBhC~RJ0T)xjB85S^in{Yfzai#mzMNwXoQe@mbFq z@sXP)m}kFW998Q2sJE|~zW4KB@zrgT^jMO#wH$6pIq)#XJ7-SuvxpcJb9~i3Yx}u6 zL$0=7W*)(u$aksxZ4Mn1c0Yf0aHh8(M|u2=<3Fj9E|o`5z{!FB%n8De$epi>n*IsT zaM%73HW|5d?a5GHkwj}Yzx9gvoaj5dINfJg1Nfa4r(PU5tn+2KP9DjEvENVk9J{q; zxs|-A)RMKMeImc}Y*RJ!v&a>n%$8-84Dwn%yPwy?b; z_}-blAUdRNnZZb><}!aj`mu66x!i2IlkYSQ_))3j8?2&NbJE0*pW@TCYSDCd^ZCvH zdsB>jrcTqz-#35f$;wA+y0?@{BguxR9ql~q|Ey&eQl$6UJIcM>9m;HR zWOv_q@ZR;0{?>@z50Y1c_}kYBE`Ck0>BG$5m4RANA=NBDUIrDNx=+(i0^Ay)8~q>B zA_1Yihlpo}XIszi`)wG14t}l?mU(W||M$Rg_VLTLeQf4RuH@h5_VgjUyMDLM?RF{F zme-mus8&F;jMe0X$1^Kc?Nse<9pW%Oj%_fqtkxGW^bW{Zb^?(ovu8UEXJbL{eMUqTGqhGyyO+c~#i zup+oi!d*{q80XmXe)meMi21wvAW{%;x3OK`ih95}c{hhAM5fhvl8dg~ zxxVVt+mEyjqF_tASQVu#(fI_?vVZx}G^0fNaAZWBbJqh!&-6!(q9z^v4_=-zvnxg+ zel|KvTV2)efXcV5P7+3zD7|}6OmlII;%_or!>ta+{!71K)NW5NXweq7Qi!iXKN=>C z&|iu6?yr&S(+^I*oP6-%6Xj3qqeEdZ;eADiuwbv^!y|UVj2A!3oNn{=I1~wIbA|kQ zOghN0dFEgD@$(wXUVNlxkn;(hqj!D^S`cb>@ipUK@+iOf&^ryYqB@{r(H+4%n>+f=`KZHDN1u$&)-z*E$m|$iln9B}! zs-*=PuD<($h;FOc_{Bo$GCPE`YvmZZt_0;*7^?v1f+yQgP{XuPP8HtBcDK7dH;68h zm+qHk`1l+wdBj2ks|Z^U>fp=P>ODZ%IB4hYkQ^4HK*HgHRS>!RL*QJO zD`*LafnQzRa(4IAQ7qtck29gIrqYtSe}~m9!NY8z-}gtL#=*MM$qMCkxTeo7%=i&A>_dxW3W#qUpGQpO~9T#9c%yOszX+yNVDr#0|Bt5UFPP0 zL4D_3zVd!LgH40KAI~ETnie8sf1|Mf^;|H~TC&XiE7)wW6#e5_@n$pR-{X0)Ecw{# zR;0Gc$pO$-82;1-Zr}f}^N)dhi~f`_NG>fP5OrULSI*G2#HeSqhMFm?H``EYrN3_z zWZ6qUcp6Sf`=ry|rVbG>y{LI~N8J@v2=j_{>=cz2!OELX2MjRY>(P1#3{(H+6rZPc z_9(3TC@S>UVx0Vz;)NH_^DDeNJ{LbN&~F(9o4cLqP7^T9cL zsgp^ZU`}%Khzsy$+Xa|_Tb9mnvK@5)Y~g%EX!Wqs{7(<9WyIvzxmc{GPBfW$HkYKA z7gB3$Og>jjapYgO>A0SB27eTV)GN0_YE@3@s%h@$aN3Qv(pPP~GhgyQ;+17d#_TU z={B&39&*!jb8qeB_g9c?@YDG>Pyq=MK#pC`YM>70b?oFd@ zIY*wEU=v;y>3fGX<^s{J4tx*$V8_F_rqz zJ3R`+9ZAI>KDn}k_wyOdH#{n{iB577KAf80;Hw=mCn zeYRaWkXnz&qtGAmv*EZ0aOZwE0LpVTlr(wWet6su|LW@MIq&nCec|Y+#s6wF>d;#) zM_~C;NVbH#VzIAP-g?>15|j+AW|7?dLvu)%jWl#h2sk1AdXo5)mWVKnCyzyPA>t-d zb4?jtbf}pmiRsJ9l#^s{-~|_-d@EBDG+(%~?9+TNp&iut2WUdni}{FIRn-Qka{{Y( zejfic6ASbvO!>^XcCH$N>;4ME|)0#2O?#N#o z+%ICUn^y^FlZ;it2DpX2{msH)r>cv_rzi#K$HSvL&7S%KkWTJ2B8FDt%roB6y)14K zW?GBslYO`i@|9MGy<2~z!@K)CYC9B?%G5x&$PhgMG(AENnCl6D+ z9ot5VQ#AD++H%>dr)d3`T&W_peCv+3pKfU7aqA+aC`|2rCdI=t~^y8=D)1Ca+GHjt(-ARQlv3@%7#3|qC=Mv+#vp;rBOftGj zYBDR+2?@Zuvyxncu|RdKPH=6rgxWv;JU-vgQg-|Up$Z!F=-Ta?y7wVtdlZ4R4hzUl zit?y?vGqR3ngKe_!~vMB&hbyenupnP9j)X(%kr}T`-O&sdGKEaE!8Mtl#8i~93tL$`6Jp0>3nSPQUg70%n@j*_t95B``Ar);z3qjp|3R9<2b+ z(;@GdSBHTTeiO)ofarsZW~%k@GL__X3Qacnt_^_K zNNme5{O;^?iPN=&JmN?~OGuS)=VmMZoIMZ-db?`WV|hbRcPK)ej_I3&V|-G>@1_5w znw{2y6={GoWSHssF*#ow(Jt@ysrPWqlF(7(wfdiZ4Yb* zj=_$y3nURwHtzc+&p%#Bua-03@9)=A_nUwykhXo75Pr4qQM9k5 z`^RRI3$g6bU|@^zG|-MMN!sCm!$pJptWqIY5R0heiz~?Ln0V`B4r(;ISJ`LrLu*!- zyTgtes-@RrY;4`P{D;bX1P@4uBJRb>)JoLNr3b)@La2Hr+W6o%eZ`TU)eE&SvMhZv z`Xs}qAjpn1jP~u&-B2<(>Nd(lup-WnOaxS^ug}uV-B@8f=D62WUwp|dmO8EHv~A8T zoR&5=Brv#Y%OJN=;!Bj-Z_`ylK4o@RF!=qEG=DzhPlrQU6=0YU=~d-hAZy~ucIf|m z|J#I&uBU4jv+7wja@8qtYXLdSVtX-qIngEf^4l8gkl8u@Tb~B-Bx$N%d1#wRMMAh5 zqXWn^N3DMcsrraXWw4?Zm01PBb`KC7!?|Qhn^Z(Q!TWq>K<;Qhmj6&OXOX)(9H1J5 zX4eZiteu?JY;HL+3EK-7)?|mWA#Jci+?u+Ge&B32T|wMYr4L(i*`xfO>8AFnMgI%> zCiVtcCJIR}mdDF$yqiBn$HHmm0D4p@fo#Ta7cYKdK2Dw#X`=cz*=R3%a(Xe7Y%caC z?iJZEa6!+cq`5f#%UBrtIUHk9s*__DPJ!YqQQQ!55$1TO?^x#|r>)VG#d%N0_aCClF-@t#HmvNMJ@E9jCpq~!lY$iVr$s}405NPmbXTh40hNs z{NFJHGI13X50OJ>j&rCVe<=-SoL!)N9yT7km2C|5kw|P;cKc~CskRc_Rf141YXZz7 z!wb$18L3Gvq8HNBY-@RG>U)^-Rxms{3L80zR^Vxzu*rwwIfL|bhLDRcFIbYgTmQz` zB^{QX5-l(O;4!(2o60QT6TECTLqw_ExHQy~gTvxl~{3w}*;W_>e4s;Qj zkVZ!%;Y~Q}v>H~=$W=3>)GH$u6sScK?4K~dsv(z?&=Mhfv^QMBzLDs}BAbGT9Y~*qIwN|0a6{xb+Y$TJm@Pf=!mu6@>F05}#Zkx` zrc`N=Q}~L6)Bd{s*h+p0_iLUyqVOFMUm#67Q+%|kQEQ7}AJ7^oQ7u0LuZX%ZtKB4a zp^Yy~j?n@O_Nn6_%6?ro3w=Cdfk zirGmI=8b~mN1P%clJ?UKcl6#@d*FqNqdjnf*pX2P!$9ad*Hp+=FG~?*O z?E40iO&5WaEqzVN;?borMs5SV)ttn<;fuzP3=Oj-Z<&nVyD7n`BIL`v zf}RaloA2*w7t5<)c)M%b`uXK^UGC7}3*k{jFWQh4;9FPqEz#DYXQIutLC{}!`d`Cy z*1UBV3prsPhRYE)Hx$VH_GHDn9sKk(R@G)z$;v1{WW%kJ`QNX`gP8_%b~W%hJ~s8Ox@7SRI8k*dY2#Otm+NNb%(@-OD-|`Xr>vkoOls`x)4&!d~&7jX6pBt zn_3h)lWQZj!zh;qR~<`Xh=!z2=ZVlH4WG2Gr45`grzPa_60i!ka2<5fd$94ta)W6v zlxhh_MA~oy@?EoN2J*ZzdMnV@xl;WrpZuIq9k8M1NARRX7RcGhXq{6=rmk{9;uugV zM)?{_KyBg1ZSGG)yDy?=EiwlE>zTh^P3enUWo5j(3pHqUxC*eO><7 zpl57?=59cpH+C~}8omX3*^Tx={umqjKr%wfUefa^OQ7!CC;kqOHO*76X#7J;`glK+ru^*$jMlR!r^wdc4~ z+z_lTr*@pw(@@3ZUw5}~tt|X=do33#jbjk?pxPcXq9txv<$ar zM6MEkN1s^eVt($0D+?u;(u-O-rB~rVD>uCWY11g?!o3qj04bkoi%iVDa88S(lCUbq zJCXrYUTWIeud!%UU%N?VAGzqzQx5*lBBh(6U!7*HDT1&I z!rJ>z<#!+5MfY*QW#5ekXaV+1{&^g8|>C z+Yyd@kBIIM-%SDE261sZh>EY1A`2xb^q~V+SV8D-6Ot6OR2R5GMf_GsEfqH9=>5tr z%Fby*D#1b{EP--hB!Qb*Q;;W4cUC|b=;6zHSAzcYo6uBoDH1{zbiN9VwU~w7$+}vF ze>CRamo#vb%8(&AdFRbAAvWhnm*(`%fPvxpE=I*6*eTo1c31n$kW9sKZ?~ifrLJ-O ztS4e0s;ml+!^Pe{RV1jam{@}{MsHJNCgB2Y+s1*LD zqn@V*EBOK@5kx27G#!R0#`QGv(I>xF@|?h?7SVW;yAp6v6x%ZcV9MLS`U?;?Rsg2z!T8Y{y=fZm*RF zL&@}K=wOX*;J1+(rIf=C^owz(F>NhG2BR{pI zE-ISK)GjsPP@l%hl4yPlF3o;tZ%I35wr@2whN0@3b6G5l#JdSDD*%_UYVeZRe>b>= z%Jg7yxR0t*hY5ZvHO|kd(~5iD+al2UEUX}H1j=s)&TT?h!D_#C&2tqcH~{1^NPr-- z-B;fU(rp3ZapO+>J{4ZQZbICy1~#f*CA*il!cNF8V>N50+%|>JJ%KPfIKpIi zWhQOPNC$wNK0E-;-^74^jPs`?Lh0t&m>}*&gGzyQgM&w{P~2Z$;N%_kbkL+W${!!r;_FM1 z)ZMfvxO)D$W?Z$oAt|y9!2gWy5Z{pSI%Hmc)?y(iQw-@-6vIrfWzZP@1lqv$!&*Zg zX0*8F%$)ukV!@<{`}$rfUiT(_21{UdmCI?{9^}ui$4p3KlEIt~dWDw{r5aMF;)5v_ zAt7`r^N=X_b&bNE21zJjGcEkq$jBgEcR2jXV)zdHE?{oxwBwp}xev>B@xrEuKwl!I z!fItB&q8BZFr(Jr7ecUBb=PLJ0GUT1#U=okk7kMwsKtcv=aH3cNLAZ5&Ef}uw&MpiD}GG|)Z7qNHMxO;Of{&F_J^!NNtxjvfSi8<|!VIfThnG3qA1 zNL%_?<(u=tT35!>qo%Ff7VH_aMxbDB6Y)_!gWv2?aSg%m$)g<_Ub&4NK-^$z!xns) z{2+UhM)(l_G<#@C=4#ICuGRTE#@&>B1n4e53}6%lZ9NuT$0 zjo)*cJ#Xi#9K3$z-_3JtR@w>s>)?5i0#IvXIVYoa5!=B;$~FhDv`Wyt4zVZJRAYizaCu$J$TB6!kYJO8Xu|5nXX3R?LbFRJYo2OAm8l!gI&^g;&Xbu-VU5iSXSD>RO=zm@l|_#(WJ(uZbCrn(A51PQ4up3x0CyWy+}2Up5!s-}9CRLCz~Mb-3%tH`$bNXQxIbzg1EHF|&1DTv&s zPG1lW@YV%k?e^9WXINRCn{M8JYXhd=*akiXw0B~;alf=vYU*+Hw*^yPd{8sdox zh7YN7tB^5sd8gY8#MbaliZZ9t^x%qhuuSyf)yd6W1!6A!Cb6;l5UQ6wFASXP#XK3# zNJ}iBHFK@C`<-l+kDowZy`F%mxqeuSz`bU1$+!TC&M?+NISi*{Hsij7fJH(?A{KZa~ zu?jJPM<=JPxdo3ItB-vIYH4dYGBg|9Eqc2wcqa8hg>OJL8uD zK^22i*Y$vO_1T=4lJENl7k{9cbFzupl%TGbWQXH%J}j%Qy~6z-8aMjFg=loL)DucS zer@PH+-x~SmMwV6=rmE{!Yl66eWfLgbRapcI;VwhN(kl-$X4q*zYnq2dT|17e_@+D z@}TGrMQR`rd3xJ6>SFUif8pIl9;Wz9c|6LIih(;IHa2YPg)DlY7A6ysfxLGNfPD6x z9HoND@xbgVun%craNj|L5z=9kZ|aWCYH7;oGpr};HlVazuxdY{|o-mItvqF0o& zi6#1ePJ63<~!^q(;jxVmb}waZ=)c=yfpDbkaK7#l+_(nQGBY5Wz9N} z{l*9ez5Dp0pZDeifq1woY7ng+fXcHlY_mRe^YQBri&aLor6`YjxpW=r_pna|hW3eTRAgz*5Rx#a?dDjB!o+Cp6rUs#@veu!p(;VC zcr|iCv5NX2dNH#qhI&yuHG?{Ne}%|1yl`&gJSXLiTGUQUAyjbKVifNg%>azwWGA58u)p!^7J=n2gbuV zo{}%r3)1#*x$=G+f((tt1KSZKEm6amUAOrTlV)Je@~N`9)^h|}h~Ju5hMB^8ne*J0 z#zn9!ybAiGie~0h(3q`#RnIPXT}^+-K!e#7n`hVG=EN2m_^>p@^xJ5AD#U8S`~`AYtHV@{TIO#}I#j#}#$^Hb!KyJ8EN%4L zkp)p{e7By))^$S-W-PQ=*`&z&(xlmm^W~`ATY9rO<;^BpZxvzw$Wu`C#XIES9m3HY zmA5E@f9zlR9pc^SK5=^Jzc9cB`jHl>(@<^het(X2c$wv_EJ0Z)h&8hTJV-fw_VA9P zF%*gxq>U&w`b;}P*^~yZ>qeZPOow1z+VBRv-|MYU|@# zrM2=wMm|47;^$M(N#BAKp@6@FTaBI=dLd^K-5DCwCKv~cq_Ug8CQPpglVeT-=og7n zOYQ|-5rEDsAl)-FDxgsv55ZZ9#Vo)@fT2@~pzxUjO}%aiVDWp-QuvB*3$}rfC(x}g z%k-ULEh|M5d)yGtSsBj^7h;5qMl`5A!351Mver)>Vn$8Cj`%p;T+LUvw{u}SbXx!> zvRfDVTPODB(tY%wPPRhsW##ppkUyA(E$c`Ytax6HNjBVh2V575v*U2Q-?y-j9(4Ry zpJ0>sMNu_#ZdMgLr1jAUX`{^Wlkhr=#3_j#77)#UB7~CbO%8vLAAA?onMr5b`~$_x zz;u-F8cNI(UX@~gMZN5mf4J(Aw%{d=2|bdoPcJ&4{~~~^f6Q1q1d5a~1Pxg1iSUzg z{ZOVo$CM9X?=T57m2aT^3cl;OA!618*-dJBx29NLY(hkS^8E(ot)#1c-E9D0N{lW{ z4&DZPtC$#-h=&C2{(Vx2=IVSR0K)xZ|7s$o%`eL6 zl5K_IoQCOxq-iX86FF<cINN$bu5~ zq*)(uv-nJu*T#>C_^T3|P zMY8=w#(b~TTi>)%5z%O(Gedo*75ppa#z%52`Phy!RNJW&t1|B;nkMN_1U?%Zvx2sO zlZ=-Q-|1v#a*J@b_Uq{>*d+0$am_}gA_}%DWH5e#+P%`vy(k`e`BAg4pjJR8{>|&y z6#j_4kEUs7$x0D^sIgN5+a);8ZTEk-d{*45cg}8a7}qecQ`N631>uR}T#76nOPq^x zz#jNS_RHWii5OA;8DtOVN-#OvSEdBx9K!cYuhckaR051Pw3eI}4U!eihtf1Wp0^@h zWaA+0RP;<3V6b26~L*5VkWU~-09 zq!a7W9Hi%)MKiMw`W}HXn8qK@l05%p5aWW@0fj90Qvm0Kxz6nbZE$PMY3Hx7WAh2% z=Tiv~BfUsva&Sk*rWYiTq*WkChk3?jS4xIwg6Iql2{x@|EHVO~wK()!qx{txPCdyj zD$nI?CP8Wv81^Kn?a$&lO(gLr#eV^YspsW^Y0_R2_A!g; z`q>JR>!WXSA?{6o3udB6%UGk;GN0=x66U3=#Izs-4#iX8-I=6OX;|B^xRmCJ*Qu2} zf3vrg%9S+#3Kl&p ztf(JL9mgJW9zB4JDylzGmk{e8l5J`jy^+)?UvId0el*6-eoHKYzCD1dZ7W?>ER#tR zt9rBj0>5V0-{}-&x?=T!U0uiJUZNw9Q*@UQEw;8@!!T{|uAN+*#nmTFwK)Dh0pYS>L;deOJ}tXkQ}$wq9@s8`gaos4?0;` z^kE%~H+Ji3NlFi`y+qaC$Th?Pl#r}T!oJaLzvME>D+%2}E_-3oD=zpSqXm1pF$f3e z)2XU(>ki3jzc5d)UDK>BanwPeZ4mE`v{K02{l8YCU3{@vKdFRTK=4#~H4iXJ-#2x; zo@Wf&sSL9>knwL0Cl3z^!m0`0;_Z@mKx9|HyR4E{2O&Het zcq%oS4!tQkyv${2i5Jv3ba@>HPY0Qe#~;j;zTd&(kL+u&cr**sPthL7y>n1Ej7pgf zT^QObgeFYZgS*~=(~iofOyU#^5O9_^>0{pKC}X4YTLT6&-VkpPBODHd7XGUtIlw*c1maBmD)xb?JX;43E9zfgKpM`^UD`@vLuFejK z3hUcKX@ppURd+2zbL((b@A!TXrQ;Dxkkd*$LcmO@!ZMqsebc`Elg01Cj^&%XGmRPz z(-0Igu~{KF6d)(Xg1INusdZp(PDR7J47$$3`0x$lec)Vj1&bI`YKZP`liSYi+8?|t z`DzIWk4%-(j3}Hi>)*@sfShO;qEirtEV;uNhdhcl%Z>e;3d+9mcj!@u;h{cK*|%Ap z6oI_YQPV|R_U$?oUViG)e`jzeR!0+mikJ_c|K4h0V(d_|SN==6fVMqsoNDWvWf1rA zwJ%0HFld$1aQQG$6OHcN+qQ80V0~vMI=|&~kCBUM0uE7D{6VF@A&NgPoaHs>CK7|B z?6m$p42#C{XMfO2B$_OPfBCJ0q^bMF!e0yj$SO6y%vUMXlSaSe+4mURq*bffAc(d# z91u`wf;s-R5#O??rY*-UV^(dTal6m-R*js`kbsB*%~RJ#WpU@cyi^|CrpzAW4(!+e zWpuq+vCS3`vKH2lN1ZD7IffwfS4G(q?9+@gb+ zzp0quN>bnzy#qriVmGSeY=E)STZfLGB|ulbi92uB3ky0?nc(#I{#FBr?k+p3M4m5> z*7)r(%EF~c5v;)?2-)m`YLuDL|JB!0y&(XjEJ9uZLx>^MaV`ujMIUSC{~^^118mTC z((AQ9N?Y{JWk=AmPh4X4y?56eByl(PImiWLz~=hC#Er4?U&>*?js2OcL^!33c`+5qaV!{c zNQMR>;%D;ZAHOtyI^t7U^ff7}RcCa*z^$7syONYu+<1yAcHxE(U&4bP@iW@t-7|2y zao-4d%RI1NN^ULQdP%63o`q}=RZG7#Psa8hq?ko^ubMHN^(PA?*A{{aL5 zVU7^4292=P5A}(|+LWmPygaLMgE$BSk+A=i6@H_bd(1j!4_z0QG~6@aTffbwI-b4HRnqX^|$n=h*&EZmD2t!e|F{J>L}GOkoyGsE+$(s*wK3`> zW!PTw`W<+rl_=u)?V+LsQ7w}n3y*bsbbnBDUu1SX=13g{x`7wAZXV1wE)JwGwD~Rc z&dse=t0`&eHqw$lVwVgA|G8XN_l@Ju!vyGmuf(lC8efU-7h3B7F9$~Q+RiSb>|yRkgerSiDntyV3mrydIkJHAk#$&N0Iz7Xh!{nB`?qV zoK1;N)wlg&X;wO4h^IFoxO~BjI==$JIwk}k>!GpEC4siW+=qGT&!p2%o_p+qkVW^X z=|eDsbF)#Sb-D&ZhH%yuMFZeJ7kcm-*WK{mSatXvBK^LoMdpeecvLB-e@A^x$5VWq zoKh8Z9hq{XC)CPIfyJWWyqT!93v@L+JDr$L=Zv!;Fg0V3wglx~OKr?t`wBSeHMIU# z7z-&2JlI$`FEzg)vW=mhjy+ebwz>%Mdr`n|*{uGRg?9eJ;HeF%_@Pn=?e-03^T-b{AcVe@?I-1 z0=SFp0Xgld;>bWkpP2-6HZOSklflBw0;J&q;7-z~CoDrhsi93>B4IZxYr!s$nCjPy zQ;KIGjE9gLqzG3M{j=Dsw4F#j$Xo>UNSl@xi;=?o z8zqfX;bZ!D!^%PNOt%x7N#vo~6wIJX4qDWyN0ikr1I26q7`^RrmjM^I0LR)lPC_Q| z+x7&{CWtl|%xP`Czof8j1Rw|ZyTP*w<0;l=t`dq9W8@ZAX}KpXx6<<3CPKVo#toJG zOy?@bDLtjbTLlvL2If2i2@{L)lIW&fXX#EQ6Wb+uWoms3Z{~Y%!(SfTRL2SQ4fNEtuY4Pb|zuD z54zY|)*iLYS&!WlwQ~t(VIw-jVhDa|?>Cw7{K~cpq=^+#J%7qqN~As~F~CB80P9;I z{l4jl=QeDAMVl570_jl5v%_b6cG*F%WsJ6DwI7z2y);}y|+ZA6~DCcwi;!@9he6y)Dq4zEcOMy`i?92oa`*DRpDL-B8u4c+S8urA{nMQu-4H z>z!xnb@1KC7cbI3j=MzX@6t^$y*{3D5qj{wfF50T=x+#E!8R|XG6s?1{}Aa7idej2 zf8iiVSt2^8YW2Ur=xf}OdJqJF7ZmgKzz}fKrk0kxTgrxdE8csf!r}OeVJ*5oPaWsq zp0tPD7^pl~y7P+0>VeDeSp}dIyL+KyCFQrI}j}`byen0enb)AR0cE+06>5E)ZYEv1Y z;ps(fV46HX49&~!+t6y^P9K^23x)1X5JY6we2_RN?hfLE?3C$u;$9E^?$~o`{lMpZ zeukSR_&#^Bmx5Vu(#_*^794QTi#rn|L+yDxDKhv{;ElmM4}6e-z=d3h|KkeKuANO3 zshF7fg2F|2X7LS~YJ1(pSBKL;3QcpV$EO*#tS>UbG2Ft7-(KTO)g>|9JIThvBPIMW zx77G_5Qks3tFQ}6Dx#`a1 z|0iXyU7k;Z{}>j>JNX@4ghQnlj;zK;>P^?9<9*l?$*J$StO;MIyiDSjeIdc$|0&z= zpkD`HQsQSRtn9PSI&*()!-9h5oI7HJ;-^#qgO1P@MBnUXDp;sFRg0>vcgCG|Qbze3 zrBgU-A~@{rSB;7%w;|hapL(WFh*;FBg4f9loOb3CEbb!&haB!zm}Cga+Wc~j$!HoM zekhWkzOb&u_d4 zjZ+MT0=WHE5}E5oyiQtz!uqK}|Az%=_ld!5V~;r@D2f@KHGk2hIQf7r@>r96p$ z&`qlzLeIP?u#Sepr4-R?JMh>5SsI1OkqobzF zEo?~`p#2Z*G7U>Vrg&6ZY+zXWUdpf<5#!q9bs} zv}VS`Wa~WiT0*{Rp@Uyk>@`>GV#fiFhZ56)>?5YJ+)H6l#J|V~QNx{mth-9<&8c?V z)XdKbqrifsFTtLtvReG?qFuL0o*fr0Vj=b4)SO4)Wxd7w7hd3Y@3m&IiR;Fz_rRzA z4zH2(1WNV9^>#I>hfftOX8P?Q2rG)Z`xECA3?F+%{eI}0$Uf(nH)Z+UFEVcNgd^NCk(q`JS`0h_fg%EE<_|9W{C;^ZC4-6jLGzw1j>+bzQ4}6sv ztQtCHdcXd`b+7}4;L%gz!1aXb(iD~-9j#PYmLJgED7|g}@l?=q<<{I_W%&|LEedlf zxt5u{PG0!16@hf8>5M)dHF#Z?!u3k+B-Aj#(6l*fSQmX_H8PnAs`{WeZ^Kb0z2=T) z?2%Ci4e4H(s8PQz{0DbkN<6GP!v3i_edab9h1hR6YL~!suWte&oYYO?c+>yBR+Ll6 zpy#`;7~0l1U2l8YV3gV2hIkA}C0vyBD0mmO2oKWc15YI|e;v3BJ&F{LrbA{&VHQm+ zD~*u=_+XmR-&QyNnkQ|e!o)X_)0XSKp=j1VF3i-O^>pnscFETbrsVh>JeM%1`0w;R z^<1*U*B3?nw5X9vSvfe_P?Z(sxpWpb7k1m1spu6jFZ^!OkO!n@k&3br)hzmg2;&ij z#H0I^(^e>oj64T>+FMVMlSJr_=KCV4G?O4Uww*HDY_hcwaM~NNPV2cu8fUXxK&DlZ z-J?+3P{L3+bu#0B#vx!{|5%t-W3Eht&C1wp7vU%7$I`TrH&e6nwPzw^aJI+28_ig2 z^A6pEFA~xTAqvBw2A~1kK8zw`m?5DGoqVsGUfn}C?VkFTK@kQoy^*bNhbODoa6PpV z%VR*{hR*RV^R?6=6bq(%YWt0z>qptsT1)I8rWlH*K8nX}RhV(=GmUA5P#Dm_;7naT z!imaUL9_oWL_WROZnA}b>jma1h%e_4n}*`^{)QYn0q zaJzup_w32#2V9je%o-*pZYKdsSuw7ETBq|Q7x1SLR^28CZZ>Ng$TIj?`|F&2T}CUM zT$E<|Q*g^-3l4JkJNuotU#w~r?G$I3Sd>T*WF;R$Ay`+5tY3hgYzNco8A%{HeCo+X zjnLX|G9m|BD*-d|d2g$zi1Pa>uGZ~$&B-;iv^Pm-x5>h}af_}C$u3m^_%F3MnW>omDt*I?%_=M~xNmj6v4$*Yo7 zDztcWI%=@b9ra<*9!*!bfZOLszCZb!oawsaU+{z7A8}x>kYw-r9*F2-nyk87ZqN7r zarIDMm1vNFrw~gSL&WZYk38VEuYWK#q1+87crnVjk1P)nOzRxb%nZlRJ}P0{T-5Z+ zQN^-lnCI`i@0ju`1mScA#FsI4(`#IcREg;J)pBbqOp%)oYEv_`$G%YDki^rbk|GHn#YPr;BHWXVSQy# zteRaKkVa$xBU~!zW(rJf%u0Gc8Ryva%>03ug$V4i~+pR7??g`61eo(O_lkkV=SydRgN= z5s3Pvn^laV4>|2=KqCjdcUapO=UIm6qR~#h=#C8|;6}Qypmnc!Yvky89$xU6E*Hr} zF@QIkf<3jTHj+p&!!7fwHf@=m2y0_3&3Rj-nEEYw*EY7QBIZ=xZiYM}3tSRX#>B0bwB^tE^KFekplhWJIKt;Vg7O)DBNQ+EhNiv73c3V`r*_91kf`O8 zUN4uSDAY&5!%h+1{7JizeOYq=kLVp{bo_qxdg*`f7Im_G|B(46#Ic-ZfGWf&)!@f z2J136fK=R(%gXVWf!O-o`)CjBaYkFR;?j1%V>TkP;ju?+jhkf-$Gm(@57vLA7dy2; z4TnJxEU*qeV*4rnn><+=naS0gzAjFHY5o!E#=Bf{Zm5*qxDI{Vy)pe$2x+0~DIM3c zTP-u}q%peZ0>R#*^7NghB`FJpKmyz;8oRV_<(H7YzUQwL{3kkw8kJ zfA1v5_P|&I9}sw*@T1%4mVeh>uV`{4@hdab-xp3TFh<36d><4xIzEXRe4L|#=Dbra zE23)K&^+2D0Uyomgpi3)1>3Jr&IF~%VaKT$$Vsm#jP_{Q7t5J1i!A1(M{bj7A)RtA zPP$51 zr*3$@eW}gS=lIJY##yJtQraHW^u&jj<=Wq>=MvPoY`8N!@;rf@%_FkEQwZJium4bZV-AyUps)AK9W1 z7=|N;qXNi4(Y`WB91#rSvrQ&tc;xTGx4$NO+(&3UPmlJ{y$57w=sFM>b`Qi1E>Uwa1~#$MqM@E`2wC zEbp$AC3Dy#frV$V-eXR5Xm{^+_#Cd3R{v4^&ld4mI9nz%IWpz)#$0f)wo2)F*KCmi z-PZqlflhcCm(fOTbIR0UYcj+m4#)^UNd2xqICN@8&Rn_od1-)p9Qo>U>z1n<(fU>P zy#H3s!iFX7#NoAjiR}Dw6|01*e#Xx1g@d%?`S()`6>S;slU!C@#I`>cM*wnPT4yOQ%vtv!23DH)xeDfLlkslX!N#uGDUFLF_3I zO0dF$bKTP7Jo%=-_Eh z|Es|ZJUGn@>v|i4c2_i=gK&(kxMr-nQ+LWEr9P7P|DQE9NJ)-qe@tKREN{J4-~Ffk zP;k^g@Nm41)vm8e%0PK_)h}ZVlGLM&@k)+c^aZ=H^f;bLfYGbfS_K&AitvN?MRzbS zo~7AO)q-E0d+YEk>#0!k;DANW#*Em^0n+Rzlv=n`wWKb@=~z!zTJY`xh<;m_Lo883 z%;ZrX7av+u$JpZAx3>Vc*`=M6;)}}OFf9ua=I>Z$DriMlnF`BKR{v?F=FiRaLyMgB za_-jk3|WA+cYsl=oH1fsR6frj;=pNrd0)EyQQI{Iatb}w!Y$;X0_%fd9h`VG97Zp4 z=cqjDUFmU`K?~5(HS}M!PHb)u+Bj_CF!@QmLXb@Zr@uv$`R`RxvjQDGPm&w_>|OoN zWY2l9ar0xiAYMq=af^J#6Jt?J0Rz<}gCOPDsw>5`!friy$Lh>f6G;*TB5zoUN)0EfyJ^i-sZOM%j&XxPZ(SQ zS4&k~mm<-v8GKfJou5K{yl)w!idpwfxY>5kNNV06$lEXG4X$%9$;sQEX7rX?l*Hn-5uB2+}D&xRcu%HqsTHM;S=-!b{M81 zs&j|`Wmk^$1ikS(pY*fMRuAjC{VjilwAOWbWr)UDz}gptCHz-;wDmZOwRM~Or1n`b zjm5(%@5R&yPBYvk^nT3{Rh7KdvNj#apg2QUxz5+!I=-rAa}aA@&zjdX1Y8fkC2_lQ>qIR6Hjek2^)=|k1o|8YXp^2hxT%dY9o&@Xa_2DN_`Msv zj6F?1cC&;)F~56c)7t4W)0^BJX?NYxcFk6Mimi<133qgF2=2 zsYwuTyUkT=M|n1iv)-25meTeI(x+RG0h$fIUHJ})i;|xJCvW#<`}UMdG@^Es`aWF> zrV2X)^qOl)!;tO(Fe=|FJ#zZ@{sLHJ903M}A7TH&<63(kKXe>PgG++yhQp6u5sBn;lrhZ%H&N*7ZQ3yIj7_poZ5Ua$eL)6g`3sX-nbWeO^6~z-m@Nv#B))ur1e6IE5Rt8l!LUrv+`P4 zQO1+Z6_8Y}0Q}p|+VkCG0P)KvyXRHRO)@28L>N*iQVOw}R@(Uh!K)SJbm9=1WaGB0 zoAsrj057W8iNZg>o5qH%bE*fO^JUhgv=sh_EoRU_TcPY(C&dtjxFHimq<-cQe^_v2 ziTXQpCJsUYL+cN0yg}yz_Op!IA=)wG9Lw~>pZU|w4lgwAM3oCI(t~APBgn9g|JP$Iv0*lJ3^=aTl`(SS5k1a^1 zIjjO!r(A6;<^$w=PWnHS&j~VkZB}W!cXhk(dn6hkXR~EK9gcaj-z$pw+`cYVue$Cp zv^Vk9Z&u5Mm5AXCz zar3*FuKV!bgvY}mf@RXE`1-E@JUzIA-SRC)WUJ<&$ISP>_`LYN_`?2Y0HJeP{IAD? z^3lI!i8`wSr^GT`N42&*du_X;mrX*g{7;ck_(VF|61K|*g(`&*`x zmhAR%5?!@bf$OMZw$U$2H9N%5!Q$*iEpPY!RCN2N)Urde$=LY5>)(X!x$@Uu<56OB zmJ^`u&G~gckL_0#NW!c~Zpwd4dus?cRroGA_&;?JZ)`)K2@)tZQ;j-NRrw$w8*ab+ zvD=ocNG8xg{F}}<`$c(qtAm3qwWo>~xb&j{!A^j z1XqyjwMQhG*#QFuI4yrm+ioC-KeVxX&{-fMHjLt$<|vEHPtT;;hVvLio>{)+JTzBm z1IAlnwG;N(xtIep*_pkX1#4w(9nrS~jsAd27(Cgaz)LPN7nl%F+%6-}Z#R0JdQp0I zW>skJC(WcfnphX{mr3*yf#=dS?1pfCr2ob|e_)3HBlD8}%o>2$j8AFFWe;b<^Y+_= zZT3VJoq)%AigN{U7ozhSg#!1iD9MUriEsokj|-<`@Rj~CWDl`pI#D|$ALpc`>u1Gf zASIv5-QlYRqmmpP{5qMDwEmWT2CeODZ?_PwU+tFR}Bvu=!GF z-DxIyZ*O-aZ$w9!zlJz0<8xQ4!s}MOL~5t0MiI81W3g@C-R*E(vUq>qOBlIcu8A_C zqjU@nkau3b&0F)mG|Sd`;I$pcryujaZvKB%y@Pw4ZP@MIpg|inwwgA!ZL_gCv6G2y z+nCt4ZQE|_q_LAd&))C*9mn@C%ze#y-|M{A`mIMfPQC7&)gU?@=Y=za-O~IKLp5gW za{D6d{_e`Xl6~gzw0{+qKd^qh^NV=ax#mvZGngh9a@7DJ^&R$4y8|QA z=VKS$_uCM%&(?8Un(Qfu`iSpUvuyW2S=Irza)U+I@Av#X@1ikoWk|H^)vNh(V@

9YUoj(GPvoaBAdp7t9qny1~)){qT-+|Mw&t)Aq$PIHPh+fDWgU05>~ z-<^2`X%z8G2te1S)}x#ar2I1ZTMs^LlrGgekGYH2YNjeCqySpyRK~ZrDf$ssxa9(i ziyfAu@6+FOa-jfBAgo9F6_s#rzU5jMZ z9YdquzG+K(3fj9J%yQgMr(7|H_Rt8f+VW779Ffs@C$hVOo+^XbCGS<-0JZ_h$!9rB zKpKqljFC9HiV!2TBc{`zJd1I&JtZ@r*pL=%O+1nw=@>p`TVsCogA#ncek1;)>n}3);arM@sy_Mn)VzPVO_LL}Ehhx%$#zrd^3keQs}p`iFL;kncbXRq&wKcIKjh9ohHqb& z>8;$7;7l92PP#_(H@YQhS~Q&znr#_uJ&%U`?1KHc<(@WA!WgFMB>7jVxYT*O*q!PR z^j?w~yHht%jN582ovrryXDZ46m+tn1na{!#y*jLN|0wLL_Yg{)j0Q*9rADBO?z+$^ ztil`e;8r=6i@|mM;M{_AEpiezE1s6JpV0;p_fUCI%DM)rFAfbCQH0jsIA>A7ao3Sm zRfo3#y&*pK{QFpMU9epvtBCb)1AA>@b(y~Y3Mw;m;*@rZnhFL1YJ?@cykweaop>Yy ziICoh0e8~-hV;=X+|Z#gR*r8wOchS#DU~`RpRY^WRk0mX=P_Fe*ZjNf-%G-$|w$<)y48^htinTATI+k%khj7Axqlq zvPHLo;}j{=;uzq3ElEC#WFA z&=9a+ewo=1IqI4CO+@SJcQxSvIV^1I=Zedc;b3?%O@^}e^2eLl8>FST`_qoR2HX4D zB%bZJ>x0_v?vLX6<&5G+joSW3WRRB}Hy`5!kg#iaVNhW_C zN>Gn=c+mU z(z1IhQZF=9U?@SL?m`-Rh5*zZe=X;z->oe`m{vEdI|~?~QI}~KFJWlwhfw(<(5@tF zVDKBF1m=&nWP`iJ5*pL9|H*{z^i{u9-*_2yuNZmW4EnePBH7Mjc%FA8SH5WNmaGD{0s(5uCy3|9!`j@k1wM?t4~y>g~Nw4pc{)hH8`EK}EbC{_K6f zJ)^y>BPxy)WL&5E<~)wFrRgz{7L&U2HDd6pV=$C6NX*z%!;9zI%hn!~9c-NKoe_y2 zDrpJuZ*Eb69Tq^tn;)TM)V0GC5L|qv;lna?9r5ZYV`(Km-FS^&qyG!on#C`m_S+Af zO}f#HTm-=atoF4jIhF5|547picap*`9q#i=X8Q6Z@6jTMKwzvwiHdjy5KZpek7cT< zq_QqgOsJVHY>DZYD42mh;~Q4mwENVdpK9wt@hj$d4K|M7kJ?eUwYr3D&mF%16$kAP z{Okq^V4GgntAp=qc+YF89RB&z-hI93qSI~gErpbcmZG8oXqTJ zimt0@;E2Q*;kqv~tJBUWuJ8HHKH``7*kRqs+pkUKKgF7@ywOrB_nW49Qopz@Uu)tbu=Uv+!39*0M|@7y*LiXlKyr z#Rg{x1s+wRKU4y8#+4QoR}?F#YY+nNaLngAm8dLHmdJC;Spv+X{Ea#l3+*o;xz1|2 zLZnYMr;L*fLRvJXk_^xRB?rZfO=#lZYymoH^!Y03*R(JikWAhu-{gon!KElkKCEx} z?Qw558=P6%$>|*>VyE$Z<6QI;<1^2)X3g&dHt6kRT)*m%Ce}#BG_NM#LTgN58N?=t zxv0*@rws4COc^KKsI!@q%`r1OIQw*~BL0B)}4NnlA;q0sKC6( zj^tQ^E;+18kp`__mKa+1jpSv5c<%lIsRV`}H<20~jTW)LhvnSp*_Hky*mz~WL8MML z4E>i=?TR2&KGK@LXY0Xu-UKIA6%N`*#FK0(LT&eeQQg?;bprlad)p9%{oCg(ZIL_U zIpZteR1fJ-1%MNkLq7N{8J-UJ2<^+gg~5`7WQ9=~cAGRNp^Q-Uj$HjCl`lziJL}TM{8H=_7U<~f_J^?rCaIPlc8E)6YgJL*2oA7k1AO1;zm=2 z@#tSwH`=V5hV&TjyKMRAqS$8{j)cK^)M>4$X%5m40)6?^XM3*D7}Rb%!Wy`hC~&g} z?={#<;q}%E_)i0T@j(~!ul?eE;z@Uuf}2S^m-chfZ|@abcDU+f{_FWj;GTvF&z?vr zE@(f@bx!`M^n_a|4hHxGylImgv}`zp&!*^SRCQSf9@rhOg%=;q9LDEBh^%(1_9;{t zoJunEO)bG!U3k|sKQS!j5T)LF3|}Q_;5O!>8^1r55RtdtC`cca}<@+R4gW-|V4;D5pZ3Fp3$&4Y3FcIH`P@ZH63_HNcz;X+}Bzdn*~Vnc!JjKO<`07!&W&$WcS4%$~L`)U#CNvvl zd0n%4WUSlzFV#58SE5eEEL>sjE@l_(;IQeLh~qJBGOs~5&GCZ#z&m@6u
+ + + diff --git a/frontend/package-lock.json b/frontend/package-lock.json new file mode 100644 index 0000000..c2d3f6c --- /dev/null +++ b/frontend/package-lock.json @@ -0,0 +1,5652 @@ +{ + "name": "eventlens-web", + "version": "1.0.6", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "eventlens-web", + "version": "1.0.6", + "dependencies": { + "react": "^19.0.0", + "react-dom": "^19.0.0" + }, + "devDependencies": { + "@eslint/js": "^9.39.5", + "@playwright/test": "^1.63.0", + "@types/react": "^19.0.0", + "@types/react-dom": "^19.0.0", + "eslint": "^9.39.5", + "eslint-plugin-jsx-a11y": "^6.10.2", + "eslint-plugin-react": "^7.37.5", + "eslint-plugin-react-hooks": "^7.1.1", + "globals": "^17.12.0", + "typescript": "^5.8.0", + "typescript-eslint": "^8.70.1", + "vite": "^6.0.0", + "vitest": "^5.0.0" + } + }, + "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/generator": { + "version": "7.29.8", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.8.tgz", + "integrity": "sha512-gZbepsdh3WDtgZKWL+vTPh71LSBrm/Y4/QDZBVCcYfmeTEEuoOYwlSy+G1StfJg+/Zy550u/3TATbm7qDbbMtg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.29.8", + "@babel/types": "^7.29.8", + "@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-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-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-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-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==", + "dev": true, + "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==", + "dev": true, + "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/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.29.9", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.9.tgz", + "integrity": "sha512-CjXrNHTnvqBVqHgdBysY3vk2T8tpJHb5/RMeHJBTyVa9xgugCB0CJTx/3oO8RV2QRQP391RWpB7D6hLjm8V9uA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.29.8" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.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.8", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.8.tgz", + "integrity": "sha512-I5z7H3bf/41ktsNVLtpN0wAa336HkqIHQ5BuPLEhTkt1jVSyZpeNKIzTgEWmlxjdg81R0IgUCcaE+Ok3NvrfZg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.7", + "@babel/generator": "^7.29.8", + "@babel/helper-globals": "^7.29.7", + "@babel/parser": "^7.29.8", + "@babel/template": "^7.29.7", + "@babel/types": "^7.29.8", + "debug": "^4.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/types": { + "version": "7.29.8", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.8.tgz", + "integrity": "sha512-Vj1jF3cPfxg7OAfoI7QnVKLoILlm2JF9pnVHrX8qx7AHMiYWT+NDAA7jChlNgRS4WTLc/fD1lXLmPixluj+3Gg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-string-parser": "^7.29.7", + "@babel/helper-validator-identifier": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.12.tgz", + "integrity": "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.12.tgz", + "integrity": "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.12.tgz", + "integrity": "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.12.tgz", + "integrity": "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.12.tgz", + "integrity": "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.12.tgz", + "integrity": "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.12.tgz", + "integrity": "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.12.tgz", + "integrity": "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.12.tgz", + "integrity": "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.12.tgz", + "integrity": "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.12.tgz", + "integrity": "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.12.tgz", + "integrity": "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.12.tgz", + "integrity": "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.12.tgz", + "integrity": "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.12.tgz", + "integrity": "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.12.tgz", + "integrity": "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.12.tgz", + "integrity": "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.12.tgz", + "integrity": "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.12.tgz", + "integrity": "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.12.tgz", + "integrity": "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.12.tgz", + "integrity": "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openharmony-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.12.tgz", + "integrity": "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.12.tgz", + "integrity": "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.12.tgz", + "integrity": "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.12.tgz", + "integrity": "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.12.tgz", + "integrity": "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@eslint-community/eslint-utils": { + "version": "4.10.1", + "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.10.1.tgz", + "integrity": "sha512-cuadcxVFE8sDK6iWJbs8Sn0av2Nrh2QSGQhVlBW9AaAHqHwjWsZHT8LJ4hFGPh7ASBV2deFdM7H/DPjulmh8rg==", + "dev": true, + "license": "MIT", + "dependencies": { + "eslint-visitor-keys": "^3.4.3" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + }, + "peerDependencies": { + "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" + } + }, + "node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys": { + "version": "3.4.3", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz", + "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/@eslint-community/regexpp": { + "version": "4.12.2", + "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.2.tgz", + "integrity": "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.0.0 || ^14.0.0 || >=16.0.0" + } + }, + "node_modules/@eslint/config-array": { + "version": "0.21.2", + "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.21.2.tgz", + "integrity": "sha512-nJl2KGTlrf9GjLimgIru+V/mzgSK0ABCDQRvxw5BjURL7WfH5uoWmizbH7QB6MmnMBd8cIC9uceWnezL1VZWWw==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@eslint/object-schema": "^2.1.7", + "debug": "^4.3.1", + "minimatch": "^3.1.5" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/config-helpers": { + "version": "0.4.2", + "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.4.2.tgz", + "integrity": "sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@eslint/core": "^0.17.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/core": { + "version": "0.17.0", + "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.17.0.tgz", + "integrity": "sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@types/json-schema": "^7.0.15" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/eslintrc": { + "version": "3.3.7", + "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.7.tgz", + "integrity": "sha512-F42g89Qd5oAWtp0k0nnSrjziAKza7w8SVT4mStc18LZMaRb4J1HQAHLCalEtDCxrTuksx7NU9qsmeLwpOfPqWw==", + "dev": true, + "license": "MIT", + "dependencies": { + "ajv": "^6.14.0", + "debug": "^4.3.2", + "espree": "^10.0.1", + "globals": "^14.0.0", + "ignore": "^5.2.0", + "import-fresh": "^3.2.1", + "js-yaml": "^4.3.2", + "minimatch": "^3.1.5", + "strip-json-comments": "^3.1.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/@eslint/eslintrc/node_modules/globals": { + "version": "14.0.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz", + "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@eslint/js": { + "version": "9.39.5", + "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.5.tgz", + "integrity": "sha512-QywQuszQh77pIXCsq998c8hbhSTI/azTty1Z6N53dmAudKHhy573j3yvRLsX2BSp8YpLtoCEG8E9DJe+8zUh4A==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://eslint.org/donate" + } + }, + "node_modules/@eslint/object-schema": { + "version": "2.1.7", + "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.7.tgz", + "integrity": "sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/plugin-kit": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.4.1.tgz", + "integrity": "sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@eslint/core": "^0.17.0", + "levn": "^0.4.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@humanfs/core": { + "version": "0.19.2", + "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.2.tgz", + "integrity": "sha512-UhXNm+CFMWcbChXywFwkmhqjs3PRCmcSa/hfBgLIb7oQ5HNb1wS0icWsGtSAUNgefHeI+eBrA8I1fxmbHsGdvA==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@humanfs/types": "^0.15.0" + }, + "engines": { + "node": ">=18.18.0" + } + }, + "node_modules/@humanfs/node": { + "version": "0.16.8", + "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.8.tgz", + "integrity": "sha512-gE1eQNZ3R++kTzFUpdGlpmy8kDZD/MLyHqDwqjkVQI0JMdI1D51sy1H958PNXYkM2rAac7e5/CnIKZrHtPh3BQ==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@humanfs/core": "^0.19.2", + "@humanfs/types": "^0.15.0", + "@humanwhocodes/retry": "^0.4.0" + }, + "engines": { + "node": ">=18.18.0" + } + }, + "node_modules/@humanfs/types": { + "version": "0.15.0", + "resolved": "https://registry.npmjs.org/@humanfs/types/-/types-0.15.0.tgz", + "integrity": "sha512-ZZ1w0aoQkwuUuC7Yf+7sdeaNfqQiiLcSRbfI08oAxqLtpXQr9AIVX7Ay7HLDuiLYAaFPu8oBYNq/QIi9URHJ3Q==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=18.18.0" + } + }, + "node_modules/@humanwhocodes/module-importer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", + "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=12.22" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" + } + }, + "node_modules/@humanwhocodes/retry": { + "version": "0.4.3", + "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz", + "integrity": "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=18.18" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" + } + }, + "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/sourcemap-codec": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.6.0.tgz", + "integrity": "sha512-T7jf+5zgsZHwNJ4lvQ7/aezbyk0nNX+zJVWpmHA7VYsEx7a7qr5Rg5IbtJFqkgze5Y2sruq1RUY8Q837Od7iFw==", + "dev": true, + "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/@napi-rs/lzma-linux-x64-gnu": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/@napi-rs/lzma-linux-x64-gnu/-/lzma-linux-x64-gnu-1.5.1.tgz", + "integrity": "sha512-oTXEIha4SsuXdTA4Iyskj0kpdx2yVXdhd75c2v3xGrHFfVMsbhTPZU/nMPL4sWKo4pBHm3aucLaqGlF696dTyQ==", + "cpu": [ + "x64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^22.20 || ^24.12 || >=25" + } + }, + "node_modules/@playwright/test": { + "version": "1.63.0", + "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.63.0.tgz", + "integrity": "sha512-oxMK4vllB9RK5NQ2l1pq1IfOf2AvnEuj/vYGDj0H2nMtmtZpKtCwt/l00GEO6xjGfpBNAvjovvYdCm50dRQkpQ==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "playwright": "1.63.0" + }, + "bin": { + "playwright": "cli.js" + }, + "engines": { + "node": ">=20" + } + }, + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.63.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.63.2.tgz", + "integrity": "sha512-Xa6RDoWa+hNiX6PgsljlH6W75RaONx3y6PVlbLhkEWW+GaPQ3dP5gwbL/erAzQHWwkvW5UxdD5l87Qx2FAQ/4A==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-android-arm64": { + "version": "4.63.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.63.2.tgz", + "integrity": "sha512-vNASxsghMfQ5s+v3PrpnJd+ryL/26lxCCaGI+sDJ7VzmHiYXIrrVltsDhaawxLM1WcoMU2oYlbPHLaYQtBzhcg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.63.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.63.2.tgz", + "integrity": "sha512-0dWDjmlrpZAgjPD/aPzUDhBW8APLRjAni5bOrM76wiiZm+E+KTMVKNhAzaTBohz8UyO2fKNAl0+fygbe2HZXOA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.63.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.63.2.tgz", + "integrity": "sha512-N58uktcwzk3+qT4KHEuNdIxX1N01RWrkfVoml69EAbSaNDL+sbNVLx2RMl4Qd23lpA0fgPvyh5hHb4weD5WKmg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-freebsd-arm64": { + "version": "4.63.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.63.2.tgz", + "integrity": "sha512-HWF2zH8EAp2scWRpt2PGe6iUGz7zi04waXsdRr3zb4DWCk2ImIo5FZu0jjmD53nP/DGSvnW0e7/1ToCNZs2lZw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-freebsd-x64": { + "version": "4.63.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.63.2.tgz", + "integrity": "sha512-MkvcwHMnzPSMOQEwB6wHnLzmc+hT8BGc5bW/Mhmjjgx3wbj6VBnlc47XsK74kD0K9MikFfXpQqyz4NUXaUW62A==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.63.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.63.2.tgz", + "integrity": "sha512-xe1bCKPJaKsD0tfd7Rb6bGfUogJTpKbTEEthsfdb7hTfTRNJVQTdirabQx0o6ERVba/smkM720soMY+0QnrlSQ==", + "cpu": [ + "arm" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm-musleabihf": { + "version": "4.63.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.63.2.tgz", + "integrity": "sha512-yOM7LdK0p6gk6+Q773OEwtlsikT1TL3yMmYsTtRlDRPha5vV2DC5x7LqRWDr6f3cSYNMKVqxzffXv8ivxNBIFQ==", + "cpu": [ + "arm" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.63.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.63.2.tgz", + "integrity": "sha512-qiWuJJV3DybA2IfzvRimeKXGrGuVPv1zobSY/26KnP3HbV0VcNb3ECzgvtbvF3xjSMkcooou6HASXZuLdjnhpQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.63.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.63.2.tgz", + "integrity": "sha512-akcZquRzCY/KpUoZAMBhGf7oi4LmXq1BzRA5CPAC3rkUf28Y/sAYV3jSL+JKd7cwEyFvR5G0XVZ0gaMedP+60A==", + "cpu": [ + "arm64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-gnu": { + "version": "4.63.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.63.2.tgz", + "integrity": "sha512-fNwYHrPyYyxauPzX/cpYw8Z7LQpp+DGA0KCoswA0aVFBpmdMil9XgjB8V3Ny64Ihu797+GKcuJqnsOKEmor7fA==", + "cpu": [ + "loong64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-musl": { + "version": "4.63.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.63.2.tgz", + "integrity": "sha512-XfvsgzR7DZqREdst7K1Mj3ilSUM5xLAHJcIMDFPKdxTs9q5VHOT8aMA+a683fqBu7DQl8+Sd9HCsQYL8EMY9qA==", + "cpu": [ + "loong64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-gnu": { + "version": "4.63.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.63.2.tgz", + "integrity": "sha512-Pp7gVZggEFlbcuztay+/U0gVG9S1XAh8i7I1Re/htbAzo43P5wHZHw6pTyzotISqlKohoh9RpIfnOz3RbemK1w==", + "cpu": [ + "ppc64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-musl": { + "version": "4.63.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.63.2.tgz", + "integrity": "sha512-zkgL2xff6i7u5hau/m6FGeS8gRkLEdgLw522WGmdWWlLd9btmNl3S80mcEjtGq+kvgUekQ3+BOYLLLcPlS2LIA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.63.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.63.2.tgz", + "integrity": "sha512-qOheJomrkVCbbHFJ7L3J97cnhfogKqguAQphv26+3ZsAQIF1L19b+dArl//s8rjJHJLz9byykyM8NBP4nmSa1g==", + "cpu": [ + "riscv64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-musl": { + "version": "4.63.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.63.2.tgz", + "integrity": "sha512-XlxLD54wQhH3FciCgMofxBw27NzUe818gJH410qWvc41UT0ZFcgxVjyX5/EK8MPTupjeVWqN5oy+9pCA9mqfCA==", + "cpu": [ + "riscv64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.63.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.63.2.tgz", + "integrity": "sha512-vdryWeRb2bLJZf0Fv/W8se6nvsHe2PkTCxV0meheK3nQE+G90VCJcke51Miy1yQRsfm2uqIyjXOu4wmUzbTtkQ==", + "cpu": [ + "s390x" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.63.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.63.2.tgz", + "integrity": "sha512-bcq2h2pkKmH2po4cZV8VWzO4lL40STyu/nLoFpYMQp9C2tCVNTdcVv86MwSsn3D5s1FBe2Ty1atqvVAUTMimNg==", + "cpu": [ + "x64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.63.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.63.2.tgz", + "integrity": "sha512-EGoo5DMVMRkTId8fuTDaoxVlR5ZTsKULUezRjd9gCw5eeY+DjCvDpZAOlNUvKPGX+7rS1RWx6j+yOpNPx0cUgQ==", + "cpu": [ + "x64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-openbsd-x64": { + "version": "4.63.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.63.2.tgz", + "integrity": "sha512-MErl12k7BFHZG1TI9QF/3lSSZARzq9KgNy/FjnqFMCkv+N4RSSzoUCA5h2mqHX4Mox3WaTVKblyzhQ1zRb2ZuQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ] + }, + "node_modules/@rollup/rollup-openharmony-arm64": { + "version": "4.63.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.63.2.tgz", + "integrity": "sha512-ILs8k07Wh4p0PsNY4wYLEaXZKMOpVhrG5QDB0yHhGhuzOfDlnyHN6sflL4El/MpUP1y8uY2lUZrv4oBS6pTT3g==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.63.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.63.2.tgz", + "integrity": "sha512-hKgB3nz/TKD3Wv78XEsyXzQsNjvhOHmwKQTvXADGOyU/cIClZDO7DsoggbdmJDPGp5V80tA3Vfv61PaKTLH3LA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.63.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.63.2.tgz", + "integrity": "sha512-T4wf1mudIDxN8Q/CWIBJC1u5gQUc+r5mPvlwoSbIvNkyVTP2TAFeobEmst5AQ4gMyAz4sSByVdoTDfvTmGK/8g==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-gnu": { + "version": "4.63.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.63.2.tgz", + "integrity": "sha512-tC3IY7qoaD9Ll3/8WJQn49j5V2f/NuI9S41NOE2iM5MPs3sPIvOkVToLcz/7Bz4pyF7PSvrtwu8I/pUrGOSecQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.63.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.63.2.tgz", + "integrity": "sha512-6NHnk/K3eq2ZFYcU1X8g67s9qIJRCOTT92gwLMVBp08dB2uuuwI1/Q/empzL2Bfr2f2WRLJVwpp90RmacQyFkw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@types/chai": { + "version": "5.2.3", + "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz", + "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/deep-eql": "*", + "assertion-error": "^2.0.1" + } + }, + "node_modules/@types/deep-eql": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz", + "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==", + "dev": true, + "license": "MIT" + }, + "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/json-schema": { + "version": "7.0.15", + "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz", + "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/react": { + "version": "19.3.0", + "resolved": "https://registry.npmjs.org/@types/react/-/react-19.3.0.tgz", + "integrity": "sha512-N0rFCuH9YoxG9/m61l9MfpJKfmLOVU0em7ipIz6TRgSSkvReLB9vL85GB+yr8Bs5leqpvg96JSwF4ZS1s4viQg==", + "dev": true, + "license": "MIT", + "dependencies": { + "csstype": "^3.2.2" + } + }, + "node_modules/@types/react-dom": { + "version": "19.3.0", + "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.3.0.tgz", + "integrity": "sha512-ZI7bU42mZXXKHn/qNLEw2IrbiINU7X5+vfgdixBHkCNpYWXjKgfQ/P+uyGb5CjOLB9UcnTeg3rylQtV2hym44Q==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "@types/react": "^19.3.0" + } + }, + "node_modules/@typescript-eslint/eslint-plugin": { + "version": "8.70.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.70.1.tgz", + "integrity": "sha512-nDNrUQ/4ruSNYbu749TRY7cfrzPtoLHEXSNBI8aaNY32LlZCajixqRf3FqcKC4p5Cam4VOHYx/t+i5+nKXvrqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/regexpp": "^4.12.2", + "@typescript-eslint/scope-manager": "8.70.1", + "@typescript-eslint/type-utils": "8.70.1", + "@typescript-eslint/utils": "8.70.1", + "@typescript-eslint/visitor-keys": "8.70.1", + "ignore": "^7.0.5", + "natural-compare": "^1.4.0", + "ts-api-utils": "^2.5.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "@typescript-eslint/parser": "^8.70.1", + "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/@typescript-eslint/eslint-plugin/node_modules/ignore": { + "version": "7.0.10", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.10.tgz", + "integrity": "sha512-HpbUakT7xp5miBUywCHf36ZEuAJNklBJDDsGpUIjMzOSmM8ELSfA9Sa/QDPeNeqeoN31u+UTCkL4klCOVvRm4Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/@typescript-eslint/parser": { + "version": "8.70.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.70.1.tgz", + "integrity": "sha512-nO974WLllwhSFWQXnMLj6nDGa8f0khKEz1JzpPJ1u7Vm/4X1X6ZHajpoknU4bb41vJyMB0HHVyS2GqdhWfIXZw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/scope-manager": "8.70.1", + "@typescript-eslint/types": "8.70.1", + "@typescript-eslint/typescript-estree": "8.70.1", + "@typescript-eslint/visitor-keys": "8.70.1", + "debug": "^4.4.3" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/@typescript-eslint/project-service": { + "version": "8.70.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.70.1.tgz", + "integrity": "sha512-62xOgboPfwc3/IgPSX/W6oQR3ZbF04194FPGUGH8HL8iLFHbt/456/8Ph1wLNUgVF+s94FlHoipBsz+v7+LMnA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/tsconfig-utils": "^8.70.1", + "@typescript-eslint/types": "^8.70.1", + "debug": "^4.4.3" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/@typescript-eslint/scope-manager": { + "version": "8.70.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.70.1.tgz", + "integrity": "sha512-Pa0EeSeAusQc1WbjQMac+YfenewYTBu0KjgYvkUKwhXaHUKbFog23Dm/rp0DX/6tyYOQ3Xl1a+3EcFNZynGHCw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/types": "8.70.1", + "@typescript-eslint/visitor-keys": "8.70.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/tsconfig-utils": { + "version": "8.70.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.70.1.tgz", + "integrity": "sha512-jumze1fPI+sDOaM2TWGQdn39PDxTr7TZGeuyLkAbNyx2vtMT3uRnVKChN0hfht5V2TugphJzF6bYXvBcE09qqg==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/@typescript-eslint/type-utils": { + "version": "8.70.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.70.1.tgz", + "integrity": "sha512-7zKTnyvaVWqzLZHPFQtX1hVHqgkMC+WebPWakNCSyrQVbIP1AM0L0TlBZtACldIRb6PptI8Odk+jyZ5kP3B1VA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/types": "8.70.1", + "@typescript-eslint/typescript-estree": "8.70.1", + "@typescript-eslint/utils": "8.70.1", + "debug": "^4.4.3", + "ts-api-utils": "^2.5.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/@typescript-eslint/types": { + "version": "8.70.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.70.1.tgz", + "integrity": "sha512-Dm1ypdhhrGCTyyehxElhgJ6kgk8MVCv5qXdoOVqPr1uqk42jX8KjrZqhROvdShczA8qrDoYiOWn1ykWlx2k81Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/typescript-estree": { + "version": "8.70.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.70.1.tgz", + "integrity": "sha512-TU8PwyGN0PQJUcE96mw8eCQ44SmxGdQlJmlWakHaHQ15eIuuvye5yNtmh/i6oS88jzXVQB71xdNkbkB/fMwL0g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/project-service": "8.70.1", + "@typescript-eslint/tsconfig-utils": "8.70.1", + "@typescript-eslint/types": "8.70.1", + "@typescript-eslint/visitor-keys": "8.70.1", + "debug": "^4.4.3", + "minimatch": "^10.2.2", + "semver": "^7.7.3", + "tinyglobby": "^0.2.15", + "ts-api-utils": "^2.5.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/@typescript-eslint/typescript-estree/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/@typescript-eslint/typescript-estree/node_modules/brace-expansion": { + "version": "5.0.12", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.12.tgz", + "integrity": "sha512-YovQ3rzhaLMIrDjNDMkNS01tea93qhEhG5xy8f6+R0l+dw3Ki+5sCoIoI942iuLZTHWogWktgwVDhU09iNEimQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^4.0.2" + }, + "engines": { + "node": "20 || >=22" + } + }, + "node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch": { + "version": "10.2.6", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.6.tgz", + "integrity": "sha512-vpLQEs+VLCr1nU0BXS07maYoFwlDAH0gngQuuttxIwutDFEMHq2blX+8vpgxDdK3J1PwjCJiep77OitTZ4Ll1A==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "brace-expansion": "^5.0.8" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/@typescript-eslint/typescript-estree/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/@typescript-eslint/utils": { + "version": "8.70.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.70.1.tgz", + "integrity": "sha512-Esgul8MsnKnRLdYU2Eb2cRV9bS5HJYtKj1ByJnOzzG2M58DGdSUQ1jUuILxipqcpB2h9WLrbD5GijIWUjX/Tqw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/eslint-utils": "^4.9.1", + "@typescript-eslint/scope-manager": "8.70.1", + "@typescript-eslint/types": "8.70.1", + "@typescript-eslint/typescript-estree": "8.70.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/@typescript-eslint/visitor-keys": { + "version": "8.70.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.70.1.tgz", + "integrity": "sha512-Vwj9lUIW5Xq3wQ9w6gv3R86g1hMK8f2zNOdGTAgeXUMMXFK78G9ruCjjqutHMNJc0+CH7LYRnHeUB9IT8wFmcw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/types": "8.70.1", + "eslint-visitor-keys": "^5.0.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/visitor-keys/node_modules/eslint-visitor-keys": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-5.0.1.tgz", + "integrity": "sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^20.19.0 || ^22.13.0 || >=24" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/@vitest/mocker": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-5.0.0.tgz", + "integrity": "sha512-66PGTMIiVJP3t4a5yxU9qPtf7MdTBs8jmToMvy+HVflB3Yy13WJZTtPePdvU+wjRV02SKK5doLbSA6o9pwOmiA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/trace-mapping": "0.3.31", + "@vitest/spy": "5.0.0", + "estree-walker": "^3.0.3", + "magic-string": "^1.2.3" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "msw": "^2.4.9", + "vite": "^6.0.0 || ^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "msw": { + "optional": true + }, + "vite": { + "optional": true + } + } + }, + "node_modules/@vitest/spy": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-5.0.0.tgz", + "integrity": "sha512-uy+luWBAPw9XfthoHi5AkfHUnuPYEESjl0p/r+meoBnU8bxg5GDQ3Ey8MjcJ6sqahkL4PFyrvfMJJBw7LbU06g==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/acorn": { + "version": "8.18.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.18.0.tgz", + "integrity": "sha512-lGq+9yr1/GuAWaVYIHRjvvySG5/4VfKIvC8EWxStPdcDh/Ka7FG3twP6v4d5BkravUilhIAsG4Qj83t02LWUPQ==", + "dev": true, + "license": "MIT", + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/acorn-jsx": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz", + "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/ajv": { + "version": "6.15.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.15.0.tgz", + "integrity": "sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw==", + "dev": true, + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "dev": true, + "license": "Python-2.0" + }, + "node_modules/aria-query": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.2.tgz", + "integrity": "sha512-COROpnaoap1E2F000S62r6A60uHZnmlvomhfyT2DlTcrY1OrBKn2UhH7qn5wTC9zMvD0AY7csdPSNwKP+7WiQw==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/array-buffer-byte-length": { + "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-bound": "^1.0.3", + "is-array-buffer": "^3.0.5" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/array-includes": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/array-includes/-/array-includes-3.2.0.tgz", + "integrity": "sha512-VXY5eFRarnXcYxwBjJzPmEhH55+rmP79/+ueDhi0F+TuqfHCItagIHqxeUZrmgrOPa31QTh9H85DjX3FfJ0FTg==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.9", + "call-bound": "^1.0.4", + "define-properties": "^1.2.1", + "es-abstract": "^1.24.2", + "es-object-atoms": "^1.1.2", + "es-shim-unscopables": "^1.1.0", + "is-string": "^1.1.1", + "math-intrinsics": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/array.prototype.findlast": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/array.prototype.findlast/-/array.prototype.findlast-1.2.5.tgz", + "integrity": "sha512-CVvd6FHg1Z3POpBLxO6E6zr+rSKEQ9L6rZHAaY7lLfhKsWYUBBOuMs0e9o24oopj6H+geRCX0YJ+TJLBK2eHyQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.2", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.0.0", + "es-shim-unscopables": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/array.prototype.flat": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.3.tgz", + "integrity": "sha512-rwG/ja1neyLqCuGZ5YYrznA62D4mZXg0i1cIskIUKSiqF3Cje9/wXAls9B9s1Wa2fomMsIv8czB8jZcPmxCXFg==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.5", + "es-shim-unscopables": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/array.prototype.flatmap": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/array.prototype.flatmap/-/array.prototype.flatmap-1.3.3.tgz", + "integrity": "sha512-Y7Wt51eKJSyi80hFrJCePGGNo5ktJCslFuboqJsbf57CCPcm5zztluPlc4/aD8sWsKvlwatezpV4U1efk8kpjg==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.5", + "es-shim-unscopables": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/array.prototype.tosorted": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/array.prototype.tosorted/-/array.prototype.tosorted-1.1.4.tgz", + "integrity": "sha512-p6Fx8B7b7ZhL/gmUsAy0D15WhvDccw3mnGNbZpi3pmeJdxtWsj2jEaI4Y6oo3XiHfzuSgPwKc04MYt6KgvC/wA==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.3", + "es-errors": "^1.3.0", + "es-shim-unscopables": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/arraybuffer.prototype.slice": { + "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.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" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/assertion-error": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz", + "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + } + }, + "node_modules/ast-types-flow": { + "version": "0.0.8", + "resolved": "https://registry.npmjs.org/ast-types-flow/-/ast-types-flow-0.0.8.tgz", + "integrity": "sha512-OH/2E5Fg20h2aPrbe+QL8JZQFko0YZaF+j4mnQ7BGhfavO7OpSLa8a0y9sBwomHdSbkhTS8TQNayBfnW5DwbvQ==", + "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/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" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/axe-core": { + "version": "4.13.0", + "resolved": "https://registry.npmjs.org/axe-core/-/axe-core-4.13.0.tgz", + "integrity": "sha512-UzGt8zg7Ny8djbYMhxl2zuEevVa7r2gJjYY5Lwr1xM7+XU2nd6CkIWFTVcCIbAP63vSz71NaVyyuSk9lHKcy0A==", + "dev": true, + "license": "MPL-2.0", + "engines": { + "node": ">=4" + } + }, + "node_modules/axobject-query": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/axobject-query/-/axobject-query-4.1.0.tgz", + "integrity": "sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">= 0.4" + } + }, + "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, + "license": "MIT" + }, + "node_modules/baseline-browser-mapping": { + "version": "2.11.25", + "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.11.25.tgz", + "integrity": "sha512-gMmEShwwq7FJqMwvfRwvCl00v4kN+KOfJqXn+f4nrufak5gNHJOksd/60Dvjuz7sI8Y5WiSFBa8FEYr+zoyqCw==", + "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.21", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.21.tgz", + "integrity": "sha512-9zeA+KLZNNzglF2TPKRQEDyx6Yby7daAkuy8MiPzpXPsYDWi/DRM8jmwUDxokQjYqBpv5DgPiwD4h4ZZSy1Ujw==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/browserslist": { + "version": "4.29.0", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.29.0.tgz", + "integrity": "sha512-3GSvyjvDI4Dur1Meg2BekJquu5uF+9R9a1+5M1Mde192eZoXbeXjzgOsgqPS2V8D5wrrip0gR5Hf/GhWQ9ZzaA==", + "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": { + "baseline-browser-mapping": "^2.11.23", + "caniuse-lite": "^1.0.30001810", + "electron-to-chromium": "^1.5.427", + "node-releases": "^2.0.55", + "update-browserslist-db": "^1.3.3" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "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/callsites": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", + "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/caniuse-lite": { + "version": "1.0.30001810", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001810.tgz", + "integrity": "sha512-TITQPUkaz+aVk5GL6NhOdwk1aEaNTSDPsGFWrTuhKGtjTF70jL/Oht2W4c6rXUe5fu7Ie19VIahAXHIIiWWNeg==", + "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/chai": { + "version": "6.2.2", + "resolved": "https://registry.npmjs.org/chai/-/chai-6.2.2.tgz", + "integrity": "sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + } + }, + "node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "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-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/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "dev": true, + "license": "MIT" + }, + "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/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/csstype": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz", + "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/damerau-levenshtein": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/damerau-levenshtein/-/damerau-levenshtein-1.0.8.tgz", + "integrity": "sha512-sdQSFB7+llfUcQHUQO3+B8ERRj0Oa4w9POWMI/puGtuf7gFywGmkaLCElnudfTiKZV+NvHqL0ifzdrI8Ro7ESA==", + "dev": true, + "license": "BSD-2-Clause" + }, + "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/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/deep-is": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz", + "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==", + "dev": true, + "license": "MIT" + }, + "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" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/doctrine": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz", + "integrity": "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "esutils": "^2.0.2" + }, + "engines": { + "node": ">=0.10.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/electron-to-chromium": { + "version": "1.5.435", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.435.tgz", + "integrity": "sha512-hwZNgb6JmRlmQX/L0yojyu6upuvtR7iGS1hB/9nc7I9vCsvekahqh3noFeXUBRirv9+Hk7E6v/LFz4CW6FvpWA==", + "dev": true, + "license": "ISC" + }, + "node_modules/emoji-regex": { + "version": "9.2.2", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz", + "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==", + "dev": true, + "license": "MIT" + }, + "node_modules/es-abstract": { + "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.2", + "arraybuffer.prototype.slice": "^1.0.4", + "available-typed-arrays": "^1.0.7", + "call-bind": "^1.0.8", + "call-bound": "^1.0.4", + "data-view-buffer": "^1.0.2", + "data-view-byte-length": "^1.0.2", + "data-view-byte-offset": "^1.0.1", + "es-define-property": "^1.0.1", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.1.1", + "es-set-tostringtag": "^2.1.0", + "es-to-primitive": "^1.3.0", + "function.prototype.name": "^1.1.8", + "get-intrinsic": "^1.3.0", + "get-proto": "^1.0.1", + "get-symbol-description": "^1.1.0", + "globalthis": "^1.0.4", + "gopd": "^1.2.0", + "has-property-descriptors": "^1.0.2", + "has-proto": "^1.2.0", + "has-symbols": "^1.1.0", + "hasown": "^2.0.2", + "internal-slot": "^1.1.0", + "is-array-buffer": "^3.0.5", + "is-callable": "^1.2.7", + "is-data-view": "^1.0.2", + "is-negative-zero": "^2.0.3", + "is-regex": "^1.2.1", + "is-set": "^2.0.3", + "is-shared-array-buffer": "^1.0.4", + "is-string": "^1.1.1", + "is-typed-array": "^1.1.15", + "is-weakref": "^1.1.1", + "math-intrinsics": "^1.1.0", + "object-inspect": "^1.13.4", + "object-keys": "^1.1.1", + "object.assign": "^4.1.7", + "own-keys": "^1.0.1", + "regexp.prototype.flags": "^1.5.4", + "safe-array-concat": "^1.1.3", + "safe-push-apply": "^1.0.0", + "safe-regex-test": "^1.1.0", + "set-proto": "^1.0.0", + "stop-iteration-iterator": "^1.1.0", + "string.prototype.trim": "^1.2.10", + "string.prototype.trimend": "^1.0.9", + "string.prototype.trimstart": "^1.0.8", + "typed-array-buffer": "^1.0.3", + "typed-array-byte-length": "^1.0.3", + "typed-array-byte-offset": "^1.0.4", + "typed-array-length": "^1.0.7", + "unbox-primitive": "^1.1.0", + "which-typed-array": "^1.1.19" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "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": { + "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-iterator-helpers": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/es-iterator-helpers/-/es-iterator-helpers-1.4.0.tgz", + "integrity": "sha512-c/A0P0oxkACDc+cKWw8evLXK83oBKgn0qPOqCYT4x9uolpCIJAcYvJC9QYKNDRPsTeGyCrQ326jrvgZWdCdK5Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.9", + "call-bound": "^1.0.4", + "define-properties": "^1.2.1", + "es-abstract": "^1.24.2", + "es-errors": "^1.3.0", + "es-set-tostringtag": "^2.1.0", + "function-bind": "^1.1.2", + "get-intrinsic": "^1.3.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", + "internal-slot": "^1.1.0", + "iterator.prototype": "^1.1.5", + "math-intrinsics": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-module-lexer": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-2.3.2.tgz", + "integrity": "sha512-poHGpORABojJJucnV9KbOavETW8lBVnphkW77ER5/BQ5Fz7oXSoCNek7IH3vR5nRjdsEz926ibFYX8KtLQmdyw==", + "dev": true, + "license": "MIT" + }, + "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-shim-unscopables": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/es-shim-unscopables/-/es-shim-unscopables-1.1.0.tgz", + "integrity": "sha512-d9T8ucsEhh8Bi1woXCf+TIKDIROLG5WCkxg8geBCbvk22kzwC5G2OnXVMO6FUsvQlgUUXQ2itephWDLqDzbeCw==", + "dev": true, + "license": "MIT", + "dependencies": { + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-to-primitive": { + "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": { + "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" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/esbuild": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.12.tgz", + "integrity": "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.25.12", + "@esbuild/android-arm": "0.25.12", + "@esbuild/android-arm64": "0.25.12", + "@esbuild/android-x64": "0.25.12", + "@esbuild/darwin-arm64": "0.25.12", + "@esbuild/darwin-x64": "0.25.12", + "@esbuild/freebsd-arm64": "0.25.12", + "@esbuild/freebsd-x64": "0.25.12", + "@esbuild/linux-arm": "0.25.12", + "@esbuild/linux-arm64": "0.25.12", + "@esbuild/linux-ia32": "0.25.12", + "@esbuild/linux-loong64": "0.25.12", + "@esbuild/linux-mips64el": "0.25.12", + "@esbuild/linux-ppc64": "0.25.12", + "@esbuild/linux-riscv64": "0.25.12", + "@esbuild/linux-s390x": "0.25.12", + "@esbuild/linux-x64": "0.25.12", + "@esbuild/netbsd-arm64": "0.25.12", + "@esbuild/netbsd-x64": "0.25.12", + "@esbuild/openbsd-arm64": "0.25.12", + "@esbuild/openbsd-x64": "0.25.12", + "@esbuild/openharmony-arm64": "0.25.12", + "@esbuild/sunos-x64": "0.25.12", + "@esbuild/win32-arm64": "0.25.12", + "@esbuild/win32-ia32": "0.25.12", + "@esbuild/win32-x64": "0.25.12" + } + }, + "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": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint": { + "version": "9.39.5", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.39.5.tgz", + "integrity": "sha512-DgZS62aPLXKlnxILS/AYCoRvHaZeXceIzlXPkkGGzJWSow1aEk0lbTlxUSlyjC8jcaKxAdOnTDz+o1JFSBsyjw==", + "deprecated": "This version is no longer supported. Please see https://eslint.org/version-support for other options.", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/eslint-utils": "^4.8.0", + "@eslint-community/regexpp": "^4.12.1", + "@eslint/config-array": "^0.21.2", + "@eslint/config-helpers": "^0.4.2", + "@eslint/core": "^0.17.0", + "@eslint/eslintrc": "^3.3.6", + "@eslint/js": "9.39.5", + "@eslint/plugin-kit": "^0.4.1", + "@humanfs/node": "^0.16.6", + "@humanwhocodes/module-importer": "^1.0.1", + "@humanwhocodes/retry": "^0.4.2", + "@types/estree": "^1.0.6", + "ajv": "^6.14.0", + "chalk": "^4.0.0", + "cross-spawn": "^7.0.6", + "debug": "^4.3.2", + "escape-string-regexp": "^4.0.0", + "eslint-scope": "^8.4.0", + "eslint-visitor-keys": "^4.2.1", + "espree": "^10.4.0", + "esquery": "^1.5.0", + "esutils": "^2.0.2", + "fast-deep-equal": "^3.1.3", + "file-entry-cache": "^8.0.0", + "find-up": "^5.0.0", + "glob-parent": "^6.0.2", + "ignore": "^5.2.0", + "imurmurhash": "^0.1.4", + "is-glob": "^4.0.0", + "json-stable-stringify-without-jsonify": "^1.0.1", + "lodash.merge": "^4.6.2", + "minimatch": "^3.1.5", + "natural-compare": "^1.4.0", + "optionator": "^0.9.3" + }, + "bin": { + "eslint": "bin/eslint.js" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://eslint.org/donate" + }, + "peerDependencies": { + "jiti": "*" + }, + "peerDependenciesMeta": { + "jiti": { + "optional": true + } + } + }, + "node_modules/eslint-plugin-jsx-a11y": { + "version": "6.10.2", + "resolved": "https://registry.npmjs.org/eslint-plugin-jsx-a11y/-/eslint-plugin-jsx-a11y-6.10.2.tgz", + "integrity": "sha512-scB3nz4WmG75pV8+3eRUQOHZlNSUhFNq37xnpgRkCCELU3XMvXAxLk1eqWWyE22Ki4Q01Fnsw9BA3cJHDPgn2Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "aria-query": "^5.3.2", + "array-includes": "^3.1.8", + "array.prototype.flatmap": "^1.3.2", + "ast-types-flow": "^0.0.8", + "axe-core": "^4.10.0", + "axobject-query": "^4.1.0", + "damerau-levenshtein": "^1.0.8", + "emoji-regex": "^9.2.2", + "hasown": "^2.0.2", + "jsx-ast-utils": "^3.3.5", + "language-tags": "^1.0.9", + "minimatch": "^3.1.2", + "object.fromentries": "^2.0.8", + "safe-regex-test": "^1.0.3", + "string.prototype.includes": "^2.0.1" + }, + "engines": { + "node": ">=4.0" + }, + "peerDependencies": { + "eslint": "^3 || ^4 || ^5 || ^6 || ^7 || ^8 || ^9" + } + }, + "node_modules/eslint-plugin-react": { + "version": "7.37.5", + "resolved": "https://registry.npmjs.org/eslint-plugin-react/-/eslint-plugin-react-7.37.5.tgz", + "integrity": "sha512-Qteup0SqU15kdocexFNAJMvCJEfa2xUKNV4CC1xsVMrIIqEy3SQ/rqyxCWNzfrd3/ldy6HMlD2e0JDVpDg2qIA==", + "dev": true, + "license": "MIT", + "dependencies": { + "array-includes": "^3.1.8", + "array.prototype.findlast": "^1.2.5", + "array.prototype.flatmap": "^1.3.3", + "array.prototype.tosorted": "^1.1.4", + "doctrine": "^2.1.0", + "es-iterator-helpers": "^1.2.1", + "estraverse": "^5.3.0", + "hasown": "^2.0.2", + "jsx-ast-utils": "^2.4.1 || ^3.0.0", + "minimatch": "^3.1.2", + "object.entries": "^1.1.9", + "object.fromentries": "^2.0.8", + "object.values": "^1.2.1", + "prop-types": "^15.8.1", + "resolve": "^2.0.0-next.5", + "semver": "^6.3.1", + "string.prototype.matchall": "^4.0.12", + "string.prototype.repeat": "^1.0.0" + }, + "engines": { + "node": ">=4" + }, + "peerDependencies": { + "eslint": "^3 || ^4 || ^5 || ^6 || ^7 || ^8 || ^9.7" + } + }, + "node_modules/eslint-plugin-react-hooks": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-7.1.1.tgz", + "integrity": "sha512-f2I7Gw6JbvCexzIInuSbZpfdQ44D7iqdWX01FKLvrPgqxoE7oMj8clOfto8U6vYiz4yd5oKu39rRSVOe1zRu0g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/core": "^7.24.4", + "@babel/parser": "^7.24.4", + "hermes-parser": "^0.25.1", + "zod": "^3.25.0 || ^4.0.0", + "zod-validation-error": "^3.5.0 || ^4.0.0" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0 || ^10.0.0" + } + }, + "node_modules/eslint-scope": { + "version": "8.4.0", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.4.0.tgz", + "integrity": "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^5.2.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint-visitor-keys": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz", + "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/espree": { + "version": "10.4.0", + "resolved": "https://registry.npmjs.org/espree/-/espree-10.4.0.tgz", + "integrity": "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "acorn": "^8.15.0", + "acorn-jsx": "^5.3.2", + "eslint-visitor-keys": "^4.2.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/esquery": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.7.0.tgz", + "integrity": "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "estraverse": "^5.1.0" + }, + "engines": { + "node": ">=0.10" + } + }, + "node_modules/esrecurse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", + "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "estraverse": "^5.2.0" + }, + "engines": { + "node": ">=4.0" + } + }, + "node_modules/estraverse": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", + "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=4.0" + } + }, + "node_modules/estree-walker": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz", + "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.0" + } + }, + "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/expect-type": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.4.0.tgz", + "integrity": "sha512-KfYbmpRm0VbLjEvVa9yGwCi9GI34xvi7A/HXYWQO65CSD2u3MczUJSuwXKFIxlGsgBQizV9q5J9NHj4VG0n+pA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=12.0.0" + } + }, + "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-levenshtein": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==", + "dev": true, + "license": "MIT" + }, + "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/file-entry-cache": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz", + "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "flat-cache": "^4.0.0" + }, + "engines": { + "node": ">=16.0.0" + } + }, + "node_modules/find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "dev": true, + "license": "MIT", + "dependencies": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/flat-cache": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz", + "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==", + "dev": true, + "license": "MIT", + "dependencies": { + "flatted": "^3.2.9", + "keyv": "^4.5.4" + }, + "engines": { + "node": ">=16" + } + }, + "node_modules/flatted": { + "version": "3.4.4", + "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.4.4.tgz", + "integrity": "sha512-5+ybhBZANEJxaH3X5evAFatUxLfEHSr7n6kYJ+1Qd0mUqr4eu9gIf6GDbWHf8RJijHrjjO8G+la14SlL2SeS1Q==", + "dev": true, + "license": "ISC" + }, + "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/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/function-bind": { + "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.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.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" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/functions-have-names": { + "version": "1.2.3", + "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.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": { + "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" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "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": { + "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-parent": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", + "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", + "dev": true, + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.3" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/globals": { + "version": "17.12.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-17.12.0.tgz", + "integrity": "sha512-cezEd/DTyyht9cvSSURyygXPfy04GtWO/5e6ZPvH7fCtjKz9PYOmuawphw1Ctd1f6C+5JypXfGD7ahNMXvevBA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "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" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/gopd": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz", + "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-bigints": { + "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" + } + }, + "node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/has-property-descriptors": { + "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": { + "es-define-property": "^1.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-proto": { + "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" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-symbols": { + "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" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-tostringtag": { + "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.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "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/hermes-estree": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/hermes-estree/-/hermes-estree-0.25.1.tgz", + "integrity": "sha512-0wUoCcLp+5Ev5pDW2OriHC2MJCbwLwuRx+gAqMTOkGKJJiBCLjtrvy4PWUGn6MIVefecRpzoOZ/UV6iGdOr+Cw==", + "dev": true, + "license": "MIT" + }, + "node_modules/hermes-parser": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/hermes-parser/-/hermes-parser-0.25.1.tgz", + "integrity": "sha512-6pEjquH3rqaI6cYAXYPcz9MS4rY6R4ngRgrgfDshRptUZIc3lw0MCIJIGDj9++mfySOuPTHB4nrSW99BCvOPIA==", + "dev": true, + "license": "MIT", + "dependencies": { + "hermes-estree": "0.25.1" + } + }, + "node_modules/ignore": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz", + "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/import-fresh": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz", + "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "parent-module": "^1.0.0", + "resolve-from": "^4.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.8.19" + } + }, + "node_modules/internal-slot": { + "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": { + "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.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.8", + "call-bound": "^1.0.3", + "get-intrinsic": "^1.2.6" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "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": { + "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.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-bound": "^1.0.3", + "has-tostringtag": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-callable": { + "version": "1.2.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" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-core-module": { + "version": "2.17.0", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.17.0.tgz", + "integrity": "sha512-J/vG0zBCbIKOQFfufSwyXdMrsohyJIUNkrnmo6WZGzoM7tr/lsbfW5b2BvisL6zsyMzK9UxV9L6c7AoFbyXHOA==", + "dev": true, + "license": "MIT", + "dependencies": { + "hasown": "^2.0.4" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "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-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "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-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "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-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" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-number-object": { + "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": { + "call-bound": "^1.0.3", + "has-tostringtag": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "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-bound": "^1.0.2", + "gopd": "^1.2.0", + "has-tostringtag": "^1.0.2", + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "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.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-bound": "^1.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "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": { + "call-bound": "^1.0.3", + "has-tostringtag": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-symbol": { + "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": { + "call-bound": "^1.0.2", + "has-symbols": "^1.1.0", + "safe-regex-test": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-typed-array": { + "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.16" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "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-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" + } + }, + "node_modules/isarray": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz", + "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==", + "dev": true, + "license": "MIT" + }, + "node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "dev": true, + "license": "ISC" + }, + "node_modules/iterator.prototype": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/iterator.prototype/-/iterator.prototype-1.1.5.tgz", + "integrity": "sha512-H0dkQoCa3b2VEeKQBOxFph+JAbcrQdE7KC0UkqwpLmv2EC4P41QXP+rqo9wYodACiG5/WM5s9oDApTU8utwj9g==", + "dev": true, + "license": "MIT", + "dependencies": { + "define-data-property": "^1.1.4", + "es-object-atoms": "^1.0.0", + "get-intrinsic": "^1.2.6", + "get-proto": "^1.0.0", + "has-symbols": "^1.1.0", + "set-function-name": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "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/js-yaml": { + "version": "4.3.2", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.3.2.tgz", + "integrity": "sha512-SFNOvSJ+Dgf/9An904Yx+CgSlIPCkIpao4qo51lpee25TIRejdH3rhR4EZMGoNx3/TP3O+wzWuiTFl4sqbltzA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/puzrin" + }, + { + "type": "github", + "url": "https://github.com/sponsors/nodeca" + } + ], + "license": "MIT", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "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-buffer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz", + "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "dev": true, + "license": "MIT" + }, + "node_modules/json-stable-stringify-without-jsonify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", + "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==", + "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/jsx-ast-utils": { + "version": "3.3.5", + "resolved": "https://registry.npmjs.org/jsx-ast-utils/-/jsx-ast-utils-3.3.5.tgz", + "integrity": "sha512-ZZow9HBI5O6EPgSJLUb8n2NKgmVWTwCvHGwFuJlMjvLFqlGG6pjirPhtdsseaLZjSibD8eegzmYpUZwoIlj2cQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "array-includes": "^3.1.6", + "array.prototype.flat": "^1.3.1", + "object.assign": "^4.1.4", + "object.values": "^1.1.6" + }, + "engines": { + "node": ">=4.0" + } + }, + "node_modules/keyv": { + "version": "4.5.4", + "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", + "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==", + "dev": true, + "license": "MIT", + "dependencies": { + "json-buffer": "3.0.1" + } + }, + "node_modules/language-subtag-registry": { + "version": "0.3.23", + "resolved": "https://registry.npmjs.org/language-subtag-registry/-/language-subtag-registry-0.3.23.tgz", + "integrity": "sha512-0K65Lea881pHotoGEa5gDlMxt3pctLi2RplBb7Ezh4rRdLEOtgi7n4EwK9lamnUCkKBqaeKRVebTq6BAxSkpXQ==", + "dev": true, + "license": "CC0-1.0" + }, + "node_modules/language-tags": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/language-tags/-/language-tags-1.0.9.tgz", + "integrity": "sha512-MbjN408fEndfiQXbFQ1vnd+1NoLDsnQW41410oQBXiyXDMYH5z505juWa4KUE1LqxRC7DgOgZDbKLxHIwm27hA==", + "dev": true, + "license": "MIT", + "dependencies": { + "language-subtag-registry": "^0.3.20" + }, + "engines": { + "node": ">=0.10" + } + }, + "node_modules/levn": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", + "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "prelude-ls": "^1.2.1", + "type-check": "~0.4.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-locate": "^5.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/lodash.merge": { + "version": "4.6.2", + "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz", + "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/loose-envify": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz", + "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "js-tokens": "^3.0.0 || ^4.0.0" + }, + "bin": { + "loose-envify": "cli.js" + } + }, + "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/magic-string": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-1.3.1.tgz", + "integrity": "sha512-rm91zr2Ou+XueDTohjQQjdQEcYM6zVi8KVUCG8Ec3vHwUEKrhSdCNyfuIywkA6hcCAteIn0ZOtAHA6eGpiX+Pg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.6.0" + } + }, + "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/minimatch": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz", + "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "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, + "license": "MIT" + }, + "node_modules/nanoid": { + "version": "3.3.19", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.19.tgz", + "integrity": "sha512-Y2tUNy4ouw6tq5oDSKeQYGOyhkUBhNOcGV/02KC+6kd9eDGqdZd++mjMiIDilrBYvjEnCYvVtsuHCuP+okSfug==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/natural-compare": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", + "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==", + "dev": true, + "license": "MIT" + }, + "node_modules/node-exports-info": { + "version": "1.6.2", + "resolved": "https://registry.npmjs.org/node-exports-info/-/node-exports-info-1.6.2.tgz", + "integrity": "sha512-kXs9Go0cah0qHVV2v389IXQLdLCeE1xfFtjOAF+iobu0OIoG1pje8At2vMHyaPMiPMnG/LWP50twML21eMcAag==", + "dev": true, + "license": "MIT", + "dependencies": { + "array.prototype.flatmap": "^1.3.3", + "es-errors": "^1.3.0", + "object.entries": "^1.1.9", + "semver": "^6.3.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/node-releases": { + "version": "2.0.56", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.56.tgz", + "integrity": "sha512-x0InOIyzgdk+eyaWaRJFH5snEtiImgBgblZ2CyPrLmqqcuMQkEvcDPHbzqbD8eDsSeJbVOjn+crzyzHaM4D+/A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + } + }, + "node_modules/object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/object-inspect": { + "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" + } + }, + "node_modules/object-keys": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz", + "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/object.assign": { + "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.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": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/object.entries": { + "version": "1.1.9", + "resolved": "https://registry.npmjs.org/object.entries/-/object.entries-1.1.9.tgz", + "integrity": "sha512-8u/hfXFRBD1O0hPUjioLhoWFHRmt6tKA4/vZPyckBr18l1KE9uHrFaFaUi8MDRTpi4uak2goyPTSNJLXX2k2Hw==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "call-bound": "^1.0.4", + "define-properties": "^1.2.1", + "es-object-atoms": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/object.fromentries": { + "version": "2.0.8", + "resolved": "https://registry.npmjs.org/object.fromentries/-/object.fromentries-2.0.8.tgz", + "integrity": "sha512-k6E21FzySsSK5a21KRADBd/NGneRegFO5pLHfdQLpRDETUNJueLXs3WCzyQ3tFRDYgbq3KHGXfTbi2bs8WQ6rQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.2", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/object.values": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/object.values/-/object.values-1.2.1.tgz", + "integrity": "sha512-gXah6aZrcUxjWg2zR2MwouP2eHlCBzdV4pygudehaKXSGW4v2AsRQUK+lwwXhii6KFZcunEnmSUoYp5CXibxtA==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "call-bound": "^1.0.3", + "define-properties": "^1.2.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/obug": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/obug/-/obug-2.2.1.tgz", + "integrity": "sha512-XrsrhT5sybtKI6wakr2SPOlGZWWYbUXZ7a0jT8/QOeAPau+1X/bSegNe5YR75oJmEZQbKningirmGOEJCIk61Q==", + "dev": true, + "funding": [ + "https://github.com/sponsors/sxzz", + "https://opencollective.com/debug" + ], + "license": "MIT", + "engines": { + "node": ">=12.20.0" + } + }, + "node_modules/optionator": { + "version": "0.9.4", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz", + "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==", + "dev": true, + "license": "MIT", + "dependencies": { + "deep-is": "^0.1.3", + "fast-levenshtein": "^2.0.6", + "levn": "^0.4.1", + "prelude-ls": "^1.2.1", + "type-check": "^0.4.0", + "word-wrap": "^1.2.5" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/own-keys": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/own-keys/-/own-keys-1.0.2.tgz", + "integrity": "sha512-19YVAg7T+WTrxggPukVq7DjTv6+PJ867TmhCvBsYwmbFCsZd344rq2Ld1p0wo8f8Qrrhgp82c6FJRqdXWtSEhg==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.4", + "get-intrinsic": "^1.3.0", + "object-keys": "^1.1.1", + "safe-push-apply": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/parent-module": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", + "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", + "dev": true, + "license": "MIT", + "dependencies": { + "callsites": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "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/path-parse": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "dev": true, + "license": "MIT" + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "dev": true, + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.7.tgz", + "integrity": "sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/playwright": { + "version": "1.63.0", + "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.63.0.tgz", + "integrity": "sha512-+7ziBLidS4NaNCdt57SUDT+wYmmd5fmiQejUic/kb+YsYSCPyOOE9sebzMjNmQrsnNpDJqd4WHvV/8lfKfUDUg==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "playwright-core": "1.63.0" + }, + "bin": { + "playwright": "cli.js" + }, + "engines": { + "node": ">=20" + } + }, + "node_modules/playwright-core": { + "version": "1.63.0", + "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.63.0.tgz", + "integrity": "sha512-rYCsBF/M5HjUch52bbtVONEFjv6Xu8sm8h72dNlR5bzIE1fvC/bxgspzkjSfU+MweEMmPM8KJebG6nnyxo5mCg==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "playwright-core": "cli.js" + }, + "engines": { + "node": ">=20" + } + }, + "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.5.28", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.28.tgz", + "integrity": "sha512-RRuzqDtt5Y9h3quz5hWhK+TPnsmVs6WwSU6LkJMeY4HstUEDuYTG8UJSdawMRzmzAtV+KEoG8N3Qg2qLy5vM/A==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "nanoid": "^3.3.18", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/prelude-ls": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", + "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/prop-types": { + "version": "15.8.1", + "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz", + "integrity": "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==", + "dev": true, + "license": "MIT", + "dependencies": { + "loose-envify": "^1.4.0", + "object-assign": "^4.1.1", + "react-is": "^16.13.1" + } + }, + "node_modules/punycode": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz", + "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/react": { + "version": "19.3.0", + "resolved": "https://registry.npmjs.org/react/-/react-19.3.0.tgz", + "integrity": "sha512-E8LUcbtBWt20bbl2YoHfx4ZDBdxVTfOKtCZn9cDSJ4l6/nuoApcpIBcj47t2wZoVX8g2ZHuMHbiShgCR1T5Sog==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-dom": { + "version": "19.3.0", + "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.3.0.tgz", + "integrity": "sha512-JDk8dgif51OjFoDE70+OT9ICyYr+69HlmihNwp1+Nsfbna3t5sIiCa9ZJktDmQ4/1b/rn26hIAR2uYXDMr5r0Q==", + "license": "MIT", + "dependencies": { + "scheduler": "^0.28.0" + }, + "peerDependencies": { + "react": "^19.3.0" + } + }, + "node_modules/react-is": { + "version": "16.13.1", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz", + "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==", + "dev": true, + "license": "MIT" + }, + "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.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" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "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/resolve": { + "version": "2.0.0-next.7", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-2.0.0-next.7.tgz", + "integrity": "sha512-tqt+NBWwyaMgw3zDsnygx4CByWjQEJHOPMdslYhppaQSJUtL/D4JO9CcBBlhPoI8lz9oJIDXkwXfhF4aWqP8xQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "is-core-module": "^2.16.2", + "node-exports-info": "^1.6.0", + "object-keys": "^1.1.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" + } + }, + "node_modules/resolve-from": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", + "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/rollup": { + "version": "4.63.2", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.63.2.tgz", + "integrity": "sha512-l5eyksV4tPBj6lJyEa37YzIOCSOV7lkZzEHUdpjWZbtD7wTcFYmEYXSgm5bT4vV+dZLb9rBG1W9GROOG4NS4Ew==", + "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": { + "@napi-rs/lzma-linux-x64-gnu": "1.5.1", + "@rollup/rollup-android-arm-eabi": "4.63.2", + "@rollup/rollup-android-arm64": "4.63.2", + "@rollup/rollup-darwin-arm64": "4.63.2", + "@rollup/rollup-darwin-x64": "4.63.2", + "@rollup/rollup-freebsd-arm64": "4.63.2", + "@rollup/rollup-freebsd-x64": "4.63.2", + "@rollup/rollup-linux-arm-gnueabihf": "4.63.2", + "@rollup/rollup-linux-arm-musleabihf": "4.63.2", + "@rollup/rollup-linux-arm64-gnu": "4.63.2", + "@rollup/rollup-linux-arm64-musl": "4.63.2", + "@rollup/rollup-linux-loong64-gnu": "4.63.2", + "@rollup/rollup-linux-loong64-musl": "4.63.2", + "@rollup/rollup-linux-ppc64-gnu": "4.63.2", + "@rollup/rollup-linux-ppc64-musl": "4.63.2", + "@rollup/rollup-linux-riscv64-gnu": "4.63.2", + "@rollup/rollup-linux-riscv64-musl": "4.63.2", + "@rollup/rollup-linux-s390x-gnu": "4.63.2", + "@rollup/rollup-linux-x64-gnu": "4.63.2", + "@rollup/rollup-linux-x64-musl": "4.63.2", + "@rollup/rollup-openbsd-x64": "4.63.2", + "@rollup/rollup-openharmony-arm64": "4.63.2", + "@rollup/rollup-win32-arm64-msvc": "4.63.2", + "@rollup/rollup-win32-ia32-msvc": "4.63.2", + "@rollup/rollup-win32-x64-gnu": "4.63.2", + "@rollup/rollup-win32-x64-msvc": "4.63.2", + "fsevents": "~2.3.2" + } + }, + "node_modules/safe-array-concat": { + "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.9", + "call-bound": "^1.0.4", + "get-intrinsic": "^1.3.0", + "has-symbols": "^1.1.0", + "isarray": "^2.0.5" + }, + "engines": { + "node": ">=0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/safe-push-apply": { + "version": "1.0.0", + "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": { + "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" + } + }, + "node_modules/scheduler": { + "version": "0.28.0", + "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.28.0.tgz", + "integrity": "sha512-juorfCmIkIw8tT+p5BXSm6PJjQF/ycEYmKyzURCIt/RaZIhL+PulbQ9Yu2z1HdOJDdqDTlxA1+xKBmHXJsczAw==", + "license": "MIT" + }, + "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/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/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/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/side-channel": { + "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": { + "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/siginfo": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz", + "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==", + "dev": true, + "license": "ISC" + }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/stackback": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz", + "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==", + "dev": true, + "license": "MIT" + }, + "node_modules/std-env": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/std-env/-/std-env-4.2.0.tgz", + "integrity": "sha512-oCUKSupKTHX53EyjDtuZQ64pjLJ6yYCtpmEw0goYxtjG9KpbRe8KAsl2tBUGU9DyMcJ0RwJ8GqJAFzMXcXW1Rw==", + "dev": true, + "license": "MIT" + }, + "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.includes": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/string.prototype.includes/-/string.prototype.includes-2.0.1.tgz", + "integrity": "sha512-o7+c9bW6zpAdJHTtujeePODAhkuicdAryFsfVKwA+wGw89wJ4GTY484WTucM9hLtDEOpOvI+aHnzqnC5lHp4Rg==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.3" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/string.prototype.matchall": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/string.prototype.matchall/-/string.prototype.matchall-4.1.0.tgz", + "integrity": "sha512-tHNHTxInrYLCga9O9YGxWA3G9/nnzQw8UGAyqGx3Ar1pSTTzIuM4woFSq4SowkXCjJIwq5sIiQvEfRI9tCH1qQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.9", + "call-bound": "^1.0.4", + "define-properties": "^1.2.1", + "es-abstract": "^1.24.2", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.1.2", + "get-intrinsic": "^1.3.0", + "gopd": "^1.2.0", + "has-symbols": "^1.1.0", + "internal-slot": "^1.1.0", + "regexp.prototype.flags": "^1.5.4", + "set-function-name": "^2.0.2", + "side-channel": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/string.prototype.repeat": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/string.prototype.repeat/-/string.prototype.repeat-1.0.0.tgz", + "integrity": "sha512-0u/TldDbKD8bFCQ/4f5+mNRrXwZ8hg2w7ZR8wa16e8z9XpePWl3eGEcUD0OXpEH/VJH/2G3gjUtR3ZOiBe2S/w==", + "dev": true, + "license": "MIT", + "dependencies": { + "define-properties": "^1.1.3", + "es-abstract": "^1.17.5" + } + }, + "node_modules/string.prototype.trim": { + "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.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" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/string.prototype.trimend": { + "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.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.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.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/strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/supports-preserve-symlinks-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", + "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/tinybench": { + "version": "6.1.4", + "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-6.1.4.tgz", + "integrity": "sha512-9APumHG7r4yOk4X4WlkmE71aZcv1gvin1czO3OQ1U9iJcFA5Ja/ygyb0vPOVHTthFozUYs8CLoLUlM8grb2lTQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/tinyexec": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.3.0.tgz", + "integrity": "sha512-QKAl9m8gWWGHV8jZcPeym6j+XULi6tOf1mT83WYJ4Lk2ytW/uwAWkrP0uFsdoYMdueVJ0qs26wZ+23xeB4ibNQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + } + }, + "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/ts-api-utils": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.5.0.tgz", + "integrity": "sha512-OJ/ibxhPlqrMM0UiNHJ/0CKQkoKF243/AEmplt3qpRgkW8VG7IfOS41h7V8TjITqdByHzrjcS/2si+y4lIh8NA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18.12" + }, + "peerDependencies": { + "typescript": ">=4.8.4" + } + }, + "node_modules/type-check": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", + "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", + "dev": true, + "license": "MIT", + "dependencies": { + "prelude-ls": "^1.2.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "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-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.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.8", + "for-each": "^0.3.3", + "gopd": "^1.2.0", + "has-proto": "^1.2.0", + "is-typed-array": "^1.1.14" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/typed-array-byte-offset": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/typed-array-byte-offset/-/typed-array-byte-offset-1.0.5.tgz", + "integrity": "sha512-0FHJvLPqZ7KJzp17O13jfsAjsqazgrxBu2zEK95PmUz8lv2+GjRuxUInCr2Rk9Dms3ihN21zJ929ZO43yJ95QQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "available-typed-arrays": "^1.0.7", + "call-bind": "^1.0.9", + "for-each": "^0.3.5", + "gopd": "^1.2.0", + "is-typed-array": "^1.1.15", + "reflect.getprototypeof": "^1.0.10" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/typed-array-length": { + "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.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" + } + }, + "node_modules/typescript": { + "version": "5.9.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/typescript-eslint": { + "version": "8.70.1", + "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.70.1.tgz", + "integrity": "sha512-AcWG7KDjZ2THNXsgwttMaGmzVi0VFRlFYfqFHYQRbDpF3owuYbuiL8c7UUrd2k8s3PoSfIQrWfrGXfcElrWLYA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/eslint-plugin": "8.70.1", + "@typescript-eslint/parser": "8.70.1", + "@typescript-eslint/typescript-estree": "8.70.1", + "@typescript-eslint/utils": "8.70.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/unbox-primitive": { + "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-bound": "^1.0.3", + "has-bigints": "^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/update-browserslist-db": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.3.3.tgz", + "integrity": "sha512-pJ2sYawQS0R/WI928Gj5GlPhTGzbMelq0+4INtSYNDV9ErKJcX6xjGWkoG/VnB3dpUm00zALaqkrUD77pO5TDQ==", + "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/uri-js": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "punycode": "^2.1.0" + } + }, + "node_modules/vite": { + "version": "6.4.3", + "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.3.tgz", + "integrity": "sha512-NTKlcQjlAK7MlQoyb6LgaqHc8sso/pVyUJYWMws3jg21uTJw/LddqIFPcPqP6PzpgbIcZyKI85sFE4HBrQDA8A==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "^0.25.0", + "fdir": "^6.4.4", + "picomatch": "^4.0.2", + "postcss": "^8.5.3", + "rollup": "^4.34.9", + "tinyglobby": "^0.2.13" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^18.0.0 || ^20.0.0 || >=22.0.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", + "jiti": ">=1.21.0", + "less": "*", + "lightningcss": "^1.21.0", + "sass": "*", + "sass-embedded": "*", + "stylus": "*", + "sugarss": "*", + "terser": "^5.16.0", + "tsx": "^4.8.1", + "yaml": "^2.4.2" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "jiti": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + }, + "tsx": { + "optional": true + }, + "yaml": { + "optional": true + } + } + }, + "node_modules/vitest": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/vitest/-/vitest-5.0.0.tgz", + "integrity": "sha512-gpsMNoRhMjMktVxPtstOH4/PJuPyovVaMDr4oDilXaGH1EcqM2OE96SoHT2VIQ6fTGtTjqmHDrEu2X9RQiXf8Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/chai": "^5.2.2", + "@vitest/mocker": "5.0.0", + "chai": "^6.2.2", + "es-module-lexer": "^2.3.2", + "expect-type": "^1.4.0", + "magic-string": "^1.2.3", + "obug": "^2.1.4", + "picomatch": "^4.0.7", + "std-env": "^4.2.0", + "tinybench": "6.1.4", + "tinyexec": "1.3.0", + "tinyglobby": "^0.2.17", + "why-is-node-running": "^2.3.0" + }, + "bin": { + "vitest": "vitest.mjs" + }, + "engines": { + "node": "^22.12.0 || ^24.0.0 || >=26.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "@edge-runtime/vm": "*", + "@opentelemetry/api": "^1.9.0", + "@types/node": "^22.0.0 || >=24.0.0", + "@vitest/browser-playwright": "5.0.0", + "@vitest/browser-preview": "5.0.0", + "@vitest/browser-webdriverio": "^5.0.0-beta.5 || >=5.0.0", + "@vitest/coverage-istanbul": "5.0.0", + "@vitest/coverage-v8": "5.0.0", + "@vitest/ui": "5.0.0", + "happy-dom": "*", + "jsdom": "*", + "vite": "^6.4.0 || ^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "@edge-runtime/vm": { + "optional": true + }, + "@opentelemetry/api": { + "optional": true + }, + "@types/node": { + "optional": true + }, + "@vitest/browser-playwright": { + "optional": true + }, + "@vitest/browser-preview": { + "optional": true + }, + "@vitest/browser-webdriverio": { + "optional": true + }, + "@vitest/coverage-istanbul": { + "optional": true + }, + "@vitest/coverage-v8": { + "optional": true + }, + "@vitest/ui": { + "optional": true + }, + "happy-dom": { + "optional": true + }, + "jsdom": { + "optional": true + }, + "vite": { + "optional": false + } + } + }, + "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/which-boxed-primitive": { + "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.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" + }, + "funding": { + "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.24", + "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.24.tgz", + "integrity": "sha512-wk4Mf4pR5mRP7eYuuTBCIQ9d0ud2Fv2jRLQpfgnRjbOxAFHmjKFValgTpitVKzJJS8ajnYQV2Du1SZ8j6b/EUQ==", + "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/why-is-node-running": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz", + "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==", + "dev": true, + "license": "MIT", + "dependencies": { + "siginfo": "^2.0.0", + "stackback": "0.0.2" + }, + "bin": { + "why-is-node-running": "cli.js" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/word-wrap": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz", + "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "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/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/zod": { + "version": "4.6.5", + "resolved": "https://registry.npmjs.org/zod/-/zod-4.6.5.tgz", + "integrity": "sha512-v5l/aFXZQeai4awLbOpSoHecE9UiMrnfx75tEXLjNonXVARxQ5mOeipTjROUchszUNCqnE+hqAMujRsRHsut2Q==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/colinhacks" + } + }, + "node_modules/zod-validation-error": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/zod-validation-error/-/zod-validation-error-4.0.2.tgz", + "integrity": "sha512-Q6/nZLe6jxuU80qb/4uJ4t5v2VEZ44lzQjPDhYJNztRQ4wyWc6VF3D3Kb/fAuPetZQnhS3hnajCf9CsWesghLQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18.0.0" + }, + "peerDependencies": { + "zod": "^3.25.0 || ^4.0.0" + } + } + } +} diff --git a/frontend/package.json b/frontend/package.json new file mode 100644 index 0000000..1975070 --- /dev/null +++ b/frontend/package.json @@ -0,0 +1,31 @@ +{ + "name": "eventlens-web", + "version": "1.0.6", + "private": true, + "scripts": { + "dev": "vite", + "lint": "eslint src", + "build": "tsc --noEmit && vite build", + "test": "vitest run --passWithNoTests", + "test:e2e": "playwright test" + }, + "dependencies": { + "react": "^19.0.0", + "react-dom": "^19.0.0" + }, + "devDependencies": { + "@eslint/js": "^9.39.5", + "@playwright/test": "^1.63.0", + "@types/react": "^19.0.0", + "@types/react-dom": "^19.0.0", + "eslint": "^9.39.5", + "eslint-plugin-jsx-a11y": "^6.10.2", + "eslint-plugin-react": "^7.37.5", + "eslint-plugin-react-hooks": "^7.1.1", + "globals": "^17.12.0", + "typescript": "^5.8.0", + "typescript-eslint": "^8.70.1", + "vite": "^6.0.0", + "vitest": "^5.0.0" + } +} diff --git a/frontend/playwright.config.ts b/frontend/playwright.config.ts new file mode 100644 index 0000000..1d9dfaa --- /dev/null +++ b/frontend/playwright.config.ts @@ -0,0 +1,30 @@ +import { defineConfig } from "@playwright/test"; + +export default defineConfig({ + testDir: "./e2e", + fullyParallel: false, + forbidOnly: Boolean(process.env.CI), + retries: process.env.CI ? 1 : 0, + reporter: process.env.CI ? "line" : "list", + use: { + baseURL: "http://127.0.0.1:4173", + trace: "retain-on-failure", + screenshot: "only-on-failure", + }, + webServer: [ + { + command: "python -m uv run --directory backend --locked --extra dev python -m uvicorn app.main:app --host 127.0.0.1 --port 8000", + cwd: "..", + url: "http://127.0.0.1:8000/health", + reuseExistingServer: false, + timeout: 30_000, + }, + { + command: "npm run dev -- --host 127.0.0.1 --port 4173", + cwd: ".", + url: "http://127.0.0.1:4173", + reuseExistingServer: false, + timeout: 30_000, + }, + ], +}); diff --git a/frontend/public/apple-touch-icon.png b/frontend/public/apple-touch-icon.png new file mode 100644 index 0000000000000000000000000000000000000000..d50528235cb36f16056e8e50c0033287eaaabd6e GIT binary patch literal 14307 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 Rw5R|8002ovPDHLkV1l9opE>{l literal 0 HcmV?d00001 diff --git a/frontend/public/eventlens-icon-192.png b/frontend/public/eventlens-icon-192.png new file mode 100644 index 0000000000000000000000000000000000000000..dc589f2b596901c8f5b87fac862e8fdfda847d88 GIT binary patch literal 13829 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 + EventLens evidence lens + + + + + + + + diff --git a/frontend/public/site.webmanifest b/frontend/public/site.webmanifest new file mode 100644 index 0000000..fbc0ec7 --- /dev/null +++ b/frontend/public/site.webmanifest @@ -0,0 +1,23 @@ +{ + "name": "EventLens — Windows Incident Reconstruction", + "short_name": "EventLens", + "description": "Local-first Windows EVTX incident reconstruction with deterministic correlation and evidence timelines.", + "start_url": "/#analysis", + "display": "standalone", + "background_color": "#07131f", + "theme_color": "#07131f", + "icons": [ + { + "src": "/eventlens-icon-192.png", + "sizes": "192x192", + "type": "image/png", + "purpose": "any" + }, + { + "src": "/eventlens-icon-512.png", + "sizes": "512x512", + "type": "image/png", + "purpose": "any" + } + ] +} diff --git a/frontend/src/app/App.tsx b/frontend/src/app/App.tsx new file mode 100644 index 0000000..d72f081 --- /dev/null +++ b/frontend/src/app/App.tsx @@ -0,0 +1,252 @@ +import { type ChangeEvent, type DragEvent, useEffect, useMemo, useRef, useState } from "react"; +import { analysisToMarkdown, prepareExport } from "../export"; +import { filterEvents, uniqueProviders, type EventFilters } from "../filter"; +import type { Analysis, EventItem, Incident } from "../types"; +import { downloadText, exportStem } from "./format"; +import { DEFAULT_SETTINGS, EMPTY_FILTERS, EMPTY_HUNTING, ROW_HEIGHTS, SETTINGS_KEY, readSettings, type FilterState, type HuntingState, type InspectorTab, type UiSettings, type Workspace, workspaceFromHash } from "./model"; +import { isAnalysis } from "./validation"; +import { AppTopbar, GlobalActions, InvestigationContext, Statusbar } from "../components/shell"; +import { ErrorBanner, ParserIssueNotice, PartialAnalysisWarning } from "../components/states"; +import { AnalysisView } from "../workspaces/AnalysisView"; +import { HuntingView } from "../workspaces/HuntingView"; +import { ReportsView } from "../workspaces/ReportsView"; +import { SettingsView } from "../workspaces/SettingsView"; +import { TimelineView } from "../workspaces/TimelineView"; + +const API = (import.meta.env.VITE_API_BASE_URL ?? (import.meta.env.DEV ? "http://127.0.0.1:8000" : "")).replace(/\/$/, ""); +const APP_VERSION = import.meta.env.VITE_EVENTLENS_VERSION ?? "development"; + +function analysisErrorMessage(status: number, body: unknown): string { + const detail = typeof body === "object" && body !== null && "detail" in body ? body.detail : null; + const code = typeof detail === "object" && detail !== null && "code" in detail ? detail.code : null; + if (code === "no_readable_events") return "No readable Windows events were found in this file."; + if (code === "parser_rejected_input") return "The EVTX parser rejected the input. Check the file and retry."; + if (code === "parse_capacity_exceeded") return "EventLens is busy analyzing another upload; retry shortly."; + if (status === 400) return "Upload a Windows .evtx file."; + if (status === 413) return "EVTX file exceeds the 50 MiB limit."; + if (status >= 500) return "The local EventLens service is unavailable. Check the service and retry."; + return `Analysis failed (HTTP ${status}).`; +} + +export function App() { + const [settings, setSettings] = useState(readSettings); + const [activeWorkspace, setActiveWorkspace] = useState(() => workspaceFromHash() ?? readSettings().defaultWorkspace); + const [data, setData] = useState(null); + const [selectedEventId, setSelectedEventId] = useState(null); + const [activeIncidentId, setActiveIncidentId] = useState(""); + const [focusIncident, setFocusIncident] = useState(false); + const [filters, setFilters] = useState(() => EMPTY_FILTERS(readSettings().defaultNoise === "attention")); + const [hunting, setHunting] = useState(EMPTY_HUNTING); + const [redactExports, setRedactExports] = useState(() => readSettings().defaultRedaction); + const [dragging, setDragging] = useState(false); + const [error, setError] = useState(""); + const [loading, setLoading] = useState(false); + const [inspectorTab, setInspectorTab] = useState("details"); + const [settingsNotice, setSettingsNotice] = useState(""); + const [settingsPersistenceFailed, setSettingsPersistenceFailed] = useState(false); + const [settingsStorageConfirmed, setSettingsStorageConfirmed] = useState(false); + const fileInput = useRef(null); + const requestRef = useRef(null); + + useEffect(() => { + try { + window.localStorage.setItem(SETTINGS_KEY, JSON.stringify(settings)); + setSettingsPersistenceFailed(false); + setSettingsStorageConfirmed(true); + setSettingsNotice((notice) => { + if (notice === "Saving preferences…") return "Preferences saved"; + if (notice === "Resetting preferences…") return "Preferences reset to defaults"; + return notice; + }); + } catch { + setSettingsPersistenceFailed(true); + setSettingsStorageConfirmed(false); + setSettingsNotice("Preferences changed for this session only"); + } + }, [settings]); + useEffect(() => { + if (!settingsNotice) return; + const timeout = window.setTimeout(() => setSettingsNotice(""), 2_500); + return () => window.clearTimeout(timeout); + }, [settingsNotice]); + + useEffect(() => { + const onHashChange = () => setActiveWorkspace(workspaceFromHash() ?? settings.defaultWorkspace); + window.addEventListener("hashchange", onHashChange); + if (!workspaceFromHash()) window.history.replaceState(null, "", `#${activeWorkspace}`); + return () => window.removeEventListener("hashchange", onHashChange); + }, [activeWorkspace, settings.defaultWorkspace]); + + const navigate = (workspace: Workspace) => { + if (workspace === activeWorkspace && window.location.hash === `#${workspace}`) return; + window.location.hash = workspace; + setActiveWorkspace(workspace); + }; + + const activeIncident = useMemo(() => data?.incidents.find((incident) => incident.id === activeIncidentId) ?? null, [data, activeIncidentId]); + const selected = useMemo(() => data?.events.find((event) => event.id === selectedEventId) ?? null, [data, selectedEventId]); + const evidenceIds = useMemo(() => focusIncident && activeIncident ? new Set(activeIncident.evidence_event_ids) : null, [focusIncident, activeIncident]); + const providers = useMemo(() => uniqueProviders(data?.events ?? []), [data]); + const visibleEvents = useMemo(() => { + const eventFilters: EventFilters = { + search: filters.search, + category: filters.category, + level: filters.level, + provider: filters.provider, + noiseMode: filters.attentionOnly ? "attention" : "all", + evidenceIds, + windowMinutes: filters.windowMinutes, + anchorTimestamp: selected?.timestamp ?? activeIncident?.start ?? null, + }; + return filterEvents(data?.events ?? [], eventFilters); + }, [data, filters, evidenceIds, selected, activeIncident]); + const incidentEventIds = useMemo(() => new Set(data?.incidents.flatMap((incident) => incident.evidence_event_ids) ?? []), [data]); + const huntingResults = useMemo(() => { + const filtered = filterEvents(data?.events ?? [], { search: hunting.search, category: hunting.category, level: hunting.level, provider: hunting.provider, noiseMode: "all", windowMinutes: hunting.windowMinutes, anchorTimestamp: selected?.timestamp ?? activeIncident?.start ?? null }); + return filtered.filter((event) => (!hunting.eventId || String(event.event_id ?? "") === hunting.eventId) && (!hunting.computer || (event.computer ?? "").toLowerCase().includes(hunting.computer.toLowerCase())) && (!hunting.incidentOnly || incidentEventIds.has(event.id))); + }, [data, hunting, selected, activeIncident, incidentEventIds]); + const redactionPreview = useMemo(() => data && redactExports ? prepareExport(data, true).redaction : null, [data, redactExports]); + const rowHeight = ROW_HEIGHTS[settings.density]; + const contextVisible = activeWorkspace === "timeline" ? visibleEvents.length : activeWorkspace === "hunting" ? huntingResults.length : undefined; + + function updateSettings(patch: Partial) { + setSettingsStorageConfirmed(false); + setSettings((current) => ({ ...current, ...patch })); + setSettingsNotice("Saving preferences…"); + if (patch.defaultNoise) setFilters((current) => ({ ...current, attentionOnly: patch.defaultNoise === "attention" })); + if (typeof patch.defaultRedaction === "boolean") setRedactExports(patch.defaultRedaction); + } + + function resetSettings() { + setSettingsStorageConfirmed(false); + setSettings({ ...DEFAULT_SETTINGS }); + setFilters(EMPTY_FILTERS(true)); + setRedactExports(true); + setSettingsNotice("Resetting preferences…"); + } + + function resetFilters() { + setFilters(EMPTY_FILTERS(settings.defaultNoise === "attention")); + setFocusIncident(false); + } + + function resetHunting() { setHunting(EMPTY_HUNTING()); } + + function resetView(next: Analysis) { + setData(next); + setSelectedEventId(next.events[0]?.id ?? null); + setActiveIncidentId(next.incidents[0]?.id ?? ""); + setFocusIncident(false); + setFilters(EMPTY_FILTERS(settings.defaultNoise === "attention")); + resetHunting(); + setInspectorTab("details"); + } + + async function loadDemo() { + requestRef.current?.abort(); + const controller = new AbortController(); + requestRef.current = controller; + setLoading(true); setError(""); + try { + const response = await fetch(`${API}/api/demo`, { cache: "no-store", signal: controller.signal }); + const body: unknown = await response.json().catch(() => null); + if (!response.ok) throw new Error("Demo request failed"); + if (!isAnalysis(body)) throw new Error("Demo returned an invalid response"); + if (requestRef.current !== controller || controller.signal.aborted) return; + resetView(body); + } catch (reason) { + if (requestRef.current === controller && !controller.signal.aborted) setError(reason instanceof Error && reason.message === "Demo returned an invalid response" ? reason.message : "The local EventLens service is unavailable. Check the service and retry."); + } finally { if (requestRef.current === controller) { requestRef.current = null; setLoading(false); } } + } + + async function analyzeFile(file: File) { + requestRef.current?.abort(); + requestRef.current = null; + if (!file.name.toLowerCase().endsWith(".evtx")) { setLoading(false); setError("Choose a Windows .evtx file."); return; } + const controller = new AbortController(); + requestRef.current = controller; + setLoading(true); setError(""); + const form = new FormData(); form.append("file", file); + try { + const response = await fetch(`${API}/api/analyze`, { method: "POST", body: form, cache: "no-store", signal: controller.signal }); + const body: unknown = await response.json().catch(() => null); + if (requestRef.current !== controller || controller.signal.aborted) return; + if (!response.ok) { setError(analysisErrorMessage(response.status, body)); return; } + if (!isAnalysis(body)) throw new Error("Analysis returned an invalid response."); + resetView(body); + } catch (reason) { + if (requestRef.current === controller && !controller.signal.aborted) setError(reason instanceof Error && reason.message === "Analysis returned an invalid response." ? reason.message : "The local EventLens service is unavailable. Check the service and retry."); + } finally { if (requestRef.current === controller) { requestRef.current = null; setLoading(false); } } + } + + async function upload(event: ChangeEvent) { + const file = event.target.files?.[0]; + if (file) await analyzeFile(file); + event.target.value = ""; + } + + async function drop(event: DragEvent) { + event.preventDefault(); setDragging(false); + const file = event.dataTransfer.files?.[0]; + if (file) await analyzeFile(file); + } + + function selectIncident(id: string, openTimeline = false) { + const incident = data?.incidents.find((item) => item.id === id); + if (!incident) { setActiveIncidentId(""); return; } + setActiveIncidentId(id); + setSelectedEventId(incident.evidence_event_ids[0] ?? null); + setInspectorTab("details"); + if (openTimeline) { setFocusIncident(true); navigate("timeline"); } + } + + function selectEvent(event: EventItem) { + setSelectedEventId(event.id); + const incident = data?.incidents.find((item) => item.evidence_event_ids.includes(event.id)); + if (incident) setActiveIncidentId(incident.id); + } + + function moveSelection(delta: number, events: EventItem[]) { + if (!events.length) return; + const index = selected ? events.findIndex((event) => event.id === selected.id) : -1; + const next = index < 0 ? (delta > 0 ? 0 : events.length - 1) : Math.min(events.length - 1, Math.max(0, index + delta)); + selectEvent(events[next]); + } + + function exportJson() { + if (!data) return; + const prepared = prepareExport(data, redactExports); + downloadText(`${exportStem(data.source)}-eventlens.json`, JSON.stringify(prepared.analysis, null, 2), "application/json"); + } + + function exportMarkdown() { + if (!data) return; + downloadText(`${exportStem(data.source)}-eventlens.md`, analysisToMarkdown(data, redactExports), "text/markdown"); + } + + useEffect(() => { + const scopedEvents = activeWorkspace === "hunting" ? huntingResults : visibleEvents; + if (!selectedEventId || !scopedEvents.some((event) => event.id === selectedEventId)) setSelectedEventId(scopedEvents[0]?.id ?? null); + }, [activeWorkspace, huntingResults, visibleEvents, selectedEventId]); + + return
{ event.preventDefault(); setDragging(true); }} onDragLeave={() => setDragging(false)} onDrop={drop}> + +
+ + fileInput.current?.click()} onDemo={() => void loadDemo()} workspace={activeWorkspace} /> + + {loading ?
: null} + {error ? void loadDemo()} /> : null} + {data?.parse?.status === "partial" ? : null} + {data?.parse && data.parse.status !== "partial" && data.parse.issues.length ? : null} +
+ {activeWorkspace === "analysis" ? selectIncident(incident.id, true)} onOpenFile={() => fileInput.current?.click()} onDemo={() => void loadDemo()} /> : null} + {activeWorkspace === "timeline" ? setFilters((current) => ({ ...current, ...patch }))} onResetFilters={resetFilters} onFocusChange={setFocusIncident} onSelectIncident={selectIncident} onSelectEvent={selectEvent} onMove={(delta) => moveSelection(delta, visibleEvents)} onTab={setInspectorTab} onOpenFile={() => fileInput.current?.click()} onDemo={() => void loadDemo()} /> : null} + {activeWorkspace === "hunting" ? setHunting((current) => ({ ...current, ...patch }))} onReset={resetHunting} onSelectEvent={selectEvent} onMove={(delta) => moveSelection(delta, huntingResults)} onTab={setInspectorTab} onOpenTimeline={() => navigate("timeline")} onOpenFile={() => fileInput.current?.click()} onDemo={() => void loadDemo()} /> : null} + {activeWorkspace === "reports" ? fileInput.current?.click()} onDemo={() => void loadDemo()} /> : null} + {activeWorkspace === "settings" ? : null} +
+ +
+
; +} diff --git a/frontend/src/app/format.ts b/frontend/src/app/format.ts new file mode 100644 index 0000000..5b4546b --- /dev/null +++ b/frontend/src/app/format.ts @@ -0,0 +1,68 @@ +import type { Analysis } from "../types"; +import type { TimestampDisplay } from "./model"; + +export function sourceLabel(source: string): string { + return source.split(/[\\/]/).pop() || source; +} + +export function safeDate(timestamp: string | null): Date | null { + if (!timestamp) return null; + const date = new Date(timestamp); + return Number.isNaN(date.getTime()) ? null : date; +} + +export function formatClock(timestamp: string | null, display: TimestampDisplay): string { + const date = safeDate(timestamp); + if (!date) return "Unknown time"; + return display === "utc" + ? `${date.toISOString().slice(11, 16)} UTC` + : date.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" }); +} + +export function formatDate(timestamp: string | null, display: TimestampDisplay): string { + const date = safeDate(timestamp); + if (!date) return "Unknown date"; + return display === "utc" + ? date.toISOString().slice(0, 10) + : date.toLocaleDateString([], { year: "numeric", month: "2-digit", day: "2-digit" }); +} + +export function formatDateTime(timestamp: string | null, display: TimestampDisplay): string { + const date = safeDate(timestamp); + if (!date) return "Unknown — timestamp is not reliable"; + return display === "utc" + ? `${date.toISOString().replace("T", " ").replace("Z", "")} (UTC)` + : date.toLocaleString([], { dateStyle: "medium", timeStyle: "medium" }); +} + +export function formatRange(start: string | null, end: string | null, display: TimestampDisplay): string { + if (!start) return "Unknown time"; + return `${formatDate(start, display)} · ${formatClock(start, display)} – ${end ? formatClock(end, display) : "unknown"}`; +} + +export function levelLabel(level: string): string { + return level === "error" || level === "critical" ? "High" : level === "warning" ? "Medium" : level === "information" ? "Info" : level; +} + +export function statusLabel(data: Analysis | null): string { + if (!data) return "No analysis loaded"; + if (!data.parse) return "Complete"; + return data.parse.status === "complete" ? "Complete" : data.parse.status === "partial" ? "Partial" : "Failed"; +} + +export function downloadText(filename: string, content: string, type: string): void { + const blob = new Blob([content], { type }); + const href = URL.createObjectURL(blob); + const anchor = document.createElement("a"); + anchor.href = href; + anchor.download = filename; + document.body.appendChild(anchor); + anchor.click(); + anchor.remove(); + window.setTimeout(() => URL.revokeObjectURL(href), 0); +} + +export function exportStem(source: string): string { + const base = sourceLabel(source).replace(/\.evtx$/i, ""); + return base.replace(/[^A-Za-z0-9._-]+/g, "_").slice(0, 80) || "eventlens"; +} diff --git a/frontend/src/app/model.ts b/frontend/src/app/model.ts new file mode 100644 index 0000000..dd6539e --- /dev/null +++ b/frontend/src/app/model.ts @@ -0,0 +1,84 @@ +export const CATEGORIES = ["system", "service", "network", "authentication", "application", "crash", "other"]; +export const LEVELS = ["critical", "error", "warning", "information", "verbose"]; +export const WINDOWS = [0, 1, 5, 15, 60]; +export const WORKSPACES = ["analysis", "timeline", "hunting", "reports", "settings"] as const; +export const ROW_HEIGHTS = { comfortable: 58, compact: 48 } as const; +export const OVERSCAN = 8; +export const SETTINGS_KEY = "eventlens.preferences.v1"; + +export type Workspace = (typeof WORKSPACES)[number]; +export type TimestampDisplay = "utc" | "local"; +export type Density = "comfortable" | "compact"; + +export type UiSettings = { + timestampDisplay: TimestampDisplay; + defaultNoise: "attention" | "all"; + defaultRedaction: boolean; + density: Density; + defaultWorkspace: Workspace; +}; + +export type FilterState = { + search: string; + category: string; + level: string; + provider: string; + windowMinutes: number; + attentionOnly: boolean; +}; + +export type HuntingState = FilterState & { + eventId: string; + computer: string; + incidentOnly: boolean; +}; + +export type InspectorTab = "details" | "raw" | "related" | "insights"; + +export const DEFAULT_SETTINGS: UiSettings = { + timestampDisplay: "utc", + defaultNoise: "attention", + defaultRedaction: true, + density: "comfortable", + defaultWorkspace: "analysis", +}; + +export const EMPTY_FILTERS = (attentionOnly: boolean): FilterState => ({ + search: "", + category: "", + level: "", + provider: "", + windowMinutes: 0, + attentionOnly, +}); + +export const EMPTY_HUNTING = (): HuntingState => ({ + ...EMPTY_FILTERS(false), + eventId: "", + computer: "", + incidentOnly: false, +}); + +export function readSettings(): UiSettings { + if (typeof window === "undefined") return { ...DEFAULT_SETTINGS }; + try { + const parsed = JSON.parse(window.localStorage.getItem(SETTINGS_KEY) ?? "null") as Partial | null; + if (!parsed || typeof parsed !== "object") return { ...DEFAULT_SETTINGS }; + return { + timestampDisplay: parsed.timestampDisplay === "local" ? "local" : "utc", + defaultNoise: parsed.defaultNoise === "all" ? "all" : "attention", + defaultRedaction: typeof parsed.defaultRedaction === "boolean" ? parsed.defaultRedaction : true, + density: parsed.density === "compact" ? "compact" : "comfortable", + defaultWorkspace: WORKSPACES.includes(parsed.defaultWorkspace as Workspace) + ? parsed.defaultWorkspace as Workspace + : "analysis", + }; + } catch { + return { ...DEFAULT_SETTINGS }; + } +} + +export function workspaceFromHash(hash = typeof window === "undefined" ? "" : window.location.hash): Workspace | null { + const value = hash.replace(/^#/, ""); + return WORKSPACES.includes(value as Workspace) ? value as Workspace : null; +} diff --git a/frontend/src/app/validation.test.ts b/frontend/src/app/validation.test.ts new file mode 100644 index 0000000..fc0d1a7 --- /dev/null +++ b/frontend/src/app/validation.test.ts @@ -0,0 +1,77 @@ +import { describe, expect, it } from "vitest"; +import { isAnalysis } from "./validation"; + +const valid = { + source: "demo.evtx", + events: [{ + id: "event-1", + timestamp: "2026-09-22T08:00:00Z", + timestamp_source: "event", + timestamp_valid: true, + provider: "Provider", + event_id: 1000, + level: "Error", + category: "crash", + summary: "Example event", + fields: { process: "example.exe" }, + }], + incidents: [{ + id: "incident-1", + rule_id: "crash.sequence", + start: "2026-09-22T08:00:00Z", + end: "2026-09-22T08:00:00Z", + title: "Example incident", + category: "crash", + severity: "high", + reasons: ["Observed crash evidence."], + evidence_event_ids: ["event-1"], + original_count: 1, + compressed_count: 1, + }], + parse: { + parser: "evtx", + status: "complete", + parsed_events: 1, + records_seen: 1, + skipped_records: 0, + issue_count: 0, + truncated: false, + truncation_reason: null, + duration_ms: 5, + issues: [], + }, +}; + +describe("isAnalysis", () => { + it("accepts the normalized analysis contract", () => { + expect(isAnalysis(valid)).toBe(true); + }); + + it("rejects a successful-looking object without event arrays", () => { + expect(isAnalysis({ source: "demo.evtx", incidents: [] })).toBe(false); + }); + + it("rejects malformed nested evidence instead of trusting a 2xx payload", () => { + expect(isAnalysis({ ...valid, events: [{ ...valid.events[0], fields: { process: 42 } }] })).toBe(false); + expect(isAnalysis({ ...valid, parse: { ...valid.parse, status: "unknown" } })).toBe(false); + }); + + it("rejects missing evidence references and duplicate event IDs", () => { + expect(isAnalysis({ ...valid, incidents: [{ ...valid.incidents[0], evidence_event_ids: ["missing"] }] })).toBe(false); + expect(isAnalysis({ ...valid, events: [...valid.events, valid.events[0]], parse: { ...valid.parse, parsed_events: 2 } })).toBe(false); + }); + + it("rejects invalid timestamps and contradictory timestamp metadata", () => { + expect(isAnalysis({ ...valid, events: [{ ...valid.events[0], timestamp: "not-a-date" }] })).toBe(false); + expect(isAnalysis({ ...valid, events: [{ ...valid.events[0], timestamp: null, timestamp_valid: true }] })).toBe(false); + expect(isAnalysis({ ...valid, events: [{ ...valid.events[0], timestamp_source: "invalid", timestamp_valid: true }] })).toBe(false); + expect(isAnalysis({ ...valid, incidents: [{ ...valid.incidents[0], start: "not-a-date" }] })).toBe(false); + }); + + it("rejects failed or inconsistent successful parse responses", () => { + expect(isAnalysis({ ...valid, parse: { ...valid.parse, status: "failed" } })).toBe(false); + expect(isAnalysis({ ...valid, parse: { ...valid.parse, parsed_events: 2 } })).toBe(false); + expect(isAnalysis({ ...valid, parse: { ...valid.parse, issue_count: 1 } })).toBe(false); + expect(isAnalysis({ ...valid, incidents: [{ ...valid.incidents[0], original_count: 1.5 }] })).toBe(false); + }); +}); diff --git a/frontend/src/app/validation.ts b/frontend/src/app/validation.ts new file mode 100644 index 0000000..4d28cbe --- /dev/null +++ b/frontend/src/app/validation.ts @@ -0,0 +1,82 @@ +import type { Analysis, EventItem, Incident, ParseIssue, ParseStats } from "../types"; + +function isRecord(value: unknown): value is Record { + return typeof value === "object" && value !== null && !Array.isArray(value); +} + +function isTimestamp(value: unknown): value is string | null { + return value === null || (typeof value === "string" && /(?:Z|[+-]\d{2}:\d{2})$/.test(value) && Number.isFinite(Date.parse(value))); +} + +function isFiniteNumber(value: unknown): value is number { + return typeof value === "number" && Number.isFinite(value); +} + +function isNonnegativeInteger(value: unknown): value is number { + return isFiniteNumber(value) && Number.isInteger(value) && value >= 0; +} + +function isStringArray(value: unknown): value is string[] { + return Array.isArray(value) && value.every((item) => typeof item === "string"); +} + +function isEventItem(value: unknown): value is EventItem { + if (!isRecord(value)) return false; + if (typeof value.id !== "string" || !isTimestamp(value.timestamp)) return false; + if (typeof value.provider !== "string" || !(value.event_id === null || (isNonnegativeInteger(value.event_id) && value.event_id <= 4_294_967_295))) return false; + if (typeof value.level !== "string" || typeof value.category !== "string" || typeof value.summary !== "string") return false; + if (value.channel !== undefined && typeof value.channel !== "string") return false; + if (value.computer !== undefined && typeof value.computer !== "string") return false; + if (value.fields !== undefined) { + if (!isRecord(value.fields) || !Object.values(value.fields).every((item) => typeof item === "string")) return false; + } + if (typeof value.timestamp_valid !== "boolean" || !["event", "record", "missing", "invalid"].includes(String(value.timestamp_source))) return false; + if (value.timestamp === null && value.timestamp_valid) return false; + if (["event", "record"].includes(String(value.timestamp_source)) !== value.timestamp_valid) return false; + return true; +} + +function isIncident(value: unknown): value is Incident { + if (!isRecord(value)) return false; + return typeof value.id === "string" + && typeof value.rule_id === "string" + && isTimestamp(value.start) + && isTimestamp(value.end) + && typeof value.title === "string" + && typeof value.category === "string" + && typeof value.severity === "string" + && isStringArray(value.reasons) + && isStringArray(value.evidence_event_ids) + && isNonnegativeInteger(value.original_count) + && value.original_count > 0 + && isNonnegativeInteger(value.compressed_count) + && value.compressed_count > 0; +} + +function isParseIssue(value: unknown): value is ParseIssue { + if (!isRecord(value) || typeof value.code !== "string" || typeof value.message !== "string") return false; + if (value.record_id !== undefined && value.record_id !== null && !isNonnegativeInteger(value.record_id)) return false; + if (value.skipped_record !== undefined && typeof value.skipped_record !== "boolean") return false; + return true; +} + +function isParseStats(value: unknown): value is ParseStats { + if (!isRecord(value)) return false; + if (typeof value.parser !== "string" || !["complete", "partial"].includes(String(value.status))) return false; + for (const key of ["parsed_events", "records_seen", "skipped_records", "issue_count", "duration_ms"] as const) { + if (!isNonnegativeInteger(value[key])) return false; + } + if (typeof value.truncated !== "boolean") return false; + if (value.truncation_reason !== undefined && value.truncation_reason !== null && typeof value.truncation_reason !== "string") return false; + return Array.isArray(value.issues) && value.issues.every(isParseIssue) && value.issue_count === value.issues.length; +} + +export function isAnalysis(value: unknown): value is Analysis { + if (!isRecord(value) || typeof value.source !== "string") return false; + if (!Array.isArray(value.events) || !value.events.every(isEventItem)) return false; + if (!Array.isArray(value.incidents) || !value.incidents.every(isIncident)) return false; + const eventIds = new Set(value.events.map((event: EventItem) => event.id)); + if (eventIds.size !== value.events.length) return false; + if (!value.incidents.every((incident: Incident) => incident.evidence_event_ids.every((id) => eventIds.has(id)))) return false; + return value.parse === undefined || value.parse === null || (isParseStats(value.parse) && value.parse.parsed_events === value.events.length); +} diff --git a/frontend/src/components/icons.tsx b/frontend/src/components/icons.tsx new file mode 100644 index 0000000..04f97de --- /dev/null +++ b/frontend/src/components/icons.tsx @@ -0,0 +1,61 @@ +import type { SVGProps } from "react"; + +export type IconName = + | "analysis" + | "timeline" + | "hunting" + | "reports" + | "settings" + | "file" + | "upload" + | "demo" + | "search" + | "clock" + | "warning" + | "arrow-left" + | "arrow-right" + | "reset" + | "info" + | "export" + | "check" + | "privacy"; + +type IconProps = SVGProps & { name: IconName; title?: string }; + +const ICON_PROPS = { fill: "none", stroke: "currentColor", strokeWidth: 1.8, strokeLinecap: "round" as const, strokeLinejoin: "round" as const }; + +export function Icon({ name, title, ...props }: IconProps) { + const content = { + analysis: <>, + timeline: <>, + hunting: <>, + reports: <>, + settings: <>, + file: <>, + upload: <>, + demo: <>, + search: <>, + clock: <>, + warning: <>, + "arrow-left": , + "arrow-right": , + reset: <>, + info: <>, + export: <>, + check: , + privacy: <>, + }[name]; + return {title ? {title} : null}{content}; +} + +/** The canonical evidence-lens mark, shared by the browser package and topbar. */ +export function EventLensMark(props: SVGProps) { + return ; +} diff --git a/frontend/src/components/shell.tsx b/frontend/src/components/shell.tsx new file mode 100644 index 0000000..97c7cc1 --- /dev/null +++ b/frontend/src/components/shell.tsx @@ -0,0 +1,36 @@ +import { useEffect, useRef } from "react"; +import type { Analysis, Incident } from "../types"; +import { sourceLabel, statusLabel } from "../app/format"; +import { WORKSPACES, type Workspace } from "../app/model"; +import { EventLensMark, Icon } from "./icons"; + +const WORKSPACE_LABELS: Record = { analysis: "Analysis", timeline: "Timeline", hunting: "Hunting", reports: "Reports", settings: "Settings" }; + +export function WorkspaceNav({ activeWorkspace, onNavigate }: { activeWorkspace: Workspace; onNavigate: (workspace: Workspace) => void }) { + const activeButton = useRef(null); + useEffect(() => { + activeButton.current?.scrollIntoView({ block: "nearest", inline: "center" }); + }, [activeWorkspace]); + return ; +} + +export function AppTopbar({ activeWorkspace, onNavigate, version }: { activeWorkspace: Workspace; onNavigate: (workspace: Workspace) => void; version: string }) { + return
EventLensWindows incident reconstruction
; +} + +export function InvestigationContext({ data, activeIncident, visibleCount, workspace }: { data: Analysis | null; activeIncident: Incident | null; visibleCount?: number; workspace: Workspace }) { + if (workspace === "settings") return
Local preferencesInterface preferences for this session
Event text, files and evidence are never stored here
; + if (!data) return null; + return
{sourceLabel(data.source)}Current forensic session
{statusLabel(data)}{data.events.length.toLocaleString()} events{data.incidents.length} incident{data.incidents.length === 1 ? "" : "s"}{typeof visibleCount === "number" ? {visibleCount.toLocaleString()} visible : null}
{activeIncident ? Incident: {activeIncident.title} : null}
; +} + +export function GlobalActions({ loading, dragging, onOpen, onDemo, workspace }: { loading: boolean; dragging: boolean; onOpen: () => void; onDemo: () => void; workspace: Workspace }) { + const secondary = workspace === "reports" || workspace === "settings"; + return
Drop an .evtx file anywhere in the workspace
Local, in-memory analysis
; +} + +export function Statusbar({ data }: { data: Analysis | null }) { + return
{data ? sourceLabel(data.source) : "No source loaded"} {data ? `${data.events.length.toLocaleString()} events` : "Local only"}

KAmF8% zPs)1~tMbD{2eSJJ9qq1CS1f~N{LARRqmfqH=Rgey)Z&AzFL6DzKKd?5P$~q;dUVHT&44VFAynXeuFTwu>fp^441{U=4gCN z$MVhNExXqh&t-p{{9E5j&mB?E@h6J#t|>Z-(|0J(_jaWaf}pTvIb4uMJt%A=OM7kC zjHZSo;wTg+)|C8|$o~RPMo#h;>4Y<^uw=p8x{H|+V9pQX-Ul$Db}|kHX;|y4wN|)j zDpS+KE0a$G0(!UZBw3+0FVq!cEg!Rb2D9hOk0b8xymL?2#(5mEEg#9}n-A|YBug4aDE3+o@PEUa5Yo@tm_)(jWYe!ZKzh489z7w&-^J-?Yl1;Ci zeDUxEHPanTiClC{l#ZJNc;w<6=CpG6LWa6jZw4M<_qzX9Q@@JfZkCu%iyJysMxO#l zCId|B-}=n}jJDjjDWstx3E00bzu>@@8bB~>vE^i;q-04wXip#=C`30*_~X%Jso0KI z5;`6Jcp94Hc~}D6?D;lX!x7G$g5Bs*w$5|Md)&@H`oOLTyq;=(^xCTdB~7mS+BZ({ zd=HEfyhrRi2J@#=$%$COG&1p;G)+#~lrQwA39`def5gc)HU<|!!9u6-&vMAxuuCe+ zA)*ulm0^`0ys9*+hnUIY18tc84w9($1Qx_Af+a)!QLiY% z5ZQx!j3MYw*pQOTkkT8`j@Bh|rubmpt#rxBk|P)6l`$E!JhWuRRP#iZ(g*JfEoQ_k z#B)p`k@}g`^RRn=IdqXtEetA@5!wwwaGzpoH-4zx?A#wvkq-+k{ddLeQFND;Vo;0O z@-L1NE`WR3ZQ#*&zf@rz#2wzaoj6p1epgCrV>ICaTFlsG;}4gbOU$67*#!xSN5xmg zztM#!Bz@TvYa9h%4&9Mr+OUv5$hb40+wIc}LQQp`!D_t*g&#}e*;oG7DTh(sT;P$i zp5dCI2Z7CvumdvL|3WJI*(Y^-2DbPj1z&Thz_9*4MhCumb7`PR5OVb!WU>7{?Jk~v zQT|hCFnb_9LE$okPnSACWb8=Lb$is*05iIE@kvXe9zOh{z}g8VfqnN!&D$vj+EME- z$Mb!X{xYMXcu@z(uI z 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ʱ&!KQ@f6zj<>-5W}g~ zwzh@EIgfv)_MCy(&5>WrCY2Va$oup3q{!VCh-ow0n!A|C#BI3jDy!viB;6V8Cysu1 zRhlk)%EJG9?{wm^l*svYw^O=S8}IFPiH%vMJbV(3*t0A`Sq;==%gKKCPGGG z9I#j3HMF0+^7U?XSdm5tTs-t{=4e0QZXdP$%520RlLJdu6ak2kgR+wA~T<9eo^ox)?2w_JBy zWcx%k76eK_Y<5;qi#}oG5w+i{;z$QpwKYT%M@xdruUOk_T^Q9HZtYGel$VQ?mRE$dCY9rH}~>t%Cq@=en4KNXIW`u+ruXaP>46t=G(h6gzflSV@~`R}Smc%I z5o>-$?anHPE-UBtjt1w^8JVuBwl6xW*7fw4U18eEj|^Cu$Z>2tI1L6Lvsl$^v} zZZ~Ur&8*ZS>UVKLgtGt}=Yz8k0QAdkM_n7yYOv3n0uewgl(HkA|~ zb2-cd&hMv48b1@Y+v(9xm~_CYM$D%u*|!9R65@J#PW_I%jO*Qu$d9&?%jqe(xd4;h zdZy>4ibW6`ZLx=B)FAYQzEEN2r1R-pC#HH&CW@DA{qEpGw;pu_QF<-+a=i&yXUZty zVSV=EQyAfY3#QZfW}r8dbw&QUIx1273-278V%go7Rz}R$56x=oEj`pv5`WGUuMu!T zUy@dH)$o#1Y|RM*M*eae6&mu6I+<3U^-(Z;=+=>ogO@LP;HMAoO8(Cv;_ zdOVGvK`mN)J3Z6`VzP%(Y-YrcKn!%e&e_kCqw9FV&fTy1!iU>aYXiAbWLZ<}aX^^f z&+9n#d;U0y6pOJ;Q8-&eF4Ge`H@}g?fg+9UQ0zCKyiePq{$2Ek^75^U6Bmgx<3f5* zz8wNOio|5}l=iYo4$d(P@MHS6WB%da%~z?a#1qZLBD9HdqJjsphmkNXmNJQK8Z{fW`Wt z#`gYU*>$2#=6V~S2yDYtMz^^XShvpM&{aQG9yxi z_h)RW+~Q_37~Uz~&Rp7X?CwQ9+MhK*N~-ofqk*6F$7-m~oo&z*x^j`T(WzRM9Y(hm zhFE#ER^-)^-BRKUiK3%-vKHvvoyjO;foR2jfxuSdtUQI=@hYPD>%v=2#k|i?wx{$Q zS0T+O(IG2=fc$A&+EPySv#p;Z4`a%H_ca2l2Qal!{TQRgCjF&G&qfcD@aoNj^X6z_ z&?_gl97V<7Wy6|L`e#BsysTqTM_e|%pUHAt^*TC?6-CS(TGkM}mTu*xxkawrTuKAs zcjfEUf@-R)Uas2PfVtYpuIi_AKJ*X8TD~&Ne75K}B2CRi4;trxNbIzJ(byPaXb+-z z&i_dS-2ZjcGWRUi#2EhgARS5LsIsINoY>@e!dBc|I-3=i)+p9>$SJf4`yLWjNCFR2>HDF3qVwHZK)8= zw&QAOPQ|6GF9&9UcGC&x(uVv9NT<}iDZS<%kGebh?&0DF^NV8cQ#U8?5D(9#r4Amj z7?e&$(Vk%^^DhlN%ne%JcqT7R`PvBpoK$`W#!x9(xFjn?O~3 zRN!NaDht1snhm=yAjndNpL*4h2sf7{iU2@e zKgJ*pz7iU@XvGXR;8F#RMN50muRnLHw%3p>WkibOY0^_w+qP$`(ta(N3-JQbHuwfO>l3&m2VODxR@tdAFaxI34;G$U)~+TROvTST?+#C z(BP)NukCTY81MpRYp*yBo12P2=5iJ_UTpw18Yk8BYq*vjls>PKJj8$r0AKA2>>7WKyE8$lG!AQ3L+Jvp*dEm9AwtxioHvGMx)B4oH9+H}P zw(tL~d`3P${yn$yuwZUOWmAZEP+`1c(Wl~BLhyhI5434JwJwIFM?3=bJXepBy4yQ+ zd+0sF(c-7474X)o^0N}K2eIZeogiZI?1*zk6qA7?A~=)g@86@YeM#AK=J4$Tz!#Z? zrF4WWSk1u0=mRAhpFTY!eOGDu+5z^^ToorV<;{Bamx71RYcVh?jaozYNBePVnGgB* zAM_pvIxQ(#WOR3QF4`KE2aN+_JAO(VGJbE$!~>fVe>_+S|9t2_I;g*=Jhy4dN{-VT zC*t8D4+~4{vH>oXAHd_dTx#9P_IDg97IOF79WDlsH@RKh1$jh0|7AOQNZU zlcTQMPF&0EP5e4Or$1SrhPmNdP%PBM0mYVL$nkF?TKr26RNYuxU?=poZ{2Fgs6fIS}y7fIEX zvPalSV>l6C|JFlnuq#s+UFZHo-}^cAViRdZ#x1?fHK9Y+V7p zj0?xTn_@A%i4VZSeh!74rk)3dD_HOq93zOL>E-7DBto3R=8?38mW}#IQ^oVNXwZ%i zH%a=hER;Zr0nYjXqNf8Oy(%i1dY6y=NA!{^L?Z|K&==-NP;8Vdl5gY9N>B`{dgu0s zPCy1F>7{6VP@ zvSyoJj58*SjVg^Qf?UWHu`R-}O_!1@{lC$7H0n86x9o4TV|a3W9j!y97QT`Fq7hovH_%(vqUwcFYP1~}u$p2r$5m}Qg!Q#pv08{W4yjLT zDs2p0J(KLW$S8iy=UYgQ8{z2tw>UuJ{X+Ve{JL9`akXY8AB?tjopb(;n@F%a5z=ZSdGpsTJ>@gYRx zox-y0NNsh0`Va}GEE{AQrWAnxmW@*=6dkP3{9L^$HjVBp&0rV=e<-PR@O!nyT9vVE zbf#)Yf8zBRaaihs=Iipmi}asIe~bh8@B!4@?|C>0vLcD#(Y#08MiA$99NWC{(9w7r zry9Am$(EiHb0$)aea_NND9J*1__$o&lbz6ka!Sg0=Nd@x>~80*k@A>IV zfY$b1$S1YwHeF%%J%`^rn4`Ag(bj6_<2oncdpi)d)?Q`)D%zq$JAHS%#r&IaohQK%%sV~=aswyy;s|x&lrj}^&lV~-B{xl4UymE#&i|rn~?$@0Yy&htBeWX zx}D8zV$7L9g#3LDTuhB1qC?3n-P_1~a}lPjrN%?23 z)wD_v=w5m1W%)_zxM?a#;*@eV?2Xfkx38EU5GTTH#U<;QjW51~H zj6m`=2t{Yt%zS013x?j4<#MH!DnO>x#a+62{4t9V(==_oZv=b|*kE-KP>Okw+_sjX zD2EWOWI?F7NF5*W+w64C(l`LZ#XqG~(G~ld1i0{Dq$#W33T$?_ZR5^9F%g@n3mrgH zyNvmaHistbyS{wRIWXDk0;#r)@7h~er`7V9nu`tlmdbuV_M=)^&in^f^+K8YGvW#U zEd98xC!E3Kkf7E1${K3aLB48W(jB0P`yK3?T{1!@#MCL|eyMVbZFHh3QH$o&YMEg# z_&c97aV<5VvbT&Pb$X`TjsP*W9nJ3@q%-j_2n(3m@#POY$Ze4$EOxMMI;BW?`;N|> z9%R%EfH7HfUsXZ>!=7g1c}?*jIz%`_r=^z%E19kyaBl2iQ{Af%;PPeQF1qvJO4He)^S!?Be3+=9sG1zslv>$D@7We=G8#pO&rZWd8Rf+=2TUt_sytqco(R(pipc55`XU&oXHmw;SrEa--+I}NecT51#im9!Iih$tZ2g)yu>Mt z|Kk1cqGDM(E^O(L4J|t`KJ`%}mEakfQ|rDA%c3>7d~SLFI4dEsj) zUY$%^lI^hWa^>5)H|s5@nwcw5kyRj|;hF${qfk^VT<|7uFxnexO$#0@1W{ zT@Z+12p>d%Gh6XTlPj$qQ%EZ>V}xL*w3)^uMFOX+DaMfZ&<`AfQ6xQF5e84ra8e1S zAwMbB=VlpmQrYzk8*WL3`>ML@ zd(JzEtChx$C8xcD<=gA|T~$Mwer4VYoDII`VW%Cb+u_rP`dJ{6RC!2Lu0xNa(^KDl zCI0Bs5TD zluP~MG-sF&yYxfpv{gPl&mfIADwthsZ z&IDvgV0!^MP%sJ;myd;yH92}csd=gaozA{Gdm%9mYc(mkSU%Xgu(ATJ6=R(hcWMkL zNVo(=E_<=HGdQu;Amky!tgs0qiYBB$6U2)(S|KmsqxSm!+w?EnQ+@fxP796B8+IY& z0i`CPa$~K~XA($4eSky1&{tB353V~JCub%{b=IqKMyE4}o*3kEfQ@+@7rNeSj`SDx ztltTDJZFlKpa-|mz6bonKwzv}bm9|QjJ*QJ`0eSK!a<~GujP>ZTm9YuqcWi9{VNikod8w-I`LQLmK` z^7U6!4Sa#Sy$q=8v8;M3Kv}9^NT{44Rlig6`!~1s&W}c{TL^8S`3q|wo;K(wFZi;t|vF8f-v#slL4xD zxJ@QM=vl2VU_VYAw1Qoca?RqGOxoV6rfIxo0!d#^y=+?i=-;63w{<0*w zXW_8^-ZRh&__09c2PNTS5>SBUkk#o+ibPI5VHdbM$hm6pDNjLgY5b(32Qh|H)@`BO z^LW?IzIFJ~gs-thJ=3sAP8BrJ+?_M1u3J=E{qYMe11&4LTzO89I-Em-fyKsxT;m$S z=O)cmqmwDk8xCL1hUNTux!9nf9N-rl6w zS(=eVhd@+b7B<#ynmTEkzIUmh{|#HhPA-S5d@uT9dCIejbCGBI`J?56I_UqH4p;95 ze*dyER#$zngR5Lzyr@1$e1@iR>RbcR$F(HTA)bQHSM9t^Sf&Xa%`li9zEOt%YC;Yw`hPxyN60Y-V ztZ+@dfqXN#Z`!uk?dW3}&kOyG84icc3^x>m0qdpjF7Ud_7PQx za#3QbvTMOCMPiB}CB!Qu{+;2dB-VuRFIG)_Q*$zD#iuoiw(Q#bE9PQJ0&nNTx6HuQ{h0mx>(35|S;4q`i(m=3fsxcIjwv9P^wF2`d-eEEf#x_Vx_6 zi>U3B02h(qSjzI%H@?ReeoqZdVf#?&E0KUje$R)IAHpHvfX(Ex24MY3M*XU?q7>ONkf+lq>{-VuVmqkGLb z7oT!?@`22Vati}z?MOzh%F1mz402fpQ9{dyX^v_M2Zb81LT*hoV}9ORjY>Y3%bXi5 zxF@ROZAi9)@3&84K#jpee##)Nt2noRJTg%h)V~;W@l!~JYDY3URrCJJf+607J54jk z$(8MzaZwZ($KbUxxic-IUQ*bvSgUiOp)=92+ViH5F2|5~%xO6n=@mM&lsCSyu7xp&P?IX^1nZD(3s#qu{DG_I&$f z0Ar^S@-1so5@m}%EO0lKEJ`WCHV3~~_yyMH(&z7a`a0eoG8nrc%7{Te*K~uq*t014 zvNDlDCgx!;n|9T*;FNaT2U{|A{ck@CK8uX?&0EtZ`NFP~U+1CURw1%X=a zn^Qg}-4_>*)J(a{P8is(J`P*pYM^+XlqOge!)8zsiEAa!UwI(!*?5Gx^3rW-QnuH& zdK7jjO;b-(p(GTEk<-yWVJh_l9iyz1b~m9c>oLu5u!J95xrIz@A6;R{3l5Dtvf9xc zhL4#vIWLI_g67@WGUqEcs-WY)oXj2K>G;(#y)#ItimIv-lef9tg8D?58jMet!xe^IK%>M2|MA%byn z0oAP$#fKA)TmK3vqP5*xHTxt-ze21Q zXLo@)70gF#j2!85k}qSe|7$1H_xeT22Yw8{i5kmb$H**BzofZgo%3+5{O=jsD`+$Iy^3VKzx76z0bJcXZtlcnc`!l z)y~|t<)AusN2Z?s>94SX+miYBbpwZI2p|CfV>=(*G~RT!lfG@R*bv$9#}6%ZK^6or zFf^%mEnZP+92V+}lj`j#{}5RcycCw(KxY}eFIp@#;l^oLGA)hkeuu+CKS<}wu**R_ zTfy;Q+A1C8`*&$G2*{UzXF}_EWh92VWkdfz5#sV$L>#RLw zD&ii0$Ov=cEj+G2H^+JC4%T&Vi%{o^uB&IRaaEz);pSfB`9NAB&=R(Le3tw}xLo`7 zQ68y20J^D@okcKQ+eC=;>7^sc50)hrIq~=)2j6A9*m1+!9pw7!SS30e6y;Y1 zd;MFLYGC~r8-31E1OJKKkryjgy!7Cji>0Zx+mVG&-k(=h2an3BY2f*fB0a2FdB@sH zGQnm5pc|2LwUvRL{kKjmO4xjck0b_Whg*Ff_H3&uHH@FlCYuD%5o}Wk0Dd)~Z*qn~ z*F}pb+14rPW8j9BxLak>Rc5j`qnB#4&cU>I!mTe;8KDK(mow(Tj8L(UJ=jHokMVK; z#4tocD0@fLf~!?6sfekXl0sCBS@>t7yP0)q#@?RLzFjaXHOe^AEGysLdY)$AK}Y{2 zi#a7t|0CZoftQI|LkwTzfIz=y>tg~2&nGFlx?Nuoj17YRe#wk{wM7N|2Kq?Ut`Zc6iV#G9oEpaBW;7~je^_8#+4l=Viu`~* z$V84O2mmr@(SuRk6o{eePntjm_>U*U?i~9^*bbPqG+_n2 zn~+{*O}8f7T_TkXZ;;>h)Su%GtS_yTWi+|*4-HNAFKTUT_v^Q^lF=f28dRC&NyCpB zJ^WTJFu^7$s$nvKnr%BhSJ*7`o0W${@E^dd0}=yIC&X!SjDY+cUQP3PFe_WN1S$rA z@%HV&%!1q513g)p4Eeh3>Ye<0RUB|hM%zgzbYtSLd<6U*)Wj(tYHZP%YBNx(Gv$U68H0eCj40R7C)Akr zXw-wT%A_Ry*T%*TxwFF{y>baLm~n#HXI3M9Z`@M1*B7sJKQ8HUQMj>=3|LxfzN!XU z6C>f~P7+9p$9Tj#O3H-qtuRqx_HvyTNuPQ3SLS5bca}&oVR8Vj^;CDh^&?ZZ$Ioe0 z`m5I72H^7jQdRg)^+@Q=D5!`=6r`8a2GsV@-iOs$Kh?|qLmwn!L*3npLF9$xcTwV5 zogjbsHC-0%;Zhp`?Hj1Np@aaWy3{~l#MRdBXbR22Tv3`|?lS2m=a$7r*p#zGKmq-c zm!tv78p}>OZ!^wP-Qdm}{7U<)%=)SK%#zHOk#v#TzYua=%(%UxLs$Ic-*NjCM!rXs zj&%9cvT7_`@y+z40Dp>QQ>t+H;S>QQ zq{L#pabfL5l%rkMDx+s~PwmrG!y~MV3pad9iOx6BhuF9X@o&?40tj2j*qQHG7wDlt z@fxXUq>Heyb5i(#EZ;(${Y`&>q-9TqbHF5gxu$nO*!faE;PvR6Uk?dwwV36;e1omO zq?lq~ba+!%ry9oVE<+dmSLzq#COWqJaqsbQAd)wYR-k)Z>9dj@P%&cRm}< zv;Hkd?LuWY7tVJVQtA!;Wh+@Yh9$zf%b3cQ(OK$MLKnJzhAIto6je1^?C#d4@@6Y( z)*n5z-wyxVGA<_I2qa-hU-#d}fZOTh#9qjz z38}haKI-ehpeg=_ck)I1%aIQ+qO|iA2E!-{#90|&i!0LZDYe`}aLZER`xE%eX<^I# ze7n?Lse7#WSO5xLW@6)ANqudH(TMmt!%oPJS~tg}eh&xSZwIvB{Q=%O5p}v8_ zk0EE1D$?|S?Maw(C3(9zh|nL}BCxQp5#rAQk~@Ie zkV4KvnUJfk4cZpwMkH1mEqy&JSr-=YH62!P@>9e2THC9Ua{d3)0^XX5K^C&z9aDW% zhi|ipjtjnn-oXSAQ2W#RzeuzDtdus?@XGC$XF$!FZqd~dMX{f~uO2+99qUHkD0c3e zsio~WAQLmw{wYgi{|4udRW8W(rTLuKYr8puuV5y#Gk%Cx^DAQFBGlBB+EVJ&I?DC%V@-ZRt; zmo$veGDQjg`|uLVNy7fBRT4Ry49lq{dagk<#4o$ZE(6_*Eg((@c67R5xg#G*|h-up=f2XX=q) zjl;;(j2Wp)8gqQ25GTUR=y$%9Lq^@u*v%ybCPRV=3~f%2+j#5M5bakc)ftPY5=O%C zFj7DywAXmiRiIh`hUTQ;I@jZWhah!6u?aXeYrj*g#%F{0B*eHeZyqn0D~Md{WAqt@ zVO(vs=%Cl7rLyDc*H-^Vs~`sPc?Oaj@p*%MyY4@?0VcHuMN@wqDr^??=xppe{Q#xmAG6cN-AIoe@8kWeTi5-E0XSW=%-~( z*&yblpO#Pa6_(H(WOOfF?nkXT@*de#RN&d_kH`cH)lFA2@UhmR+ zB#iAhe@(x2hdqT3@)=z6wEz$v;SG$)=SQYvSmLyNVFq&0$C%DtFz#hUFK91)`O^A7 zpChvRcMsJUl^#A!m~A+Z9g;foqGzZNwedu;t+*1M$(g ziHfSUrFA0f$w6UaqQ6xMYtyBj!WN1jiiWhzo;@JO9Wf^-vwxo%Msrfux`s4EXGwXT zrT;vVPP?5=3c`SGAi{all;VHe+?8Purh^lO`{>qe@lay&G#Gfbt+eE?Bhp$>j@-8d zZ2onph5h%aiFYe;2%9}x)W=oBm`p279e@O6)t1IS$Lk$k9=SN1V{sdUb!Djd%a2gP ztK%+lX-NoRtd9;cdKpUS&-=nIYi`Y{!n1qe3a1fAT0!R7>E(&U*8l%MYC1mq>`FwO zD}3=09W3XJa~+yjF+<8VHiSiwP*{&~S;57bdJnYJE9fO@&{hjI5c@=M8;2`XoN?{w zg)yaMfI&WQWV#}i=fpP3uZ9|q3J)%X{q4${$ z49Y{bm)X`UL)~oMn=ns-ilcAiW{OXT_m{gv+lKaV#aZM(t*ns5rud`ufAmU(Sf_DWA4fJy4W2W`va%RZo-3*?Z=b6SaPwpr2?7XA?s)j52i(se{ zgaZ{MA||$d!XDoctbtE2w>Tt0%er^^2q$J9fA3y&G^HWbfMK|0&>$275@$tnpiohQ z=uzXv+jcCj&GFNtyG)y*36lTryay<_f+#1F=W_vdX8#15qp%!hglWQ_H_Mu00PiA~`>0QWEfIi`({=8FGnbUc zcAHNX&|Oo(E6>2rjQ|$*h|X6?3#L0sPajH<4Yb_q)4+?q2hNWgSLFT}fIQjhqUbV< zyyAL(ib@TV<3uBVO$5IuE+X9XQ~5(A9|{%rdMB;mFRq9^x-b{wWB`aqcrC>lluFZ! zvN^KJ6TdjhiYIUp<_|XbRQB%#>PbJm@G{K2IhySk$9%x%MIgHVYh(aJBkh-SzoSbR z`=(QYePgTGfao#2n7kN&-wyTmX`$qj4yny#hIGBE%FAvh}`p($}Xc^8xOBW-) z+|8KlG~g$6^RPF(j*-DM_47cOfX#fPjX2u3aazL8Aqzf_>6K`IXg!a4-QI3~7Eod;1lSw1&3DSC&6m>J)uH_J9l z*1b)1exr99f?Fh}%`KarP*UM9a{tS?^xLv@Mj|^qA+!$VA;;XIbfj{W?vzwccb273RsH zL$u*~8}z$lz3owH?(By1)r!@(X{nZH9|b<@)sXS0$WlDil$uUo`$Eus8%)98I_xvJ zi^;%Z$ov%kwc~s8eTk=Zk`7z4U;h{^wq{zj2`_G5Xwys?klM%mKU95ZSX157Hi!Zi zil9hGI!co!Er5uEfHdh{LAvxBx}qRmI?@HHflxyyfb`yb3B89BAR#1>FFwyX=e@rC z%f8lLd-lw%DfeD$hU2j9g?rID^)bo+vF>B+`+M@j*N=52y+g38+-qKr7q99nED(23?>kzZ< zUx=G?g~IeP;0|w|<1~^2ShT&L;gzc1 z<;yQnekgk$oEZt4#-3pjEIqfRe!4Cpa6H#S$Po9~rX9=tz%0z6U*X8My;NZd(o*i- zAsA?TIl(sJ{oPw_xh9MdqFU+{v=9gpO>O%d>O#59dO}=@`YwpZ3mg;_Z7X_d1KB?2 zKI#a{)51)t3vQNukiEC5(B2RR3~lCLUWN*?QDB)?F8>C$`vF85r{2N)Q0ma8Sm!Ih zl@lA>=EcY%HO7vs&bA{W66Stk_zhdsFcqWPOdl{cZXqabvG`f3vRc*%`o#1a1s9_f zR2@j(Odq`D+>1X>DtpeLmDItF4<7}d{n_&~`eYEO zJB9PsS6I|Ke{Qivl;2F7ekhOIP}<~Fr?srX>3JB;@26c8E}v1PU&{+YETmi3{bYSMOu^52AcD^G9l`VY^T9(1iI>f> zT*1)He>nS#%LaaW;Vz2%Y4oL|Ba_)py2D065-Uy*F^8YMTc)?}(3E|U0mK`lrhee_ z82^a@tnA3&_@I!^M7v?ErCy?vkDPe`cB4!=5@_H&u zd*r*vme;#ah{9`^=oejjKbPxh6(R0ftzJw?$rDN+FKrqu4{se_F-c1!rZ*H6eilb< zyNVX)N|k@dTjUY$XZYm1C_T|^fZT?e+^y5$KwVorbYwpimRVe*0N+>)?6{KqL+JEH zar2^ojoebhX+iX{73inBS8k;rq4)Fj+p|;G}|kF zT~zNs%8-*#EU_t1*g-YYHk{WWaGm9ZB06tbNHt&#?t(5yN3(NrbzCg;DkPp^+)tl! zR2B?wPO?Fs5pJjvxBUD^F`V96@D~ypK6AP$30Rc0x4HPKEl-6afh4$N$WS;^lKR`$ z&mvgU`>^; zG|J@?^*K8ba#@P%=#m@aF85M(yEZ(N2pXH{Dn=M96}iv9`XRT!&-;AmbfHJiBybwD z7+bJx1-WhJ;7jQ&J;1!-TqBIQk4P}Z7y+lBk~#jOnV>ySl-Gdmuk-a_QYY(=QsW+R!?$c(7^i;z+T{*xt-0Vd@Md{9`te6v zKZ)pB=Ndpu|5xjs*RR#H*2>h0feC*>hRJN5rih8pe6-?>%WC#P7Xczkgkt$#d!W^C zz)*h)d?R}4UPC1p4_xo~>_T>9lfHLdIzGd)Jzf&*>V@;SM*p<8O?<+Kf}n@Vmx$*y%c}k} zQK&Roko#6FvATn0@vp>;po^Fq687@tFQNW%vkl17*!ZJlvT&KQ=8wzeo$37+G};u4 z=(4W2M_eKZ=?{!sB{9=1O;%5}tF_^g?(2vSYnn7!e}4H)5XOxnj|?3g znni!hbJ{C<%2eMrQF$SI@E_EHgJ!!qhCP;I>{w{9Kscvh5?}Pb8Q-xGA4gTWj`&w>TOXpoT6d>t&iJ4*Ec?h}3GFQ?y1sTH%`+v&_jd(htN3&KA(AKKhFF zIoXe!@)~w>*3&mx4!X$wHWK)8FmzMD#pV*LcUdejbBFHBiFo^!3rfw{Oe0F?rR*Vo zn~G)Bv|U2lKV(tn&%9T{cY{2{tZr+7T2?8%fr2Na%K^cb5{WbJ$ooqRGn!8G_>z*_ z%0ZQTX)Ja1+|f7>cM;qu!}y(^E`t{vS z^U^YPc?EoZ=CFPY#iQ-P?YadDDTyqnwZM8z0e?AnR;SeMjrWS<-$Fu&90Nv$N;2;m zWxmJ@C;J;XF>~Hf@f{+b3H-qxzL4hu7`!J35uyW5*gIczm@caVYP?xiXvsI-l38s` z6RO{*D`Lu#$N(sy5ypXsKg23K)co-c8kS)sdX70kDp`!A8SF5(?YJg?r))XK6Rs!d ztE0P6bh7jOxqA?rd;L1aK6VAdwD!iL<5t-uao6qL1A)p zCmKP%mm!<=vpbIE3(r-Tox1Yr6fOE&UJDvCb%pU$wpF7`Wqh)PJLsBaeCd-n? zjZi-aJ;952?GuF-vSXG5!kHXx#lmSu^+A2QtmY$R~I_> zERo`t4YM^J0*uH&c~zsr(LqPz{Q4$1ruQCrpG6(s6_=QTO$swJ@$ArufFEMO^FgO| z*wrm(pf+JdkgR)01g>f0)_fINj3T}_8$KsOu^!^?dwCU<^@W8BYqO24_pTqiY}+Md z{v`$Qgh`${11Qn1Rfm*TOW&!P|K;Vj=F;=mQILNiuVw_^MIc?$Gpu?~QQ`b><#o9s zd}9#{y|B-xX-cU8QG3ozSW<)1(s<)`YzK_;ZMOm?+>oCg^Ks zrkw-g*Dnt@7a!}cP>$(I)7LeULTB*KzX+*vIBA-hIeA!E2&3|%qzZTFe1#T6;4{$) z`>^@G@D8TGwp!vV-C*uV{@#TS`C;iV?#K|r3pJCeT0bJdAX1>1L2Z2j ze$I^YX8+y!Bk;?Oc>#BhlY(wMA^@dT2I4sP3Fq*Z(Vz~^s2o+lkBYJ94kcInv{NXB zcb#HW;K;K}HwnPOv6+@srg$dXrE3IHe<9YMTS@l+@+`@H(&0G@BMCGrQ05bIFy>}- zE8*}e)3tOPb_OMfl4A(OU~t!0tydfReTDZ;H{YzOMYAi&`U}M)T7?y#Gs>1F)PYb67n52{}(T0+h*!2YLAZf;V^K)WRkd|$Z?6dO+%r;-M~uOY_<(W2ubj{Quj$!=i( ziOA9kfSiIvGQR$FGFsW%jpGC_c@rM^2&CD|s=Xu4qF#Cu@ya;e!nYAl7NnhoB03z= zYH@Yp8Ni?XI7-VPS*RI09rNSOInhA!?Y{ylb zGXtNGW&x0lFG(EhIQb-f*+}Au)DYVQ-ZXd_UX3};BYgWcgoPh;Rc^gmTgfrbenIZ( z5>KioA>_ytMaeuG9D4UwfJDm*Qw)b2TJmNmc%1KR^s%+HA>c>-+0!0ps{NC^f?W?GrXZYnemy$qUHwq~v;_ z@P1X;zAvo^yu_{^g9Y+pvm#kC@uvqi<+3pCr63xvOIF0%GzNQlIdKHM1E2Uk;k>wR z!);zi+L1*r;Wyl*uf^mQN-tQ_p>c(%f0*6)NjYFZCZ@h7ietndv$4;7ufZ+yH}U8} zd_Z78$Z-*QPpXsvkBuj}?TZ$U!qZWUhkn?yuCt;G11*pP2;Un6wm`;oXdLdpqBNPbYwEBVK*O979qjLG&_b}d}{9Gsy(A;W@#r7oA8 zgHZjk=8N@*t(wc>Q*JBgT^1NEC;0HsnxZ1H3H{r524wiW26AalFY*oVwmi?==(SZq zzVQVp((WbPMm|f0HK9Q2;WQUf za|r%ZlBO0L@1?3#@9L@%9`egZsD8$7#$0FO-~JprZ>RL%bl@+FnZ-(RfJuW>8(;ag zCaK>*40ZVJAfKHDw%o=I;Q}1z&W;>~_F^4~kU=d7-%8BTq2asmY~PQYq3m^Yx3I+q zen5&*P}E{qg;68Iz>gthPUd%IP|ssU1vCR8JI9E#-GDxy-&U_(9*RKktb=d9{rlNm zjKA%70aJXpEIy9gZfe62Tky`X_V7ki=fuRJAPe27OOAi*p3tKQ9SXmq)SMdCp3s=j z$2pf=M2k$UhHGQKF#`SS%Ox$gTO=j8>~`@v%(DrD*oPbHJf4mpd=NO_UAahHk^U^^ z?SS!@tH)=IFEzux=WGC3=_s9V6cU)r*iXjS?>iFovt(?@k^ra;3(qO?39z1X3$#AR z7nH197_^qTX9EowD3>!>#n)XBfQ5G*NUrOBPjU8iMqq#b^8E}P6On%VL^?5Soa6aJ zn~KJTgmPnEn3oyR>DFml$&&3ko6}q=;4=U_DT#sqb~+pXC9XdAixw5_E^9EjKf_Yo z9WoJqO#XJFr7w%+rwiTBu9l-`b-d(frG|+qCL2S4L=*ZaPw{ONkM8Lo5yfK8BjOTJ zFFg5m3;e5Rb~+(iKzM|+r3&ZdL^gk6d8|#D!?zzhhRy3O`)>vcjKTy3%;b&OLQ$y| z)OyR6e~ug-KV;U)yc^O1=^K4e=4|-BJfD%0JRQ_S0it{8NPcyGYmYKXdC5uIW>_{q zK%Nh5)`7Hn)mxbe0ihquhNa1FmrWn`#jCjrcX(G#R0&@FB+z`ziIoPe9WLo zem`y}et6=n0d9~vnMF2bkZi<1@ZPbutX>Adu29v zMBbH!*i)dVJ* z*-{U76=+frTM~w@Ru8Oi+sxWN2+TDTe0*$1=93?shjX z-ewWCTaMu5)EnwQ`Wy?e*u5k3ydgZz6X9NjOfF=B{$8Yq7kU^R^2;OJhNBb@g#w0| zC(2UxK+DrP^SoJs7o{L(p!IOQ@(ZCTA!_e75%2PLa)d?sNxYwUDP~2wo4}!8Nu+#z zDa>;0527T}Hphpqd^{)AA+h?IFEDIm< zJ$|pngJKN)E@h7U>Os#wyY#xfvDdl@EwtJwF_$m~h@Bw(R@h?=YS);-I{hVOcE#_+ zAQsyu2hkeE-G<1#ZgeDqOB()_cK}r4U3LTjPOInyWXbHxi~JVqNxJJbtzVp=OLQ@5 zwb^oKNY3B@d9FI#wMn9OX}>$wB^s&3Q4JRO=EnhE!X1bp4eD033saa44!%a3R{XTb zxdb_q?L;d><<4$D>J0s~Aikl^GU}3N065=dT;*BB;Xg9DZFKyMWKttvzA4!_;eLEX zpuPB293Q6%;XA@6g5W9*A5!b@`dvRcc;?IDHG6bv0b<{2V4B^zZ{X?;R5vz(>|A%T z0H~_MVnNmIRfet+joajc0*xwJJi=7ElT4~lFN3xg3L{$>{p^Qxx1APG2>{Kti=Rh8 zUL_96vUP{4_S@{`x2By8P;plR8ORKYj*mu8?n^`^PACZi)oCyTI&Qam222_VOCMSN zAa(b*b>(rs=S1Nk0K*APvqxDE|2P@k$<1EFnVWEo*m?W(d>23B$Wqg>zC0Jm{oL&L zAy2YXaSGQ`|Ki|~rp$MXeLW&Do8)Rqr;4N?{llua-hqhY8guS~8z4_9im?(-=kAoa z! zlc5;}TqDOJJCrmXLzP;|c#k0K<+1;(9ay*WT;|lVGTo?tt>FsEqZ82zr|VU&8BGBfoS^>ialZYjN)FwL*_ss4J?i_tB#a_`T2{ zCLwDqNvwA`1z*ePk{jM=;lVy%><9&gpY9bgTC(C8W0tvUVrEM^|C z@l&Q7O+CCa*a2Z=R!r~_$r0y5UsG;CV>g|*jPN;<^Ai!Ew*nmzeO71H=BHVU>Awg` za&*|&LX@pSue^l&@z!qjVq)_IjKKT!W__9vG;pb|XGm)s+@-#S110XW5vT5#gJX+M8n+`AE>vDgd7ae zy|BAOW7d%8T2PPm3*SAL6R^%_I`vNgRGSC~E{D+%zS0 z#2$6m2-T!}&V9Z1s1qX9_5nH@#?Kw*QdPXc4Q$p-#SB&F^{l@TQTG zy#AK-IGua1Pb8F*m;Aum?ac>hoeU?*Q)46x9JciiP1n$%%8-J27^a%K=OZs)0BOz_ zy4O2!kIsZNJu*?Ut^1AN^(_VIr=BMx9xg#AJwHGj73p#6a>AvSqtnr@t)(Bl$y}$n z1}ZvAmpX?Hd2!BhA*X-9Qqfu-wr)VyPa=x*`i`YM_19mx7UY)5HG5-yLlPwfZ3UYbZKGfM2t}h!vax(H7wJPnzng z`n~hGA9a=Tjg@7&L<#)}iG2y9c)U_HU8T!_s)dWl#_l(pn?3H?#wTw&V9m^oINvshJart+G?|*e z#MsL3eu)!)>Xl-_aAasZ0$n#NJ_8xBe96>w0o4;ez`2Lry>5(qkRNG3=#{ zwN<~p{z>J2ADfM(NXA_6h>GP+w+j3eyc=c0t5JS74fZq`tD`R5&uG6R3K4gfvDv$r zx|rEic*+(t9h2nt1iZRaq{go<=?%G85x<#_^EKSs27w%zcbqz!ZM>>}3;uC+f(sZ6 zVl4mVc7#-kJmSpUWQTS~Ob@utHkuFnzCUTH9#nGgBHjL@FL1FWp%r-4zm}&aDnP7) z2CMb9Oc^sA!@g%t)_y!mi5Z#qp5VKJUUzTtUbjj6FRZpdV&p;GgH_tZ3u*`69I%5< zrPW4|>7}10N1|R*6Pov;JEFJnH8x;FZcZ~e_KI4JS)WJ;BaB>0JDS4#3u1M+**n?U z@{3m|c7+Db3@!~T>zF#tKXy)UoMzu!h(dnxt*Q9g(#&aj)i}x1I#-!kRyB9t#p88^ zakfrMGxx-V2XsddO2SMA4#RbWu5xh(D6KMw0bE7SsYpVWZ)hDh5>9Dz!;#@LE!t7a zr)lC!)CjS~Qf_flgZT5k8`$!+Y)|T5{61|>8vYiYsgsf-Nue@#;^HS+>SiB>q#9%V zzI#XMk0gYu89nX!?E5a!Xmy#o5LY;jj8XNHZ54Rk^WtKR;jHYHf`U5(rub>Fg80O(Q*A-+F2Dil>Iz?ibwaF}20R&L_S_S=wr?G@IR!GG9cV@{zdyfi*IJl=E+((wih_Kc%D0k)Y&xDTi2+d{|2(82BOl z#AEaXoNv_3SXOI9AGkR__T9}jQ_nOM8iPI)IdA%@mzfA=3QdkG4ojCsG5_8z4Vf?P zaHyW?W8X7%@+U&iKlbwfK_Kkj6(VN@BFuvU25j- zMVU1KQUzfbt!}%vlX(eew>_+U9+B)`9<&6+zocN!q{E zOwG3-5>W0sYeUT2VOyCkPi4FoIiwWGX4tzJS!G-%7Ynmw1?m1ojVOeiPQQn>z0og@ z=T$8`WnOu#Zk4`h1;`?fIvEef+|lh|U11J=XtK!J-u}x-!q#On{IBXv!9A}wP7E#D zM>oTjFutTy$z2#i{knW)Bb&8;H%OU}{B{6fx7ZV@S{-!eX@X~~Jcl-C zQi9{`~?;>-m{;$$wfd!KOMr!M!!EDOF2jD~d?v16fJeb^! zDP2gup1CK*sSQ%5KlQ*v$NK3reT9Ecs}j+~g&7yHyq>G%8@5plB=;%V+gAFbbdOf8 zk&IY@0!!Q_@^`7We>HXzNQ!5I_8O}InX-#E(cXhSym*#&Rwof>RW}7lY_ZI1D9VzM zH&XPf850|_C88%e?X1icw|6}to$B^!Sw1yeB)3ky{e6vfJ8w*e@BW=({K3Hl z!GCRoj*nTgaL~I6?HDHPv>@zj4!UjGe_FhQlPtaF!9d$V`-bO)8G3Bzwz>0#zAezg zYJ<=yFu7B9PWw&bzMZJ3Xw9B*?#)3Lwd0S;vIV$G-Bv}A$^?$QvH2O6U~F{MetfMZ z>Ubu6%SsBEtugH5Teo%pVs*46z7sEkG|)%#Kwl|?fA$6_>z9=cs|(IwcYSmn$S! z-GBdmB9_9@^`AGbdQ z%7{HxBi;O*6-^ZRa8R;M5BIWUi%5w+!? z(Mtsv*veKg>qk#-f=KXUHTv-CcI|4Kgocq>bRk~OQyx%3(X68!{k&hle(BbsNici; zgtQ%kbeCM~g1KQnx>$z9;OZtIJ9XseVn<8kC4gmE5B2zsAM$Y- z-|~wR*wqQ5=KPOGLqo!$@GvsY_1Z2uwmrciDDhn;f*F2g;vw6U zYFy-dS1#$&=UjRd3%-S8h$woq%^dqt+h+m+?cSW$>Re3U_O zutGL;QYIt@dRDA6RWQYMS20)bkowgyz&xg*C_80q8^lZj?YVc;o<7&qjCll6R2z$J zJNm9o9m_RsCS7wS6MfP$T^sBkIowcm$3r&*WZCuIew2f_Pza(P1r{#zF3a_X5D9_v zJit9`)0%lkUKGK(>nnX`Bix1SCj^zJk68|fX4ZzszN(9g-y98uIa8vBTtFK#ZD~>} zSKCC|n{=*n{KIdHf$F9jJ9XaGKWODi?MStobNi~jgXl|} zF*Q%fyK*ZFmV);#_{5Z~bAdGM^hTvmj%e%L^9 z|05QiFR!2A1NqKHUKaC^BuP0briK4_PXZ+rBYO|c_fk&jXq&mm0G!P&0GA0>gFoJ@ zYrA4{wVy!^V3>4T(|12Tk`{SZEx+SZGIg^tEkGwnHk*WKNHTh}q=%y_Tdp&cyM096Df(D*(8 zDz#C`5;(XW>6GnHxeh!Amwl7;`1;Bp*i6r}lN4*&>QSFfv3HtQeN6o!M_-uCWv{J8 z5oDSCwloU$$}l?X-7%ARErSzP9oXuh{6gv6YDo-saEVRMu+M1hLYK3<`j(ZY>%ZKWe*i-xM4W~_s`&}~rv=1gzJ zQL0NSvDMrOqe=F%u z0Er9@%-j5kk!rhvCwe$vYTJJ)l`71ur~adbm9H5^FZ-NENcThXn|mL@JvCrdiFrs0 zi1`(XX6F80@V?8N>q|MWz&M}l8)jwM;<`%AN^qFZ4blPeb);S>!ztcr0^Vw)%f|UB zRPK4XLLREnnS*O;?ljojQ`|~lEYmb=s@YrLgqo!ah>NcXnxQz%LX1hKirotJ zyxH+vvDpJ^?0sRRHT2Im9d?j2 z%6@jZozyd4+&r)4J=tfMA@p+Mu4+_as~*3ZQ#wvOw-LdPB01}ji3^rLKUzxnLDg@)h5zvZ`k;CS95NqmZEdMvQkQ#q zMa$KdgFJwc1A9KO5ge_UqZ=MKYaXai!&+HFE%m;ou{LeG&j@Iu=f)e{t*gOb-Knl4 zyXrQ4Ko8i8mitYtZ`g{m?E$F5-2 zILec}oS2C>d5jXwq5v}O@m9MLvrl*2^5=Hrog2~nMK?t!i-?Qm$7C~}0_OHzlK$g# z=~FSpB>H`5od2X*|GYeT&6wA)%t>DZ)Wi++U(%YOFH1IRO99vps+sIRJDunR z_y&kF2irLpUzzy(m#+6rgDqpzOG09dYvw=5n=ctr9r;^$-*A4{ z@9CeM#{PV)Is85u|8yx8Klq!%z*l(d5#xK^iN|Uk%bV#>;XW~dVa(GFU7%raBMv3NT7@vDa`&`L@Ws(h0B)h(A-x?ruOec1Qg_GHZo8&#?B~#bV zcZ`x~!vm;JVwUD)9m$XFg`5e<0>agG(*n)&XF=Ibu*&=ORnK(uetk9@ESXjSh%Muc z*p~MbR+!W<(9u79>PdJG-f(oD|+~21h)txTjAWlTShcM84(zQ!~995 zgw(}dyn7^_qAUm}_Vzp8Tv_?Shg!5jtmm{ZWqF%P4Z=vXHC|GUj9+lV5WsYkl}M3Z3{SBw>Tq&T#@j&8if`DCxEV$y5ru7zu*n4#SRc0cXeU>p0mP z!}}#gy@&OBlAE6QDdZ}(6!S_&=tUn8p1nG7+31a9S2EL=q{zYFc)c?gL8M3!9cTG8 zZM?|mFiqdl^_c1hoxqQTw3-JaZ})vpV*xV!>>=+)i|1uV!LJL^qp)w;B) zoeC>>`41Vr4q{={Y}{gi{Pri&>M|{JtrUkCYx5_OO#pbbVqR4Ryz521TGR?3kRyIB zH;L{=t6bm#53%OI)PyzAzi7SE2W~>&CC~ZJ+&R8aHO6OmA+b#KHc83EB8i(j3z5g= zc;_0^5yVSz5Pgkmb?cdZY4`#g`IiU1aWgW^lB-|4`Hd9W;yO5uai>?Ub4R9qn?lVe zt<(%xMaqFaxa(u0|2_{^e=p}NqrjXSw#m6HzT^b5*ez^Nf#ToIB;u=mQEF3s%LezE zw|eMt z&K|ziJ3&Eh1QGvGw$GYED5|1i=N4-8?mSA{n|V)~WtQUw{N5uAC`syF6`93!$in4s zZISAE57`<&UaR(nr#Zea{^jZZb8ha8(X-N8k~&B1h&QZ%u9Yo9G6mlsJXOu$ybKyFb#z z`egDbCjI%(n=EaPu>@Wm_Rh%JPk%9J^}8o(g5%kL``_8K+}8!3-OaK2IFO%{=wa(k z?f_+(4Jsb3gb@uooUE2KT+lI%U{Et*t+?9w7n)Tu^kVjtMOrhijyFfOh3T{7UFX{! z8D6yIpcd1xgE6K;!MTdjf5!lVpFb!5{F%Xg&(cgi@zF}LDnHXT^ZN=nTkg7WLHwz> zymc58=e3>8-|6xcO;HfioSqnFM;FACN|?KY+r6B>m+@1@5!T#~7NHOm-L&jvrE{8P zT*;|4kJYR8vTj%sl&SE{>yG$$q$ks)J%Qsg)ZOqz$)8osFvn@`%Hn_1d?#o`5~-7# zukq7$$}^FA@r!K}R6iUVq+Oeu>@u91bV?S7EB;3=w{5IrQQhOTFaA*mNjH&Tl|MK! z$UEU5etSB}#CXX@@cY%9K2ELMU~jW0{O1Lt8}SyNSkwKc!GMuh>rEn_f8R@O@c#Sb zR3qW97$_a>8H`9)lyU37Sin8KWya3-tx~EIoj3oJm(2QjV)mwHP_DveFyVuLw4c3B z!e#BuOZmrUrb+3;#8u)!LYj_NGw`pu`G$VdXTE1Uc+kW=s5$it6#rEz82=}hS?2Qc zAW5?AWb5~Mfz_&MkGv|J+ zzyHUDXHco@Wys6t;}$lE{V)-8ohq`12q6$V^8x;E;&RMXi4?Komp@rH^I|xt?`6w%OOY zIastb{%EYv)BrJ>EK1%eUF`l>m5TOjV-$-8z0)wxg5~;|q5l$3Vt1bj7^94J8?R`d zV#DHI@fSl$Xn!LIs@HvyY21hY9Tp^-|7g(OWy!kO0X~5Ft59iD2yJ?43eT-FRywdG zNh%MpdhfRFFh*Ch^|RUrdCtF&JU8fZn6>+tOtDo$(HKCYPkqr)b+RS7i>S)C&|q}i z%4suX#C;Y){QN|1^It_lGR+w36PA2J=AWR|#`t~>S5s5)yeAi~!v|X0GWhgu~@d_&p>F;9t1SN943`7mmXWZ4SU8xPzr~8d7&$bBq zgX~(*GI2_5@cmN?bzI#kDJ znju?U5$DNY8E|sJy=-|d?bC;;lesJaafmBjDSo3EeDd5_Vgp%tStB+O?)Ve_$dM=? za){XTTJqZ~ZSNbBDO&`bF3&ZUwNRedV>Fl6#*(VJTWhOGTjayDmovACY{I*!_xdS+q9K-ezO{s$H}(A7 zr-H>3AfpNVOz|xi>$%e*#>=glkRr!zRwUUymeU1o-{^HV0=F<3PYuC25o=Z9yIf0R zuMB4v!n$9F=6wrn*;^J|c%`xR(Hdw!`o!|nRgdG);m{z)l_b(HaEr6`$T$Sr($n{&KiNn^ zL}cbM)9|M?nHK4iucd!JblhQF9HVmisX?}9bU5D3Y$t3$iOW9>IJ+Bk6%>$i%IwV~ zT{DU|N>C@iA3(mT5rxdTa@;%jo2g2PwCI}0ct6~wu+wt<%(;ihEQF~#DmXv`ec@On9*K5&0!$0IWz-De`H)fsBJma`)a(|l1GK$lk3x*UvVTjdLkhW@vXyE%M z2v}kwrKo?1}{76tFd*Pi-HXoJIMIFTyFO?(J%cSVe5hkFp*gJ zE2~{U|Bq0|ZHE_x}NL+dS`I>u3d0Nm&22_EIfk7pa0ZK5Pto zT}K@+`|L$9Nr1ZW)SqlllK=cETg<(rS1c`0*j{|VebCp`aRog|1US-Bll41PQDdxd4oAW06=#Fzy z23}Ze8Eq?nVEINifLn0Ku;?IVzu0mw;KpzRf3?g*60g&c7XnMr_wu(v&5nWW`MNQ( z*o!gzamdK+h`BD3kyFc0szpSAY{z)%>D~?AT4#*SqSc^HYTcs%lWuLx^}YUPA2+id zy1d2dGZCIl?V6>Hqq#abYx_FM->`2&BgA(-&VJ|X^9MCx-6vW^4pvq_>7&T?>E)k; zlr?DHs@DEw2gd|=Ia?rwLYO?izJ|!G2=CqY2M?b-5oCZ^5K_!FIGzq!feA_uQbe$H zy8`7wrw6cQDsOEPfLaUC6^`(pTVQ$|4=Z0vGW zuk=dSB4gUSN#~xG>bm?{FzxZDg+iOLmi3Q`Vgr%e+349SEQH(g_&ID@@VGXk$e3fl zzZ342EK09h&OEryr^_hd3Hdn1&Re^X1jM-a!oAJZmi>IN7pT`lvJ5}t5h`W@35>O^ zXd46#vjA@`IiH^X7!rPPS&+kTtYd%FG%oki^97wn><-B}F|W&y|=wbsBJ=|(ps&Yy2ze4rS9|9h8t$6#Ti)j-mURq`WS z%$jRyJ$kan&~534D`sIy#NweI&e0;5`Xa0qJJt#XE1Wo>VzTYJud;6W5d4z~m94S? z(tag&=Le8RQ{m$!r9>V`ayU)rIGX^mPwf-w@Yo*SlpFrr{CQ30W))RsSUL)`_!QiD zuj<{Z3!)k?Vk=X{V=YatP71k~3Cru&=e7F)6KGdy55#oKbcDaPp}w9QL>MZ^BNk zp>4wGQs|lNiY14OAE00pvAD(tIgF_lyJUvgTY(D2S5uL(uQddm9IR7i14z*U*=bWV zPfcCxzq%qzeF)Rf#GGmyFjidyOaZUkX`2owl1HeeH46@;d8}+-(Cwpb3L$WRF~jSE z`D^OO5gv(8ur&>pLY^<_RG9h#@9@p z=vVt4!|_AowCN8e;+m7LXtF??H;H0X?+4Z5WkQmmneFmzy*;5GisihHi-G9R4aqqgXIM+GP^E%gc$8SMPyI17AG|zJa z7UL)woVL1Sg}x(XG?}85cBB{DFjxhWFr=TeI2pRIN|+XrkQX{zY`)OB=QW)#qfy1H z8OfD)?WCpb1~X$4`Eg5Hx%PRXr^Uu5-yDXeC=!i<`uEJ$v-5RN9l#7$Y%ge~ds>M{ zy4RY{2$uk=U+{AWeC&L{ogbWcS3H}d8QtNHt}n9yrVq-#T_fw?DV=$Ig{eu(wq$V2 zYiw<%bTs{goO>XU0)MST~9{3 z#`-KYqOOA={Ldyi>^A>hHmTW8+L(d5M; zSed875UI$2EP^g`_;8>P=lAeN>WSTE*Z-o#Qo&RanMz1J$|ABmE{>R6*j8koh$(kr zC~feBD6aK{fW$=;LeWen^*1gs)DlZ0V$y}**wMsZ^Vpsoz> zXtee6z%EXj*ko+&nje-1@65v@)Wq1AwWlYLiV!i)mYwz5nu1M|K<|S$5dR6;*X@sZ zeCFPVwcae#jH=|Q=beLC5Q&ZY{tHldZCGU5`-G6rrAMUh%C}>l1sjJ5x8HGe{MbBL7ExKl8rc0< zk3km08+CWO#-FNu07yo)^d*p(BPq&~@!OJG0on6^@$?N6$Hmp>!iqEs0f2vDQJuTx zVqi4X0qcoR>FWwrnf40GhbQ3>t)=dEhzguUi@^!Jtm?Sei+K;tv6lm78o);bm^TSe+khIVPGrS&~vYGXU8ll)e^_ zFrgoj{XRz*sLayyvJ$T8ErD*A3qSmUF7px^8ln>|CksS2yQ~Q3zbO8X1^kHs!IaK+ zSH*r{3+%6Y*WIWP5or#Bv9(SuUjEY%>XSClBhm$oE6dM2jio>$RD4!{OF-H6p#@!} zdo9#~FH!1gH@n|GkP9U2n184-V=q*}*mlAGFSe9gF1$8~@sLuCVh+8W$Vcf2_*us} z1Y7Hg)QV?Gz6eQAV^yeU3GB#Hq14f(aSOD`16+x`?7v{mkSN>uUc6Z8L21!)b9k-T z5aFddM%HeuRK7iNr{&D~{+O%8dD)!Illr}ozVHhsIMsd{ezSP^C61Wq+6j~Ko9c6a zW5cw*&*(hVKN`?HlJ^$Yok|t?H=sY#$x4Sw`))VgUF8cX*kMiTzu5Kr@jQIyxACc- z+~+~QBObRSn-d-<2}f6bkCEm1tl7!{)140s{-fDAlqPlhqR3O!!sDa;r#V= z7{LdNne=qRJ(>;;L(6EcuPy^Z-`%MDqfVN96ug2BHk0Zm&?dQKt{$%gqyRRoeZEgntjdY1 z#d~}b_7LE?0t=>(WQA3c=+@X;|CB;HW=XZ*m6gWimu%-|Ni}<&r`bLfx0pqxYhq*A z7!_H>e;>vqF{1gZ8^JpPgG#K85vYghd~kK(Niy<^uAlvUbeB|_axrW1UXKD8P;fCq z`hm18F(L2^KU_>mSkF#`;WA1X&MAw?OqDU9*;QEvp$9R-01w*BrsKDxv5S-S*kz0t zabiPtPHZTP1bDQKFCc8S5#JizE^yUP)xon}DQY0M{D2Q;H0wNYS6doa6kuNv+u>QA zD1zNIGfVgiZE=`7LPWtnSa93`apfn(P9K|XS-SVKv>dd~Az27BC1u_|JU zEqw;`$?h-RDV;z2BuCF7?3ClYx4Dd&fA5oX#jN-k*0&@|5pd|1xNK?I*B|i}M#&^P zwn!v%7sPT-`>j{OVYQJvHgB)}yqzFFGo2#OAi$Q<%)L%yh&8FMIa^6KQL?Tgk$#mi z!_0o@byZRwP5ZBWQ5pVk85C8pbmzW;up^>3C9|X1gW!bZac>WzZoyIU)H23W3!7>C zf2Q}`)`#%H#lyB4|LY8Y4aioVv}SFMiE7$1$pF7$m`XFU$n5u%<@8<>>Ey+Q7G2@* z+00#;4$`(4fN32=Y3rR5c?a3{?JCH8(=|!V&zuk1fV`vHAKGRRELFd{ObMQSE%lVh z)~wrW%H%r6{M)NID8m6PshYIYOhk__x1CA9bKLGAhgH^~@Z;G-*sgeW+F<7@WZeEs zks9MkkBi8r-)1k*-Np7Qzb9Hf9v{lCX-Yl1)o5~Cq#DE4(iclroQpq*7ExzI)#O_RK8Q%70GtmuFZ2A4S)b`-QhjTe9|sml^k@A1x?SEH$l zhIjt4va^oo{BCeQLd1h1&gH+GC>VZ#JaLo)Km;ehIm1{38jX7Q>QJCY$>n_i{aA{5 zpjh5RObPa)PICEzkTs3jE&dtN)4>~J@9)2>!>23B~U{^Mjw{N`0KQefF0$rq2ISUj?Dv6V|Pzgx}SR?Q13ADyv6Zkr@$w zH|k{;eSM{?_fFWv&08x1`dL{0x4_kN^J3^8E9ta%Jx%%UZxMFLQjeX>T^{vhEq?xI zv`)*b5MGNd=_|)pSCxAr_Iqq@*Q)mK);##@3!n;Dr$uGXkbKhT#|H`N5uK*@CoBD3 z!B8a!(9GtPl^QbT#4=$_ZDEWz>HMcb3<|-)K0(DJ?mnjne$g_iMUmW*64D4bjn@JL zuGss&souH&NxjSxbhF_^^Ni9s7v(F7*<}Yc=RJ!L45!LJcRz%Yjo%)iQOe6CM0gpy zL9$Iep)Ktj;A>=c9CP&}QZ<#h%l#yia+dNtFBPvTt!h0XRZFd%GmF^HR0W#_qfENs za+{CdKG9{~2&LQJpVd^=F1Y12i%~c8AC6@Ee&g|~dh7jHN8SLyVuxT^TBV2n$tMh< zzFQ!gwIeO0t546M150E5w94~UTKePkPtJI)@l=3|>BPEkxn2Zf_MNpQB-nxmyAs~9 zNw(;D^hH@pNqVLSNIiR(kk=Ok6xdO?<>c49-h=?7Caf+_Vc=W6V>zB`9*%UE-s2W+ zQoed0eN=Ybjc+V=Q%`eLVm?qcqh=z>?Tkoh^-m*gs*JGKt9|2qH^xizcRB^`;>Jnk zyr1D+Gw?AAW%bB122F&xC;3?X8a9X@mVao5JTFN-tLnzK*dKrTarPmVT-Hr(Gb@YO zvi??<{&Wdm8-_E>M|tX&ooQpioO1`yDl8F{Oc}4GO!Nz+Q+y}Xn$9aH41lv|-CA=3 zdUS0NPW9RBd{2t`>jg0pM!X=g7skaguBh#^G zd5X^&)+oS7h?-I&5WoW4V~AL@6tO2gJGzloc$H1^-lhBChmMV6WidRrJ&vMkC%ZL7 zSf9_5p&wBpiXHJu--Rrm4IE$eJDn&S!4 z@~|E~lhrr(WDpZS_k97FN_;Q1(UmZ#n8y-YmwCtGZx`Recd^gc_o~U!ary7W_KC%! z9Q~HF8P^;oAD!DKd$onmOnq1z>KI-;R{Yzso(E1c7{AUYkTfRyLgHvP;)9i;rLuxi z0N$I@lc_&lkbqwJEr%!^6Me#0jcLLeD#!3lWjv@X_~vdpk@C)aX+tUJL!SnJS(3Vz zhQl9VM-{=yDTCi9bbBLNg97b4S>=qwsktX}r&IF51N2XQQ033( zV8Uji_{%AaxOsdr!^48%9ks2sM%-uJr;gw^tEuu$@cL)f2y8bU6xnY?+PoSCmz@W% z#GK5!nn)~b3iZs?^7vS<#CwH6Ye33d-8dx4y7S=e6CC#I@w8_f4{}cQur0R~$Gksa z<<)PLqATE_m!`+}*t!ovt(C~@WBTimt=&@j?v$YXmjG62zpZtxlawt>s&xO8Ph8}% zPzolAceNhVRbCe^aA^Tt3Ft;|o#&Gr#GIWcd{FO58PcmBjB)QgR4X}lXF~msyUiQx zp}EVYiz%6t0xNghu_lWbT0Qp+E?%CB4PwudcIgfkf2vbR4}Q`0@Rn=EKopH*Fk1rr{u4kK}j&`sFCW zNe?v=pl*a9>`#rek9;lTV%`z21QU{cCxolK<(A=aOp&T5AyqJ7HMH$ASxVux-zAy+ z`stNi_GZVF_F4&h_!D7I#vL08(?-$0m{gRgWb$POG42ee!so)Cg35g$1e|2wETa`pi3uf<7>bc6*+aP$ zr%qM?kPi7v$CAia$<#OfgfHr!5J$f6{OO+t$&Amv8-?;!SY3Yd{V3f3aH zCefxLV3(D1RJ>il)$ayqeUXZ{#Y#%w_o$}@VfoR4Lhyi>Uf7INU&6VIu!cBL2C63k zhP~1W?i)Y?ZqjmF?DV!glF{RagOB-$481*UV{SN)O+2XMbeWL7?{^BOGgq!5x2&@! zUYIs2dItYi;N!VJ0Di7+*nCw$pd_GgpvC;xVF6cZmZoEIn$+26y8L77!uMIRFm!4N z?V2!nmv&F|dO#W3diWNxs#Ovvoy_TsThIZ+j6=`vv{p%AjnCoZWor472RS++gjCI6 zU5b%AA7Je5@>IO`%Ttb;ZECwdg3D9rI^J<@vTxwVpx`@uLNP>th#g3yu-AP4*31 z9U-E9kE1w0500?|5Yg#pwrRmRa(6`?9Qqmfv&&Uv1-}K3oTmqVYoNilUw`)c>4ODG zVo*QOjmAd$tkWvsyFV?<9)3$wBX2=ANT@lEmYDP(=cjw9E@x_8x{#o;(wigg=grNh zpW@VTKxE?I!1<_YXY1Vr)!5ZWpP#z$n7vfSj#CvL(!~$Dv#ojGwu8T$9kdZ$e>qh$ zdkmKh0+pi^U(hl$X8QG-i<<@4lvW3KdqRXfMr3n8t4SWW-aB7#cSI~AMm>sp_xn&P z{e~C)j3A8h(Yfa&cK?J5*Fm~SL4G#ta~|1S6vlw-VT`C#ZCHOn+nKgT!Tm!if^6{I z=L2a)w+K&$%W^2i16~#w_H0K~rkdq?h-$Lfy@TW&_F^K(23=y58Eg$MZez<20Ifu+ z1HZZqSb-dh^abrsqmVT|rzsquKK0#T`jmvu(K5(UJ9$=$Ol%Cbs6A+(=T4;FSPpCI zgUWfcuKInaM|Z50fzDkeasxx$Oi~qlOGUoQA4uS^r(cZb_ZWA|P(0C+T}?|+CopDs zGr%FCw0;>&udZ2FZ`P-_(y6lAg+7_XO`W+Ry-_WTbH!ZL!)s>po-G$$>67zmC;PSO zEX!7s$K%c;D^5ypY7u(3Xrn445InTrb{EZR^T5->})4|qlU`X@+@Wl3k z6Xc?S@f6U|Js!6)La#{CfcD9=_fTS`zeibmHpkc9d|-j$dNhxUaOB3~mcqy$V5Djf zoT%o3UM_i(y;g@zfL(0ENl9&C|3FohqZTIU>?z~gXIx3`Ut$zR@bXVn=LXJwj zQLeV_xg*1HdpPR0BksFC+4I!bf~%+YcQ%v>b8Hlv>9fVgIp!WpbG(%=2*} zdmndCR(^+^-0Cjbt&HK2IxOY?-sHYCV|1gh*X%J{PT-gEGB|Kw-_T0cUgGJ{wjF$Q&%%i+^${aA#;0r#Zca5u=9=Cz1Jf+kk zkbtc!y~p-A_2HV&MBbWN)9wVnE!07-jJ-&5oxadF50R2$F=G2KjV6vwK!W}@uO{=ER>K!{&8Hkb4Tn9?8{T=gt;%I}2iRW% z8xQe~pQ=9JP#x=Z++k@Px1W{7Ia@A{McL&&G0Ai7XB^!%qH>@62LJBg6u~FMm86YW zp}i(^e@}E(2xvcFxe@2&gL@5SnS`HfTj|(^d|)Hq@$>AJ5PZaI@!Y``#P31cC)4cI zH^N7OI%V7{;|6!sE2NFuyd*!Psv+!}8|RGS9psjT2z(oCd9EJD^}USxh8$(wQGMum z^z5z{RpVYy6)O~iIlJclps;NJ14kgzZyXD?VImK5EqZ z11&zkbB@G4>EKR3m237aM*ZIXUT2hf+~K#%{l;)FEk6L-OTj3TYirDdIrXXow+#NQ zvfhbft}`5ui-{Jo*A+u$Bjlvr%@N&7`B4EvbTs#A}s?Fj+tOWCuj0W zm5tY1Ew z#YrJ&YbCtY+1T@<1lgePW-i~Izq=k&3A4Igq0Y*5R`?+CvtXhH!82&#Gj1+bNTUim z8+vYe>=%i9E!SDmin2dg=pOho{6GCAGwkh5e?+`2{O^3TPUMoCm+=yvDdfbaWz%;#f46}~axC|mV_N2K* z0f4ZoZm>RebCUW^`9j43TCp7RafXRSsO`2j^>sPvqk5v zQKjh{1(dE|qy-ynkI09rf@`;8{PbPs`&kqFNmHiJzutoTN~8OEf-s)j047ZyM1i&Ca{$!B#bUc^D z@jCw4lfilYjVEynE*~!uPEGJ_;1$Hh9*2{xu!3Y@V^C}p_Dwec-QC=H{vN>5WcOxk zUdCxAIl}K`U1}}%mEKAU!~~cxhZzWbf8OSt;-q)K02%7T4>Q|TJ7>Bn6fm<)Ca1;O z)>B2dD3x;$o~f4Ayo}E<`|9&+M4^(Re>Rh_{NY5NrTB^k|C+R$dfgXz4StFF)HYR0 z{lPb0FS7SYsNU>oRnQH23DNTceVsE@o`dUi)%;shp=^FvH>aFTG6V-ErOk!Xt#x=vSXs9gwWP0`poIwTN2l1(}x;>Y_ZbVBLPz}9N*BztP zxS4W1B44K5y!zeqSshKlyZ4r~lAc&S=()Iv6G%WLoAL_&Mg&HsPSyrGsXcBdsuP_YSe0~n#_z<3+diz zg`#BnC13*wi|yT7=s=Br$!$auQZChM5Xs|Pv5Of=27TE8-e|x-y1%}@5S5m;-vXzqS*pamE6Aa1|yPgOvP2%MCxq2=JV1K)u1od^n4yj$ji2pTcaoMZtYb3b=n6j!Ps>muD^5Q zc+yA3-n%a1vRfK9lpqvMa;d~CBbufB!VlIFTON(Bd>*XhlN9M= z+?q@>_L)SB$LFVan|uUxwd}WDGRzCxAJDC*$~vbWSP3;W`?p%r=(9i z24pi*yZX%8O#P07pIKHB&f>trr_K*h9&RMXJL(pg7O=D8iR4Yqb2M0Z2!*+*Y#iQR7C}kK_3=Y#24-vUJ)~~ierrolh^hX%^)@Wyx=}DXQRYMX} zS9*pt4iJu#OZE`2Cd@T{E*{+8xagz=OC1{-GsmBAFRG8Eeo#1aSGHQZ&o1(;i?qaYHBzov~$U;%-ljCjwvc%*k1BAg}B;&2o&2eQNw!4FJtqW=`24hZxn<$8`=HuEvCE%mFR+q zWF%o?3O`Kb$VXS#;hi$?SL5>jX_&GRK2kpMa?r1GJqr}s4iSvr(Z}xbWR2w=;|&F# zD+;ZSB)?n3eQgD_PJOr>D*PWUF1k`e#1C}%7E_#v&@9FeL<%_zLAzcSU6fzs^LBNi{KU#F}lrO)y<)`^OlV3d^LUw%)Gc$BowJar~rIRkabG%zpSZ~N+dzV zHeIWeJKd+_UbQ*;(p-GW`c$kaN5OQ~@qop@+z^Z1BU0~fV1Z1xs_fr3Hw=$K2_GH% z1ug?i#XlV+>Mc+FOPWeeyqGeB#GgV5Y5z+^=g`W%`g~d0sJ!KGEeKJt_7-%R=`Pd&xAhEBWQJp#O%i@XyX3 zH^`Z&&U#}voUJt7Naa&~hfwfwc;yK}9XI$6(PM@`PdUL%O|kd2n0NurO+@~Er2qth z1ZwT7&_z<8%GCd4{TD)*m}jkEqZoWH{;zJ^Eu#<6IyQ1lTHZoZ^$M6iJ~v`@Roj5( z&+KL^JCZaem@+V=Ck+0*&LDIpk{Lf4FS$LNmVDs21)P+jBcOTSFEB{xH3b3wR{n!V3UK+O6hvsmnn^dFzQrX+@4Q>BOx}(8Bm*af# zNi7`CimLlxDM&2&;15q0MUCBF=g)adQmvmHIQH;`txPY(jABBWjX{Cm|E?_5S!ct& zTCFa>=KnV!LP^`K=U$PLV`+7T9YffW`@H|L0H51<5#eLHl0@}n^Z&{A%?4kly9NGl zeQYu;M+wRt@zLMU%>SODz~BUoXwi{wwb=a=?)h9so5||Mw%MDUm6DXEqGUi`3Q&zAtq3 zFy2pvd%9}|51IeyA#zF~spQ9AzrjY?Ij&d58lpsOzb3fI9V5 z3nm%hA&l)}26X8B>MLQqHTFC{i{pNZJy9ZS+VU?l+XWsCu~732oI)7(maQr6vp;QK z-wKY|j9;N6dO#a4%GXoBUdBu)+dJ77Y)j*N>-S( zt1}1#mRBN2DUtA$H{Ma91W$?%SJHfEK%9V$L;d}_r*E6a@Wsbf!E3aJjd<Q-0GyJ6tg48nH@#)A>(k z{|-1q&+~vFM9J%+rdkB$Twl1>-fK=X_L`hLbwAX^mm8BOQmrri0N#Dx4I09*n-`;p z_k=DDJKj4e6T7Wg9v=~ShPq0$&Y3S7^g5{Q!h^s(zHXBQ_Qx!{u8j9U&L@HR6CF77 zEuMcTjJI9O?#O@!o7eB25OB@3wHaQ|PDd8siKlxiHUHmxp<+RxZ#(|qi~D0Vfo3m%ej@t0DvWxQ5MpupN)nsUkhCw_3Js}!x3#|i zmsYkIy7&6Enayi^Sq|Z|;R+;##MY^QtnjbR=_yKJy*O`*1G*Q=>E{%BJ^D(9$X`fX zlq&|b+4u8OFwCk2-LYL#{bzlBH=avpcAh`1aR2zcsx6G;73h@8`LBq1I6v$HNp-R4 z#2!lDABsOo*ZVmil?Uz$t+${K6kichWeF1xZ4xF`f9Lt}uW^|)qlor_@C!YxyN9Z1>}n} zU1D|oZY=e-(j-xA#_uENDI`IIaTtO(F|jr%}YD8n2=ovy8T5DW9s|M*uGWfx6O??sUN zHIPf7P~SQWta0CQu65vR*euJbFX@sopU1WsKbypxS4EsHd`|q%=0@JgFnU;n^o4$- znfi;Pd-8_4Oe=JNS4UhPn+YMwM?^qFyf;Hp*8 zurX1Se|y>SlAhjy^{{3BDqf<+(}};H7%MhK^D%kaJlKjMNYo)+r#7JJHzuhR{$nD? z`dKts4)9vZ0{3068FjM?*a{^FpsE)qycn6xAlYt#%kVE#p#g)0K&|`#*7=d!n`JtU zCAz4#=V9(2xx_=cW%Wa$TPf*$G5n{<6{Ewz`K66B+ch%Vnh(wYy+G%J@25;Kc*Yx$!vW2>I}d_dQ7RWFx05qjY7=U!gH4!ZGgjg7fzv{w|$3 zf4u~|aH@}DD)loP>iKO}U`|@7V#l z#eW%2ju4cf7BV<2!Dm1l*!{^&gEMiX{sG_xD|diDF&il4Tozb7$+FUet2ascOtgT; zx{>Q$RMbx|yb@F{O}y3pL#Gl`E&ThSk%YA03Aw3L@u>uc_OZ_5fbgwlu(4rwYAc%F zws;`qMd~0n=Z{75PtI9rBDB%FF|th}{@1i50=Cl6k7pbiBYh)hEEzNg897_9KC+GW zOFO*`mHUspyR^?<-?|g+{rhK#1>~9@>*A5S(bXUkun?1s*Gf;^%2Lyy8u`ml`)@K9 zf=@L!+cfU{)m3@0+*>5*<4@inE(j~jQ=}LZEsD~v0wrL@^n+xH>Ji+%kCnIi4WEuW z@)$Ipv9sCXZt^Yzo~~F~?D`?2K%oLg%@9vDM_3hlD5$x#AgT>6Z111^g|!YkS9gYc z*K}?fB`AnLCAbG@Xt!-K{l%wiBdi)PO)Q-bwcWqnHC3E#)a;|9U|2^&U)N>eFsLLw zB=3R%LrMg=FiGy-j+z?}%*+$U0icfXcj$oFy6DK<-lRlTrKfr!CfiA++9@^ctTL=`5Tu&p8sLFEh2la=tk6~PkKs(z^~dPInAcFg zWwWmMT07!3;M-)BE`K$|{RVLN=Ua|~RTVA;vyH2w5AmLyi}7FYS6s^d7h(MAO4`Ht z2#>HN?MA``q>kc1#Lio!w%|1_lc#ClbUu2km{PZdP$JAt93dgyi$#h?1i7-<#BpMac6d9tumS1z|>JqAOo zWCUC5x0Sw|NhC3r@HGD_hYu0ShN~I!`y5#*(#<+%hH4wxecObxLv$7lCmZna3q{S& zMNpmXiJ2j)o7q(d(Z?_J7Ahk%PsmJiJXp6SbEsnBc#_F;rB>++TTBR}ysjnYoUH+G zBLcA_M<;~SzV!kZv-DtWBrn<+C`>Tm`{R7>>?@XVJ4!y7MH*68^n?FyT3cqkX03#U znN6BBszk}mu(3MIBOL~>8@dKAoNt_g4#}$6)iyMKxm@O0%ZdK(0tFBfQP1*=E|KQ&yye`AT`!kC#C5)4Ddml^bzo`Xdgb22CRHPEdK_)zrqs zp#hxtNU2KDX|`_V&x4vcWRvAEtW#aIG@}pLZ@Z(~^07#x#Y2@I`+B#qNzq&*H)5#S z^7_TsKqTo?wu2C(F~^4D?y1wS6Wd-@oAZbWmgdZu&4d-BXMii*-@KTnCcZ4->?>|v zY*E#*3OJ!pGwHw040-YHTzmsk6zsLLTx>^|Vv{h^eqNaAq%5x|@#iH+ze9>@C`RTF z42RWbTI*iLP%`c7y4K8{BpDFt(fbLNTyy|*?dA^Pwk;do#L?Ps2L1kcOd6X7DL-cD z(j_emmYey70=G;!E8ZIgAs_Q!db?b9HMOzdEG2pvQuVwy&iQ1jGNmVC4TV)W7FNH;u6WMR zc^@x`td27HeJTC8C~KKx5d)$ zRMe#Pc&!=_*ZH#>@!@BOmmGx*d)@uZ+K$LcqHd0%seR%q%zw6b@cH6@v&<~rh>*0+ znj3FzS3H6}R&SLy(C4(2Kp|s2>2wJwh+t!My^+~m{Cf6aS_R~Ud(+2e3wYa!S@cVd z`Bb~f7Uk`t_d2k99!JkK5-)MXrtZ(0W!?9S(STMKm3EJwcla9h;YZ`@dk7O2Zs^IR z@@mvz$M38ELY$&h`B$_qgL=Q8i`(W^gxQBWy@Uk?DbtH{CB=}{0T3*KArt~<8@cLH z_jMd4k_=}+4CNJy==8lpOD|NLo``W%JCm|V_tOFmYNnzhJvu0vpq=oK^`QH?pft^4 zyTZGKz$&zrm**<-QP#M}_V?kcSAxgfy4PikH8ep_TeTZ66g`SP&OTBFuk_X^iIJLd_-Nrl z1RQqGGpaKv&$u!Di>i2gvRs5HX^7Dh=V1$#7>wjaa%AybG{#kkA+RQ0V{rMuH9ojE2WY z#w9&M1FHMjOh=zqdG~3ekAqi-RwO2&WSI1Rb2P=@4Br#Z_IH^b1 zaPq6@72}!8CnfK=$VH2ZACL;I0tAgR)n**#`iwS(;JKcyfZa5s3lq#X|IfwVpxJG4O<Ufcz}}hkten+>34CM_pKyYafe6x}* zWx+;O0|%;mNbDDg0jH+lCwiiiVkx;oP8O=6t=xfU#QSX8_U}rW(kwu`x^qR-w@7W% znAGqewJqbPT3JUy0uZyMhMs7pTHpcUo#~1)U1F{XK@9 z2hN{gT1)q__p(9MRo~AT?hOH2UvkCa>qHFj=g3%-4*xRurX3XUpm8pA{(Ck`Y(5PM zee3j#D3^t+L`;wA7#n9qMBx3vtz=ky_F6=&kV=VLTSw_80cY9tIn8?VPRbdbgq5M# zKAAL81A-Z3vRot}D5}D1VfkaX|H-{_2XYS2n!K48#Uj5$FlmD6pLg{8{DP$=p|i6? zxr&5lAhe{3rQC?)M(YkQ!!UG{HOEbv8EF-ANd`8)hXrdc)4g4yBSRF^Ug39Bn+FSX z$4Tv1GnHCzO0MAH53>KLvcZ&OX+lx{U(L@(e$MbuRrGeWLH|UF`Inb3?;=vYg_;EC z3Y$p3xrjcxz$z(<&<547l$ZX=m*e{#qaB>sM4tZ!-Bef4R0a)hBCZF*1s4{N&jI7uAMNWmtjT^ zLxWNbf-Szi_bVu1{4FM6`4pti^{GGB8g3rD6x1xZyKg9pKg5URZy}V8&3t?kDw#dV z{Z4hT6}s@D`?l6_Gyy}Ct5QVNlosPZn5<#bcR_{-x8%hiDwjf)A!)U$h5B{(sNmxn#_sxFLbnw^1c5n5d|Jy7LOChq7F22GJK8B&T z$S`0090B0Yr+QWIe=oE#=_vBSy2hM{1Kx_=(if8x zM&RC+w+$t`3B2bz7ob26+x4&zc6%;pWnk0Zd-cF>~YMcmf$`X z3gwKRu>ysSxx^`=o${*(f7W{J|LE5G9NTEtWhGSr<3z>Gadm^>GajL+Ad{Unk!C5Q z=9)oJ?jdBq=1il@k8?No$yw;|Z-RIjxJ};{m^L{?D_r%GAhZaa=XCQ6yPsqr+~1gM zs*1F9=XsEy@E@)qpS7Er0+`e~dWQA>#W+$!LC!i`esk8wyo@lAwjT~O9f5tJR+`%h z(oj>OR873XSUhX@dQNrRsYtsF9$fE=p(*jB&x*!Y^`jk(4}R6r4F$k3<3V1!PzK+2 zThFKN^y1a+i(ZfN&sYe79o8CFE|F9R*017wUb%yv?>zH@muX=v>NouY!!Tqv<3#I& zBqB)JDw$4YgX_m^b9to-lnVhJe~XXU${2<&5((2sw8a-G6x7`o3n$*l9{sRws>uay z>cMPth&ez_-d?IEtX0aG-D~B3M-zb_TE*IA%*2eJF^3ztarwU6H>c`;ZjE{2P2gL0 z;47*0C+XMalk+Lns%wmbVfWnOWobcQrAVyp_+E*T*bO8G76hTECsjAfJux5mm1+)3OUogm2BP-KTWGFQ(sXU4({smkBZQX&!FLb^`%kR`XHc zHR3FXZu(g{ypMi>+Fu+r@>mZ@9Nsqg+$A^v!NeXJDWkO#S~!p?)a^<}=Q=r{_S<)J zYB+F7)!)r(FnJvIb7jGJtJmDiO9x}IQzksrYnND3Da~doMW$Z?>^DJLbx7w)baX%5 zG+9k6UR7aV8-;A1>!zt^!jhUM#yvhwQQhyqQYsrdB_A4aGrYDU08rkdfOItWPc3TF zqY^w&EvK^4G&xA{SBuJ{6gz#kAbV;L(h4w?E*?!N|CrFb1*F~f&k@@5t20^rwF_Ys zcex^@)3E2FMUSW&oj@$1Uov$^`h4jL(2CJR<`YM&mFNW@@E@5Ear}HMvGkc5@<0(A z?k)CKtf(!0gRPqD6n`ra{hEU#i}_5=kw9?C*3+|Qn%oNoTH(;yOiwg2}{*K zc$x9Uw#fKx{z2ZCTL;pa)!6L$<0hz~c!0}(pse5l$zTy2C>JAL67at4A>_svPx zPYfBL#4V2R$4Lhr%gKpWOkUq=oYugfF|kDnN|gk1DcvVN$yO_VTA2h_nSh7`cdaDN z20k2BK0Gl%KQzpdTvgH;bcX$e8v&jE`qnMW z&`oBUwc4I$3kDZmDef}Sf(w;XV_?((^d)NE8or{zm4A0uJ|N;w5K~+$5{mX zsWT_{AtAPOssR@+(i~X&u@s9&P?YBM?C-$Nmi&w=8fMk(kI7kUR7dc#v;e>Z}>isEZ*LW)`ByS|SJ@~B9mXC>LL{Y;5hsXftnslExTT~|)i zdH9jjp1FPdX2xXX(5~$bX%P}P18=|mv)vqK9zc=L8m9wDIH#_7v59D>sdZzOoMmPC zQtmU1p^! zIij>QsF2Z-vNO>`TK;&uKcY6#U?ltY9J(Ri80&K0Q)Nl?e>+fY~7(A*(S+f5)+u`GerCq1(`bZQMeN z=(&k~5+9D>%wQ%w;bL!NG9rDa0CkJ#(BoH-kOGVLxldLQRsY*r`u}6=t)rTL-|%q| z1wjD?kp>kIBt;qt5rsD*EuD&V_eN|WN=PXU!YJwP?vfliQkqR^7`?%MFTl_D`~BnR zIl?)dvsXNOo;$Aly02Ri;Wp!Fgv+%ZbN$Z-GFg-`WmduOe)|0IGg|-YXKC{WG*8BD zdYervhI9|=ID=|d=pD_q=(!vv36Sl(5x0JCVddxdW9{suf651VpPo{^Ve&MM1G&~Z zZ&rlZL!MM<7MQPp{%M>4fNOc7>m<@PH)mt!gJ33KNakj_iB0D(rOu=BgE#lx>dfCr zp3M$tsC4+>UO-G1*F5CCRa1*%P5oO~PJwe?2Wf+MX!)kkhC$sqd`_`yHokaEoIQm; z<&XW?zVK$P0;eTQ zJ0$b)#8o{dL}*IItMGzTNESDb#Fxx1elIu}TcB5!iSy-pZ(RPV7$H?6v{3V`Y<^DO zTsiR_30A=&MRK}irxkvmF5^_d;$x|N>e;FH`iiD)gKO8*lbaRW-zDO4CVL-+DQrT& zyQl9JDIM{yDv?pcedxs{K@berkCY~_U9FpE!u;@*PfXEqb{_{d6n#!xIi)SHc|qQ< zwQW2%-(|o1(k5Usl8pEnZP&&*%Pcsv5h`!FUk ze%E|@jiD4rsJfgZOvEnItm%EXnMX+?F<@s?|EO|pDC+Nh6pYlX8XINN%;+w0cI>*` z49?^sGD0NIbHc^w&$s_}r|^mom20DV%_7deQ|auJXAUCd4!zv}+I;9VTN(N8gYK}~ z(>j~Bd%r3@8>K&4{v}^>tSK#=&Mhba`|!tCMJeNIo6&UI6%Ut*7p-P2poDq1K0aM| z`Mf>-Ei_!{{6}r=*#NqjT2}BxR@~vkPGO|5PYRALSp=J&@H$40Nk3lt4}OW9?|@x! z!Fb-sx&I&=7VgY=@Kq1-?beH0<@_~T{$d9WEq}F8i)QoZ16oczdanz&vu?VEpDpzx zOg6XqToTO>Eur5WmRg0B0=Z8ZnFw;!)@{yxGM2dHHWaU|B@h&NA5e%rA$ECpFV8ea zr0e_O8h?e4V?uxVpaa|uLw}m0Y1Hs(Pjm8Sj9QjTYi)FI%hpo&G&k7%|D~H7g?U^XyJ4DNgr9Tddu_UOgI4 zKb5h$WtcyUvBv=UMPe-zNgdbb{(P~dw@01l+Ff%193Am$F;T$B)!k2DSb**^Ehx4Z?11B1Kx-cc9otL$ioiIQroE-p!4h z`jK;mqP*k{(R&w5l64t|@Ma+4z^2qXF=`FV`T zV2n(+|4?tX+@{Jv&9dXn!Z+azImTu}0DYDar|3v<1-x{RERS-#z*KYuo(AgXQ_U{W z!G4yV7q87s>^(+qOX5uES>nhj-12s9Txc>V_>a`&OsGSe_W_0t>wIP$*i`$mg;bmA z1JD*saGTshFw?k+rSBUfSMvtAvo?E}!gLX~TDiax)Z*niNuuMk zLQ025*V_rWkqYGjL<4^US<3vqX#-6I=NJiFk1FcrBDN4hTsUKjhV(pGGyB?l_;=li zJYw4KKg`~h4Ho?*@Z+(KKXMX=y+vYu);mhOL^lb{sGrW` z!Xx&`k|h~rvBZs5`-mn6M%At^B4sTGDWu;XWanaQm#F7vBwgb9e-W1Wc+~2$bIee5 zK@U*cOSSVrUes*!fiDyLTB-1Hf3yH+rwTCAcP-UT(FK>IyVRpw^}AZ~jPOC%{43|a-W;E$dgBxx?;UQ`R)cD< z`l=dMzT~lFn*F&uzhHLlJ!9`%7HU zZ;BOePx|dlXycj`pWv4LJSt}Pj`N=vcn&fMT7$a#8<{1}x}*o0+MsVdmm`Sg9Fcj{ zao#*@4o<5%I3h)3y^;OICyZ6Jin@{(w;G?cx<4xJ##Z-9Z&x&p3PsuRLi*OkX!;<- z*2lAV(b7${u=j9wt^wi=c2JhEnyW6J<*gqO57u#9f?2Wlvl2rt46dZ1fXf z*Ke!c1PY01C*+LH@8@6_SsOh%FsKx2kgU-;2NnNb`IctzCt$K^-$)H%asc9|B+8Bd~c_E+qt*O#+sezi(;dxA~>HJx4+>~ zwYh>__m4?P=CfVrBzFfRakVSs-BOdIWt&s(k~r~K&&e9Njibdd>EWuUCll{y*hm2C zefL6u*fDl-o0*fwQ>itLiY0Vr($z@!wH(}r*>S=Y(v$gk??u&`6T|pN$W+?x!*Aso zlGb3=Ug;s+Y{KgyNDD`0vU~ok!~81at+?+)5bP|C6zsNSQ9^5Mc>KHw6csSPhdpUO zVL1W0ooAwpEmkcICK#(AJI{c{`)=cc=^I?K;@%Xc>L`DR61xGcR60>GDv640Qu=F^ zXGU-JxXlY96BUmMI7H5HT<^cT<>?ZT*I$qlbR8#e8hDuwu+AzPirWMFnvYzJFp@0= zZV)=bn)Fq&-p2dnuDV9fbpGY@pPH^Cu>PCHts+g&il=JsQf_a-x#rLwrv0%cR3E{n zg7LU?D&vo#G$}mQ`s#wH_AJU`#+d{@F3gUVRKVMDtzCDb3L>#R)j<><`63au7vGl8 zy(|dCar6PmCWu2CJk&p{@_2LFm5r}0B~G{*YfkzSZd`SM#BA$oJO7?J@h8qdM7z0H z`dc6&61gjAnKBAtBzKeXD;RmaFjPSiJB{EPbWbdFt}=#w14*Voyoa2_9-A@G!m9_@ zYT*$rEmvIz z*EF9UMhvv-J{~`)ZXWhN5rBRv!wPM9PQriXC;C$~GoT?dY)pecZ~J_<(egKk&}r>; zj5-^vMjn0x2mnn3>mOesG4_UpI#O;1b2q6CWtHrlJ<$Jnh|xPaE@Y0XCmWya&DOQ{ zq+h@CpnmWyfHu5pjrW@6ENP!b#0zSSAvpDlaVzu}{hT`Xo=*#MzfAOx$b^Wm1@*lx zLkzwXtLKxQCGFI4Iw3({rP=8Q(t(G#8AP56V>U?|)7IfX5?-Y<1oh*r@4TXN&5rCF zz@;(=EEnY!mx_`JRIx|DO^U)ZzyBYo#svu*$v=5=V7xZ=f$XX3b9TfKp0JY*?YiN6 zBNa+gBgw@7!OG%QT1+ISP9gyTul$u4$}O&l{XPSp3;caa^ETbZIf2hBA~n>T)ce8B z9nf42b{vxlwS||J)Eeot90Eo$3<`SKd1|9H{e2!o(Ly!&jXmhXve|FiF!qq(YM zB=aVAa!VE60$|FHb{@uYfU~Uwp;K2sp|V6g1*WDrIakHCfkdgHl&@tufhviSlA!3n zPpS`4W%Baz-j-l^&`P>{@K)uDgub>vEMdOuWSHtHer@mw&xKJQxZd7p!fZkJSc0YA zAB2G#emq<;+(9AaYfetRbc+QWo`v%{{}dL$?Tk zVSd1TKf&@*c>lSz12MUF%joN&F*!U*K)3M5+d>IJ))copa4%ot z&xoxeg%kf3#fWXpUjEVYYZk((r=RikYo7nfBux6z5l-a#A8ajB+FMEOwHIX5Tiu;&dp!m8ux~O z9Nl_9se76 z1$DLdr=;`t+Iey9q}=rSq(!L6e?;GbjvAoeVPgq&cb5y7Zy1~>L=*nM`*Rwh&avG1 zewvdR6~Kwpo#Q|YmW2IVXrUr#H2746s8_Vao?zWtRo>U93$z@6lz&Rt!KY{&$a(xf zEWo@lyr(rzfAPmPw)A0T(udfJS%mMUa9?cfq1zNM-pMn4UDqYyB@2$8_& z$0ccBf6tWfO`EMIxmE1t1G68_w#lXOt}0@cGsL8HNv>})w5!wCpepTue zBKS>5PH%$Ekp+0Gkk;)(2hh&*>GAc8YKW!dzrFVm{<$Ai>k)odC(2q``!&)oEK#se zLICq~R)anXL~+&7qFH~old{~6JKGe&apSgj9+Iu(ILtEn{$loK^#qh(P!(V0d|Sik zA2o#VYv!+JDGQ+txoVFyvTA%fmuncW%5UrJ)%Q=r&gz6fh_B`NzzPbUx07GH>`vjx z#xl2NDibIVpyENJW*Je)2G7z?PC9%-D5;YbdKtgmxZrKfCf@LJs^bvwKS!lM zZ_nP&N068oAFOk_0xpNX>`iwEw<%0JraMxEXnYxcYLCS2qJFk^oNx^-6hGv(a|^H( ziAfv+iE=Qg1I(z@fmW+48(J$Y;$Vj^QNFjis3rNYlS{%37}!MDo7-kJesRIUT%dQR z()CWT1=-UuNiAET&B#1kJ$Ia6|DZkhJur4IN$$%0I~#6+=lQNT5a|&ApG#>baY#_~ zGA>sOwdVG2-Ze>?6_8<8uvEHlP+JDtLu!c7t)506+OtFy3<`;XhMZ?cwxLan6O%Kd|^5#2LIvejv zZrZ2UZlBi*`9guq?dqzPds&Xuy}|jbGF7l#S%JnTi!^?dxnlW{J{@Z257T+ARfbMGoqDyloa?Y#?60`%oTO1w(1O+}g_13e33`Bz1 zg^5I;R)+&ZSm(8O(b*+8anhASX$p?J_&1CG=(Pv8U6JUE$&+MSD}YDecyZZeqPzhv zA&mG*8o?p4)SW>R@wkV0n}Y6~Y2g^kQYZ5PEI`UkY2MiK7HdUUsrdk2zYvgy5{iXx z>7MV5CO6 zB0+`IP4ER$ogn+bd_3og`wSrY8J@oPc!AhfE9b*+^+XldEy3_fCb@(##(wtvPW9ci zPs>^))??FkviEHZX--b+FjM@RWjR24RH_2dxENCjka+&-{zyDiqKkePx8yNkhVYqq zdaI#n)uM!M;UK=&o>C!pY@VRcn}xVwdDX-Pmf@dtgWJKXBU?q%;aJji`{_CTL^)Vt zIB`#F)5{q)zsNng`gxbuh|;N5dTZlFJmw}7F=&-Im2uV@2=9~5 zp7FOyBm-lrCxH@O1{uPsfhZnVY~)6EX(A9~YNWib@BGjrl7E zofmhqJ+w@9S@TK({IU3dlxV(Df|}r-7(6`{@k=p$HJh~{LTX@{^WVt})eH@*4qiNG zZof{xJsAM_xXE}i#Cw8IFGGuzAwbkQx76pT5K6WYTtFGHLG3^kkm-+ z9CCF{@)__ShSw9pZuRm+xegs*wX_PyTzbia>$&!HDuoWofra_4mq5TB`%AxFy7I`B7zoOseu4ok+)aX(R1yB^JVsBO1|6{OPyS zpXo*vdf4(fjBmqAO$n3Tw+;$kW_U~MROS3KoU>Ok09ZX2#a|gC)UgAf7s#enavi{U zrLWIzVf$*Y-f1bxuM8MLN~=I&(=zUYFWfRNFZ( z`qZ>DBB>Jl>_aG?h_S6Dc3~umdiHz)UZ}#;(7=Cfw&@sQmA{mC*&uEc$psB^75=6n zAowQ5(9uYDH&C#Ne|oY>=1sYA0s*@5&NAwQfyjTdIRR@UODT>*jIlr8!{}@GhF{-*Znw{OxdF zqm+FNVH-jxwQZ!(z!XEopbmBbC9nm~`#gfBXHJ=I{GQ`_UPxZJq{0`GR?q3_YF%w} zQbYT(O`t)7!SG~^5#5}+vX@&9MNst9z4=>73A4k&g>)OeT6)>pd5_iYxg7dUO@Gbi z@)eY>TU0iZ5p0!fH)DEcpTMc@zin=qt+&00HspGkdhz}7#lVCo5+O%X^#kX%mU}M0 zMP{)b_4fvA&st~b_ylI8LEEpiB3$${KmPe_F@5G@r?tJ+a`;8hr_y7NXH-f{ddNj5 ztFAU(V;j++f?a!ZZcH=yzB3UOrs7vTV>;R1Ofe8(2xWfmleU3wPqA>@zCLsKvOcy8 z`B)l_t-_hv2_JfZY)Y(Cdo9#Tk!X^2flfYZK)dM0dQyA7v3%#THHXSArGc@@P+0CR zDX8E;pK#YUIQeTZT{Epfw{yPsj0feXT1AbEG{O3ci*5Kr5T}T2SxRnsWlfFBuTeQ? zO?5UNwAL5$0WX$k1W*+kmgrJ&)Ywhi6^clMM?dlTk=~L}ujaAm@gLeUBm!f*Gn zIb(rOB+S&T=*P~+m{H$(qD=wYk>dW(f@bW_aG%R9zk-4KR3UGIF9d(`%zk@SeStzq zxG|N9;>cZo5%*@?>)ymSDa;=0dZtg^r}-8#_3b%@)@Yx)9Y(K9!Ojy$AiiD6gWk9- zCxK)2X3qc*-NCeBct(IvoqKCs*Dq`_NmXCdn$XFKmB>~D?gk=ZbGj{5-+@y|OT3!_ zA9?2R5mNxkP&pU1)@hx-QLDlJ!^doY^J5N2QL^#%v7Gfxgjk?<^JBW%5g<<0OvH=- zK?DN2rs2Gat_^!XknepPfmhsINl3!Gv8WSAnj=*axgMh^9au#T>#X31onSXC zU?N>i@B)0_yb8`ZoP&=^#(C8AVgP_J`*mwW?I%_h1Jz(J@@AZcHetfQ&dLgVUy<#17#W!*BU8>%C1PN)6s(LDSq!E8z1?L_5^( z_!CshZIsd&uVmP;^j$9Mx7BiN>27~E)ZKM8iZUb!WaLpOnWa?ZU*e-%zpzz#EA%_u z0@gQO={>tYAq8_9?Y1>II=Q<+yvA-eVzU|d_Ri5@v)MFfJsaK+Mw=MD1L#SQIgMMZ z7|~$CWSt4EEA;piwvXPz4zq554SbIiAq8!wsgFG{Kuz9vh$tJoJG&XVc%Z5c^|apk z>rxsae?qx@i11Rfx^5;@nFh?o((+1gZ3niI=2`}w#M-XRETCnwp)JxpzW*JBM(V(- zBafuvbE_JLCQ@Ox<_C)m5)6W(KR@}mJ>&scnle?xRfqq>0xs1OtOj#`Ny}gr+J$c9 z4v^%kzrQ0wk7r`8WJ8TzMHe(to8zO*=3gACwGZA^3?$nk`w@Z=r@K8=)Tf%pSC>v{ zi>vr)issJYzNo-xdju9z`dll?*@;}53s=GnH)*fU?Tw!JwkD@K&@Z~DoOZx+p#R2v$f&<|UL)s`e5M~Br@L>0I5(K)YJ z^|%erjKhH(cn$Q*Up|_yP0Y!OlPln!d9(L*nrJ#rrB9*?w%2t&lP=LN7ZQ^##M5uk zsA!4)WXmSWzD%tp2EUUgx2`Y|>j*}hoU#7pK=@=l?(M?(uDK~DXgLT$^w>aM( zo2r(a|3N)<*et?x+%{!G@UlKT#RvAp6pQ{M^tnK{YW-vpE+svyQ(;p~6;N=Bwg8;p7Pfs z^wfT)vyWEyOtO$&0-c{-kL#V?VwWteMC?^Ylc(=T8R}Mx7zz9T)uiVPI6BMvb89ZZ zBYVK|~*HEt(S?>djDD;ci;X(KG3D3-5lSli(*{dCD8AfDD8lavgK15~>LT|aX z!QyTl&}Rvp^U8ktjCa`|55<1>P86;{BZt~Hj6}RhfiAT1Iu>drNE0UD2NP7pr@k&0 zbP}E(bI`~PWZcY4Rxh|!!8JwlQkbMRU^+=+V{};}{m;6>1|M!+@OdA?X#|Wiz6&`|(+j^b_<~cc;UYp?8b?t|LZLlltrR zbzO}oR)FqCQ;{ctBpYjx!d|LG0@vM}{D~~;G0Rmimrp(MG5)Sp#=#-@3)9+LQ$&6g zdgcsIS>U`6mWs%Cwz~s2tOp-hmf9>{p(+`O@qVjlIPV`VV5SWX>w|vog|Us(RJIh^ z&&i>eG6?x{eY=yY0LW6=*;jsRkc;blXwcB?$8Ru)BN|yK14wP`&6vV7);VBP+`^zIt`>esh-wG-$lXECB~hhr4KKG1X!$r zdwpF}(2evFP~1OAS(GA+bgN@2D1F z1jTuRZT}HocfI7?8xzvi?P?9=pT{{?97HO#e8uXdRvGx0=u>uDEc6Zh0qE9`q?l~A zObW)ZtL4$m&ZvAdnm7E)|CW+qO;MIa?(JUFgJ&A^cTH5S$A(#h^cDTs)@{E_cG2fO zw5!-yn$GpZyXbxa+DNj(nqT+@5WVIyz?x#I)i{TTCwng7DML4L^?bo#`BA!Y!7Sm! z(4d_^1Ew&E7v%87_CS;c{I3LI7=8r1jw1AMpXgf9(yLU7O81 zUG{vt&N8+soG_now07!pzk>fWgL$zQVvFYRyCz=V<70U$K^k9F?Y4Gu7gAf(k)$C~%o(St5%Sv<(VMJCq<(DYct;5_U?#Cm( zcNZqb0LhvBBS212dE@Q$3ZMYwd8>8o^Y)GS>N}Pk#kvFJO*H?2Lu1ls`<)zo^1h^U zY$!U3M8g3<+v;j%tjBu(aA01q(lne_(f~D~FG5}<=6WF- zeA*~He{j^y$k^DsVVMSVq45P`o1y<(dQs-%kxdg5c{^-GcCUb{@#uFW!*kk;jRQpK zLZF&(>m63NSN<1~VA76MFi76lbTuuVT@wDx>)8}gL5S?}2l^Pjr*nf*wbsx%(dXMU z{+QN=Vjg?ZpL&#}TjRiI{j=z1^K%KWlB@BbGR59VS{}}$%|$512UtrhnGsnV!5{pl z51+Lu)C6}Ou@5fxL)|HG+raf8!eVvC@r6b4yw<4kivkU_ntgq&N9Eyzb~B^%`&9zk zhy-$mHknX7|JjdJR(Sx*V!ab>8F_eBs9Ccf8uO+h=}-`ThsLG9VH2mjdby~H;fk^0 zykP*FECRq4-GL8}4hHcNJu1Lgk7VH%5T3aHdfic)r`#^V5&iS2n$n0|)Ul9~m(pc% z$xXxt%D0?P{;a0K8iXE1xd8~W&78yS z!hU=*IwHjCyTuAQF}KiNElPG0_UZri+w9Sy-i7WGUQFSolvtz0IpIAR^g8@E_^4bW zZ^x3uBfL_JSi8&gVWconv-$5S;8i*Rc-`ze%?H%a@QYi8#S3xH0pePzGK~1KFwY=q z2cL7&YQrIeYV6;*-@=E}F#EX^)N;{gkC2+E+S*;<=0BN%%S;1J1&@lYrOXF=BUNyM zS#w7hoh`C8CytbhM&ljrGPL;N98`H7`~RK?Es_51KaPmcFu2V(c`7E-Rkbhj`F@lM zXM~by20(|&yynAo9WawP?4;!(T~1;pMYDwPXIX~T=2MJ@3Lod5^S9O9wp?{`&6{ik zL=kn1y`zl=v_F)>DM^*Bqk$jaypH`@ph*v5dM)R`1TFBLY?IfI-9J@!dzme*FN`ta z$C}=JqbbAi{PLi;g8|e!KUqF%VR&p8fFjanm-FK_`1=(eJivq{q<9J#NL^#tZkX4Z zrNhs9Ms3!a6Pet#^i`{-MuurHxbvYeQ5@0cUMc_<4!-jrrCWXHud%`_<*Cek+&%pU z9p8EJ2(^6dy$y8hf;Lvv?7gy*4VTeRY5PUvnnV)t#Cgf`kqd~ME*DP{3LGB6cv(^Q z!Mh7J&|=Qij|AH;BMM#%A|;*MoDZ+PoXukG<>mqnssr}v8LVA`TfgP(r);ZVt8lEpPq4r<(zFJh|HGAkD)R`t%_ z5IGe;rep9)KR=aL+9)~L&3^xZ2y7SP^NGpF2dy^$UMC_O*)Tsj9Q76N%~=X5de^Nv z>O!ul3F$qQfJojxNlwU^ws79}Gcvs{dUw7B^R5EnZQ}dwSZU=Zr@}A&^_TgO%~;9P zz)Z*1)aPDF^9_~`#h7H z-nVWv$8mto#X*;Lz;QqLnQX{0UHqx4F{;P4{( zeQ;D2{h65m+0tcc=U3EX@$BSkl06vZIv|2=x8dTNkkZ*H@A-%9j`4SK4Q`Jq zu~Oql8?UOOr-L*zK}5yWS0m%bf5nvNOUx5G<+TFUL^pG1R=b*cnlf^tFS4T9={RE6 z_!Q5eA)rQVYWaZ@Iv}8TR8urcN!Q<+ps$zsjliL?3`@N%hpqdDyNRfeIL~}}d+FNm z^V6?n9%PI&U(P_9y8+IYZN1yxJ~F$c?Ong8i2C=Q7iK5d#+|lgF+O$eNWS3}i-Y%? zSBHIUj_8C%!!S#{-8DsPtB~=V+Qj3?vBmG%;e9jg|K5hRNUWu!VdN3wfY$B*=PlA( z6_gy^Y-1mHB)d4-gj1@zyk3j)`V_|n=DPl|k{uSi+#4Bn`0XM|fro5ve7|NbZ3mfZ z0}WWCP2POI)NN;+P`lsHJj2 z>>xTyfR@6=V$J1Wa&P7P#gU`NGi3bh|0iHzSnt+F%M-pa(+=MYU}4~d#R<2v7VG>E z3kbfMiivsiQQ@_}yea!dWYJ_5dA%3{1ihKLgurhhP!OSu@ynWsK~WaWucqJkDEcqL z02{KWzq}~S&2N7V5B#B9F!^Zp)(3zF;{#w_Ys0Cn8bw#-_e;V+G94+mjyQZQ&%;q| z4&u%gTjX)IyA>?+07zqeLBSd*kQh^vGNsG-V=S2%3sFBOfrV9>%HGg^_Thj#)0~O+ zXK);)^q`)V-SECqaWD|70d?d{+$Xz>@=;M#PyqGnfFicu3lw+53l=>M3b0;V9g8T}+MD6D&iCb9PKSuO zDLK*gww4#g$!aPa8pcEloXlj7)fJ+f3ILe#GGkuk?ey-4WLy5NvsnLYdx`Wz`nQtPNm-E7qtMZ zZK`9qr)(4L-Cu>@6;Z-gWYq4(11*T?kyB(UUPxo@`{-h?=>~_nQH~`4e;UIV6SQtEbM6vAe56`GpYz zpC`l%=bUdXU1oXBg3ULtdHsxQ#tq5X^7iJtw2z%=^M+sKm22X~EOZU0LJFU{C8~im z5ZIIFx*aP|hMtLkJx?omUAm`A=O4ISY9v{E}Ku{=YEMdHbyd|f*C8LKPaUc5{>i%{Z;*NnKI}^+rD_gMEg$c%`EJ*_0kge2wEC{cCLS< zmhg3mJ8W*v_Ql04PgzApj5VB$|9YC|(nH?CYrHpbYQ}*mZ7XhHx#O?)+ufCPm;3~` zXdu>`LtEd87`vWLmlWU(ID-S{^j6}^XF!+IYxTc9A_uN`RxQ%@UW&Opc!=d`dlgxs zGi$hebLG&w*9Scmw%95pc@h1PtgAztPg_)C*_rE+#H!Pp%wqbbCvAVT_8T_4>!1!uJ!W z2mFXsxefzuHa=ePL=+fvHN`0+!m~27daTsl5{XpVFb6%d?R$vSOnzWO@6RW@P%`=g zuSxf329=4A^Q@+A^eE{lMy{A@7;ApNCnjW1iQ@^li+I|E+@D=kUG>HD3NwVVS*&su zoD;Q@&7JNRtZ+EaIea72^L*(aC7^4FXU{j%`PtQ6dG5PE#+Q>gKZ07HWTdh!>a%O2 zSK_xTsOwy6IrP5#;pXCU4@_0mN6p2_9i%+6d@DRrCmE9M6h?(rqcdF-7#Q{c69{YXr&{CboOKR)}$;p zU`t#~F$NbRX$SOZL`n+pns6e|$~qf-b2~{Se3|fqdcmq2c3+T^kRqx}BfF>94J4u$ zSzW9DAiPOJZ&M=idPHK1sVF=0JPT$axXjXmhqU;}?%Lpb6O}lbo03T4hzBB8{uze0_R7RCbP2B&;5NMJxi&v0)luJ{bXSJjPnxM(9$XMXyj- zhYEKG;2TmNd7Iq1fq$**4i?n7rE_r*C>RSh#q}Bi%0i*j@Wt%_cmWXDa2&u#45&Pe z{xg6du3b()Nz?}px4Yr$)I2jL)YJLs(Kg;MFMLkGfLiqwHdWzr>Swn_WiM8Cx_zqn z#rAw*DBkFTlgZr|N9epq$b=N}E-$-(-)!qRno7ZoNe#q$pIlrzoBg6_-Y>JLS}w61 zy3u=9Zx|TUM5dP~L?o(gXa7Y97v#nD6_5}hA(95TIir!6o=i=282QSd^1@9Qw;LoW z2+b4phb4N95>Fm=1_xe!iDc-UwhUrGbVE-_;tw_nc8L%GmVUsQiPGGImNFb7^1hS;*Iq17Sgn5P%pV>C{;j3%PS9-a_8%WG5>)|AKw6DYf&e#B&rm3` zLRnv>5?Cs$B^mwhMS;OzV$LrT2pFORyZ!>|$z&s~a83V63v}fQd&j-S+$yZf+Kag? zR9G{u$3)}u)@j(u{HCP-xAJ1lz`@z{9kAVl-u#1^?x>!$tdkoA+ozpV0rpOSEN6)r z$11+TEQj~9W_Cg)=c>$;6bgWnl&hv3x$sl`_<+xz+w*lVt8J?(fAxTAv(!BW6Z z|Jy3Fcn4se-5DfxS%Jv_RPiUvDhzdg1#w_&hjw`lK6ZQF3R@o4e6139UtEUs>runk zeAuR6caouEMeS8n#XgU;y*A087vx`)KS}j$ND4Yk^7-A!ScQfBl@qD1{1GA?=%Vpl z)Zy28wGp^O_i>3tsklNhBz>Q~W2xvIFcb)mYz0R>JBFP65ER+ESlpS-&w4{)V3MWr zP=cb!ZL2zD>!*C95701!oxSY^z9Vgm=K$njRBrIXJudpSK3cNHz^mrzBlC~DZ-U}; z*(&|7Hba-#@B*uyDDdO{|A8V2U4|A^%@{t3{$l87XFpg;n|mgsTL_TsS{iC8;V$Fn z233fUuXc^dAhVjX{d@dkH!xc-IR@3&-94A(@7mzVT^8pD9Ae6ucER=`sTjS^f* zb$lucmvsIAJm1F63bd*Ptu?dZ+6dwG0tP+W)v^7KxIP4@N65S4&Xd93 z(`f??J-@Bjp<4im`SeKgmdTMg7u}5cC9mW_ zGf3iH4&J(j!w9iuAJqHYDVTyy1Qwg!J4TbCARK!lr2#Z9KhUMK+v`bXqd1wZ%lo}^ zNzJY9AD_h)0Lym4$$$O#Y zLa#Z|5{nQOZRV#YgR6{lDQCY@bdxWa#r!ar5 z&K`$0Y<*(nz9lr{y~QW*euDfh51Um0g_F$N;+M0xa5z+aY~5I`|9Em=?vcJDe#s$a z6<@Qc*K*(U7H+Z>Zl4v6Idc}uEuX_Z>0%=dsjBuHCA*X?-P`d*o!j1tp!qdxjBmc3 z9*iVk=DBb|{6Qrbr)kvbd=JkPGH&0-0!hVpeAOR)3#y)(d%OVbn7E?auT%OevUF_t9p%p1FqumK}9uU9cQ=O zz^=Vrefs?yZ!^uz@(*xC1D5Jr)x_@^qr#L#_}7_(pi{=evKmY1=;Q22=#>1=>6b{6 zbMT>@b*Nfjtj=tyaalu0d;9;e0EqDU?8ku(`AN|B4H2@H1Mf0x*@(I1zi9$`J_ix( zP2u&@HlIVtBIU2oYcdwS%VRjU>NfuEu``i;>xGzLtILq%xjMM>Ebf3-7TNTU>+lxf zY&6?fb=4WSH5*qkrX`i^r;7St8oIA?#iBHx0?*;-6eEfxH8Gdc+L0kxO%`c63+c;0r(vXZhN zQgX;u_%C-JiFc6HNswMx{r(AVAYL<26c**(heIAb`s0L)BvRU2*vll(lEGYfq{dnP z?Kna>(S37cQeUANlAOTo^!FFU0V5?K=Va{wxR2r&(J4nZKI()H@EiXH0o)BWG6jn) zDYRcy3c(62M8EN8ZKvuwjL4+5QJK7CK^Vezo%1s0fQ2bg*tm?Xc_dB9(Cn~oB_8*(Hp^9PZOYFW-g-o46;a%`n+NECjUDVgKDCY$d(q!R~qrWXh2hWMY^^gY0+ zpnskNMkUem(W6JtNhtd@3F0CtRr>fNZVSB0uT{Q7K3@AJZUggy^m?M6&7ET1LeHL) z;um~AW+%$)=$+`X6+E7zx^t4cl`oyf^`Ln3=8YTM5XLqqWM)%!N@N9fLO3|K;EBU<5uB zQMN=bBS3zzQfTyu`w@;%4DkeYZ&$jbUmMDlRaltgb#o0NBwDDZ4CL|>kxNU0cjr!) zUIL0u%@E0N*8|@H-hE*)wG|&YG{0={QO!?V;U3-%ak9$q>@^=g`-qv4;oe;NCigt( zB3~H*NI*cx24S{ldoUrp)y0p76jSFMcV!__H)rL6UHu||w5lVjkm->PaJ#^O0slZTGUDjaGdc1HLSLaS-O~Rc!1t7?|Cru%Y_n)9u9Jn)6K3G zOt+0o`_~i#`!rm_2fWZ=92b|5zAcvCaVXH^Apo*0*%ewl~EPM&$;DC)iLCEZ>Gm9)t#KRDARxMGjCsqCCC%}n;^d{mTW;c8yEmLxmf>`}vJpMs|&Bk59j zAz^lp%R->F1UTn8`+?z_2$9Zs$7$J5N3xRe8&x^em23Vr#niEbdX*2tFB+wg4yP`@ zeF&eAgBUiTZ%jiYsve0))Ok7K>)iY#YPSs2xVk?d+J4WK=(|sh{c+}Rx zV3M+Hlxr3A7+=pyNJ(e3V)&gu#u_LKSnpVme)~oUIMobgs8aMUKy5FH3ZZ&282W5` z^v85x>E-tK7f-ARMcxTzW0 zT#~${x1rdeR}LLfjruHjCCE832W~#sqe%h3?!e~X31bWapeVYr??2ssR$1j0T5S%$ z(vM0UGU)vE!te8Ho|NJ$gGmBgwj5fv^R54sv9)qR=R>MlsKLYv05}=~fa5q4DA97B z;4HQs@bWpguu!Z3QS^Pbs_R_j@0DB?*s97ROJ4ff`;odgSH(c_NpKs_Vz0#MIk}jYsPeDUHYcPg>jD-xdZ^G2VZ6EFo~muC z-L_OrxGY$k{GRpMTij~R-v39_b;ncvfB%e-oso5sD9WmkYu=*FxJ6c0_6qm9WV>YV znLVS(3<=qL@9gd3+M8=!?(eP7@9Pf_kH`CZzs7x?^*qn>I?13JJp54$v9+pcQYdpDzpm)X@)GnI+$tP|Q^_%P%kijX^Fsh8N^mY<~@TW{r9_ z%nU2Lm%yHMmvQgJYeQke2XOUL;HhK0qnjaQefvxBW(6SfxxI^ z3ceO1bkYyW^sl~0o?fc&(XvsthG?lEd%RZ}ve_#M?>iOG0^l_5*^%M9&tknsl!(L@ zkgF?p9LW}QCp-||R{R501D2X#>F+dt#u&T{aTnRkW9(3T9bd&uzNF1d5Wr&Rf?W2P zc~dQJx3|xg;W|-e;c^=`$1TPno=EU=PeT?-F-1_A{T9FfwNwm_Xhk!}TpEuX5vpqN znma<@u4zS_pCan7Yuk%eok#lpJ)PAJTW5{5zd{%Py?IGtq!>=IQ9tjO%+|Znk(PU` zc2VU;L=GH1uTFk;tqzJf%#2#qm#_|cwgGpxaW*u8m>PJQLY`E<3w(X(lD6s7n29YF zGG&p+yLg%+q@&Ayc}|< zbNWW9Ndry%KiKZv0^|zTQa-SL`}gknA-|>c8~2Qg8rhse?!2wL$Sj<5<&Q!a(m3KC%oGqW24XakkgEq9g*M?G zL99Lg;oA<^?-AQhH-65{2>UGtV2C3)_o@Uht7sr|xgeW8my_ymFkXH(ur!9h<9b4c zuvD=KVeo-NLPByGG@mAF>g#m0e`T{k?&;t|%jHEZ{=t0ziEk^j4J?xATF8W5GUb?S z?SU%N$oAVVC&HS=1toAoyI(_c7*UFD149i?c7{9Ru#7L)-@??|*Ktk4ok-sUIbG(N zv3(Lrj5wPQH{0RG8%~P!cP4-sQ7_pqaY-hA*g1PJM?lUNDVB)x1}{w2^oVE*o67hS z?dnqePrij++C@SdFPR_iM?Vvtvdj)w)$lFbWso@mx+|u*rCn-$Hx7R`WvRkCz7Q-j zwxBbtNto_#`)VQC-40PwN)(y*mIS(N|3|EK|Fql|%)l~_n7mchcEb`D^L$ctpg(zOi+rS@|u+9ha9PqM^Xef#tu5o?v zYjF-2KYo_av3#$_t3X?SWTz{mvpu|e=M%s(*8uz{_*MT%Q@0bmA2>Gs(v`whU!pcG zc_F~7VABzVpr;)g6zi~|V3)*v+> zVw@H~?wx9NbPH|&=l<$f{h8E+P=rCT%wqZ{#V;5Q+`}X6wHmKp23uh{GMFYW#*C`* z$xnEgax@5((BgbA_Q%PTLP!m9X!0i1I+C$pcD{*=^0)D1aTLbBqf^qX+N5q zxN=dsm*XD$LDJh+@9ttkCFikWj)r@eQjOy8CkeXWnajzs=6~YQzp}l~m z^Md_nc@}w6WlzBwfxvqv7dsbcxW0Oe82p5ijvFC4&BFNy<2%RGlB32)3Z2Il4RfTQ3z#pKYS<;#tv>=IVGt20=KZ8g$Mnbtx2m%u zcx`T;R6dvbCzCAcafhY&4?z$2X%RWFcO;Uh~uXLG9nd?PCZBo} z%tf(#?(Gxj zo;5@t=&A~P zuUDOWZq*rlag$~ZN`4k6oQX}k4;{=7Z2)BVj{+dy*_P=Kx|8Jqbpgg7U=J6mvLJ_k zK^yoI4WvmQZgCJ0rNTE_GfXS-xkJ(^@AlG106jAoq_(JV*tte1IZ<_gySu+Gpk02q zU#qFH1s_0Vd07u$`v!d+Spg(7fa2I0Pu6asg4PA59vdhWLa>KG*XM%@vR0aXn``%A zwnR9hv0Af(qOh+#Cwgwj?|)dpTf%e*vlVQBG5yg%9kAbTeTf)6W0(ga4IMD=h9B82 zUax$m^#gpIp1N_I=q7d)_6;x|bqzmBz^)%do=Z}u%Z4X3==Ceoz@1h0Fn*UJ%PUW} zg!&N)kF+A+RhRq*tR}1_G{~gUX#Y0ztOpR8ZX6CCc9G&lbMj{EAJzhm__J6Hsp7 zNeGyU3qYq-m58Z^5}?5Rl#|zCc&KlTG|xIZ-IwUv&8+o49UNk)#r2m)CSrKC+*a1Y zBwy}DLQXRn=0TiW8CJe)`Stu8kHYV9h;SUA>l+q*2lTbd>z&s6p9^rG(T$} zHOK;$IuGDB=;1K#q!YY6wv>36Kc^RmyT6t6xeq<{vsb1B#<7rTFW(^{wfz< z646y>?8|rm{O8Qf!T3^Xibt!Br5*S}v-}>y45)b8DrP<&)^2k5dK)~aSZgBSFo-Rt zyvsC20Q&x<^qjqZ{vzo~24r*Qwr@b(V8d~%dz^=`f0IrR#S*Xp;eT!mpllw2cnKNk zi2YIZz`BBfM9zoneGru=7+@4O?bK-rK$`cWr6rvX(#Ee?b1Zra!NVi1-d7jI0t6vj zxw{_Q|81N^qz$aF?~5T^G6Spz?sf-ss2VyGmMRM31z7|F$ViwF!Fz|XpSN32ZZpI% zz99#Hg)*PmG_rm0I!!mp>2(FK6~;8R$ffRgH4#8u$Gm+ky#MD@zH)>SbVr`bvwNMQ zF%WEqdTvC+Wzz+&kB@^;N15MqRmbts2lBlCKAycsHSJxG>(_0?i&zUh7lWL#eQ;dO zl`qZhzp?Z-`Y5r@Fl=Rt@^-s+Fl}ejr^{|N#6Dfcrsw<(R;{c0BAR^oYwaVB-MSwR z$K%)`BiE5dpDZ_d(-4MA&6d}2T62E7X9@|r@n5*4mA3!DK~&WOFS~Moc^BUfyE0T- zU*H-ygD!B6=H3!wHFxLRut&K%PBRS2p?y`4`9#Q354O0oY`7M232PC`1LFu`(!D3@ zd$RP!G~fA^wV#v{CtgJ5m!#h0AF((i32Jd^eDA33VOtdN0wm^2wlX)?$4|BG-_^YE zB$Rt6G8U>g{BmZx{?Yi*dYTy!RphiW-bp)*=4zum50ndDdc(rvP<)Ofl~3wPiLLi9 z{CRprQAxPI;5G4m$ldE%6)>xJ7MvoYP^YW-jKhKDLkmyAAkG~h<{+#pa*{1;^WF#;&LClD_sa>|3zY zvyU%*tU*4AwB}T*Hxyy)G%@fvj`KFzx?JQxB;)Re?niz~`F)k&z&ln{)KdD?pt!y4o`>;upmBs-!L z1l3<%Sp}wN zHY8b=>qi_^;MW5K7IT&FDJY=5oc@!EhWE#q5=Fm@8uqn3HoY3K(dcOy+*g0P%x)Ek zRS4!hiO@K5yvwmDEpCn^X5@q$MGZ*a{h*>9$ock${~q@z54-2Jh744p8Q$DOb4St5 zZGerLWWr~>C;Zqk>e3vjHT-?ldYq{x?jV=Jn;BE?}fd-yW^R6 zlyx$;C*n%n;>qi@nvItkC@h%9MFI3fa}=+R=M9 z2Fph-Q9GRMA(73B!lcXC(7qozs8ORIW-Gfl%Kx-4!lTek&%N7kfj7v)rGOAVT9|TV zJ)rpQ-DM_SLW+#=sQCLPX}8#NmtLzcWchR9_Ge+;3iGt4`Xs z+<18?8h5k!Tgz(Y+mlg6IqHfaes5vAacsW#0ZR}*ZPH$`^YsiFUXpZoe$9HJebb)*hot+TAQ|}hsvnE~ zn)v?hJ0mbpfg;1Nr^er@VVM#lT-+Wq>c4(ZA=DQ7sCUJqSA^=djr98P zO}dQ>{GsuCD47IS$)v^$#7T(JQ)E)#_e-_pCZvejU`t80-h=HSf*N0}3~zA0vIxOI!yS6X zZjp_alS3196;ZMAACSAx6H?sz`Jht%dUNG+*?besCHy^6MUIm*wW-`WqSIa5*Asjh z?S$ulUjO_VHjeI+vok$1;3K>G$_^t68kfhA%YLP|91vh*4|gHQQ8nb&Bst3v~ZJVr8a&;VvA1 zXNJCv&fshNYxSNB{#d|k6UyhzZ5(+#vq}=Yf9ql?(Aul~;^h3nu!AY5xB=a9{C&3k zV-sduMt6d&ga~>7OVhQA=Fn3V8qw=O4jo6T z4SLY2CUM%Q(p6l|eMq@G21%uR*)QoOq~^$2S))S@eal%nU(){KL~1pHGu?t~@s^0{ zbSJ#LxhW9Inp!{MJTB!&+0B@M0TKn zqN^${LW_6n-3wMdu(=_B+od1vV|1t%e#Wo#Gk{$DaGMUj9VJzaYFIm$=U~PM6Q0{p z_eV>L+Ga!tY$*?Mz#H2x{cOhBK5(VW)kvC0O|_Itm=B-+fTdcCTLo+&qTf{;7Gy1) z%zp9a%zfay+Z*SS5ol}*?WCt@e$P`8_sIF&IZsm-G9H=aAH^OZzj#(M%87KjLOITi0ch#RdsVE}U!b*CoZ>ms3_`W++JvLNdeZQirA|^Ge?|Yz1xex@z zNXsh<;gQ((u&UU< z@NUGKbM9fWm%{|R+Aib|M&Vxirn?x#=|MY;l_k2Eg7l{uz;24gzwghJzzov;B=EmWZ zma#{b6;dXu)Z8h|#4y57-w_4T`ntgtg&4=G_*Ezzzsln84Z8igc+J*o1XfS>u-QDG zd*tpnTbA0K$ckDmT6lJNM4<`=Px5%+19?T%VPzgoj&F6v30$nq|N8*3pXphv)t8XNva!-*osl6m1>pu7XU%`=8R_QP|E|u=DIN5*BqGx_dIa_2PoxLC-K$zqwToTF ztl=em>--2S{$`ael=bOM-LX)FeKi8dXt_BqmjEESBvOA86Sx`tsG7kD= zfFv6k-(+9oHrb(CNbC?X`{h8!bwrly7Ln#vB6<@Ud!Oc{;P6xV(l)Sl2-e^2DZ^8O zGGk(9^cEQs8+AChz&Nz;NNye`4DP+nFd+Fah`NqR#K?aFcc~_x7FZz9XE0ZPFM%*& zBC=y;%D&ME;jYoj_~tq~fVEuEV_4pBZGVs0WvZg=rLgf%aJzP8$=sz-E|NQo*ic<- zP?)XZc+UXHIjIof79WAd~bW5!aZM#aQ zM8_W_I2~jhI;;rEk9p&v!%oSJKLPB9)21J>Ib6-lCgulHu{ZoXiYcrJT$Bb!JO{d9~dzMlm6)kcY5CQOmNL-7QlD}T~x`}s#h{DM{J0tU2syi zkhs3jt@(o5cMeJ}9c+gV*PUjsgnw6*pM>gxwoVNq7PpLAaOh>^VkD~eG4|4SafZzH z-<+r<(}CJ?SIIz0JC}a32;|XF2J{LOH4ujX+xvUKguIK3rZ?WrUi3GTxSK=%mRL83C{Z&orCnv!bbML@x3TJMwS8GDH3!y--9>S6N5C7iX^>1Jgk#Tz zOl(x^+?SAZ?hHQjMgMTjh_C*+(NQdE+J|n3yXAeNeTS(!>B=g&N5kBK9vie48Hc%$ zdcPG~QVS|r6dQb>u+7_n%&r8w`dqftsk{kM;)<>u*9uqF4IH&l@~!?Si1$>;*SG^y z4^Nst#f7kkOd4w3INL5zaQ9Xpw(xM+BSw0$->f2{)YV00RO|Oz9Kw={SNkZZMSO~U;8?u0AyJ>vk^Z~+8ziNBzDnT zsQ+c}k~opHo-V;9k#Of<<}{{o5tn)E!lwU}!W#qusZV`wKF4!)-Yu?`V^admjhbKD zFHQ~?Fh84U9YS|fL;u4~(tsBBi2l;%(nYalZ04u&Cwq&`_~d!krlnsgBKw_$H`F79 zT^g7_T&KmnS|64L%7eZ(edFhfb)Y$-{H>X2(VK2SrXoZ`$NgFvpTn;1A10tF){QU! zs@1>rZFeYXe75BB(YyfV52lNSh(0kjM`;)j&knor8^{7U5cF>rLfulnt~4qQSiXuq zH(%q89Xv`MV#<*jL3!!$e;+6xfZqWN-0SZN`f{-Jd8O*Hi&DFEl}Q0rEqo64?u{Nl znVKUU5hr^sYCsaBXC0E{NeA(_vDi*HBz)qdV;E`C>(#*)nPmPlINQ=`bbQ;W$FMXl z`QL0IOFV%fD@0C?FECf^^2hn;P=bo?JD&=xth1uKlYA(JGBf=;T`^%6wf zPyTaFlYc15S9H|OJe{8YMFlF)Ubx5b3;hR@z1-+|6Z7AVyNWgJQlCTbF1B80*5oj< z;fT&-5zXPIn>}Q5hyu$e7r|A>PP)cyG@V5*3b{)h{qErh>4BrUUO@-m|Ne!cf#?SA z!x~1m&ZZ#(%KW;O^ydbXddl{3k<*yZ7jWu_;?jTTcF{7YiA?{{fg@X}xC{3g$ZV-w zlbQU$n@rZR;1cn3RDCR7wt5_V?nCt7`AfsSKhIsPw^*1G^xo6<`JUtUm^SfA z(Jjt@XYTWewlBk<)s<#Bv?`f$SW?=Z#t zqcKkS*V+^uZ+L+oIiV<>RXHW=jD3q(~@GT#v>&4mIe1goP`m6&WPiO_ z0}#l<2L*CS53Gt||LF3PEfNX3lVNQXY{h%S-EMpQDW#>OLLuy9)ibnH(3kU8*G7*2 zmn5>F5hRcFgVLnN^!sIoF=zRt!9B{}=k%7l5+iy9gbi90P4!h6sgKFZrVQ<@|FX?2 z=~BfdZxzI=mw9X?1!b&htEKM5r#RfGKG{UwVqty~k<(90$+Qwh8zHm7biWY!-wq=> zUYvjNzPne4YQ3^b4BR}EXq-70C&ZsG2zZl`q6=TGGWmAnpQe;UtC`rcQ7LjKNV+ql z3DE6{JDLtU#(NVVnLCuMpFbJV9y)6jD&XJ-1^yLkcXd<$Pg*1>ns%8t&vT8~>>B6s z?s$Fjt82=vAMRtbo1OxU2B41a+F8MPWkHi1JX3po@T(iTrA@)V((zuA$_LmW3^Ejc zK;z5+Xy>0wprBg5@$e#R(cSw=4BO80sCoy<2#({1TcEE#Vmmx5d-nFWe;kCt@|gH` zdiV8`a(l~UX}Pnk+{=#ni!MAj&FusE6290cXgwTH_yZ)p1*==WkxD^TcU;Q&sK!q& zYEA!~w!Bb*kKMGM+NVE4(ucjCCdBOK32EDNQ9+VY+R< zT+P5=ox8ZC_NjWdPdVe16P?cc=#0*m`|$1|-^jAoFNCUkL7t(fP?4IURN|oD<&!X* zz1Qno-)5i{0~>9VBg9)+QtF>4EQLL{8S7G&)wRNlo38Ji; zO09=)-Zq3JbD!`oO*z5JNfh66y)8%@{FmR44gA=tGR}QW-J9{0cn5E6i06$v);_0d zcPi`W)yZ2;=R?p1p0`_^Ci3FE!OUVZ==+|jd)TG;ug~ckA|5=KTF&kTo?pa9hw1%7 zy1V*EgALIx!C#Bv7qkOT>N;xs;|v;5knFZ0)P0i;*)Np@T&Al#pTFAhhl)=7&VFMH zYDM$4J&hUW8lmbz4LQd{ZbH05NmA4P^msau%X?G8 zOW|BK)f&TTZhWOVs?lXQTHa`;gdgdB5dUrzLA&}S)aRl5p_L46GB9kf9Z%p)&V?8J zF4dtm@uS_>COAVy(lPKG3ASfBb@+U9xUU64vojyG!je9Ji2MaP8v0mS_q40{tM;>) z=5(!yzZzky7EXqms@ZMg7;&o3jyEZ@?)kZSsv#wg3Ln9%AcURG4oDXLA~;PIqtc&`*ZEEJ@VXI_Bz& z1p7))NL!aA8_x}6hfh!*_H*31OH6HGlv+8Ip1g+R;bw5vR5jwP_?tl-fZ!(G#BIvrzs&T{rg@^55sby zaW@j~*Od@ANrbO7Q1G1kaK$K6o1)$EyEkk0LVr2pSo@7D@5W|g=>l&tmOiIR{mSlS z%opl5@~)6s23l-2W7kl&{8YI9AU>kH5Wk{B(){gEAhN8mwC(VZPP;wDzb{GH=s8Jd z^)ACr2Za-7Z+M=4+Q!A$uvUT&^p!+G&@lEWed{~i?;$h73=zBM)%8a}LW}v~!ul^Z z@s~Iq@r`>6_48R;>AyxY9B#Rb6j&JAgkdfACVKMqC4WPiT_o&@PguoYA-_@zJ^3nu zAzaN^$^7N^LOu38grV%R_lZ`q`_a(qgLCa!{rK-rk2REMkAB!6r7Awq}j-#cRt zKoMHq+M45BS}H%Zc5|R?=#it8PTx=Vb0@XU45bC}&xXEecg?!O4CrIg297%PDF{c& z@ln~U9?c#zmPxH;i?odi=f>$zs_D?JXz`f)6X z)-N+=Z;MsQn~ss2{JT8+cr zSw8;(paItbbgWI#A7V!0D{CC<2iGTiXJbv0U2GrB_@B`87dD{Qk3nvWKl4ad?rtWX zaBBNh&A)2>baLltAwQU+S0+Pz%r;kW4k>-qeUiiS&ZY&nmP5p(TFvPZd{H++bKXy#E?WW+Q$<{lNYE-%heo3sakXpbz=ozTE zdXxAf+j8q}`)v<7zxw1>wguz+hgiM)R7;l@2aMt;&)hY2Mc|TEVO5?{y))u%wuSm; z`v&v62FKjomvhdM=Ob~<_`_P8A*@GPKVhd`agAD3`IBGJ;&*>u;pMjf+ud;0;>n*Z zW>k+!u^L-=5wS^lH^$F*H3*)A(MhXqnd5R1s;w`ijB8G9l%Ii*{Y2#%TH+CnkbLS|h^5olV?~%9QdAU& z#K=~v`z+D3ZOnx5L;fyTFU9)L2gsTK3`)wo(lupKva;MdS{YTuwzrEE%>~4^e`d4^ z-62kIH$V`J`fNc!MX(M2aN6#-Er62gGZ{ zBHFqU1EnpWygnZqdWez$;odE=kj7}hDHgm27|GT1K?kX!FF@axGsI^Od4j#pmv?7@=!Iw=!Rb& zmWHn#_S4HZKhS>mCI0jNgf;&`I>6gVBc0(9*A3X3;7iMt`mm+7l<-WWCr_$l!l|vH zU2pQQ@4P!&NUYBm_S)Pj1C#DHs#G6NS<&vGq((=}efgNAB{{6a>c>YFroT2=7Oum|U zb@1+G_#ga_coDqYG!Seoe@#b_y}S^CVrOVzer`D2TF&;x)$!k%KrlYW2IMm>)qr&H z3@>X0cu#RHE|Tfs2+(|DN9d`-n(oCH&@Xb!H^g@ctSZO7**@BZm-ZEplChb^>fDiI?MKD~V#q6R|6y(N^s*eQkk>E_jvjteKdi6yR&HxGd)SU9d;VJ?N8Xw9 zm%PfBIVZlJ(JTAFjqk&=L#q6&ZYyY23g3=*^l%dYmaHhTh{jRj%hW(4Nxs&zK36HO z)hn-FNUnYhJ)gLmTTaDkb^ZB$vc>7N#1nuP^#EEj zk`slaybj~rcU=}Uwcpa|rZXnYBO|u0bD+ryo!_Pu0h`pt{G*QY$Lf4@L`mLihr?Uz7q`TINZpWN*@pw`I!sLQ8uPZF7rzQY^xGvq zOI2}t2e}>jS=nFi&%5HiPGry8wxLf|l~^_#UwrhC(iZS8A3GZj(=Xg+(09n$cI{vy zP{=$c&#RsU4r)DxEmi(q$NVR>hr%)j_WoZ1eqYLC`Ng2ntBuYp^zexy0SV$WG5P5- z_3t~qT6-|Aa6bVijs2_r%FD> zm3v;2?}6Igxzz(z>iZD+9`DaTw6oR6-`z(gjc&vVhq27E3qRrs7j}skjwmE^3nLZI zY;m6t+ehA8;Z|YYB(o`04@s48>$9K$wI&_2pC>~#U(}2mIpTtCsWDp{Ik&hjf?p% zf5tm&l6@F~rgs{d`=u3i_;Pr*L%y<{X00k5ZA^aWumb9 z-t$)KL5ZbZjECbd)`rVKs+yBb+LA!MZ@2*Q6Ux)DFu7Ke`=jZEPQPxcXcuyr`b;x3 zDnv5G{}$DoV6GN5=31c+M?-@=&Hkc&JRfSzalc2ib&XJ~9m+;e2e!Rn6S&k`mTKhj zPUs|_81^Iv370$)*unCqN<<2CIdAZ%O0)u)JQG^pyn2vXPwHt~x$qU&qDy0vZ#`_5 zTL8HbcF;wjB>0?w*yqHjA0(N1)a-+XilYt@9~zU`*=>o>)Akh39zKY8qRKp9K@7H> zFX&Ut~H3ItY*@q#XLkm3rYT8x1cd z26xW?9r9^--&uBJCcX6U9}qE2hkWW8Uq^(10YIrgffqKxui(nQy3%&97BsKmKqfc^ zc!&SM+dJUlRUWchs&-x*?G>HzkLCP3`EZvNTT;ngOKv9n*%@44}iUv zY2}%LXFv|_9!ih!JVjyJ{+PBNpWFZ{N1+iB<1m%i4djcli!$RpyM_t!C$yA6+DfR8 zDjQKu>~#=}ct&}8be8G)S}>Pwx0fsns}37uIzqnmFcQ|&xS1veJ8eM}H6)%c@VmULy0W1qFQx zl~8n10EuKN5k)!yh3k(Oz6=4HCpX+L` z`M_&Bi*Cz_gGU}NJ5`YpTP@rz?Prss!XkPX4aKL1M~Tn4ejkpaqPFhl_A;L$opIcB z6HRlD3JyP|8ugPi0>$LVz0E5R6SD;=3!4zxq2QO7Y8EXqcYOL^kVHEnAy0A6-e+td z+E_mM4}sMsO%a0GN$plvdWlord2(&vII@9Gb3?xaq(^}Qhu0ZrTH`;dq}JH949U@H zU$_8Bygr{)q0GX=PW7|o4M%&ck5xN=+S_wgU)TN4(i0rW)M+oJz!VOu2ywb~_w|YX z{hkq_59SL=R0!>y6pR}>%LU3V!sX;Ptw1`yM1sr|(IRxoa?v73h`yKSS614uui81i zx#@N_a@)+js=0eH^1-=sY7CU}x53w00C4w%NM1>{BolvBGr*q%2zkD;((u%q5fm7N z@GpEdv3&U)>b`SFv7r49AusXypzpO6hi?=WnI>!*Kfg~W(5ELIk1M9>mZn>OceoCVTBqO|eW!ha$S@^qccsp7ti;Nmn>#M6H(g~%u zS$6HLxRI<~b<8*Y$R7pC8_T-Tp}*GZ-tpQc5vzllSObp1U%_o_|C+C7DWU z^yhaCruok9pR7gj6$3X-MH^JN)W=(uC#~(f+bO4YHd)7STv=;)#5`?zdtA3|BMo%g z1zfG6hh_Z4lk_G2zET?MkN#jfx*tS+)Djj|*>tf4t||X(;O7vPJQj@H9`E4L`Rv;D z)(3{XdON6M>hcmOX^0C$k$@QZBEQ0^fi+%hx%At89kCwQcc?CaMT3_zfGXJU92E-_ zJ^F+NPl#i3*OkJ0{qAnp(E#LqZcsJK(m~|)7mOk!fT`jyYtMNyEiXjGdb`Vo@d0#H z?{^VU^4Is7m1mrtvhcb$l9M+(ktQ|F>~1mG1eb=<5@BKKm!`*~yc@-A)AbcwW8X%( ze+vt6Qd+xS=6{2IO-rAsH*>wXLp@Z?e6c*{TV7(%vukNL;r52BF1LCy-6qS-6_MaJ zTT1@y*&A(l-I2a>jO5>$;rjggdN(MhSA1f0Vwlo|TSifX|0D2|yZcsj=2^AV3fsnI zb9_5d3M4;>tciS9Uqa@%x*;O{|bc0fg+UE7&OSWqKCUBM5$>Hv}#zr;*akl23q zqVfm6C;Nerre6+4mW?#f$NjuEKfkC4^^lI5eS5sxz51Q^)xAKu7q2D zHwMpspdiYr+Sjw8+1P^kSNmO5>soe*SeaQX0EP zh2w4-eX&s-@5!CNPBtL#P6WL)EFT5C8?Lhn6=i*14>=DunGkH9^-nj^7w%8pAPxC* z;`HLUwxDBb-8Z=&F}pLD9un+iqF-CPzu;g-5+Zo*$zDIKAnU;uF z!fA~Y+d|lc;ZN3B<=qzBEizYZf|vAgHq6^c^{b~fxLb>yEa3C5+$nB>y5B~}2jMkZ zd@jGN#4r5o@7Coyt;8!QH_}Yp`yUoyZ!XA>`Q;2UCaY*QlKv}P7c93aO=kk9dNzOg z*H(q1Pkoz~YG>2?=862zRwuJx54SRoBy?wmCfQ8Rn-6!a$aa40{&8o2z8id4Y-{&5 z;VbX3V~PD{_o!Jx`~hpvGsgtW0p3|Bt>MTIMdmD#ElO#b&w})GHpzHgNgh71li7|c zIpliabxnqCsk*L7lBPOa%gRH>_Tk1GWcpATP!_XC)?5do(J9`q)dD7(x0UEQae;?U3 z@zmPvF|3QCFLB1nCJ4;L_}i2=(8N9Azq)5vYGV+XG;Cet2hS#Zjq@s}84kd=q)vBKCq{3wU#>6w=sV;C3D$~d&3|g=?-_S8<54-e(l|Kfly>im zKABf*#`RJ1ZGUGy;G`$ms8QVYyw~U*!+FwE$S9p1F7Qsp?33`9SGlfr_gB}gM!3UO zt)JsI6s8e(sR+9+2mJ!qkar$mP-HR;J2|uV6BEMI;wo^A!pk!uf_yHpk?%H7qs`-L z-|C;Wo$HET9sNMg<7~Jg4K9n{4DzAuw)V5j5Qdey-!un?Qn+qK&00~6ROKiGgp=9g z9qK9z@OG^BJ`YCSG{|H2#5Un1-3418mjs9BkJoxNIS^V-Vlf-e9>wa26i%^byc!p=oWy&XP zL&DW|FmZWwef%n}@yAAJ{a)Y2m_2rUw#Lw7YlCNfIXr-G4}X})hM7JaaAniwsz)=M z4&?#&$g7Vf|Y`ZH$Wk z-_L>2+I@GMJMS`-hoXWFYi@a+L}`lKQ5JK4!4mHMk+5Ix$?D}^_Q1&^zDtABRrMD4 zYnS)^YPYX!a_4s+F)YT1u{(E+1BJanja9rF)w$$jRuGM0;PkO!+zi4nr&XODN-obc zSJ&XYefolyAw#G9h7Q4V)S47Ufx({4(z(~*)j+PH%ijz1#r3vL<0ZeO4?%heU-Id)#E z_eMt6(1b>*-l&Xo@_j7utNF}L-))ATIh_OWZr=R`y;{f{1TW*|GPgmn3(k>Vr&Bl< zmn&17*83I_KW=VwUU?13%TJ>^yl_K{byaA{sYo20JTT1utbNkO{pZ=v$|PfDES&Cf zH5HkV_49JA=L(@UPZ>DUc=YZ^F*~!@pH?qN&8K28y$ca0j&t7QI;Z!YZ@(Vz^R_eeRhr3|6yM)MZW5bfGKTggM{D@A-gilGh=R*vQxP?uZ_%G(GZW2EU^tM!J3wdSMJ&X+$$dTpM8b7wG9{-F(TR#Jz5Z8fFIE2f?)soufu zG+(S5iifT2sfGz8Uv}2bpRpumjMV85*n7APwa2 zfm~tvky^MgZC>*g3T;_ce<1V*V&Juf)0?fOWuKBCbtp-l?vA|Pk88(k5gG`-IA7eC z^~-p69IHz?BVMK$$?bPH<}JY^6!JKlVHbz*oU#cb7&?d=g zJIV?7EcbKL=gXAJjC5fO{K~9ccas6gX{7T_LpV*dh2Q3 z{Tng2L>u-G`nG(NF)s$+^WdQIV)j_Cen4Vr9Y8)P8PtS6)x&-7ib*=L_)AH4z-hfi zA@XM!2j37Re`Vjm0PW7tOYf_Eulo6SVTrnvBN0K?D@5^IcVLH2rI@W%{cFld&K4@o4TO6Y zKMY181e0BH1L>14eI#Oiiyc8pn7%u6f_*!k!Shwy(abeoeBZpbvatou1_mqQD?1r8 zT765?@c!DPI~$i}1TD+E+t_tmLyZHWyd00!@PhZd7tMmAS6R9_>Q`+&Z58!Tzv=aA zT%9)i+FIM`cs)Rth;WIxU@;}34LMKCtSNhNE3pD`hv{V@B|?##n`V+Gb%D5JCcfe2 zO|LnT(RX4e`z|t+GQ=H%cL6=MjJif~@PQ)qS504BQyBwG7j>3AwBv=?pRm%!K4vFY zXz`W_!qYe%5&bwJm`<3WVpnCtWrS?l>RBOA^;+N8-EkigD=}@Zy{Z0@MLaLZc=a-} zs06+Ky1w8zw^C_-BI2=ClW!#MAR_o45w?2P$v&Bj3(X>>U!L zFT?k|CSS>WdR?VKrjNpJ3!t>s>K0fGs|LH=&a`%Bey+1fUMfN+O82jL3j`g_>ah0p zrArCAxcyKzPKm9}O6pw(8c^-k3z0#knj?N-Mg9Z-FsXlfIHa*!?l!nv`npJOV1yAD znp(b-5W>#9P?=8%xAWOx;#}U385v46V=T9UnWX2h$}1kH3GM=yGj;4{NXIZ|8I-M_ zQH@KgqV!IDb3%IPU zPy8QIZy6S4_q~6MD5waih)9coG^lh-Hz-J#baxJoNOwzvv~>53+r`iP)P9iZ0kiVwe%JwtC*!t4&Wk zs%*h`L);{KZe#FULDe96jCp58UCnig-#FrRv`cT6U@+|yT8<9$_VUDLRnbxY;@G>3 zn6h_sW(?tadH4PkoZ%K}#r#JLgY|vVp_b*Hw17LeH!ogQI=`+Q#cAHgV1%&Mme9t6 z3C+THdVDdJNSvJ&3=es}Ws?M%Mplh)=Q2jz(cS?HMnngUZ96Z{eQzm5kH8F3O$enIrxUF_}8#bX$|(HODl zC5KiC@q4QyzqszFmhDmdZ`CJ~b<6_WOu%CzodMHuR;R{+Sqk3W6zqzm_;POcfcxy- z6O!wzv$AbqSKT{Nh;4LeG15S@^<%=ac2=d1xf9um)2`5Pn8@u=)3f%Azgd_o-F1G# zo7;Vd5=1-d*25|@2%-h%c=vfAZZP+{Muq?G7Cpq%5t4U?G4RLW9iHnJE|etdxpc0w zwbEW(63GnQvfBEcutn-2L4FltTZZjLzEelN`^EcphLEW853|GVjz7aNw`hl!#oq5j zGt=p^)|8NDeK~v`1LVe+F-o~vZ<&$G+=KJc6L|UlRzp6k5a>b9pldxkDS8Clu(X6| z)-zGjg)7>ax`qMJidA5p-SIVlvt@Cc_VuLg);b;5168$10L7Mrb4WksSK zZlT-xU1uqc@K{K@-;6`+dIbrLy|H2^I427?6{gR8=e&_Iw%TB;#?a+JWr;f6PW@r1 zkK&D7M%FZzfiNleB$!U4^mX`~S-d;d6<|@N#P7~`@jPzf9E6jxLAST`=BnSOcebOy zj`A*??G+pPFX zGTPXC_BjIfUBs*CRl!cRrmkHU6tB)##gFz}gE7)%=}?)6g!$}7Zz$SDT`#IHrH zcK@j}nXEO#zJ71{P#n{CM%Gk>0~$w{TxQ;_hX@WlInFimcY!aYzzr+?(|gkBRAfRs_twmd>EG{_b^u z^uyESUSFIPUDuZ%F?Ev(;Q5BZ7?=99ECWEm6`FaY{j_SH!N>7h>G{suN#f@ZfT_3G zZ-0>gcEg}0wCB=WOEF6nSWa0Ayb$S8Ywwy3jT#)m-Lpu;708_Wy#&&~8?*;i z{vbMZ{dvjQDAn_$yY!O4sVa2Jj$t^pOri{PX#+|%C|||R%}`G58?plf!Lu^U^g$;# z$rlllOU@Qng^y7Wke4D0W%hkrWasnC@++dO%lv^rlyB3v`fg2nCtO;3=M#2QmMlxu zw@;mRpAee42Yf;!`J!zWQ>jgCt)|bOGMjZ@4fw_`f#u2G-0XX_Hc|j$ky)4V`BBcS z0IvVl0@hY~;&kIL5j&Nfq(u!`8o|;2n(zZ_sl_Se@wC`UGubX--VzsU4tn9ZC{TyMV zvhogI-g9v9o)Jz0&G-u!U`5{LS?p06$2Zxjj)6ojCPVG(2;c8@>q#x^ug- zI9$`K)932ge(D&4_xI275t~cI#>sE)S=k5QWGA@CH1YUe-i$>yxrCxeHf9Vrmsuu^ zm;~M{c~x9Psj7MTvP67aFLyIK2CMF_4tSOru8YbXG=|4!&8U8Pq(dk*ilizJ`ac zFa=)sljObHu~CREU4~mdaTJk=+YTBZTSO4XC}cZwRNg#4z%7mi z+;2Tb+*IEvlKF~Ns6963P7cDTsN^IFKv-7ez;i1RwR))yU?i{sGs2x^*q@uKB1%Qn zC;$n$#Ow4c%L)7Ws!eg6e6rM8-NcHog};VcG>A%*@U~4Vc1T|$|J^dkkb7+vLVM?X zT}TbndmnSy)e#r`)ey8Ocp5ae6H}guhEJL$mc22UIeBAa8RZwM+#U&%} zKXi92!p^WMl;Lf@P5B{?RAqj1|`lsQU4m)hcm_SC;S)BPr;iKcrRgVkqC4J7GtIsVY=g z8!p?zzCk7a;9oEC8T2_HyLC+6pBk!A3g><@nL)RBRfF!jKR_y{llG1YzBqGz%J}2; z=hXPOCo=l}nC}Xk`G&6wZLceA7`(^mXA_~gJ_y6;m$P-3S4YHfzKtsD{l8W0b%yO; zc6FkJjB}sA``zi&*NglI=PynLRzF*IuSJb*}JBuoz;ml=k50e zwt5ZykNeJP&1P5kZy!5rdk7M!Mpq^B2AAOom=W-AzTqFG0q+06G0+jH6qk3RTD0VF zcYXkk2L?FMq5SWbjM@5YI0^mA-RxHFPe#TW=^c<&?wuXXu)WtgFa~Zy$DRtR7~1Rc z>|yG`?|2UM1e&(MRWa03lcfB97tv+99_6JnP#r^fWbEgU>qpd(z}xHj`Bg&}2<->~ zSFNO0uh>ouE0&P?9qk!=1H?nDviZQOrX`G3kYmwvHF<^>E4HJyW(#BQ6SqC(x8*6T zt#rT`@51f-gZH*l!W4BDNoCV)`||rB3zd)QcCb*_glN4G{9}nSV5g;YK+i#8`I6Uf*(ycDP;q`0^t*{dlHObZNHLk1E#X zFZhChs_^#gmYiX^>h>(rr*Gey1g{aKMvI~=Wy>!e*(q&kpQIOwbbjvUZs>2vvexMD zo5;OX?VRE_hJ@HRY0^rGU@b0;z_sBk=c?zhX^_zUSX`%VwotzL-o96kW$5{(fW9O!UtCqBRG+dAaaKH_UZ_lU|8j| z2DaMhMR@pOhLo-b82)8to`YF#O^y3he)G}fuawpf(TG&PrupQUL|*&cJWcZsQ&a8_ zU>*f3G1GDO;MC)`u-au&T=iD3gDYMlaVW6Z>1 z>Lug^<5zFpnaa*eDY=1ho)H~#5GBZH4!FI(`VDcxe86tE$~i6x)$@YG9olOVcZkBl zDmqcfZ^)U|Ns~`M{UL35J$eu9fF3EKVHMTgL~PEZo;aV+-dxGT3+_4G9aB?1$Ai%m zfg4bm1Amjn%WXY65ue*l^w3>0VT}A2ssCGPe4+%uf3{q}?Ao%@WMCKEEV18t8JsJe zhicD1ilz=5oWqM(JcBd6FEA}(y~8Wnd>|%t8$&%x zl#?K^vQoP@o+Wy-EI66I1Um9;!Xo<^|60aa7{Xd^adhY30%!UhP0MdHLxj2LtMae+ zyuYgF?X#LLs8NG%qMF*?Jc9`e{vZ-4*(0Yz>t}42p+fJ`_JeMGFNJ%le-kigtXw5B zShn~zfSpF^X%(*2lk!c);Z^-rmm@Fz#Y>xfyL};a2%(m%6$TWw((A8xGdE!fOz-x? zjacsXItc1oX2rSK1XeLFYK43m;y;}_d*_8A7d&+C6BY0(+d8#zGL470z(0gN&@yS+WkUT`S)ypDxtDa5h#7zoOqoo%C6eYNBa zx2NQCwo$u9QkqM(2-MH?t^wGks4uj^B^6B&BfSrdG5aAbp9))$y4AaWkkmjTIIi5VcKzd zWh2PTj=2_B6>u!cB zHjjN&d5}8XQb?V=eBT>D91D0eF@TMYv*Y7n*%R0Q*Gt;{!AAuP=im6{B(vZb`7Gz| z7*)I>G2ri*9f39CNaE`Vg^ZNu@*|cp$A-S%F4>x3miEhV-bz*rZ3l?M;IEYXgP=q4 zmF^cV`Q5H5;ww*DCR!lB3;|CBQz$Ka>tCQyn;y*rv6}`K7tYYC zS-r{tT!OAYL-u#|LbSZjeM|C=0Nq{9gm3F;~<(4$~P8<^%|4$3z`Q2&m*w&e~V`$oE zl8z<=vf!aO=lAWnoj>bmok+3Jc%we(E_2ZlKSmrbc$QdwrIF(dq)^*a&#o({VCd8a z@N&a~dk!mi`pox|7RtZFM<>b*4JjU*N&5*rJ3|Qp9IkJ^+-&yL&!-0XH3>C+9?9V* zUH92lfEMRSv3pnn-SM7N{!*M5WzS zik-Ni3;^N!GJ!gowtH&l&3kMze_TGZ?sXlP$Ug_P#sd61d+QN|G>8Dz9L60AdN|-) zL}vqnv~}S9nG%(EgJ;-QfJn{h<3F(u`G2%ab_-^G4A)Y(FkFom0hzzaJe)&>nsHC9 zcpcEEA#%yPk450+CiLs4MQ(gIGUP6(1KKJjLb6U28n0?aGeSXTw z-0A1(YX97{0JOW^XZXf(<}}LXG?ds8H-&uwE64fbr%|?+#4FEu02SDI;wiy@ z(JMFXlAFiK#Ur3gb}w}QsF&uB=>gy(Nu6E9&fF6*T4A`q?3K@11cV$`K>EgJ7oFsS zrvS(_Y008S;{frT1t6sZig};OX6tb0sR#7*09MXxW9U74_m=>Ka-#zd{X-G#HK$gc#Ko-m zPt!a8!zwhF$fdt}ondv)_^tx*!hiA{ElGN6`As>f}@&qFonF4UeoF2tD z@IQgS{%9+Clu=XfJ6UareMe9|)=dC^%tdY`DPx9-UpN+D(^}X1x6#3CjBNHyORAIq z=ji>XK6(mU14xfg$DZS2p1haORU`fL9Ns^hYuQcf(vM9L66y%FA{+ri=jMltuk5IB1=J!+337)VRp$e%9c< z7}6#W9OHYop4&h_5w~07pLB=spJ?jm+3EKL|IZu6P#QsCJKs5dR3`}8AxW(W1{i2H zaCC@g?Ev_G)+{Vf%6=;;!{!TJ_gNBf`}q&@_YC-$_*fviePyMn{U;G6;D5bx#P{fr zIGy;@>?6^$XIFWG0gGi?wm;(*j(=_Q;ZZPb0xy?@z>}cc1R9Kf0AvVQcff<=AZTy+ zWOehk>zRrMhGpCcpwozM7Et=+t^0NYNG(9m+WEyDQ0&yi!dV^l{{QdGRw6+4wmn`Uw}oL|m=;CB;~s@GRLfjEtllfG*c_@A3XqngG?F=+VNEA3}$bYU5<5@oJZ| z1}`rBQKTSGW^6&2Dt~L0CzcgOAo;Q;nZ>^zy6ebLFp+itkC0#E-(10#VH=4dUd_gY z)ku6qTvMUi#IXI`JOHq)PyP~pDgpP)ufZ7uYK}|0de*Z2Y=#v1oE2$_EF>Xr7x$2a zqr>To)4MOZBK|}lvP9PcgDL;{)5RZi|IG^NCyQcN9`Rz5?`G)b5o2B#uq1TsUz{xc z@zdh<;%xWPEV+RvK>L%~K0Kd$y9wZ8KLRA>5ad67?<}A(eBW;9X#TQ=kfQlWbBl@W zvs{aG1W)@LfR@U~07Q6O&u75Xk_MQI?Ck%^#2xcZ<$+1ayk)VnF&M-I84|;Q)SFzc;W%UT51V2ZtPy?j_=2tZP_|XE>$(AoJ^M zv2ZwRu{?i)hCZnKCI!mPH>yAt`)Apv@vri+<4Zs~kpF!HxIaGpPoo(-jCRA5>U47F zliXTc#a6U4>-SqrdRoG17xz!EmJYBD_~+*Ty)2dU_ zB}MS2;a30gQzw9((gmO-Lceb@(m*4mv1}lu+rZX#SW-w1S`QvUU|iAT_xxv7EF-Ki zlxy$V#ZT6LgaTh484Lvo&aqH#&-S=~wxn3#CV8$I}eWv76AVNWMTMS=l|NKUBK@A|Gw_ws8fLY%%zHivAGRl^?^~{Dc{0z z*E(>}`LzbTECF5C|FYR(6~$H@Ewu~?a6|b*gAIqoS;gHbwI0)OV?W7$=F@ZBPqBsd zAN@oI9R&O?K>mGS#XYv!kxvPuQd#4-Tn?5x^IC_qE!KFtx}-B2huozdMTMFz`~=~# zH_R-#7Q$}PkUHV> z0xGi#DsAziC%wKd+K=b{-UGG}hj90I7ka&61Uo+wkP8#eZgSVsZ*pFre&Hk`aa2}j z@BO!Ww#7Jirek&vd1%FIWv5k>u^Xi1!CjE5``jJqu;j)|xEFX3PdbqhtTtT5Yh+!y zRF(%WD@8U^6GEW}RtimthpQG2=^}ji#L?zRVb||R#_Qul-zl>Yf>`EIg`w(cAE|6gAF5rIRG>Q#Mpxz zJv)yw|DetZ*#bs98tT6ow6%j~E$zL%7Wy511E6W`uITnBRu(2>Je7WvA|9mNq`VHo zj8hbgjz_#ka66??v+KQvClaxC-?sg>><2oDW$@LuT4^kyOLbl+_D;P8Cp9>PlbcRH zCIh1(#NOQS8!m(>r#DqwS)nl9XeN1vMN}Tzy6vcy;?3YZ%6N& zsqSo038Nw+^A2iobO-|yd!YT?Vl%Kq1a(V(@g*}6yk}>@ZFfUWyOCT!k$2>FZpt?6 z3iV=7X@XlKHBlT#oo6xx>d~P2f`R_rr)cvkz!z%T9#TiSFi(I_bW=eCA$V{-t!?m5 zf~-g4O{SM@jN0(^hWz2SfWT+UZnY7ramh5(@Kd)|Un}6rt@oGK!(ppahnFyJhqC{a&)S`~;@$cbwVg zBGbvritDgbZiDTUkPsjlJ;Jwfu*rU?OZMt0ui$#``pLbIY7CL$c*Pe&i*waktAstH zJQWnmRL|XO>b$&+_ISw+3os9Q89yc1Y`Ixx1gsg-9)kf<+YPhOjG6#quV!%|@nr@P zr0nI|4|joaTz(lQYrcu)N)l1@v$qAMnUU(swUqtI&v32A!=@MjxFl0>E+3PNgJrg1 zQ&raPj}sbM3%X6VUpX#*(nXcoL(im6)g^$r7mr?!&4J?9wi!urFR$NU7(TwLlH(KY zp=}Z7pe`lX6tm?CH~fM*o=orjD|4q6-`hlOLcMUp>Y&qA%)a;;`lkJ64;Y_Zg6;p5 zmg)!fd^`5`2Ypz3UW(AmRbIJroGC83(CiN(J8v&+yZ7w4a`v69kOU3GjmlZ}cJY+e-jBI8t%ah~UBXwLh5>tOQ z5%NVk4)Vhz3RH8tQW}j2Q7Bhc)q&9c$)azId!V|G^8AEn@tyF6R-!YGYU>SMF*fieCEZ)QwHg##)?~3rqx!)$8Vh zz03s42?Q79i)Wu6E{Vb312K>xJ$$o$J+K4p<-V6w#6%`F%{(%;gv_w`ddmE^ILr;v ztdH5BRBHC)u39Vv%#3bNxh-rc6U`7eUp|=h^cj5?U@;pH=MiAsTG2VYu$R2 z#gd48YmlSt9dGYw>2v0)v!acZMV7aoPfQH;Ke;Vqux6){xJIeu-DQl6&+<4eDf=sg zHnaQd$o;mb9d5FLkH<)i54nu!*XlXBU5ize6#p=U~kRT=E{=xuc7 zb$FfF`Y5fn&<`k6qSKPMei|%!y`%|IF20l$`>#5Kn$anR1ud_ZZwpTU&;SA>@wA0S)h|yWriS zdTjLdT^EaukrInwlgrumqyr2Fdyh?%us&pJ%$B5A_WOkDQfowTW!emxC1wRu8#e3L z*gqj?CldTqdbT^T;``xVN#-bymdL00E0+Qz)hQ#lete1w z-1K)$csV?tl|y@RY5b{93}&udp+d`+wZ&YvY_K%hIqrLP4z?P@AF{sL%5W|dcWsMK za&Z_eE|)BA_jsO=5cR?M-6dbO7#pdLZ0YXyJf8OZ{tPnXEg+y!_D-X_)4j8d%tpa* znX>Il=s7T5*t?bsYIWHN)iEX6KEJ0-;rA-5e}G0R>rwc$Wm_!L6rDMvXcmRv|98ZC zGWc+T7hwQ<-~UcF!1QkZM`A;a!23a;(^Cz+MV%T0#bF;%93m_}b9k#SaR8eo_jR0D zy;QLl@eT*W?{khJ1#`101K-=vz1&?96~&Oo-zTxQ&l9yQU4^GZ`*xpuqO=I$Xh&%T{SwpY)L6CAk6w4vP)#7!%E73-ki>d7JwKB7H!#+2k2Y0?k;1>jqVxPXwSfT2PEDNGN z;L2*5`IBQewO$GarxOP6i(S1n4j4j`59wr(wWXnpT$BQ854M5SI#>Xc5J1N9GJPRG-T z>QF@rB8?i?cyQvI=>W3S_z{zg|+)Z0IS7*appj)i*Q?X{qt%_dZE3P%$s8bNFl%WpEih z1Qrb{9NVeA4J6WS61zwzF165cv$4#4LieQk2P%TozGPV%aEc9Cdo^+`Nw$-0n=FY0 zb9D~MY)5AV>B#vphjcSBvdM%Ah5Y>bu;$eUQkl+EnwzQDdb@jEon%9_XRG|0Ic27I zUyPQ%oZQFzihVnXhD(QMiOgLpWu|#jS~5}Rn&+gIT=ybTr?r)epo!IP9}J8iJoTDz z=-s2ZKOYlRobcsm<9(LY-JDm;-7RbQlW%KtM48$posl$!D+GtgU9`JfMMH72*IKH& zI27_s)Xp7$-`dvme!#YM=XWxYg;8O)FlvXp+7#Kz=j&Wwn|IUbn_7{{zPOxla^S|} zr#0Bon9%SL$$40NvtWaIxeXe0FJ}9-G~|BmBsJt!RuWJo6F~rHb%fZF=f|cXXC8D&mCc7O<=qrw* zqH{NMkP+eZ0$6TcAK(<^i$(oI&i3FuP&gn_Ek=jj4R{AZWvjM&w z22F&9%f3V-LCdx7ZLpQbuaxLrv;jMm%iXQPcNsN69`ko& z@kkU|aSuuM8H9JH9k`ovYIz{UWfStAYh!6|h#8l9p<#rWx&boB?~iEaA8*Y{>?q5r zuzE+CAI-6fmE+K_pLJSWS)*eROeh}-dmrhN|GM)hNo&HAzfZOP(wwzL{7-S^Ij;1T z5S9x^TJg{~Ml3egMjUC#d~2Sc^$Oh#YIlCLlzj)TKN^xzw)!+9=qIzN11ujWlC#dr z@?IMqF=d9H;q|^Wy9W`)cz;FfW*0z8??3l}{~&tFaEuc?zvw zazDOz*tNo!sKw$DJdPry&b2&ChNbcm3)-N*3K)-jh?EH+$m{4dHDS=kmBxcz)%C)m z>yt|&zJ=4SD1DLB(qmijq--7oNoFeysf@wFt0_reXd(&LLzOlUA>e`zQ8>`3rDIoJL>(y4h0iKO1ag|1_0di1< z+Bdp8h_N)j)%Tg<)r=J_Ab1lyO?vFfk>XpLa907%oAGjLW2@{rQ`^~tX`z;PaW3<> z);H-IN0K`3ntKS89`@v6;yaB_qgH0Yrq&JF8|w$>Z~A_$T@~cqYe_a06|2pue;D0; zA=d8nG1a>vSZOF+TaVfN<)6^n(#<>TmeQIV_j!X)7J7#ZWtQ|pmO>W2Ux&Gla;9(8 z4<+dtl+kTdUj`MbWCgLKX&GKDn&mgi?cASqUUL2uJbo#mFYrU_6yK_9l_FOx$E2k( z|2E}q*v0X!jgX>p!fL3R3S&^D=7{HOGZazP(FrtSUq)P)*$HI{m*pI6 zGW}`f-mk%J8M}1LzJIZ6GuS+lB}nxxHpfX*VamRksElxEfca!gZG9%1e35VUtW48r zxWM`OPXD(0zRq+Aeo?HC9*Tsir`0>x^$OLwRTyp?4_d56%35s|oH=njoeFw{H_Qr` zTW)qv*LdI(a^T6XsyS?(C-(Iiti`qt=oQx$6ev#9FrG8%T=mG}$e?nGQGe z3xx{XjqP9b5?WQ|dY$!&HryC$h0C_x?#*OJ3^LUccto_CwI!KRSo)gtRyNy~w`B)z zS0}+lYq0ifUX2g#uyH5WPseD0x7+PTVrXmqvbDNrO|oWj+XQy63)D=$!L$Ue>hsLF zZ98D>crc%bS3-AMKelK_U(i0JLmo>yI7FVfK&RYa`mz$>X1MoBYr@_xEh|KbrWL5^ z^4D{^f46>WMn8@cC#fQud@G1(FupMsrl-%(L?$%k^Tx~zj|`B1+ld6%uV2iede-Wn z!%V`7-=IOF5RS&$bM<*^jpn}khrs-eaOa6TIe7maXa=@h0Y%O)bnMMb{K^Iin0DA; zBD0D^Qlc$b;-(i@VPaQ_vE_c>d-EU>HsNQkYqBL~We+f!yq?9&!ec#NsG-?+<>}X$`4a1o+9`+De8qr<7O=`Hvj(w_c>D z)YRAO^$FD`im26DvZ!?!TB^QHzYAn5)56EDFw!QZ)7Ew`_VXO6bM6fEtxsSW7kM|i zZf7xY7c_6bh^yr%>mWLfm`25qxSDl$QC?WSQ!{s3vSU7-nyH<%!n+58BzotiE#uAF zyVt2~2g&YhpMI5{Jpf=UL`hD=_8u#3>00xF=j^H``cO%4Bg3q=)5JLVE!@_$=JFmq zPWaELX0F&`!0Di51Wsv=Pr-Uk%wVw6$X{B;Ol%Ri@2QvlPrDAsvj<(^@1uCL+A8v_tYv_eVxm|x&qeaTyG%@qm_%JIEmIg zxhI_uUUpj)`ver~QK}N&i;;G|SA0&3>u8>EMf?F`j2~vchOqTFopCQ(+&b=6+9_gl zRS#BH*mV>;tNTu>{f(ET%+V+&XlSyxFU@&J=VFt)&;9{PQ?y{lWck{;VlkJ`+Zu^- zHU;b+_*9qs7jQ=wvBp3wWrCPo`ILJ@`CONteS6~a_GT+x+11Re)@(VX(NLfJj^0y| zitR)_Cs#XP?x|_w`O@q*mtL}oLk`z=n_`nD!K%>p$*Wqf`KJd=m2#2q+f=xagkuqW zw$4)9Jg*a#kGy$`wR0=o2d;(3 z2_1JHKWxo6$W*{%d}qt9S$(>wJGrFI8#Jz;Q!O;xnxhPxR_ct<_~) zr4KXWTiX4!ACAT)S_80?iP%L9j2LZi$O3PH#9KvqO|?h=E_9 z-iP4Cm>1;O-TQz@($VkqI^!|Fyku=X?wsFCEUG4hphy@J!Q4aa(nw{hBK3&Sja)rCVMYlt1E90ufnW5OoEe* z!=Fu(ALg+fL8`RLU&5!{A^eKAW~;BI(kGhA%gdO6f%K>HK6?t`rO!#wB1`p(Cxsia za;XF()(!JprEhi?N4YkFUdBdlq@_euGR_GSPWn5-1`ERbDbAJ1>58WFESZFlV_>qy z)@!I43kgq^t|de*BJ*7F1!kkPfSZZLjopiEXlEi@?ae~`-wzh((Bm|-nUdrvy|bY{ z9ksq>_gm|&iOCtoSdkOwHdO|nnZI_bUu5-Vq;MNoF81+9>K%?rqD@7ck|>k!0W$bh zb{3`sgisW#ncbj$gXdK%3rxuG8%8L^^2~@^Y180nZ-FGpAt98+&P?+eUQO7tnv(?y zwjJ4~zRbhTB)q_@24k|xGX%Rp+^o= zN~RCg;uo0nxr|v1`;g7B^3knA;_Y?xA;MS%mx3Qy)jNr?=0awZMHemB6m6I}j;hIm zg)DFFS;$oAjMv)bql=mF-LYg-(jLz1Woc=MoAX~h0}rVd3yoh|%l z&X{j_n|EeG2Tfbv9`|t~H|a=S2C^BWU0EDI%Xl>P>l>f=|W4JS4!uO(fp?l$JkZxn)%X zOA6^|Hbld%k}VRDL>1XJdD4pWsHP*)C68N!x5M=kVk=Sk6@3B{Eq%PlU<9w|!2Q|5 zsMBX4CB51CizsxnJw*UzCp!Z94LSf#r53vE&ASUct0vV?6$HQD^3kDU)$Erel2kl$ zguW9MAkZ;9u|34nSdGAu%D)$#U=!eqwwSo3BW%+Y)m;|)SGAps{IHSiMK1zUl*&oN zTHR9vxVSb8XGjD%Jp^X~F%Nx@>W=HY<@Vjtsby*AdOVjtW)x?2apCSwRXG>inRFYJ zc>gA9QTk#5J;{GzVD@xRU5iRf^BsK4Y{j=&=&q3)e{tUZ(cQ(HIiz>LufBI#crn3; zzO|`+r_`m%H;43G@_kOD$-ZxLqm#U_8wj#|yOi-lU^LZ@k&%riDvWc#9>fxn>_kvZ zvaxh~u-RMo8heK?tG=c-hgC4b+hk3V9M2c|UmZKQob4}WC|%tFCvQ6=4ljMfG9N76 z@+0B4hvwBDf~ah}n|N}TDpoe6Nx5WHEHkBIyWWeOm(CFc)jzM`fVf^WxuSw!bQMhQ!sZ(UR$`|F`nYG z+E8gbH!xaQ^@ke@l&$;_;n4IHA?G;che|hR)0S1H>cyn;MMCP|Jw`C&#g7@Us-Ej| zvD8d`|44v%+|eP^qZMjr536WXj`M_lvV}#lcw6S==2I_&8CSA2t_`U6fYKxX(>k3* zFnd5N1|V*HOjqUP9LAyE#o}dHnSQv#t*IP%a3iq8LC#BZv}6v2dfu8P2YI_U1aanm z0ejEX%^&di|fGldWgg=WO?8}^r4ldse zohx73b}JH%OSPy1eFLYJ4+H|_g|>>osL7d^5Nq#k`plk zS3NwqAe0CEK56TRKGMhh64WwRCU@|b(AYWnIcUl8fNsOtW1m)q^<5{|F9kuv6&&_% zyQ-}SHYx!2&$#Qq*5x!%v9NUw6rme_Onb|CAVx&$dtNYOLZ~ zIEiaY+NtI~CYgTwM>KnbihRK9w0w}sB($!>e9x4d&hNWl!nj=LXlR72S{;n1Fi}-Q zpm}GDXKTenso(d2aZ=M-PUAP+wc3B;F4kDtPsr)d!Su5pXZk_i5A8q70ild7)N_zP zC&%iZ@ak0IGWh8O&t_YPgp!ZutIauV)X&%NMRRjK@sg~_&vKXev)a`fQ%>74CkIi` zUXM^&b@}PltLJx^#B!zVC6w+eSTm|ET;u$Hh~M|9#Q7DPy!}Tij8|FRD-;?3!gu6! z};R%Zvm)PsWvC5D#N?b^F4J%Mw(t%Y^iXOH*w zcRwb_3Rg`Vz$z%!5QBt}h}VnSgYFr9$vj(58~cxGG1)@eRh1Mbt3!WAe|h;(w#^fs z-KmLX>({#2IAk#Fy=p-|sH-Ucvr-q`R!Q%gN`V$?|HN&0qy8?*XYg%929o?UKSd1_ z(Nvucv$ETMzTnp(q(fO*f}ZO=zNOQyya>d|(02dTv`OZ|+5UpYar(Xb==3%1cFu2O z4L|wG$LhH(E;i$Ozu@TZ4_OG3+m<2Nw}2%vZM?eBkVx>Jg$b94Or~g`LvX_Gtr-cf zN|F}Y;9HNOwmVw>RW?^851X~qfXyzcBZ8m<(5*<6?4B{jF+Ep-Ni zIj`|v!aAp-`%Ej4e(W5a5=4E?I#9!WRoo6X`u%g0HKz;Cha>wn-`n|NpjpAXmR|;^ z{*b+kq@fDEdqMV3!r583{bcjP=^3|GLw^aj=E*OAS5jl6(zx?g8z~)SGSsJQ>|e=z zeaVQORfkjd+ECKPd9+t^_O#Ptw46+&GvB-;^y2Mk8FF{YTyW+uJvd@PJ{Ow=6!ksq zkbgWP>6Vs$%mDw8?_y}L^6I0qC6y3@ZWimDP~QJup}iHOqG@uv$}DeD9fUq|cW6Di z(j{Id(#nW!$494mSyQx;Anj?L7dQ&dts{Wu!@ZA;qa6GJ+CNskVpM6r~At$wLh)rwoVUFdz zXkCb)#hrdmOg{@g#hK+qV$LVSOLRYD5B`*!&18X&G%$?Swiov)lAx-z-djbLEZW(= z{lMUcTS3_Htn@0ceA4m#`U2V`VCLB`%cvO#o5E)c!U6HK7Vav#ve~WN<*imjwfG7d zyvM6o(5e1@KI>lbJF4kC$}xA1IKeQ{dV{&Ib#divu6;dJ-%js25Ra#7?FIOD#f$!o zs>opg-?uZ2FK_EQAGvispCAihO+c=veT-daV$3n3i%q0HP*s4w0VOO?v%Y|22>*Hq zT5Nai(C517oo=ZdlbsyvX>gc#1D%!QD^1N6a~}YSYq`M$A-xYgJIJ`1ughK+gTsnVReGXij+lDWwCPkNcrpaSyP5J zctpqN@ldP|x%kw(#S`l>u6r=A{NAB0WX>y$Ei2?)z(dHp_31hLtG+P1BLCA9 ztnAV3nYO-2LF9BEAj5udm!H*E?7NsjG-=|ov|U7u=1V1`I3`-53dy zIoYbj6((w3iOb!aQduy2scG{aw(HRx6gp7DcA?rdcm9Hg;spe%v$f3Z?2vfX-a1=( zk+BFs5}WQo?VmSn_j(iz*(a_x6^}Ju2B<~^jgT*zlA6c}=%cXWn9i;rTdO%P)aREL z9^@5{AU#z>_rc8e7jE*A$CvMnk4Ny8=qvSr$W?GZ%4?mokau4WoP!f9S={xN z+A=*|YD4`lPXcOF7-5~VT@@_6vAVofNn@m&=|MjeK*OYrc!Xh9?kf%OM)Mn~wt&t? z$~^2?E__JS7ckBkgtCHtZoG?z|7ZEL?%?-6)`R-(`};XkhuB zG8nVT+Ri?)M`6+xM#AF1xB(lbbkS{Wrk(LTSe`nJ@dvKc-4wAT(S z)-v*V^{)R#^Ox5e*B!<$4pV0R6}mYClD+=C%~4Jl%$XPV6$wMnL`~f~)`1N^AhTyg z+c--5n&c2{KF_w1dw^Vud!eI5%}3?uriHhzZJ&^5pl@-jui?&ZX>x~5wPR;5@xjvX ziqg#<;ZmEuQ=dWQ%wUPrfaDiOg*iWVV`Ov}sN7+q12j2z6(m!lIyrdrt4?p!`0U?i zp%lA++fABQSqSgU14~zRa7(eSmrg?w55_Vj?$Pq>340Z%6^-Z_0(xCq$+68AH2#{Ju)cX)Mm@*bGqBZ9%-QQ0RxBbrLy`@r$~r?>N=3%z(I!B|#vn2>BO!xw!v4p*K?RJbs` z#*jirk;jXw|3}qXM@8|5eP2XE5LQG$T14rP?hr%}q?PV&SbAxsySp1CmhP19?q-3d zyJ6uSf6x1z_q_jcIA>>OXJ_uY?`yu-=cB&*RisrXPMH%sRO-kom%d$I4#V)Bpw`znNQj`r-2RlCd-)7uXW6pQsnd$SSsm0|> zM)3tWBKXdyrhU)rM1dxc*U_Uul%9&A^|c5>+Bf>X^z}i%Kaj-dm|71uQbox(B@lb~ zQ_I<0&vQa~Y5$cPPU6=E*FZSGN2ndl_?WqEhD5xvO&7!n%0LDZv@kKC6>|*?fJkoz z_TdMQ$IO?{Tuu+KGbq}l8#{l#DqM;(S=22J&HDQMc!v(HE#RucZ%uPm+R?~~Yi8uyx-s@Z*(M;pgnOikez z)GN1SrkDEnd}{s9BBW>a=o*0O4Ur1;bc0cUme|-1yLgXuWa0l9e!ihn`;2z@^v z&R$90xpQ-mllIeLn@-b=@7*B3XBq4?`Ehrx+E^nD0$zv37Fd)2TMHQQ`PgUEnb(8S z>)r+ND36v+l@G@Yuj*vh@r0y%Gza;_R#ZXo!5|Ia)|_7`B>=JO~3wCBuR7}mMZeJ@uh7J)$5 zvFqM_fi4RpRpPQ?`)PD1xA5<_Kbtmn^w!nmJW~?tlv^5Y-~2LR-wFzWO#2_8*F!P6 z0Q3zmDV2hrjdwFNHA5C|k0#)PIyq+|fYls+F8r@+9zfXcdqU1B)&;E5rr+U0$+@-Z3J8G{J)wRak z)ysihrWH-aXc*;~=>lP4Oy7XEIh0JK)TR`>lCIO8w^)VT zO~>p5&$$}=*iBA`%=)YW^Rx?5EV~^PplDdymv67wn5}024PGVM=>PV>*G@r_h?jtp ziMl-QPkaOiK)wt%o+}$bQ}gp)mw%8qZCgO#r?5Uh^SJ*TXyKWJU3FS)FAWeWvDb6V zkV+U zt7mrV9UMy4YmvMJY|rZGwLiKYh3#`L$*H?-Nv4dpv_d+=*w~UDrwoM}3tFjgZ>y^t z7ObNp)J;!$;qL$qy zhT7t8uHv+_EF0f!r!kYY8ZQ?ODf)LI4DtE(*GWFn9&66gZvfleD2lQ8izoKEPEs0v zBb>X{BqfCDs_S%?##>=E`vM7+!G4=&n;W|jvia{9wc_#oQ9k=`L^-P96-}JA@*?~h zJ<(}WN2@6jmsOUQowctL2&R(sV%_vC!{fAJf+K$c&@^Xym0drws{lVkt0D$<2{23l zaWLOAUDBgw*bT%#M%rH{wS`22g%xvU`nC?%1zNbxmk!{G=z!jgYIe2@wm#w!b$tl*WER@^)AZf znI@Op9G23X%AJng*(rC=_5Tvn!?3eTo8vt(*RRYNAt0X3*FE#E@O|nCz+v*wj}qT; z5ujpS-{!lZ8M_CJ|e%BOJgj88KT{dZchmesGs*6wc^otCZ1 zr1Iqf=O3GeG;NlV1;dHO|5CBn_SdoTag|CcqiR{h>KUY9dFp0U7wzSxert7OcjvQ- z%aUFui?Rl{^XL(xrj@QP9D4AY+p=FaFnftn_F8OMZrteg<@7lEJt)C z0`~D-eXzJjpERz=q$h!qvc+H5{Fpd(Glm=V@BXxAGn$46rmnTf;8j#UDy>+lnUfN%;mO^GzSj767Gi=?(Z(}O zF)J%L#mU_mc_pv!?6QBT(GVW~N#fK(_V}>ZRddzX(B@#`?m{J%dvI9}u^aqk6+J)*eZGH?bE)aQBiC)*NQ?0lkT|Tz7zkRmJ#=7Z@~ketx-!()D~^|o_?i1% z!qDO}TD)lq9zPTL#co_}XoQrDpvH>wl%7iKSy~Eq41er|qFy^{QJ&p($--4%^t;nB z|6{dkBkCY-Tpv<$qm?7w*)8vf$VmQ-cI~E>~lkByFTV??>bH}e)E+u<*#)SnW z;fGYbSqJ6z_rVY4NjX%*@H~1}gt3$>c!AJL?x>(Ge=~F(xLKaG%j= zIpdq1t%bVZ_VMGi>2dR-xRk8lqH7RMIJoM-(93 z9F<_vmd|n*c2&(C1;-@rUZqvCJDfTa-tFz7W>*}rNlRv!qTN|>S~nef6^kv_4D3&6 zljpZF%`+*9s-&wDGg=+ASBBLhANGe3JK7#6Uu-(^hOId*MR%Kf*(w=1ss8DU)dP4M z3$>0alB#2yhWqf2C}dWUi~u0*rBsd-AO21%h2Bw0Q(IdUP51uF!r2RJ+oBLBRnvU?EKk2aD>t2vIFQU_ zCtuw`EumyibdWaz%Ri*fQHTHhYWtXrtfl59N$2oPSN%G^zY$oU-pGIZs$WWpMDye| zu}$qMAqMe-su|k6hNvn?=h7_Vvt1c5%YrONF)FNb+bt%i1!5n6ti#$=Gr<_O9Fz`Q zt^*_rnhxrdy73-Zq|SBcyc*@1+e`{ll7vOpO3#~i9n7gF2%i%QnYxdta~dE2IW$k` zlE8}+@7z?gf6e4j)*X7x870dxx>WzeXIcvXlvktC-U>#iM`J3}CxI#4qnnJoqGdZF zvUjL!YJlUkLzmi^9TQA!)_((?c^U6Ovlq;f1r_Wz2#OEsMk^@QG{3jA(%}pjY)EWK zO^#mdn~Wi}c<$3~$B5si)=zw>Y4A5^4qGX}?mKDlg3+ZCllh{iwPgD43oot4|MHg$ zq61P3d2e_h{idcr@>Iy*;ibEFHWI$xH%OKJIAx!FKx^1ZH#3uKyzVGr^AyLYa( zgQjNElLqU{b%gkek6u}Ls?#R}QpdxPOLirhp1#?-sQqOm=(geaAqRFLE{j*+T_*rZ z`TT5qf*hpIRwPnQP(~<=>1sNwU!4W;Z%Y{*e{! z77Tr=c*-?s!s}J9letzdml0Y*v5DQIPkPlcMh?pt<7rJZj;D72#RNOJA$wOtRt%$z zq#lCP90_6G;qIIAOOK_+K^-}_^N2H?CWiKmjdQo)ZRZVPixY_9ff^e zpk2-Ce&QGIBsKWQAZ+}mvggK%G#TEYUF^Nww$L+Sz38;_(^M7f$fK?x+mHxX-Qq%H$1oJEl(4WsN%Uo|31V876Nz{=~D)so`_U*BW=e zyqH)PGCUNS6s$}tyL)cA4-bzGPg42PJZzc+I((nbI4Ik@Ff+Gv$_7!-$o}-^u|xsiz$LX4h1 zw^(oL#2m3&YdD>w*(^B!${YUW73^o-IIV9pzV)3Kza8vMQ8l2=C5}*1 zn1Py~G#!^LLt0Ixk9mlVL%*o^Vi#M_k7>9 zs&ZPMA)max0H5OnX>M-+-8vD^It2vRJ!Sh4Jj1oq^~xWc*=YfNlGV!1tu7ILes>P{ zS;>!Q2WQdZ#W8tnT0y z4*~t{i}FF5MVU=iOrZsdz*LF z&tDPFBZsOysun^ANB(82N^GN*{y7~}!}Y00iat`E7a|hFPJFDd+j)Kh%QYa}l#~LareETkPf61K`fO0f7^+nANzLfx4x#jfijR@U|xFm{}7r5zO!)Ag2L4CpCm{L{8l2y=zyy-IK zeUyGY6}jZNXlaR3M|x71Ij_p6Ttep>7=OL2th_q&wn_?3Ql_vB-?}O!okR{K(ljvP zc+vIuyeqdHZW7RqDws~6*Zkq>8?mMiQ7WEJT@4ln1q$-sRneeiA`(gfGFPS^LYzp> zeu~WIvxv9aQaURs*k>`-U*E{mM9G4lkXi3a)$PY6_H3bg3;rdVKPyP8{j-w7O$yyUB>N*X-_68v0$&JSE!+w{jM}j(7 zY~5FBX8OyzGt36|UGiUZI@J)6Uwt~(sp&X_4F)xZsl_F)AAh_Lu$tQb6X4Z&Hbo6F zn76+U-?F`{)`OZD%=daVb<^0~Rrvj2RARC))9TB|KRi>*wu#_7 z5qLrzt55nzP$6>cy?j39efsd}+GO&H|k-DCc{K8LDt zipBmh;t`B!5NTA6@t56eH2VQV$};vniK8|vWuBQl1$RWx4qj!7=!>~J2Am~>3l4Y^ z>Ubgc?)#6W7R*OsY>QojD=&C*^QTtwEb0QGJ>@&;B}SW%3VC%EH+J9Ex*WdY>Qas8 zi7z;!*0d`0cs;mY=MSt{z?U-Ahm`zfNqBy;J?**Qn>IP$6{NDtyr_NNe|@UQ4~z+; zgSr0n2I{?OO66_d2M6T%MZXxH)o!o$z(VOrUkR|b2I4yH4HR)THTxF2rU>Y2n5NZF zc#4d?x$K$M+}&$oSiY%LV4Xh6&96-}OiMMUSE2-dAWPck8`;@FT4IADT zgRy>Fnk=_xwymaa{TIT<4qAeKyFqCz;`su?_~AU)(C!T4L|0g2K-tmuz3&%7iM0JY z_J&aEy0ga0tHM#$I}yrzJJikK%j{5#u%8DerSCkjNhni2`0kdcu|Q+qPTPk7-x@;) zsvJn$mEEZkQ8mi~0HYj-r9L!MddiefFnu6ZVzZyba5s0U5wQ2!+m?jsX^-pM+X%b! zP8ReWsn61J1f@0FUd7YTeozcqgdPSG3qXSX~7@=f%{E7EcQ;f_(8B^`{5qVT=;Zae^DqAoi{Ki1S|kxTC7@O?w|p@lPS}d(OtY;5X65 z@1!#{PZ#z_LG;YSyE|$MOat&0?vR^EgXNpw=aMol%flPW?peWQ=_s3%Ovk!seN{#t znsI#Yz|8M7&)BdoB!>L-uYyfe;qJi!|4$a!otm|)L)5EKU5=T(DWU!JMG4EPaiJP` z`0BDEuaN>C316s$WsDv5uS@$QtU~gdW~AGK+0usXy$TA1_~uL}w9!Lp_efiyJO?XZ z3mmso{MjY{K!0|W$bDza^1&U(Qe~AfFk0H!TKoGNt)_I@y(v!Xs3++`4L{z!s6cOG z+CVe8`p`y5`jB$Fvw(^usoF>k zIyJVDAt8hMz=vzTl&Z*rcTVi3Yq!1W4}EU<_z`fV2yqwyXJ9J$JF>IKb@FG1Gjpj) zR4+~Z-5601oDQ|x9|X+8TF3mNSozSprG9cFn2F735=6t;+N@nqUsu@A{*vg`A{_h5 z%VJb8r-N=L*a1UCKh25O!Cbjdr;!4{k4IKJ4skW+DRm)BANnht-ytc)1jL)ql=`Qey)lg0yGD6SR$QFxC6e)iQp?zV=yh%$i$V0fl&8n$*Exke7 zV)O1GHIkd3TB3-H1L)lj@^NYvu$L;E@}c)YSKf~S3%W=9r_Au5T0rweD_9Y78+^NU zAw_SY=8`US-O>Gw?8ZaFkzU$f&Gc-l}npmB_e$x+37q+6x}Ysu*dBK5xuM z?4^dZDGkC#)4G+iL?@99e^aMNjO|Lwc83z1sis!UP7fR4zTGHb0ljjGo>Tsj0%m*3*J=`%7%KGvId2^;lqv{2sFCmg{o z8cfe8u%u>#oQip!9y%A4?k|ZUns@jYe~YNoH9OCKaAmkX@kt+GWsD@Ypw+t%mN9b; zLWPU>V=fp?_Vj`-=QB1rbO z@bL~Gr^(HT+a`aW8{XL@97!Ug9xyHznw*x#4cgASW&!G1kRf6&xdywe_3nNZ=QuyQ z_i*#n81HHCa-q|VzJ6l+JRhXV(~09D(msyYh1E5aX{I`@wx=0y=2Xd9PkQpim1xV{;R2Rw z4kEYE<1vt)yx-fdRb)$Z{ZjU}pD?C`t5rENfveT&Qs0mse}G`L?YDvAb%DiVw@uwH%a<3w2YOQ|Q(H(_vIW3qs%#FmIlt2*s~3222F_&tM%#O(`u-mC zR+ujTbz&)T#C~k?Qe{iu=S9W&uKh@2L$8+BRIjG6k?WaP_T$6SdpDyqjcG16*SH;U z=l#h?*mJi#-?Y0dgWh6+$;9~$;$e-+2(CTg`4xIt)|%oGV5^HuFJnA3kIb+i24##% z%nfU8@*|?Hsjb+L$HDc&N`Lvx!GxGuumXkz*1R>r(@^|Pnc_r3*r~mP`6FPq9G)lg zrmE<4rRS0XMS(F3VsmC%Ao`foOfM7a0NZm+Z*4-EbF3Fj@i2 z&a)lFgo-JTZs1t(d+}-8);4qx$4#C7g*zsCQF8T5$)t~KU=mxayVeVzTRT_SU3vDy z01SCq69UqZ7}GWP)a`4!fEwH6{a#5i?K3MuzT^SQu-hFXG^1^8U3HmDpi*(m&U(`m z71}u^n{M|cpc1Ho_=N?$1rlWH3CdnaX%`P|x%eNEw&vHDTgsWLuh3NnrKQj5c|a4X zW3qRj2teBBK<%~o=ludk&dS94Y57g-Bcbv{5CKYr`H8b*eVz?H5xJ~3CjUiKr~KqD zd`YqoVQK7_Yg#XD^GAbe6%wx}JT3#gWHPLB{Ilhn@}WyG`a|6;h%!H>4FKM8i)jf| zR2Eno3*S8>{NDBiAilx*4NqhYU&BQP0!1YB!e4Rm8>gyL>ikBq{UY61H#$0g)^u2R zQj4TpVz#u(bCM*dwF%VEQcSM*lrKl^@$U+@W=>5~W4e~GL&9XW8a=d7yb! zXjaaMR>-+M^YHgo7k{GCT;-;|alK|}3LlFUtXpjeOO$#1NA7$JxsO)|(STDg#M%Or zJ)YJjd;m~hiA^egFA<4CQaj*x)Utcb{S0fR;|1uJ6l?*O?5hGCwEtTR(6t|~<^qxR zIcrIq04PK`K7&^AH|YYU{<=%PDCA~GNMt-$6O@*t=6CHm=B=^8NHv<~xcFb*&E(UK zhFx7(G!w1-``}fA&F0)Gz-~3aPyEwHxb^O{&e-d(y__~8S2y!w)!elX{e5TG;pDi* zAwbS%H9%=IQK`d>9<%xV-+I*1^l)>Vf1BuQ=#*`BQ0cw@w9b=5SB+Jeh@M!kB9aSO zf&nyt=4)|4=7KC95evu%=eX7*?Zhw0!XSv@iw7mYK7n?#KBirGU$^{cI1x$sYu1IG z)*0~O4H!#Hg*P3gtf-X1CWkGLG2Z>G*vIrpsk-%l?ldo zUH~#O-B}2I^xVEM&PHo??F)y;q&X1Q7Q@fL|B{sV=&tWKH@I<(1L`^BxhN+6iM0*@ zBqt*|z**cgCmVepL7YwjK!G((dmlStJg{e1`z8I#UWzQ4L$d8lZTLjAyhH&XwjR$u z_)!As8Nh^k<^wt0E};sNYn=2A1}v{A=;+JZo;>pl#1f1lCRD!4YK2Du&qjkqA`y&I}Mz?Ap6DK^f$+h{3&YvzyHoJYw z59E97+LLZ&bWv1X*Pb^#QpNk#uj)Cgk!=0jxNRTB6OaO_U$sj+1#IQ#QRf{Xl)IE5 z#H6q81m4=~3}U$ti~$sK8W4tRVAmKC^d!V(Ho&z>3gG_+PtcbX_Er`48f+Tk>Qa-e z(bbUr+wpV`y+a619T0MRt!wqd+@nI~*sn2<0N$PtYH!ju!2k0Yb?CtbCKKW#clIKy zxPGT!b;p!5H7RD+v;ey2!{%w7iodCr!FCwuf=SstBFR^Lmi^FR$pk3vG-5wtRA-Dq zh0TfOD#{LK>LZ-9Owv6+^I{UQJA0e;C8Oqqaq@Z_X?q_@?zy7we$}nLe&%Dd|8G-( zM2AfCANzP=VPfqzr_`6^cH>>zcWJBkNW8T!SFadss-f_zop0tQC#U7SzRk0l00lDh zo9bjAuxFXf+vRAmcHA+N5hV?BkjU6}EV^vsFmfno;}}P9dx&}t1K@ZB5X3^f>5=;X zkd8$~(qB!Fkz_K94D3)Ws{K*PLB*ndu2@9PUhE^!nFRrF{XaG3@V&j6hsoLNIgHQ5 zLZ3gLC*Jb+_eOi z=r1km2VjKjQy)K6JRf4ma66yB@~uI8olbXB^xSraC&qTCH+A+U%_TA-8sLL&#*5+u z=+FP|3oGa6Oh=9Z{!5N|*~Njir`ym}ri%jJ zi^PZ4!{*=np|C8Sc=Sg7jatV56vlY0z?z}=B@AG?dh~;_f%d3tZ+Qjs#4z$?Wb8gu zWK7NdmLl67E{#$yi4ajT8yYttW^*SnONjQ0t2vQJdDk^xrZB(r`dJ93euj)dteqDOj`OTo#|ZPqoST>beP;>0#F&uq5uXK+iD5lN&D`wYRvhGWs`8Qy^3&>mx2zE7 zQuuul&i!MyeWvhTG`Ym@=Ie)#9#4}GsxRKQZezZ)#}{8nuHpO0NAT|+`sX(RLQ{a` zX0o%jF2}b|tg;p@5!A)NzF?A51)xhK$|_K~8b>)M0AEt!4*P&8_5-%qdpAw%oedz& z(hx3QCK``A&r7W%wH0{JbMYdCLTX&zdEG2GR!SR4f4L6dKkK_C2z0Q1MDJQhd;!3} zCI8*EXlkMM4=W=Y+&b-<6bBdsiF>|9wm9*j3__3x#&rFEkYCBb4<{QlGy%;tq9q*_ zS5UuVundn$H@WT6NsKk=cDhL<=wJgL`e%$Yv(^*KO%#{db@3IS4_`U4mGMTFv( zBl|sl~Qh>UfBov>e(VmYFV^_ zj_$o{)aKM@%;OZ4D>FPz-1tD}ueO9Z&-h91(2ViCQm20^&!Lf2H*9TG8%7;~+>DVU ztVg?50`yb-zYHyuvnqBL*#Pusk4_3e<&Jd>Pkl;(B+&FXmW}>*d>{iKqqAd${I`|O zAMR1C${?KVx2m1~39rZnc1kFaM@e2F9&dJh0N;(!yz7C`D&J$Rk$bxPQQ(I{;hME% zL;<%;IJ7%vRooav$*85ofFg9Za;k5zO?R!JSBAv1ux*UR2TfFaK)^gDHMCMP+>iRQ z%}>8>F`8hvw`en(V`duCsPcyt3|x7uwR0e*_4WtcLU7eT8SMwmg-0a94s6o-vhJ|} z2JP)gMY1R7q^RSMid$uyH@$!LD1JYhbwfHsT6Hr}B<~=9Awr`JKwrucd=C*v7r{Hu z0gONn+{8ogeYEI6Xd;;)QWgVb>jenWRRVzz$6DLd#SEI~V?>0|!|PnMRqIY9<5ciA z^(b$X{SEaft-zy;_yq66P~xbrg78eOreK!C9}>0$ z?u=G`u?quI(i$NV$PLu3Ct@a9KG%pp8ogcvFOl-QME1^&Ic3Y4#ci`p$h4>BCRu?F|T;tlac8dyhg&ENjJ5UGa5(EkdIltY6@xQ%m3 zE^fQ+?W4;}wxz7e_@9}Q!XLM~$$L*dTP`znuvb~^H*XDC&qwx2Uv9iLM7di19l@Qk z^s85_qhbFUnfsBp#}Uj~1D~H;ro(h*<78wXN)-q*2YZrmyn@~04U~C&{z5XpA%51( zK}T+EoQ&H^y#YI?}Qw+iIPqkTuyZUlvSCP`?UySGY6 z)8#Lhvzpq*jp=J^JyFDp!OtipPSpU~droJyi!azNv6G}fB1*rP90*X?FaM|MHVe|7 zybAh-rK@3$!hLyCqTAU)bfaxuNm$C7m=YO49Zu%&ZTyPNMN5S=-JPkZ9ck(lO<84z za}54NNml2*`X~j8xJ=0XRa7v3T`YdDBnC=}Y6$43+LHQJCjNDS4~KKQuihiw@#$z^ z^aoYPEW;4;(~OktZ&8YUxq_!No*%#wXtBTpo4HIy^0^$j1)q|JnHGhv5C1(m`rqy8 zgBRP2eN{N;9(ms^3JOWp4m8wr9t-RsVsE|gMQw29)KuB&ycWpkc=V2Xc;BspLMyZY zi~7GP>yj@pCq9dO!9+euOm(3S4x~<57HEIBiMcd1!N(h$!RB`1*>;Xk+EyVDOnf*| z@Oa-<@GVqu+K!=IP-;XUPbJil8b!$X>-;@+ILa0Ig5BeV5=-3dOm??yGpRFq5dNqV z*_>x(*}UB5B=F%jm5?^ZD+N6Ur=JsCQd=rGZdPB+XEr>+f8dri&9z319wmtb=H><6 zac3?IEy6rah7d4^_B94qtc5^?+29+n328L98=M+a5+=!%#B%{PcGsIS9(~99YDoT| zH-I|gX>@#6rupXFN&6PdhKo=|sB(vEVh3B77&Rb%XIjabO)5P@Mazi2xzhAeWPG3t0L$Am2OHp8w`^9@{5?H1oz!oeLcxHJ)we! zHT>!!#Kbuh(b?_7Q3j)^1yRr4tCJP# z@K=lbk+!sJ#0@RbtzFZ6z>YSw1&qvSA3}$ zY9m(|lP(m*%1H(%R7ia0C!T0?7yPQ0 zc#ge=08}k@*ru24(`djccRsW^dWVYP=mZu4D-inaG+uxfo~G(}C~ARkbd5Em&W(c@ zAQId@-~1vuI^O9icw2VraewkYPBz(#-{(E!WfCT{|6A&zZ^X;8>@DhlAEcdj!e4rK zh3^7o^TL5+Zg0{A;2F^H&4FqrmkelNbFmYPPQE;92D3DRV6m@@3Cq`1e$2>+WyUAmsF9p5906BFL2W7l=mGpw zjEgM+E$lk6IXaMF{|?q(hVP)WLnGF9sCjZb2Q3l)upjFZMYdON+IN@X<<1ptJKrdSg~~UAK9Cy3!&;f_D9!w59l4nT?`*a5A%n zKvy+AjUGf)T*GN;>&vKXLm^55(MY(nDy{WA6ip&pb`mT%Nc;{N?x0YA=8{Sv%LpwZ zOAc{G3+ruMO5uPa4`RnEr?IudU(65r)O!oB4y0$O_{J{9Q!WO%W@l~9MK6D*6kj1q z1Uzw1bzO*X{b22Q?ezEaaD zRe=mj&YugRaaUod!a6EN)2}nURvq#-O6(s=7W%-WT%SO(qcr`Ee&Du-a6JsWUse zQgxe<%ubpCahr*H21PvFT0i7Cqz`9fIiSBhi@Kydta)sE?6Vme#I7)`8-Py)ak&{S zyhxgCtyy)utmQjb*OIOJtzbF7%v;e1KgbxmU&FEb)H?IjAMuJSUn8nsz@Lw*wS<_F zFL5Sp=Nb)jWC3Dv*KD#EpZ0?N<8ZI}xdRQ~@Brj=iKjZMl8f;gJGrd)mFxV^PHNYF zO_8`SMvo5K@$^X6FA^ir@3l5dqE$SWVx!ptZyp?zSu&{By6JJQ&ptkX^gF3sOjWs% zLRhh<45!&uS7jyKX(3hrQL7|2nkrNmwL=Qpkn_9eBBJ=P{Y;dGHU4X->Bq2e%yZ7a zxlkB)-+nDY4RN)d)b$NN8KQ9!BbV@!05p7`PP{BX$e;2(WpA>!xp&2W^LlEh?)w1K z_2iTX-8PJ$Fj@lXcGB}+ zSD#+eAN#1)`G5iUdjOAnIy-o9WEE_~0gZWa8``)**ES4qY+kE{>p-M0$26803m5N| zl969U<|3mUzv=fR=G+-%|DkuQO)~4zeR?>5Zu(rS`3;!dLMS`w_0!j4fA>vU=DWU6 z1W0Pr!+UPx;mzILxRLL%!+NS3(Yb&It@rHOD&D;&x>Ie+nBj|Ec2N2V=MMO?{iYML z?vKxiJlwX2o7C>K%w*1t?Jb=W*`_m(A~Wt=SNR%4Hk))_lOnIp@mRa$D<}TU}|mOKqT=t2bNkZ9~GUId84n zFvsk@cdb0gQ1(1~@dQ~PW6NkdsiOCLd|;H-`aG#w4qrcJYO)ghjO#^kEc7%1#c=Eo zyVi7fDUh`Ie-BDs99J{g3=LQ@cohk?f+qVr9V2u5QEd?*o5AIRWbeSCkZHo9+if9K zCSs2}J}0fGba=~cn9fMSZ9~2weZuv`X^ZU-i$&&?QnF`%x5B1;STghrLinoPi9KB9 zPPiNoU{9p3H!Kh++UEoUIyl>%%{ajQ-lu?slgv>lrLenbwMOvy4i>j5y*ncm=x4m4 z`x5(`Ts;9XI?z(_Rp+{VN?dfww& zvmm5$he;~Wee7z85)67!5IkfH3CO)IG&YaB%F1@iJ~~wwoCeQ|Og^&hr*Zbclu0%B zBx?dzh`_X4>xB+QhY>m^2eZq3ZKEbAcG*X0=^E~XtMj>7Vr{{Q(WIT^bomk~GUI;6XCcv@E*`ZxqTZ>4^^Y;GgmL;A3VRg;wHw!&j-QSDLvG2rsq zHcSih#7rvCFZ~V6aP$z2hMu6T2+DV3B6WAB2{1|Lp|{>qQCv18J~&HqnvAkIJ0F|j zE923bmO1M{VqbpCVXrOS^@S<7fBTs^adU6b;O(l00*+7K*(7h5m4fbMulhFCwNs}Z zz=a5Ty6;#~pE&ZVVV1^`Wxte4qfWC=fPt9Z#iQlnvQ%$~W?3ON$^(h{GAous58_OQ zi!=>~AB&~aSXJLD#;QG-T8_-^-eQifJ?(vdXgVMjm@yqyw|yJpktVNQ;cC3}aH5{- zY21A_|AV`;L2vYUuJ7?c!+Abz@VBacx{dosIvEQvoX>W%bl^4vIF){Ke)Wx-RuiOF zR7Z+tlBQxmS7&&3ytZ(M*T{e391>0;7r{K<>G+Wjn0oyRE$y;V1pQEi1{iftQ|J5_l%d6s8 zuBtq8zFKz`pSGU`b1PS;M4_Ul!)os0=?NNW!+=nu52E{X=XpkV>^;C9Y-kQC+ z)%r;GO8YYE`J)caS_9dgO3^e)G$7 zreDc(f9$xoCWF&)v$riDem<18k?uI-TS`rm=(yN=@)*hpYM!2Pa9+%|qgCBKkiGw1 zG4f3u)#wZ_jWu2zak0=Tb50g=#CIX&`T61aF+Jkp@p8hHEvO2#zqElwikOrQ-6{@! zxJl{EIJ*Y+F$#%mf0P{|ZZrIn5~5Nhv=w{Q9A1iTKx|9)y3ausctL)w(Xr=iX@2)Y zi^p1M44hb!YV5=a`Mf@UanIdYbIVRKJ4LMmr)>4Q{C+$rJm&B>f%QmsxWR09A>vPq zF_OdL(~l)Nt@1wV=m~c&?!m_?KTO)5$t9s@CcoW&OD)%RoU3Uezy$-~0{mMI-cwY; zOQ-7vt}dvXX`R9rqU4P+Rqy{{>Z;?SdcHP|h=7QQw2FX8iFAtyC`cpSh=6pnbV-Lu zw{(MavouI8z2q*v^s>YfOT24+-{1WQKX<(|bI&|;;+b>iD#W|cJyezNu?P?h@uqmQ z_R84=NJpZ1*3B$2Qnz0I#BoW*lT5(R`@HPXjBdeW2VXd0nA+>-!dSho$iA)mzLz!Z zak#T->aJ+H<&GJX)zy12p%35fX(EtUf;|6Tir}`e-OM`MMIP|xBtx;WXFG)@$DnS- zeiiq$|_f06Sbf1@LwM$H>xTq$OJswQF z-aCT}oZmS>z$(`SWHRTOrqhLt;>a{WG<{Wir>|zq(z-4Ok|*pxjOT16#wgy!ziR?a ziDJlVoxbT6zdovOL#*GN`#C~gA+u)JgW~!(H{N@x@3IY$hX=8{wQKnMmm=*N6&DM! z98FP-NH(rWe`y;A+^l8)NL{70X;w{q^jtMQS)(hwWW5Y`O zbk#Y`M|7(_C);i({MSEXY_SPJtuH^8qW)*UW8ye4F5{Ul9qy(f5Nqn*ipz z{STfz#oM~+ks>Rrg5CM}JDw?DEw{;@uOEp}BR?XyZC%AcKRGkwZNJE;h~564fyzuO zNhrVaWvN#~scP6f~TE9 z!9T?ZMJ1gq_RYe**Bj}QV%`F54_l}Zxi4D(IwOueN#~3 zb4pR-O+<;FXB!{4kjQ55ND$Bq;cc6gnC!W8)(jGO_x-3aJn@Tx8gkXlmbS7#G#g!+ zq8k%Qmubs&iHek41gA;_c8Fi-y!~jb>U6h)tiWr@xJ|WL|^S038x!NNlfOdZ1b1_-t^XLr74M_>o8;PECk!o=X zF;4?Nk>(@Xn<~dS;I7EVh?oD(@C5$)#D|A~rID+bqR?4A4`KujvXzTXmF;0))hw^w z5)?3U(|kEo_z9a$Q+o)avvwq*esW;Mi=hFEU;bW!cfd>ob3~0hM3aK3ko; zv~Cn`L0-4lrDa*6OZ$|M=^x$<61>?RhrTkml~dIMs(9OAb8;?1#o73`HVy8?&F-$V z!|4jv6!CPMcP*%@aI~JO0?$vEFO%lu540frg(;W>{4WMEl(pqPHSc5?c&?}N zLk=S0SLpdB&^Uo%G~3>XdM(2B6A6Pe8hHeFQun0}A1%#$BxS z`**C{b>c?auIUy=v>*ryNFxduF z%svjayj~Z59c|BH)+;RrxZe~a9!vFb;dJ)}b<=K&&^9MP>}BWu^CsD!P=>K9gnEuo z^%o$n=-_PRVYL@(lJppOd5h4T{}RE@Y8#Q#t+feY5v zpA&@faIJYjYC^w4I2w~caB}-y090$aRkqb(m{n2*;$=$@UFj@o&GR{B5M)2k*epB@ z13}vTVTknfuRm8fBG8P}Q`ejKbeYn(Vj61$lzu`>qE;Qu&UrOlSZYT~>?M@7?t+z?#m?No_=}}2TmAqJk9-p^*vLF+_mctMb{aCYub}a#>*7(2 zk@*{~Z6)Rm?@fj)=7Uqi=oWLxDaT>-na=_NfV0{4{orlR`HiE&=;O?@vr>j9xUMPg zBheLRDOHjwB9G(DuIITwxTz(kMpU1@;l@wed7<(Aaa)X1@_XrFn$UWq^G~L?^32J6 zPLGkw)-f)fd+oQbx;7-q50|GsE|+zpDIC^DeCRxpIb@v9{_|e=z_S;ZSF<@yOp#5N z%IA`ni=NDpfTL=N%)=SG9rkdUYj5=;%iTgwALIdNGa;YVjF%i`xdSyGyQ*t*c7NUk zgdZ_XcG|iM4UWIc(wEFWrCqSoO?}wddPA^HsD+#G zLw1T$PDvfkiaZn;Pb~9Zh{<9dW`ayY1;fowJz2$7ZVg#%b0*C;9&`c&np@EoVjlez4L(+$ehA(QUEo3B$Ou_m z-GyI8qn!RFZ7QE~p~*)SM?rz4jtNP36=Ax9X25X6QWEMooq;Y=%aFvcPwmOVH z*!2W<4Sx=6+{H-V4vdWODuQ`XGzQ$0)bX+7OTD!?xrbRgPU3SU>ZKvVV^%rOj*@9f z9<<2{1{ytcb4*)(vxT9SUY`CcYOrMA?A=yFSauJ#IWV#GjNCk2_NXmXDl}VSLsk7S zVoJs(@fy_EBpv_C5+!5!6A1UThJ^^yFMg(Q@&Y^<91AtP84eZkAaT7Gx!T=_i#&#E zElvU9vqdI~Fk3?L%h5+3_2(qb9+{hNXO1R|oN|JmuuL%t$;{XG_02Hx3z=|voW?3~ zHf=inW|LAfqkXCwAHu>hw##`Rx--H`cIG$GS8bl2%{m@7S53TI)|lR0Zf2ldIc7oJ zS22&$=ay{4OXKhs2mtKN;_uiXk~BVp0Qcu4(Y zP#Y%eQq(yKTjsEs%Sj(0bZzid#Pf!gS=Y`#?U>b@&!Wc+q?zT7>kjII>V3N0{-qO+ zI`F%rA5sn(c&$&T8w4P(@6lx*)fd6r_B)%?5z7_q#|g!mxlwbA;6?Y8E#@z*IvJcJ zh06T0*z}8$o<9Xm7G$NJPtT}TIe|sBN9}uyX4d*Zj-G*5GtckvP~NGT&?h^B%&?ko7tH{*gg} zTgo{$xJ2?*nY9y7J0Clu32k}0+huZ%W4X^o1i%_oPrKvYU#Jli*#ke^rHie8`)tjz z>*_VnM;`}W?hh5qhLR4pxIYJ9$N}kM^z2U~Df4hE5_=N$%Lw zn&)B)M1>rS;McKa==8&ano*GNS3m8C)yjgVqP~SOy$)ce(#|M5qor|J3l$(kZySo+ zMBd{xb%tShT-AHNBgE2QxYzCYHmQwQutpPbrII?18a!&b*%G{8quYP7P`jjpj0dY1 z;`vj!ycM1Qg?c0Q$u3V%$Y zWfPpYOw3r1jFbbN;nkG$Zg+;$02CT&w#s^245p5tm@X9=cf-EPixfZZPmaJl=A%<7 zoBB+r-LPAx#oWU|I~^*&HSmSQwkEe@Y;x{U$nCjge1FBY$}k*5btmj_;6uXK8zJJj zbNI?zy$3jelDJ9R*ZRT)wa;oqsHLLmyhe}A632DAb0_bD@CY)ohcZdrLBw9{f&`8s zcBJVZG`GyL+^I>5ra$wNuiHcNpZqO}$5q!;pBHTpV2k(aI zK6+3GKh?f0vzsK{)3)+@P)m1b-MOsLG&re>0;#DXu&=aqc(HD>&c5T^5$)XgHs$pY zjp67JCNaO;=W-f#5B-_d4OMCD(H_ns^S6(fama4#qq4Sp$k;PK?QWux`GJE4tHaa<#Qy5 z)0T8Jh#|2Pslik)Mxy!=I_}PSA z8-Oh%qN!g&_dR6&!(8=p6RGG*Pci=b6V^U*Q6ed}3ZL#p7k!l|k9QU~@&l?vm{Izh z3qK6(ZdYMR-NIR?RlMB&F@~Bg!zTCR`cAx)o#?cX6ksdr%@6ce0$0ntIK+DWbEJ$~ zxQPi%d!#f6btL#?B>iTz^7{``U znw@;G$SYD?{m_?(;9-@IvLB z2YQT28&|KT%H;^29GV*V5%-Qxjeb`!%0`d*EiKtA+Ntb>JI=Sha0q`5gcIMF3fR|d zc2;RWbfIOB_|5rX zxu6M^fwSA9qOFIM;j)xQ=Ef&y5Ur(tfhwqRSCad}+kM9b+eYk2{4(^5Nbx;?QM8!DYO9ZVDCXS=dD);r=(`Sq-L9V5<{o~aP9ud#PShw6e z2XLz*E8TU()?HmopDLurL=Ib$tG*eL6+ZrK@=bOAbg}wDw)J?0bpd97g2kKi}t~16V+9UZbKHq4vVwQoItn3Sm@2Ud$Qu`H&aIg-Q}9t zaz=VFWKZ)OkB#%{IGdw`2@QBdz*bWhoxQ4{{z4gVyx`xs*wba*A9XH2!b>`zj=Q_R2tS18Kt;}J1k6DvF-?2Ck zfgG>s02@6v&v~tIm4#nP4o`HWFeHP{)MVz?7oR#qI}dB`NX1&Z{9KQ^$GFLaSpmCDSqi$w zggY|tw}wjH9}!(ZDI_;dH#R$G_d3hI8JH08n-$8~$kpG3J32n{yQIhzvn-^KO2OW_ z5HNF%tmeA{54#dwSbU5q*q>UuJCrQEQ|afe@F}C}hvVs}jjK3-hwwV%jtyOk3pE+-mn58-$2if{9e|H^ha(=gO=b*F=WT>+tTet0wsogP zhhWpb+*wl^#d*D%+*QcDXP<>1nSc$esOe*ZD1$uQ9XjYM_!y~LDY<^G!Z1> zu9%D|Dd~N2&OA&xciZv7x09XDy{DR>ML7tp`zL={y;VJnKvFsNK56|>Uzy+eU;=0I zY<<3X6^wW8CT>BrPYNKnZ%0q!v4(i7uJ8Nh(!up3XY+!!=WY~S9FJSkB}dmA_trYz z;f2cxj4B9f6eE zKmMxLeL7ZLNX@?&Jzz0f&GV!acbNr$H<ObQ*x)rxbK50ia9y55ihciQhsq3^W496h+8rwsrU4)h>;$CMwr6+K*nh(EXP7}*SmIVtIIJLQf zN*ogv9VQfoVcV72i&{7n_yugh(L4zBz8l$wCPV#h=SuRR>GPOaq`(<#Hx z;)XFKh397|p!E+&hkCL>!PR6!j_Yo$yS9O1e2=E}JfPbQ=MS}?fs)*VW?WdI75mLF zX-)SxK#Th~{R@JiQmzh~Q6o zpqmXWKN$Zai=HD*7***PX}=ynyvkD#P`hf7%(wiKDZPKw-N-_XQhEn4}hk3T;5I0qAJ4(RO9VPxR z8>fDgme{7#SZ}CE!C{7p4tq3ibsY3?a*%xcRA4_}>X^94W#mWf#}|gDmHL5uG-M?ns2D)AC4p;43jz zkZ@yxiGRp#!x>61(^Hr9*qJ0VyKu;Rlf)mQ3ym8Vn%??g7x$Mf?!u#u90e)oX;H1$ zo5d!aI!$LV;i>U=d*8tHt*gC#Gw;Vt?+!_*VqY>T>jbyNbe9dPJY(F}b6$udVQ_di6_@Cmwr(;p>w5n^aZ$HD^~Fr0(}kHn$T)Ci z?SuXfFTH(;;EGZaWR1qJovz$x0l?wN^IptldK5lAYO*M_rR~sJIufO&LEm*vWef^( z!5g41f}QM^xxqYj+txHX=1QhX6@AK-MqZv$QVQR$02_h0FRWm0xh<+70{#6E;c#K} zq3V9gH*oaVD?R@pC* z2=m)L`yh9%gTb1&svFhcnj;ep*)??{cwldSkDeP{t>>WmWZ(ll@9_$Y7~BRsW895n zzxrJ%g@sEQ!2Mu5)*WoMJCPsb=zC6^#*w+-C>l^=+ameiIvr>wm^#sn?8(}>_S|x5 zGydZB=*Rx@H7lo(S)uJzz=(ijPb(uf38emL;8cOepB5ol;bnhB5Su^V<~P7=Sg2T7 z1AELF(RR6+uPS!DOzU}>JglVW{aggF`u*GdQh4f8+|QA-ye9QW^(Pg_oM|Fs?~)C7 z-nCZh`AHFf-(Wb&CY;q6Q11onKt&ZndfxYcBtw?n!`G~;ou_O)E9n(7cWds3JDvjecy-kRA!+8|0oG1!fGu?W!mv$iTWJxLspmgo^3rK8Ez9hrT5_-CvLUP~@Q6jiw zKB1xP0TWP;5?0>MVi823{ka0V5+VvAQc%P2_g!^bc+~7212H6P9ot4oLV$3uL9*!< z;4aSnmWVtKHi|^j4sruz5T$uWgN3+gC-@t?pD6qCspk7S}~00DwG6=IM(y;&&@Q+HddZfe4Ti*9qd9osyRBR2j|<*X!wUY}b=w~sd?$I5AfN?L#b-!l= zvA3oB_t&$g8BIbs7F;L!HX85X5i8~TE|CiWL>oW)m~K|F4Id+v#OaFwjq*{~YS*x_ zk=uP7wS0A~K0Yhk!$%OKd(evqs5^^<3HsITqPML|=UE41fji;|lj!yq6`>uqE+p9= z5q+>UlMWrECILT*Ona&jI$`L$mGg*`ZVTlS&JzpcC%P|-OJvp*XL{Qg zZJ2IGTr+C{SK2qy#O*4l82}?FSqUcl^hTOfZx9qxP}T+E4%783MJEbQ)MX|-6EGi1 zS7#BZnXbhGA)a~#Z@N)+UG))FZh35Qx|{5MmW*cUdK^6@^mE4Vkm!O_i;EpdIC4Xp z@#TiO9|F0;;z4AV-_0PI`e0Qnu>IMxzEb(TCJg%=Cv*TegCm@$ z^q@(dL6*^MzgQVrTN%N-XYkV{bG7<< z{t{*?Ml~e5yxNtkdrOh~Ab&#bGk~WDT?CP{tAL{(E#}?=w3PiW<>An#lj)PE@d=pDUw(LGtll_>1$R2)+lBNH#i)8>vt%XcD?;t#gZNTqUY z_2IOt+tK#|O&(NWdbziq?z87f+rmi`jY9+w!q^C$2VjA z(Hha|?(YevXkEX)*=Tp{5PE}Vf63f$e;68#w&Nbb{M7hH5L3zj3`hT=1pQ8O^7fAd z-qCOD!IX6NA}i-YD^|guJ5Aqd6=awA<*(tiFpshcEkE>E%qJ&SUu2}mNA|j%yM5vwE3u!iJS+Q_kxI&)0E)jS9T#I{v|v`{7mZ-nwm6=YsEGbS}m%+ zQxZ6xsEr7GyyHl1tiR7G0tz&%FA__aGU<)vQ~`*-OrThp^iGo+OHhq)f4E0$Kbj`9 zP0A?^u-FVCyK?SoR=*GTq<}SS2~mo!46Brfp(EsuDxmq3{Yyq+1O27jRNt&ae!NN| zdE~J`5bg^iTnC2b?&S-@OgbM)2Yr#wFe?|1GTo-Nj2Bj4F}UVfBltoicsRW*p{Xnb z{kam}nr9>HL;S+r-?rD{B}agBa^5YdgcjAHt2JbX%l_Uv*ak!<#Q;wd0Du#`RlWA- z=HP0EF#|iK%66a4#RGJB*b5$>yzpLG>lm&`9$`2Mp~z`@>eO9y-BfAm2ozZ95r#^2 z$b*0CwG{E2G(JC!vME@imRy$~i(dOG{Mx0XJopwuFn9KDxJ%m2JqUKmR>zh4j~PPO z{AY6hEn9#>(Sta~Y1uIQmEYDMLmfGGrnW||uZ=|&5>b*(aJJmseE+pkYXXU_4;e9C z5|0TVC);Zju8A;)|W2>cX$!uqDCrMuo8OweE~;It2e7Dx7I0FmVhX0;pV6 z5bS(B7!*QAAnX(WQHHILB()VQW~YIMo&zDc$jF!00l{s*kU+aDF#>5##3@7xq$Yr(2ndR#5GR3z1}fGs== zZK%DkLZM$9yt&0}rZ}xnvyJxmoYM-d3Z}}KkRGm9l#n(-Ib!zxQ!A)Qi-{az!XnE_ z#*H}p-O;(j>~qE)GAUPubB3+&Bu7KE&(J$kXeDHD2PE|K zb|rJ@)J5LNtpg{z`-A-r&$S~kB)iX~F$Eod(FdFu6kd)!$D)M(4DI^?dk3*rBR#iX z%(RuzeeFkFrGUZwm;FRBP-OCAwe2 zL~nvgl|^9?k{D)?M9@C_)8;TQ{o+)2s*<2sWVqe@TyMnb6BDKEHMXV_ScvF+-48wd zCn8Wl_Pt*sKv%aEHJ*kDiCqO2O$77Vsu>Jo6-lLFz%%@4pZyWT$Yo%WXfuCn3I~(v zIc0+OC9$2#o@o1nW{%f@^%%ZC{|O?b>lBWY?dTgCWP%^|TQo7vwC33WV1lEsTstH% z=qcTE^EN51hiw7B-W%;&4Srs6Zu9(F@83&&|IfQ@r1)|{CXX~p%56x7&uR~plvO!B z%}_EbnBI-SE~n=I`fW>WLP!Orp4>=u>5K zxm~~i?T3qpe(TE{d-DiKaz_@trLHrqg%zN8Kt<0}<=9lW&QT)hw5?VF9 z%G9C6IhjaGe(%dQ3-pSn+C-To2%%j;bQki)p%{Yi=}~~ zYb=lPoXYvpOQcvMuD*z#grqOJmu!r{r{k*8f<}Skdsm$BMbVkbv5M97D`>L^jE^}2 zKWWaxbNg=x!zD%N4o0f{M@Id!(K15!DK+l*kc`b(MQSJUFd_{jDF_mlAlBY-@SygB zt`4+Vu;>XsSILqX(-!lVC5fAJv4K2up}tdTiY_YRvkgQdqux!h?fk(zMG)C2=mhu0 zFlO)VH-F$8;OHBGV0ySZp@}t=m~AT+Eb?run$b1W#bdb{T`|HAPZ4u;vkRt>^dDm0 zO^t!mdX_YsC76o-Qs9Dzop#%<9pk9hfG88(ztF#rhJf|T#O=VaidX0)7!4^h41PQO z`nNo9k3HY_1){gZLLX;XeFoaPfszn<2`9e4p+eXd3Z}UG?$wx4Mjf`)pP>=K}2;r;+RA?ivJ!an6#K|hYqTiGeSY!KKR*wIp4FC69(0{1# zNC-*zRDifN6??&f9Bo~Hp}QpG*^#%r7@ycWU0j@Q;?R*dnO$-BLJFy&B}rts!p_p; z59#PSS~}5-eB}M?)z#bf7XCZ6+u-}i2Q4Ga?bo9lxw|xIp2jS`~-!e{P=rhr+U*CSqZsi{q z%UH;}-HBhQQ~g==L@{n;ckG{;|IV+_z9#;GtMSBY1x}~*eZXeajgA(RW1RCbOG0=r}qhRIy(w9Soh!B<) z6`74R@$`Qa<~J94bzAeFre&gVme z(t#5en4StD^#r$q4=ZWja6K-4mt^36M&u)Gjpe4!;>FRhpcwA{>NniKEC)7tVH$Zc zl9EFL&%DV3_H~rEsHQTCo=!P$qAYl76c<}LLZYJG<>x^)6m&cmFD@?Xn z7lf^JDJ!8xXq8hdoT=1EQPB*T+yQT$1j>JS24#+r(W3p)1%LH`SFvU3AInSe*djlX#kZ1xgnBz zL>sp>#L>TKM<%fg-o$=^qfg-sZJv5K;;`(O-NIa$D_Z>?>SnF+Z=KP6is_R+(7F7HX|Y6X5hCG*w-qZp7jqEggxs#S!!GsL*q_BY^(95&vpz(`xf2Q07IvG z-~V~CU$DKZA_7b)r1W}aX*nljR;9t0!L`4W-LfuNANNbT+e4U45+gFc{DY!+{Bg|tuj-QP7ig9OPXd11 z*VHI9(B}o)t#I5Nn}{C&aiMW{UbPCgXStDCt*CaX@L{oubIY^#OjyZ}I#4Y^uAAq{ zQt&$6vCYVpKHBR19mOM>k9{^L!tL!u{~3pJC&Z_`vq>KOB$+lVoQEw$eSH&?39Jn5 zKTG2`FmkfcS8d?Aqwivj{+PyR7&iJB^WPV{^@U(NAA;p!w)Ti6dNq(ywl(|6(GJGH zq)`7))!^VyLyM2Ri;Tp6@Z&f9y#3ef0Q<|uJV(!=b}AIJm((yFLAsQPL4>}_;v=Fl zPMI^YBZ7Wi)8kCiz7svUTyi~dj1os*i){fNe*A}T?r_!;Q8X1o+WunqvA{D&U)CG6 zt^aE=Iqqs~8IM0Ac+=`ndK51YpQCmtb3Y9c++$J%Rm6vkC6nL1)wCU|*{n zZsy&5WE~MQJs+1!zjIvChJfv`!V4ht;J+FM2OpBI`qhgO0rhlg?acbZdi#$_)@W2h z4=*Wik7dPza4&V?TdPZW8TcqMz3M0W?3-Y3 zi%t#V)P7lFD-UE4sPc?7s2p;K=R0W~1p!z1!j!ag<)-rZL5D zCtN{rqvgg$@}p(GhAv8a{bLBOBndi&V`SzyKse~ru-3=ef_Me(zoyTE7o%ad)#_b~ zI=J)po8P{9St;&YirAC{{~L1i(HmJ6EV{SYy65V=q6bTRB}>^Q6{zlUDGvHMvAegM z&^7ul<<%EcU_BfXLF}F(KHzx4JI+`^YGcodKi&y{w+V!aZv^Ew}scND9!idw5y(DJ4d`6=cibv8J@ z=noSAJUxn(;LY^Ir>7O#Xg#8BMSjUL5o79$owD|GX%67D@ehri*cVp=(*4ngZM+&W z03aR_ZW+$+5kv|VB|Q4@o~k-75<|m&SL3rSY<*utQ5YLI087z&zjNnSg+4O0q(V4R z6%qO=!F#DA^VHzHvZP{lhH^xYVxStH0j2jii7&7Mo{V|e1m=PD98WCt>!Pa=ACb3@ z8yyzO=M#0$D{*OU)JgIeeG0Wje-S3U+e~A+F;5xVH7)+A(psF~`2DD+K?1#7dD4x_ zGvKd_I&f`6De{S*;uNT{_)c=QoR)_3i&V~uc{w5=u_JC<{HG5pbbpySNJ`pxmHb5p zE^}+8OYMNk@sMj~eEEM?r`O{_3oNo0X!M>fEL>90dU>(pRd|KT?B)Tu#%W>EEAK^H z)cV&KqJK<&hU>`9hOL0=O)BWS=gsUY?;Pe|E5rg=;Li+|4w&RpE)&8}dQMekam$mC z%K5n6IQ{pAi={bJYhzpY3$(>{^sOBKEpy(_c9_F2@sp$z(K*<=RveeC?=tF^{h*lY zeSXT=g~6mdIKN_P9U1QAP1pZ_$U+@>Mfiqa%qqk#0Em5O+29@4=#BfmSG#b|M&V3N z>|BF-0v>eE^l$kIDL68&=v<*c1b!ggUiLxouTYiyuFxS^gpOpl4e^WGBoZ1;ijSNb zYI1V5He}|{%p3n;B5mWj2t09n0~^-z=+A@BdbKQ&T=Et5E0vH`?9$I~%dZa7eZ@-o z?a+DKMGZBb@r1wiPO9LI&q9j<`i!@~v1pqDb!=0hG=nZ57R@OwyY{lz&WvFD{RJ`o z&9Gk#bRJR}xs@97D}>Z&arkX`4&6pRuKee&v`h(3SeT3_-AataD6y3)06!JL7l?-d z%}$f-S06iy2~L^_^}^}rKD0Pw{l-z)T>3hz$TOj#|D;{^9#3SUWI$pJU(G68@Gc)8Cbvro7n4RMp-eDe2(i8h(3#w!PFSPD{ zJO=+4>Nu?F1{=RuoCp(1i`N}+pHzSzx-NBd?b9n+7g@}*)?CETTb*l1kThjsFVHaZU`~acAEy= zZyEo!hlGxWg-O`-hv_nd-ZoQkk;QoM*35vF*yxaz=$gU}BV^}~25P0=st@CDM6CZZ z68W&}TQ7E42|_1kh5vbLk8}ag(s+K^A0s=eGj*4_SYwp(y7t zJ-U!FrVoBeq)Yuow=d?~ks?vU2iva54k6r1>pyNA?{>Dulg#%T?@0(?7$%Ird_weM zQ;WdR>CQlJf#3frBv@A)x%ZL!u08i?@g{+&%pL1_9AmOyd?tEJ$4Im+Dc^BBB8&ZM zg#Pf&>h8{h!>kuPFlwR zK(#TkzJH8cg3t^6nJE{9#d}#F98I_I^LD0vo6u+sxH6p~8D|{6)L#+FgDiTEjd5lo zZLe&_u-zPey&$}+Z+Bn)1?O@&Ec$lP1EpCVm0z&kgpG9dw{6 zO@>}XlbjfT__#tH4Q`6`(-QE^KekLI;Ne}Q@q1O8;xR5cNk?CasW%{2pzZJm28q=@ z;X9Yh0)J$o_eP%eS60Xr0Qd?0Bbu`O6TOx&w7*0~pqvd9CEa%UlT?zi)3#c-@6rpp zeV?4(=fn|z{EX_4lf%i!oQI4F!0$Tp9;W(-HJXq3?yuf;cy0rLY>FDyq=v6$m8PJW zbQ6O1AJ^LZudf_#Ld8n|y&cFPhw77jJM?L?zkVSiF8L_Lni!35*u9TIi@hedg%(mB zxm1@(FGa{!8SwGrL8Qh2L-22Ro2V>AT8e_YMn%WtR5;q%H zabDMveuDEiF2)qFuyws?j$#p2fV$eboz_ug9=#6d#N<$Us8ak*o(RE@4;PjwEK5S2sT zH#z7R3X@>g8{9B9Tj@C!!6DWQDo*mzVq8fiOwIdLyj(IxJW+eu`*}hvr#1+X82ivB zXQGU}LXtwn{M+C=Zg(SuNNIJqaK~^Vms+~#xEM$Ilh=WL!1o^WzM~aSd+c|h2F2q| zMLdyXUu6S=Chp=BRip&nX=&uqv_ELv#->?m;9#s=dINfl9enASEgu^>4>0FYSatJu zTB$Y1gM4n1p|) zb{?eHE4x&-4k6yRB+Fb4cCi#cl7rXeClMMsuvyGdkQ*Kef)KuW1dK zL*1Yc3wg_@Tjqb;-XJ6(%4`ht^@6m@HywY&kMG}-3lQ1!=NF6}qfayzDxY*PCQcA( zW+D)Hy2R6+HAnN-+#*EsPP7;|HnqZWOIuU9&Qr>URwg6jS-~Rm`jeXHY1;PMABmqw z-+QG`q+cw5Jz9LC<(%<67)zh*`;*{eL`~a(mr}7K)Z! z>;m)~)uIM-3n+T^X^@77Mp)`wEaJx_4>avUR=-B=sJb(>-%Z9YO&Q41K4IEFci0`b z(x23R$suRE=3e#yyuSST1ww5qNDQ(=Z1U13c3i(?`dQSpTXkbLUqZ>#<`IWVOPhUf z{1Ua*Jt1lI7KBdY^@Ii4Pi7fQx*X@-9rVA8IAk*W2`7$n5mG##>?!8Eg^kMR_5QD> z>yAqL54)C`zlNhMOEk-$D|f>!t}M+=QFG!fbK%YfDbCW&+B91h>_z0dR9`+P1;CE>x@cXdJvc|s(v7=Pl6eUo|I#P}^yaX9MF zWPmlSY6?7hhmGI4{wiHwJlpN<0^7&cS3!X-9EhpBn-Fb7r6ZU#H8fnbZ0`6lGJMoI z`P5mxXFa)6(0X}4Pi$7$>!K!Zt>(Ie*ag8V*DhSl30<|yxm(COls7f)#drq4!Pq*| zlL~eQ%)J^K3(!~XY^UMkj_8mR-_b~nxq`k9DCmPVzj%578x6&;(EGZ}Qt8P*rqS6a z;nAxQ1K9?daXJZ`gz@XwhhWF*+P^P`jT}$Je6Yd11#aac_<2lknxswtGawRIpfe6v z$s$g<%QzMJ+SvCFR_O`xIaLgQfnP_uH0s@)5%ju0xHk8--PLGj{poA8M`4F@q3N!s zWfalmY@zsgll-o)#no>uM~$j&8|N{{LLIsC{3a9aH{a!9Z-BPV?S-*`(d)o*B^o;B zX{@Hc$%RnvShjGo!L|V%GjI!MttFhe`Wcp;X0Y{v zXmuS+)Y(5Ij1Pxq{UrSUT#%vkiq;Qsho&A$t3<5>^QnOFga^gr3cUKAZm9zw9EU5b zi|&BDZG`gbSzDc$Gx=UK{3A-xA{vaV&Sb7ugnV*~+Wc{iF0eH5(Ji<6wul90i zluExMJmzL9*P?lICQRyAmnx<@EjWHYdPp){y6D)|?rZr(jTlb&(zjXKv8#0N9Wc9@ zHo*Fl0TgyKc~%FWr2a6iqGZr5BD1k7Bzk3rKJq0=tG}>(nn7Px=_YTo=!6Ah)oYg> z4HL08AEq~90=5CrQNlAv-D?pNGdYZ@)P2NX!h@v;V765%&tB%vy9=({AkXAj!n;CU z-H<}v+rKLLU6G!idF;T@Vn;{hFI_uk3jd6j$njqDjfv5LFYhB9^i9uK7PBBkIQ&;m+X1f(01F^hwvRnO6nOKvW-m;wjny~{JJS-z`Co&eXtL@ zn+-fEqSw)Q%T_V1k!MucoIK{IB36cvOpE#KY6P|kZkhR$~{(Z_0185%x50BkY7ueGt@y@>xTH)UUt*oL<&Qldt8)m|laM+U^i0s$$1+Bn~9+};+Qd}gZF+dOK%#JK$QmLrtDbSPGQ zxQcs5`ll+YiwhxA@?NIB-IM9# zC;U49%rWjNZW5ZRtJbpz5p6}?bH}+MUBd}<`z-}-wobeEIZW$xt+I4QVAa2Ov$L`q z`v4RP*0y5)Y^&+{%}2x5Ts-uQ7jJWpMGdw~c{m)Oiv;8@^(clCr2le{dCtZ==9f%2 zOl8ysp+%HFzz`l^Z9mCtY-kPxZnm|Jv0X_l*GK%v9t(;-3|rSPnm`K6@wVEPjmqIe3c zp~&Qrwf?a{3Yl5H?Gr1*LW&r^546-1uEWM%wnmk7#S~7_0m*h4& zWzxmhsC~|nHd*Xp4nbJwOrfoy-444OvsW>`j+LIg4A*qEP02Z!|F2((Coi4aRpr}O z7cbo2KDEL8%xd&`<3#_Y>uO=!Y#A_z!WPM-fnPLv()8!I)ccyFu^LQt!8h4n43T0Qq4OLX@%BVy3o;Nx}ITQPVAyB5CP_$5tu)4KTd)Vu>& zoktG((5hy+a}B(2_;uXHQ>K~xZz%ckKZK+uxv)f-?54bG5c%Wn*0n5w_6J<&RrE`G3E|s4O{N>+ax0l3u#ni_OPuF-GuVfwU@3O5T-*@kM^xkn zQ~~_+Z?9{BIf~Y3IUtIf(;cAz{yN)-YP0N$RIWL(vB>DayymXVe4~tca{AN zk)z+spsu#0`$O5_aTP(4pklC?{v6$oqsze+F=DOx`e~ zkfYJyZ(~=@tlZ7+*vFQ@lE8b+gAS;HCn}o~6B}%h! zV)vohLTt>hsyNSmDGYl>dy|z_cEHdO;K^n*WnHt(H6)JhJF!WTqjCRNU92rTgoeS3 z3FO>(Z&{oaqv>Bq`G{pqTRR%$SeRnn(+?$ z3x2zwYvp%uS0NwKrpNTKT{ebjt7z=AJ#)5sprP%mO@j~(_J-Q%37;G05-b|~wTffW zK5|~YCG=G?okkmg#G0)~sxYCGw%2C%D|L$axGlPZqP6n4FVekd@598}Y@!XB^4adK zK) z-W6)0W#U+(JNr1i!CiLy$)Ab}9e&hn*^H_^ShYv{8rW=V*vphH?TRZli0l8gfYb{W z^(+ptx#aliA80x70kVS$S_gf1bBj1y*oLX31npUH|N4Ea)zvOe1x1Y6t%ahB9cuo} zF98c$F_E!^Vriq^HF{`0%mWF=Ndmx}ePjOLH(BYBJL7^_XY%=DC%C|gH1z#v#G#y& zX<=c`yt<}K9CR#tH#Yt!wUDj8huAQ&pr7_o3^j*_Uy;N(f9PKOX?vZX52mwcozFs< zqI5^in+tR85?t?!>MRk@mDK+ilG}u~<0Zz<&|-BpRXWKNzk3%irqfBGxN&QzbR=vu z*qzC^kdv*c!KpyaOtk_oidt|VKA8R44mSyNpN0#nb}yog#wt=3gqKM#-q0hiat40~ zhA}hGXK*7lo?jLeoR=(p?C=~yx<3lBje$T-d~jCw7>1*a+KD z!FvepcZ%n!d=mX8qFq8+#38+1LXc{Ol!hTWhvN z2eD-3E!%Uk;k~AEmPgG5(YR_2rTPB~Z#-pe0sHgrYbplPki-m}$5_P5<_@r2)Sw)W zyP#z169|-${+uWP99Ne0K8$y2Wm*x$e(!*!*ohDeR@NKG3yDW{Y1i2WYx>WOa>z|@ zlJ9_-)aahF{ha2(bvIrul+?j2=d7yu$rd)pnj?3>`N;$I_mFynuM`7pTc%A5F^iwv z%hh!qRu<7-k)zwEc9`f-q7}6%P)Cyz`a5(&XZHWBDOU)I_8^y56{zf~SDqsJeI7OmZ95#15hmF#b;C;ST=7Y(9bNx!DZPp1hx zr&g$yx-XW_kQz(tb~=(fV&2|N$bJ?~m5@9Z74z{gB85y-QdKche2+cT!8c5H-L!hu zAk!LvncW-B<;H3;riE*hc?yZV>r50JlBZLN1rOMkY2ke%6}g0fDghJLeQm?yMm;!{=yml z(s@XnE(d#egq{$~pd7I<`Prv6s}jcc7=w+^jyUv(>n~GqL3v}@-;MWh!2YHgW|leg zW=at@`@bT*L2M2L352m}JAZR7oo{PX?9~bu?Y>lnVNXU z$2raZqt~5CF|Hr9ia`n7_(I+J{kV#79oQ8E6j;My0rk%RKez{d9!@?mUU&XfjD?6* z1C3>QaH5zAuql>tw}n!Llhd;9j*ZAxbksBpeSB4$n==aAEFZ#7+)(R?!Ida)`Omc5 zZWg+?KiT2=HIzZ=TL&Sl(weNJ6o>qAGS|>c4A7Y1nihZtB!jo-%CGy_e>-OhqI1d* zPtm91t1%4>dZ$Kz4Jy3MpcH#YQ|T2wGaIBOhlhDOg9FGu(#Ey`MY+Q(M@EvVv`7)5I^k8fD5e+XNY@c1GA1%9Ls^~a7>!vyhg8uG-$%R-eG699N1nXf zr7*zd1&Tb48hRy^1__(n9cZvRE~gg-;ptrMkMp&rDw?1;MiD`TH71u_|6z8vRyRpo z>8QyDx<~YTMU73S$UUV6aguf5%FUJRG`!4`3rWhGgZIw zCMDcHFrO=97p&I!KQeG1=c0DXFOG~J^TWPUqL#dN_R~qIs<%@6+39EJthLOJ+BX|d zf{C-ioEqxpL~C+1^^rrOhxscv4}fnZR=aMz&-dzk`Lqgg$-Sar6gtYh?|zBJ#(%QnxQK z!WZkt9vSMUgEUUZ`6(tTliISdANS(9EddC8Lop0xL}OdM8OimH^NZ;An@QNovs^FZ zsp`YZrw*KC73D*A=_l1#^|(jr21vl-7sjp_6vc(P>86-#VA!gfNQ>IbI60L++cTRX z`QrW@_2i!Gv$=iT0`h{Vj&?(X9;bf~zQ3+Y^)2smaq$ug^wJ&?t`oxx1v9~j)FJ7& zqqL`5VnDtZ?Y*A~>CirxE$N-?cWOC@5)zFAg`@oGCwAJLl;cj2r3~k?l-24nX5#}$ zvLIW14zJYm;p9v3*U;JG1ccC>MZw$79iGSc_^fIQ`ZKKnpPGjC+j%#QGM`0kt(8x! zjo}?TgOt*s?qZ^mO0iRIw-`G)!mHeW5TVwdUY+?PD;~7c4QHi?!!yBQY?3b-v^Huv z)CIH3&DruISSU`_;-aR-G=Lk$cFE(7*9M{S^sK}uD!z9hT_bW_=Hg2$J*z~i`zSGv zM8vKhui&?)c3Y?PmEJ6>*vw-RKwc}sB&U^zIU)=+d)j674aPGJZzjaspAqXpm+!MX zyPIvpBozHpMzEbSbVseeJH8te> zn@KuVmNy21X3x*kZw73#=pH4-^d5kbLEQJurplMe^6WSDBT{g=le@b8D|bum9>E9` zC`kLFs;h#MopLX3H?*y=kk#FxYJSCafilhKk~`i^V>dsfkf)wt@3yw36#cw3srI0} zHqAPHbYL~jgR)kf>#;u7;5mmCajLoCew+|Y_H54lo$NDRCGT_ci|Hk^(bnnt!$z7U zhvpsm0C}HNss3n?*{8{M6`uiOH11Nya0U4LiDD=^Cz$ zD%zjU?w9m7N5@1X2eguDdnH^>tOz;-|WJ)LTelx3aDQm4x;)iNWTl`4^t#c zML+!58Bi4OsBwz{-KIJPOr1q;-zLKzYo6X3&huK6W8RP^d4J~YK_vO z-djJfPk_I&|FEb`NV@7mP}fSrO$6g59$&j+_G#yU@Lc?;Z(~5Nv>Ebe$bDhK@y}7H zNKsNp)qt{|FR<&A*?cwTUUwSFUbAm(nAe28P{<7vHzz9YZnk1rhWoHRASW8=S` zZ=A`KMLHOEPl=_L22i{$57rrjYy~Fr>1^N?bGMs$H_bgl6c>NEE~- zg&D1@Go2225!i_EU7_Q@tk>BG&w7SR0PAuzFf@`E~F2T&xd%Q+*hH z$2(iEzTAP9K=*Y}q*IcaG`0DJRO8ab$Z@B<$GE7kKye5>W(2G3sKG+MYZD{hwsVO+ zq>{8XTLoJzOfj2XIel8;mB1nEKS6j{hX~WgK`#c{eNTorodNvX8U~^}G`#)#jz&}N zC%>Nmv+w-ALKW`Rt=1FuV+xlY2V|%RDgKPM;L*c~g z`PBsTs2KBhl400P&+XF6sT%0*5{ywg0y>#9vtLE>vBY;Y=WQMJVA&@smKGTNTm@72 z1$XriGbbsxfk8}U<;6KiSW#SR=jYeInghrb8binYzXld2ud6#WjGIs&_SMFF6!uE1}hKV0%ZYiP8UhYId4f9W0AAa z=2O05(djKy5+f^9u88bK&j3ur&2vGk)RBhQt=07`Ph+nN2XBdDvPyTJxi@gn*U_7H ze;^&TLy}X`YaKHV;Yygn0T#EwPEKeOGTZB z-Ke04ux*sC{nvWZ0mDUWwu_+bqK4jsPC*&M)3T%))&YM99P^-5WuB{Yrv1y1_X0RGt-=fZvS7H5C5!2TRz+G(4(ckyLhS85nY{g2A&%ZB4= z-d)e%t0s&%>lbK=c(T3^-fRXrq;S5_Z{5KA19b7)Je~XAU{frdUREYk$5A4XogL?D zvotrh`uu98{U>M*a6wk!bLYP2rmxr5lo!cn+?_Zdhw{EK`#c|)*2xc(mZ{!3UrQs< z`+SC4E|3SVB+^Elu00y!+m*GJA2h{%j+NeDW-SG*)GeOSjmm#IK9FdtHS*n8FzeVI z*D%Vv^XP#J65=w#HTNCVg8|BlglkzyjfUZmCzzJH%J3;L_F@zB>i9|17>;?d*(NRP zTHaeED@?8Di!_;y4$iw$vd;e~S2-A!yDSGYKfVQ6H?Hg6!Bbm`$W7L{m=kfY6usUFK50p~xa(1=D`T<$EvVt5iYDGKZm6H=_Nh^`{w`t$d9Ev(HOpGxIH~+3gb6)I5Mjz_FTSdMlIWAGEtQ z>Du~%72uEXm)Y`rM^z&BsqVz%Q#!BOkKOe+n-xa12tY&5!$pmNwkOv*ho1OEkft{WE-h({aEwpuY+DfHxX`@ zUs;#6<_2jZrWBz@Z=KG&8Jyq%o`Wwiq-ge>97kp><5Hx5pb#jVqZ6p1q^&XPI^>c} zt-(65SI*lNWzj3K2Q;p0>IjFZ<;UF%CYTiFx@Nvzg_FhKZ>+QPMZ{7Z^JQ zAfZOlnM?%4Yz zdhtBS(WuIH@~icaMcZ6sAGY<#tjf*G00d#wg%XVbY_M2OhrchW8)Fehc+4jScb`#m ziV7jWsj zg~iZMY!~K%>URaO@FtcnxK&nFadOIHIvR!#C^7ap3wb0LK!Y3S10IxAfymRAyBqlP zIEiWWyno%e&%*b$V)+Q)Mabh)_f6U@v$DfUfs(p&?<7A5d=&{Nezq&{$IpZ1CQYz$@ z*@<;*JXWsuszSnGeERg>^+MXRiwHk3uA~^fE|38C$FP&bu?#-Xx^QRb+m5})@8G0R=3Dmmcsn{(8YLzeP~N;oJ7r@SbISeqmwgutxNKhwa9ZnoIQ5CNE>`y#_CdiA=4yy)?~M3cB#>AR@-M)qEK!#8%_T8 z3X3@Z;}Y%tnaUjUWOMId&Zy@%osy1w(43sm|UmZc%MZoQBp#^u%PReV)R}< zy*^0WbQGdIYg1yU+23QAr&~^-7*XM97MN_6feG@&im>9kNtusqx7HR=wO~N803t+U z;?g&40gWV!EPBoQBh{+r;XUt-G+f;N9zO+hE1Texi2*- zkHy`j^52KGnZ-$ZbQ48Et4!^(AEa1k2uynuYYD^*k7nv zcjtp>*%D>NA{ICvNQ1TQYJ$@-v$a^gp@rmg9PO^%Ag-?;ncVY3}h#&5!< zKhDK%sAQrUwaTfv-|^9fV{bv$agW(JyU@pu!G71yqZ4 zofg#bA-h1qzE_t5ZC_*3=TR@kvPyzIS@p$Wa_;A(p@utMdmUwXtO{>EbEZoABt=*S zPh($gvAWk;F3|j1aRc;^kKHm~5K!u)1hmMdew^c?Xo$peHq8nl3VXjmQ}(pxsZOlz zHFfC#>O$4wV+Klek`P@b9{M<`Uws@+9Eg~pZ3y8lp!E_=7?w4uL=E;4sy-0oning0 zgMB-u>K@I}r*xGbwU9x4vZGx& z_D`t|_bQaWLUM|FT9$Ui`RkD}7kzFSzCU00r=AC@IyafMg9%n;09(p0w=23d_GecM z3r-;d8Gv8!jT^9!ACkDl`BIKeHSX}yVISCcb9ld|xRrL8x9Bdt-x{jXF7E`3<<#<< zR1;OiRNH>tq?*XocaCdlj7Yr8t=>j!3HX*u-q2@?YSA;hs5}sDv&p|S zn5}-r`HH0dPu;s3p@qtRb%guKc;+ODgkn8Mh-C^Cg(9k>`OroV6g0X4?5M;ly~hs5 za!;z}rS@AEU`RKMEstHd3m$&%P`&ykbJ+dlcUi|)^0a?CUb|Q9qBDb%ZKQOeF}Al` zZDUoI<%g~SHz!Q@R*3kk%+q>IYL3r6zvV7bBv0sVI+p5^=720c5h?@LznG`&tSoze zF7Kl)9?Q$agw;=VNASc`bpDq$7`Xc=r1V>00Wyd7t5TxTDnDyD6}BHLP?Rj3%KLP1 z>18toc5%v%4*bJ+r$^gsg)1GwDW_ zz3!Xzoc!poWqXmTkhy802>CW2`CZ9_?wTY;s28ADg`vA+FXXAHs4gy)6aoE|Cs+UW c>(o?*mMsB^j)m_juTZJJ(s)_?!aU%A0IaD7%m4rY literal 0 HcmV?d00001 diff --git a/frontend/e2e/accessibility.spec.ts b/frontend/e2e/accessibility.spec.ts new file mode 100644 index 0000000..bfd3153 --- /dev/null +++ b/frontend/e2e/accessibility.spec.ts @@ -0,0 +1,33 @@ +import { expect, test } from "@playwright/test"; + +test("workspace navigation and primary controls expose accessible state", async ({ page }) => { + await page.goto("/#analysis"); + for (const workspace of ["Analysis", "Timeline", "Hunting", "Reports", "Settings"]) { + await expect(page.getByRole("button", { name: workspace, exact: false }).first()).toBeEnabled(); + } + await page.getByRole("button", { name: "Load demo", exact: true }).first().click(); + await page.getByRole("button", { name: "Timeline", exact: false }).click(); + await expect(page.getByRole("button", { name: "Timeline", exact: false }).first()).toHaveAttribute("aria-current", "page"); + await expect(page.getByRole("textbox", { name: "Search normalized evidence" })).toBeVisible(); + await expect(page.getByLabel("Filter by category")).toBeVisible(); + await expect(page.getByLabel("Filter by level")).toBeVisible(); + await expect(page.getByLabel("Filter by provider")).toBeVisible(); + await expect(page.getByRole("button", { name: "Previous evidence" })).toHaveAttribute("aria-label", "Previous evidence"); + await expect(page.getByRole("listitem").first()).toHaveAttribute("aria-setsize", /[0-9]+/); + await page.getByRole("textbox", { name: "Search normalized evidence" }).focus(); + await page.keyboard.press("Tab"); + await expect(page.locator(":focus")).toBeVisible(); + + await page.getByRole("button", { name: "Hunting", exact: false }).click(); + await expect(page.getByRole("textbox", { name: "Search hunting evidence" })).toBeVisible(); + await page.getByRole("button", { name: "Reports", exact: false }).click(); + await expect(page.getByRole("button", { name: "Export JSON", exact: true })).toBeVisible(); + await page.getByRole("button", { name: "Settings", exact: false }).click(); + await expect(page.getByRole("group", { name: "Timestamp display" })).toBeVisible(); + + await page.setViewportSize({ width: 700, height: 900 }); + await page.getByRole("button", { name: "Timeline", exact: false }).click(); + await expect(page.getByLabel("Evidence time window")).toBeVisible(); + await expect(page.getByLabel("Hide informational noise")).toBeVisible(); + await expect(page.getByLabel("Focus incident")).toBeVisible(); +}); diff --git a/frontend/e2e/api-contract.spec.ts b/frontend/e2e/api-contract.spec.ts new file mode 100644 index 0000000..7eb4c80 --- /dev/null +++ b/frontend/e2e/api-contract.spec.ts @@ -0,0 +1,64 @@ +import { expect, test } from "@playwright/test"; + +const validUpload = { name: "sample.evtx", mimeType: "application/octet-stream", buffer: Buffer.from("synthetic") }; + +test("malformed successful analysis keeps the previous investigation", async ({ page }) => { + await page.goto("/#analysis"); + await page.getByRole("button", { name: "Load demo", exact: true }).first().click(); + await expect(page.getByRole("region", { name: "Current investigation context" })).toContainText("bundled-demo"); + + await page.route("**/api/analyze", (route) => route.fulfill({ + status: 200, + contentType: "application/json", + body: JSON.stringify({ source: "bad.evtx", events: [], incidents: [{ id: "broken" }] }), + })); + await page.locator('input[type="file"]').setInputFiles(validUpload); + + await expect(page.getByRole("alert")).toContainText("Analysis returned an invalid response."); + await expect(page.getByRole("region", { name: "Current investigation context" })).toContainText("bundled-demo"); + await page.getByRole("button", { name: "Timeline", exact: false }).click(); + await expect(page.getByRole("heading", { name: "Inspector", exact: true })).toBeVisible(); +}); + +test("structured parser errors have safe, useful wording", async ({ page }) => { + await page.route("**/api/analyze", (route) => route.fulfill({ + status: 422, + contentType: "application/json", + body: JSON.stringify({ detail: { code: "no_readable_events", message: "No readable Windows events were found in this file." } }), + })); + await page.goto("/#analysis"); + await page.locator('input[type="file"]').setInputFiles(validUpload); + + await expect(page.getByRole("alert")).toContainText("No readable Windows events were found in this file."); + await expect(page.getByRole("alert")).not.toContainText("HTTP 422"); +}); + +test("rejecting an invalid file cancels an older pending analysis", async ({ page }) => { + await page.goto("/#analysis"); + await page.getByRole("button", { name: "Load demo", exact: true }).first().click(); + await expect(page.getByRole("region", { name: "Current investigation context" })).toContainText("bundled-demo"); + + let routeStarted!: () => void; + let releaseRoute!: () => void; + const started = new Promise((resolve) => { routeStarted = resolve; }); + const released = new Promise((resolve) => { releaseRoute = resolve; }); + await page.route("**/api/analyze", async (route) => { + routeStarted(); + await released; + try { + await route.fulfill({ status: 200, contentType: "application/json", body: JSON.stringify({ source: "late.evtx", events: [], incidents: [] }) }); + } catch { + // The route can already be cancelled by the browser request abort. + } + }); + + const fileInput = page.locator('input[type="file"]'); + await fileInput.setInputFiles(validUpload); + await started; + await fileInput.setInputFiles({ name: "invalid.txt", mimeType: "text/plain", buffer: Buffer.from("invalid") }); + await expect(page.getByRole("alert")).toContainText("Choose a Windows .evtx file."); + releaseRoute(); + await page.waitForTimeout(300); + await expect(page.getByRole("region", { name: "Current investigation context" })).toContainText("bundled-demo"); + await expect(page.getByRole("alert")).toContainText("Choose a Windows .evtx file."); +}); diff --git a/frontend/e2e/branding.spec.ts b/frontend/e2e/branding.spec.ts new file mode 100644 index 0000000..d1e8b57 --- /dev/null +++ b/frontend/e2e/branding.spec.ts @@ -0,0 +1,28 @@ +import { expect, test } from "@playwright/test"; + +const assets = [ + ["favicon.svg", /image\/svg\+xml/i], + ["favicon.ico", /image\/(x-icon|vnd\.microsoft\.icon)/i], + ["apple-touch-icon.png", /image\/png/i], + ["eventlens-icon-192.png", /image\/png/i], + ["eventlens-icon-512.png", /image\/png/i], + ["site.webmanifest", /(manifest|json)/i], +] as const; + +test("canonical EventLens branding and icon package are locally served", async ({ page, request }) => { + await page.goto("/#analysis"); + await expect(page).toHaveTitle("EventLens — Windows Incident Reconstruction"); + await expect(page.locator('meta[name="application-name"]')).toHaveAttribute("content", "EventLens"); + await expect(page.locator('link[rel="manifest"]')).toHaveAttribute("href", "/site.webmanifest"); + await expect(page.locator(".event-logo svg")).toBeVisible(); + + for (const [asset, contentType] of assets) { + const response = await request.get(`/${asset}`); + expect(response.status(), `${asset} should be served`).toBe(200); + expect(response.headers()["content-type"] ?? "", `${asset} MIME type`).toMatch(contentType); + } + + for (const workspace of ["Analysis", "Timeline", "Hunting", "Reports", "Settings"]) { + await expect(page.getByRole("button", { name: workspace, exact: false }).first().locator("svg")).toHaveCount(1); + } +}); diff --git a/frontend/e2e/eventlens.spec.ts b/frontend/e2e/eventlens.spec.ts new file mode 100644 index 0000000..25d9524 --- /dev/null +++ b/frontend/e2e/eventlens.spec.ts @@ -0,0 +1,40 @@ +import { expect, test } from "@playwright/test"; + +test("demo investigation workflow crosses Analysis, Timeline and Reports", async ({ page }) => { + await page.goto("/#analysis"); + await expect(page.getByRole("heading", { name: "No event log loaded", exact: true })).toBeVisible(); + await page.getByRole("button", { name: "Load demo", exact: true }).first().click(); + await expect(page.getByRole("region", { name: "Current investigation context" }).getByText("bundled-demo", { exact: true })).toBeVisible(); + await expect(page.getByRole("heading", { name: "Incident windows", exact: true })).toBeVisible(); + await expect(page.getByText("Analysis status", { exact: true })).toBeVisible(); + await expect(page.getByText("Deterministic demo fixture", { exact: true })).toBeVisible(); + await expect(page.getByText("Current source", { exact: true })).toHaveCount(0); + await expect(page.getByText("How to continue", { exact: true })).toBeVisible(); + + await page.getByText("Service failure recorded", { exact: true }).click(); + await expect(page).toHaveURL(/#timeline$/); + await expect(page.getByRole("heading", { name: "Event timeline", exact: true })).toBeVisible(); + await expect(page.getByRole("heading", { name: "Example Sync Service terminated unexpectedly", exact: true })).toBeVisible(); + await expect(page.getByText("Focus active", { exact: true })).toBeVisible(); + + const search = page.getByRole("textbox", { name: "Search normalized evidence" }); + await search.fill("DNS name resolution"); + await expect(page.locator(".event-row")).toHaveCount(0); + await search.fill(""); + await page.getByRole("button", { name: "Stop focus", exact: true }).click(); + await page.getByLabel("Filter by category").selectOption("network"); + await expect(page.locator(".event-row")).toHaveCount(1); + await page.getByLabel("Filter by category").selectOption(""); + await page.getByRole("button", { name: /Next evidence/ }).click(); + await expect(page.getByText(/of [0-9]+/).first()).toBeVisible(); + + await page.getByRole("button", { name: "Reports", exact: false }).click(); + await expect(page.getByRole("heading", { name: "Export report", exact: true })).toBeVisible(); + await expect(page.getByText("Redaction preview", { exact: true })).toBeVisible(); + const jsonDownload = page.waitForEvent("download"); + await page.getByRole("button", { name: "Export JSON", exact: true }).click(); + expect((await jsonDownload).suggestedFilename()).toMatch(/eventlens\.json$/); + const markdownDownload = page.waitForEvent("download"); + await page.getByRole("button", { name: "Export Markdown", exact: true }).click(); + expect((await markdownDownload).suggestedFilename()).toMatch(/eventlens\.md$/); +}); diff --git a/frontend/e2e/partial-and-error.spec.ts b/frontend/e2e/partial-and-error.spec.ts new file mode 100644 index 0000000..6231dc9 --- /dev/null +++ b/frontend/e2e/partial-and-error.spec.ts @@ -0,0 +1,25 @@ +import { expect, test } from "@playwright/test"; + +const partialAnalysis = { + source: "partial.evtx", + events: [{ id: "1", timestamp: "2026-09-09T10:00:00Z", timestamp_source: "event", timestamp_valid: true, provider: "Synthetic", event_id: 1000, level: "error", channel: "Application", computer: "TEST-PC", category: "crash", summary: "Synthetic crash", fields: {} }], + incidents: [{ id: "incident-1", rule_id: "windows.generic.attention", start: "2026-09-09T10:00:00Z", end: "2026-09-09T10:00:00Z", title: "Synthetic crash", category: "crash", severity: "warning", reasons: ["Parser retained only a partial result."], evidence_event_ids: ["1"], original_count: 1, compressed_count: 1 }], + parse: { parser: "evtx-rs", status: "partial", parsed_events: 1, records_seen: 4, skipped_records: 2, issue_count: 1, truncated: true, truncation_reason: "event_limit_reached", duration_ms: 8, issues: [{ code: "event_limit_reached", record_id: 4, message: "later records were not analyzed", skipped_record: true }] }, +}; + +test("partial result is unmistakable and invalid extension is rejected", async ({ page }) => { + await page.route("**/api/analyze", (route) => route.fulfill({ status: 200, contentType: "application/json", body: JSON.stringify(partialAnalysis) })); + await page.goto("/#analysis"); + await expect(page.getByRole("heading", { name: "Analysis", exact: true })).toBeVisible(); + await page.locator('input[type="file"]').setInputFiles({ name: "partial.evtx", mimeType: "application/octet-stream", buffer: Buffer.from("synthetic") }); + await expect(page.getByRole("alert")).toContainText("Partial analysis"); + await expect(page.getByRole("alert")).toContainText("incident reconstruction may be incomplete"); + await expect(page.getByText("event_limit_reached", { exact: true })).toBeVisible(); + await expect(page.getByText("Analysis status", { exact: true })).toBeVisible(); + await expect(page.getByText("2 skipped · 1 parser issue", { exact: true })).toBeVisible(); + await page.getByRole("button", { name: "Timeline", exact: false }).click(); + await expect(page.getByRole("alert")).toContainText("incident reconstruction may be incomplete"); + + await page.locator('input[type="file"]').setInputFiles({ name: "not-an-evtx.txt", mimeType: "text/plain", buffer: Buffer.from("nope") }); + await expect(page.getByRole("alert").filter({ hasText: "Choose a Windows .evtx file." })).toBeVisible(); +}); diff --git a/frontend/e2e/portfolio-assets.spec.ts b/frontend/e2e/portfolio-assets.spec.ts new file mode 100644 index 0000000..ab85f8e --- /dev/null +++ b/frontend/e2e/portfolio-assets.spec.ts @@ -0,0 +1,29 @@ +import { expect, test } from "@playwright/test"; + +test("capture deterministic v1.0.6 portfolio views", async ({ page }) => { + await page.goto("/#analysis"); + await page.getByRole("button", { name: "Load demo", exact: true }).first().click(); + await expect(page.getByRole("heading", { name: "Incident windows", exact: true })).toBeVisible(); + await page.screenshot({ path: "../docs/assets/eventlens-demo-overview.png", fullPage: true }); + + await page.getByText("Service failure recorded", { exact: true }).click(); + await expect(page.getByRole("heading", { name: "Event timeline", exact: true })).toBeVisible(); + await page.screenshot({ path: "../docs/assets/eventlens-timeline-evidence.png", fullPage: true }); + + await page.getByRole("button", { name: "Stop focus", exact: true }).click(); + await page.getByRole("textbox", { name: "Search normalized evidence" }).fill("DNS name resolution"); + await expect(page.locator(".event-row")).toHaveCount(1); + await page.screenshot({ path: "../docs/assets/eventlens-filter-search.png", fullPage: true }); + + await page.getByRole("button", { name: "Hunting", exact: false }).click(); + await expect(page.getByRole("heading", { name: "Hunting", exact: true })).toBeVisible(); + await page.screenshot({ path: "../docs/assets/eventlens-hunting.png", fullPage: true }); + + await page.getByRole("button", { name: "Reports", exact: false }).click(); + await expect(page.getByRole("heading", { name: "Export report", exact: true })).toBeVisible(); + await page.screenshot({ path: "../docs/assets/eventlens-redaction-export.png", fullPage: true }); + + await page.getByRole("button", { name: "Settings", exact: true }).click(); + await expect(page.getByRole("heading", { name: "Local data & privacy", exact: true })).toBeVisible(); + await page.screenshot({ path: "../docs/assets/eventlens-settings.png", fullPage: true }); +}); diff --git a/frontend/e2e/real-evtx.spec.ts b/frontend/e2e/real-evtx.spec.ts new file mode 100644 index 0000000..dfa433a --- /dev/null +++ b/frontend/e2e/real-evtx.spec.ts @@ -0,0 +1,19 @@ +import { existsSync } from "node:fs"; +import { expect, test } from "@playwright/test"; + +const fixture = process.env.EVENTLENS_EVTX_FIXTURE; + +test("pinned real EVTX fixture survives the browser upload path", async ({ page }) => { + test.skip(!fixture || !existsSync(fixture), "CI supplies the hash-verified public EVTX fixture"); + await page.goto("/#analysis"); + await page.locator('input[type="file"]').setInputFiles(fixture!); + await expect(page.locator(".metric-card").first()).toContainText("7", { timeout: 30_000 }); + await expect(page.getByText("events parsed", { exact: true })).toBeVisible(); + await page.getByRole("button", { name: "Timeline", exact: false }).click(); + await page.getByLabel("Hide informational noise").uncheck(); + await expect(page.locator(".event-row").first()).toBeVisible(); + await expect(page.getByRole("button", { name: /4625/ })).toBeVisible(); + await page.getByRole("button", { name: "Reports", exact: false }).click(); + await expect(page.getByRole("heading", { name: "Export report", exact: true })).toBeVisible(); + await page.getByRole("button", { name: /Export JSON/ }).click(); +}); diff --git a/frontend/e2e/responsive.spec.ts b/frontend/e2e/responsive.spec.ts new file mode 100644 index 0000000..ced98da --- /dev/null +++ b/frontend/e2e/responsive.spec.ts @@ -0,0 +1,17 @@ +import { expect, test } from "@playwright/test"; + +test("core workspace actions remain usable across supported viewport widths", async ({ page }) => { + await page.goto("/#analysis"); + await page.getByRole("button", { name: "Load demo", exact: true }).first().click(); + for (const viewport of [{ width: 360, height: 800 }, { width: 390, height: 844 }, { width: 768, height: 900 }, { width: 1024, height: 768 }, { width: 1366, height: 768 }, { width: 1440, height: 900 }, { width: 1920, height: 1080 }]) { + await page.setViewportSize(viewport); + await expect(page.getByRole("button", { name: "Open .evtx", exact: true }).first()).toBeVisible(); + for (const workspace of ["Analysis", "Timeline", "Hunting", "Reports", "Settings"]) { + const button = page.getByRole("button", { name: workspace, exact: false }).first(); + await button.click(); + await expect(page.getByRole("heading", { name: workspace, exact: true })).toBeVisible(); + const overflow = await page.evaluate(() => document.documentElement.scrollWidth <= window.innerWidth + 1); + expect(overflow, `horizontal overflow in ${workspace} at ${viewport.width}px`).toBeTruthy(); + } + } +}); diff --git a/frontend/e2e/settings-storage-failure.spec.ts b/frontend/e2e/settings-storage-failure.spec.ts new file mode 100644 index 0000000..87e7caa --- /dev/null +++ b/frontend/e2e/settings-storage-failure.spec.ts @@ -0,0 +1,32 @@ +import { expect, test } from "@playwright/test"; + +test("settings keeps session state and reports a persistence failure", async ({ page }) => { + await page.addInitScript(() => { + const originalSetItem = Storage.prototype.setItem; + Storage.prototype.setItem = function setItem(key: string, value: string) { + if (key === "eventlens.preferences.v1") { + throw new DOMException("Storage is unavailable", "QuotaExceededError"); + } + return originalSetItem.call(this, key, value); + }; + }); + + await page.goto("/#settings"); + + const compact = page.getByRole("radio", { name: /Compact/i }); + await compact.press("Space"); + + await expect(compact).toBeChecked(); + await expect(page.locator(".settings-save-feedback")).toHaveText("Preferences changed for this session only"); + await expect(page.getByText("Saved automatically in this browser", { exact: true })).toBeHidden(); + await expect(page.getByText("Preferences are available for this session only because browser storage is unavailable.")).toBeVisible(); + await expect(page.getByText("Not saved to browser storage")).toBeVisible(); + await expect(page.getByText("Interface preferences for this session")).toBeVisible(); + + await page.waitForTimeout(2_600); + await expect(page.getByRole("status")).toHaveText("Preferences changed for this session only"); + await expect(page.getByText("Saved automatically in this browser", { exact: true })).toBeHidden(); + + await page.reload(); + await expect(page.getByRole("radio", { name: /Comfortable/i })).toBeChecked(); +}); diff --git a/frontend/e2e/settings.spec.ts b/frontend/e2e/settings.spec.ts new file mode 100644 index 0000000..c90a2aa --- /dev/null +++ b/frontend/e2e/settings.spec.ts @@ -0,0 +1,59 @@ +import { expect, test } from "@playwright/test"; + +test("Settings communicates browser-local saving and resets accessible preference controls", async ({ page }) => { + await page.goto("/#settings"); + + await expect(page.getByText("Saved automatically in this browser", { exact: true })).toBeVisible(); + await expect(page.getByRole("group", { name: "Timestamp display" })).toBeVisible(); + await expect(page.getByRole("group", { name: "Interface density" })).toBeVisible(); + await expect(page.getByRole("switch", { name: "Export redaction by default" })).toBeChecked(); + + await page.locator("label.preference-option").filter({ hasText: "Local browser time" }).click(); + await expect(page.getByRole("status").filter({ hasText: "Preferences saved" })).toBeVisible(); + await page.getByRole("switch", { name: "Export redaction by default" }).press("Space"); + await page.getByLabel("Default noise mode").selectOption("all"); + await page.getByLabel("Default workspace").selectOption("hunting"); + await page.getByRole("radio", { name: /Compact/ }).press("Space"); + + await page.reload(); + await expect(page.getByRole("radio", { name: /Local browser time/ })).toBeChecked(); + await expect(page.getByRole("switch", { name: "Export redaction by default" })).not.toBeChecked(); + await expect(page.getByLabel("Default noise mode")).toHaveValue("all"); + await expect(page.getByLabel("Default workspace")).toHaveValue("hunting"); + await expect(page.getByRole("radio", { name: /Compact/ })).toBeChecked(); + + const storedKeys = await page.evaluate(() => Object.keys(localStorage)); + expect(storedKeys).toEqual(["eventlens.preferences.v1"]); + await page.getByText("Technical details", { exact: true }).press("Enter"); + await expect(page.getByText("eventlens.preferences.v1", { exact: true })).toBeVisible(); + await page.getByRole("button", { name: "Reset all preferences" }).press("Enter"); + await expect(page.getByRole("status").filter({ hasText: "Preferences reset to defaults" })).toBeVisible(); + await expect(page.getByRole("radio", { name: /^UTC/ })).toBeChecked(); + await expect(page.getByRole("switch", { name: "Export redaction by default" })).toBeChecked(); + await expect(page.getByLabel("Default noise mode")).toHaveValue("attention"); + await expect(page.getByLabel("Default workspace")).toHaveValue("analysis"); +}); + +test("a browser-local default workspace applies only without a deep-link override", async ({ page }) => { + await page.goto("/#settings"); + await page.getByLabel("Default workspace").selectOption("hunting"); + + await page.goto("/"); + await expect(page).toHaveURL(/#hunting$/); + await expect(page.getByRole("heading", { name: "Hunting", exact: true })).toBeVisible(); + + await page.goto("/#timeline"); + await expect(page).toHaveURL(/#timeline$/); + await expect(page.getByRole("heading", { name: "Timeline", exact: true })).toBeVisible(); +}); + +test("the active Settings tab remains visible in the compact workspace navigation", async ({ page }) => { + await page.setViewportSize({ width: 390, height: 844 }); + await page.goto("/#settings"); + const settingsTab = page.getByRole("button", { name: "Settings", exact: true }); + await expect(settingsTab).toHaveAttribute("aria-current", "page"); + const box = await settingsTab.boundingBox(); + expect(box).not.toBeNull(); + expect(box!.x).toBeGreaterThanOrEqual(0); + expect(box!.x + box!.width).toBeLessThanOrEqual(390); +}); diff --git a/frontend/e2e/virtualization.spec.ts b/frontend/e2e/virtualization.spec.ts new file mode 100644 index 0000000..4a9ade9 --- /dev/null +++ b/frontend/e2e/virtualization.spec.ts @@ -0,0 +1,22 @@ +import { expect, test } from "@playwright/test"; + +function largeAnalysis(count: number) { + return { + source: "synthetic-large.evtx", + events: Array.from({ length: count }, (_, index) => ({ id: String(index), timestamp: "2026-09-09T10:00:00Z", timestamp_source: "event", timestamp_valid: true, provider: "Synthetic Provider", event_id: index, level: "warning", channel: "Application", computer: "TEST-PC", category: "other", summary: `Synthetic event ${index}`, fields: { message: `Synthetic event ${index}` } })), + incidents: [], + }; +} + +test("large timelines virtualize DOM rows and keep search usable", async ({ page }) => { + const analysis = largeAnalysis(10_000); + await page.route("**/api/demo", (route) => route.fulfill({ status: 200, contentType: "application/json", body: JSON.stringify(analysis) })); + await page.goto("/#analysis"); + await page.getByRole("button", { name: "Load demo", exact: true }).first().click(); + await expect(page.getByText("10,000", { exact: false }).first()).toBeVisible(); + expect(await page.locator(".event-row").count()).toBeLessThan(80); + await page.getByRole("button", { name: "Timeline", exact: false }).click(); + await page.getByRole("textbox", { name: "Search normalized evidence" }).fill("Synthetic event 9999"); + await expect(page.locator(".event-row")).toHaveCount(1); + await expect(page.locator(".event-row").first()).toContainText("9999"); +}); diff --git a/frontend/e2e/workspace.spec.ts b/frontend/e2e/workspace.spec.ts new file mode 100644 index 0000000..4b71da1 --- /dev/null +++ b/frontend/e2e/workspace.spec.ts @@ -0,0 +1,77 @@ +import { expect, test } from "@playwright/test"; + +test("all workspaces are actionable and preserve the loaded analysis", async ({ page }) => { + await page.goto("/#analysis"); + await page.getByRole("button", { name: "Load demo", exact: true }).first().click(); + + for (const workspace of ["Analysis", "Timeline", "Hunting", "Reports", "Settings"]) { + const button = page.getByRole("button", { name: workspace, exact: false }).first(); + await expect(button).toBeEnabled(); + await button.click(); + await expect(button).toHaveAttribute("aria-current", "page"); + } + + await expect(page.getByRole("region", { name: "Local preferences context" })).toBeVisible(); + await expect(page.getByRole("region", { name: "Current investigation context" })).toHaveCount(0); + await page.getByRole("button", { name: "Timeline", exact: false }).click(); + await expect(page.getByRole("heading", { name: "Event timeline", exact: true })).toBeVisible(); + await expect(page.getByRole("heading", { name: "Inspector", exact: true })).toBeVisible(); + await page.goBack(); + await expect(page.getByRole("heading", { name: "Settings", exact: true })).toBeVisible(); + await page.goForward(); + await expect(page.getByRole("heading", { name: "Event timeline", exact: true })).toBeVisible(); +}); + +test("context and global actions keep an ordered, workspace-appropriate layout", async ({ page }) => { + await page.goto("/#analysis"); + await page.getByRole("button", { name: "Load demo", exact: true }).first().click(); + const geometry = await page.evaluate(() => { + const rect = (selector: string) => document.querySelector(selector)?.getBoundingClientRect(); + const topbar = rect(".event-topbar"); + const context = rect(".investigation-context"); + const actions = rect(".global-actions"); + return { topbar, context, actions }; + }); + expect(geometry.topbar?.bottom).toBeLessThanOrEqual((geometry.context?.top ?? 0) + 1); + expect(geometry.context?.bottom).toBeLessThanOrEqual((geometry.actions?.top ?? 0) + 1); + + await page.getByRole("button", { name: "Settings", exact: true }).click(); + await expect(page.getByRole("region", { name: "Local preferences context" })).toBeVisible(); + await expect(page.getByRole("region", { name: "Current investigation context" })).toHaveCount(0); + await expect(page.getByRole("region", { name: "Analysis actions" })).toBeVisible(); + await expect(page.getByText("Source", { exact: true })).toHaveCount(0); +}); + +test("Hunting combines facets and opens a result in the inspector", async ({ page }) => { + await page.goto("/#analysis"); + await page.getByRole("button", { name: "Load demo", exact: true }).first().click(); + await page.getByRole("button", { name: "Hunting", exact: false }).click(); + + await page.getByRole("textbox", { name: "Search hunting evidence" }).fill("DNS name resolution"); + await expect(page.getByRole("status")).toHaveText("1 of 6 matching events"); + await expect(page.getByRole("button", { name: /DNS name resolution timed out/ })).toBeVisible(); + await page.getByRole("button", { name: /DNS name resolution timed out/ }).click(); + await expect(page.getByRole("heading", { name: "Inspector", exact: true })).toBeVisible(); + await expect(page.getByRole("heading", { name: "DNS name resolution timed out", exact: true })).toBeVisible(); + await page.getByRole("button", { name: "Open in Timeline", exact: false }).click(); + await expect(page).toHaveURL(/#timeline$/); + await expect(page.getByRole("heading", { name: "Event timeline", exact: true })).toBeVisible(); +}); + +test("Settings persist preferences without persisting event data", async ({ page }) => { + await page.goto("/#settings"); + await page.getByRole("radio", { name: /Local browser time/ }).press("Space"); + await page.getByLabel("Default noise mode").selectOption("all"); + await page.getByLabel("Default workspace").selectOption("hunting"); + await page.getByRole("radio", { name: /Compact/ }).press("Space"); + await page.reload(); + + await expect(page.getByLabel("Local browser time", { exact: false })).toBeChecked(); + await expect(page.getByLabel("Default noise mode")).toHaveValue("all"); + await expect(page.getByLabel("Default workspace")).toHaveValue("hunting"); + await expect(page.getByLabel("Compact", { exact: false })).toBeChecked(); + const stored = await page.evaluate(() => JSON.stringify(localStorage)); + expect(stored).toContain("eventlens.preferences.v1"); + expect(stored).not.toContain("bundled-demo"); + expect(stored).not.toContain("Example Sync Service"); +}); diff --git a/frontend/eslint.config.mjs b/frontend/eslint.config.mjs new file mode 100644 index 0000000..27a79a8 --- /dev/null +++ b/frontend/eslint.config.mjs @@ -0,0 +1,43 @@ +import eslint from "@eslint/js"; +import globals from "globals"; +import jsxA11y from "eslint-plugin-jsx-a11y"; +import react from "eslint-plugin-react"; +import reactHooks from "eslint-plugin-react-hooks"; +import tseslint from "typescript-eslint"; + +export default tseslint.config( + { ignores: ["dist/**", "node_modules/**"] }, + eslint.configs.recommended, + ...tseslint.configs.recommended, + react.configs.flat.recommended, + react.configs.flat["jsx-runtime"], + jsxA11y.flatConfigs.recommended, + { + files: ["src/**/*.{ts,tsx}"], + languageOptions: { + globals: globals.browser, + parserOptions: { ecmaFeatures: { jsx: true } }, + }, + plugins: { "react-hooks": reactHooks }, + settings: { react: { version: "detect" } }, + rules: { + "jsx-a11y/label-has-associated-control": ["error", { depth: 4 }], + "no-alert": "error", + "no-eval": "error", + "no-undef": "off", + "no-unused-vars": "off", + "react/no-danger": "error", + "react/prop-types": "off", + "react-hooks/exhaustive-deps": "warn", + "react-hooks/rules-of-hooks": "error", + "@typescript-eslint/no-explicit-any": "error", + "@typescript-eslint/no-non-null-assertion": "warn", + "@typescript-eslint/no-unused-vars": ["error", { + argsIgnorePattern: "^_", + caughtErrorsIgnorePattern: "^_", + ignoreRestSiblings: true, + varsIgnorePattern: "^_", + }], + }, + }, +); diff --git a/frontend/index.html b/frontend/index.html new file mode 100644 index 0000000..18b9bb1 --- /dev/null +++ b/frontend/index.html @@ -0,0 +1,19 @@ + + + + + + + + + + + + + EventLens — Windows Incident Reconstruction + + +