From 9788479ae765c9928f69c095153531720dec6194 Mon Sep 17 00:00:00 2001 From: Fox Date: Tue, 23 Jun 2026 17:47:07 +0100 Subject: [PATCH] initial commit --- .gitignore | 482 ++ README.md | 113 + backend/Dockerfile | 16 + backend/SolicitorsApi.slnx | 14 + .../Endpoints/CitiesEndpoints.cs | 17 + .../Endpoints/RatingsProvidersEndpoints.cs | 17 + .../Endpoints/SolicitorsEndpoints.cs | 60 + backend/app/Solicitors.Api/Program.cs | 42 + .../Properties/launchSettings.json | 23 + .../app/Solicitors.Api/Solicitors.Api.csproj | 22 + .../app/Solicitors.Api/Solicitors.Api.http | 6 + backend/app/Solicitors.Api/appsettings.json | 9 + .../Solicitors.CacheBuild/DIExtensions.cs | 54 + .../ISolicitorImporter.cs | 6 + .../Solicitors.CacheBuild/ISolicitorParser.cs | 9 + .../ImportConfiguration.cs | 8 + .../Solicitors.CacheBuild/ImportRunner.cs | 15 + .../SolicitorImporter.cs | 20 + .../Solicitors.CacheBuild.csproj | 27 + .../SolicitorsDotCom/Consts.cs | 14 + .../SolicitorsDotCom/SolicitorBuilder.cs | 31 + .../SolicitorsDotCom/SolicitorParser.cs | 315 ++ .../Solicitors.CacheBuild/StaleDataRemover.cs | 19 + backend/libs/Solicitors.Core/DIExtensions.cs | 19 + .../Data/IRatingsProviderRepository.cs | 6 + .../Data/IReadOnlySolicitorRepository.cs | 14 + .../Data/ISolicitorRepository.cs | 10 + .../IRatingsProviderService.cs | 6 + .../Solicitors.Core/IReadOnlyCitiesService.cs | 6 + .../IReadOnlySolicitorService.cs | 17 + .../libs/Solicitors.Core/ISolicitorService.cs | 3 + .../Misc/EnumerableExtensions.cs | 21 + backend/libs/Solicitors.Core/Misc/IFilter.cs | 19 + .../libs/Solicitors.Core/Misc/Pagination.cs | 7 + backend/libs/Solicitors.Core/Models/City.cs | 10 + .../Models/Imports/Location.cs | 8 + .../Solicitors.Core/Models/Imports/Rating.cs | 9 + .../Models/Imports/SolicitorData.cs | 16 + .../libs/Solicitors.Core/Models/Solicitor.cs | 19 + .../Solicitors.Core/Models/SolicitorInfo.cs | 40 + .../Models/SolicitorLocation.cs | 22 + .../Models/SolicitorLocationRating.cs | 14 + .../Solicitors.Core/Models/SolicitorRating.cs | 14 + .../Models/View/LocationInfo.cs | 18 + .../Solicitors.Core/Models/View/RatingInfo.cs | 15 + .../Models/View/SolicitorSummary.cs | 19 + .../Ordering/DefaultSolicitorDataOrdering.cs | 23 + .../Ordering/ISolicitorComparerFactory.cs | 10 + .../Solicitors.Core/Ordering/NameComparer.cs | 26 + .../Solicitors.Core/Ordering/OrderingType.cs | 9 + .../Ordering/RatingComparer.cs | 32 + .../Ordering/SolicitorComparerFactory.cs | 20 + .../Solicitors.Core/PaginationResponse.cs | 7 + .../Solicitors.Core/RatingsProviderService.cs | 11 + .../Solicitors.Core/ReadOnlyCitiesService.cs | 12 + .../libs/Solicitors.Core/SolicitorService.cs | 44 + .../Solicitors.Core/Solicitors.Core.csproj | 14 + backend/libs/Solicitors.Data/DIExtensions.cs | 48 + .../RepositorySetup/IRepoSetupOptions.cs | 3 + .../RepositorySetup/IRepoSetupService.cs | 8 + .../InMemory/InMemoryDbSetupOptions.cs | 6 + .../InMemory/InMemorySetupService.cs | 11 + .../Sqlite/SqliteDbSetupOptions.cs | 6 + .../Sqlite/SqliteSetupService.cs | 11 + .../Solicitors.Data/Solicitors.Data.csproj | 21 + .../Solicitors.Data/SolicitorsRepository.cs | 335 ++ .../Solicitors.HtmlParsing/DIExtensions.cs | 13 + .../libs/Solicitors.HtmlParsing/HtmlParser.cs | 130 + .../Solicitors.HtmlParsing/IHtmlParser.cs | 8 + .../Models/HtmlAttribute.cs | 6 + .../Solicitors.HtmlParsing/Models/HtmlNode.cs | 92 + .../Models/HtmlValueAttribute.cs | 6 + .../Models/IHtmlAttribute.cs | 6 + .../Models/IHtmlNode.cs | 64 + .../Models/ParentHtmlNode.cs | 92 + .../Models/StringNode.cs | 57 + .../Solicitors.HtmlParsing.csproj | 13 + .../SolicitorServiceTests.cs | 130 + .../Solicitors.Core.Tests.csproj | 26 + frontend/.gitignore | 24 + frontend/.yarn/install-state.gz | Bin 0 -> 408488 bytes frontend/.yarnrc.yml | 8 + frontend/Dockerfile | 15 + frontend/README.md | 15 + frontend/index.html | 17 + frontend/package.json | 31 + frontend/public/vite.svg | 15 + frontend/src/assets/preact.svg | 6 + frontend/src/components/detail.tsx | 138 + frontend/src/components/header.tsx | 42 + frontend/src/components/numberField.tsx | 114 + frontend/src/components/result.tsx | 44 + frontend/src/components/results.tsx | 46 + frontend/src/components/resultsList.tsx | 42 + frontend/src/components/sidebar.tsx | 159 + frontend/src/functions/axios.ts | 7 + .../src/functions/capitaliseFirstLetter.ts | 3 + frontend/src/functions/getCities.ts | 6 + frontend/src/functions/getRatingsProviders.ts | 6 + frontend/src/functions/getSolicitor.ts | 7 + frontend/src/functions/getSolicitors.ts | 32 + frontend/src/index.tsx | 129 + frontend/src/models/filterState.ts | 10 + frontend/src/models/paginationResponse.ts | 4 + frontend/src/models/results.ts | 25 + frontend/src/models/solicitorSummary.ts | 30 + frontend/tsconfig.json | 20 + frontend/vite.config.ts | 7 + frontend/yarn.lock | 4693 +++++++++++++++++ 109 files changed, 8666 insertions(+) create mode 100644 .gitignore create mode 100644 README.md create mode 100644 backend/Dockerfile create mode 100644 backend/SolicitorsApi.slnx create mode 100644 backend/app/Solicitors.Api/Endpoints/CitiesEndpoints.cs create mode 100644 backend/app/Solicitors.Api/Endpoints/RatingsProvidersEndpoints.cs create mode 100644 backend/app/Solicitors.Api/Endpoints/SolicitorsEndpoints.cs create mode 100644 backend/app/Solicitors.Api/Program.cs create mode 100644 backend/app/Solicitors.Api/Properties/launchSettings.json create mode 100644 backend/app/Solicitors.Api/Solicitors.Api.csproj create mode 100644 backend/app/Solicitors.Api/Solicitors.Api.http create mode 100644 backend/app/Solicitors.Api/appsettings.json create mode 100644 backend/libs/Solicitors.CacheBuild/DIExtensions.cs create mode 100644 backend/libs/Solicitors.CacheBuild/ISolicitorImporter.cs create mode 100644 backend/libs/Solicitors.CacheBuild/ISolicitorParser.cs create mode 100644 backend/libs/Solicitors.CacheBuild/ImportConfiguration.cs create mode 100644 backend/libs/Solicitors.CacheBuild/ImportRunner.cs create mode 100644 backend/libs/Solicitors.CacheBuild/SolicitorImporter.cs create mode 100644 backend/libs/Solicitors.CacheBuild/Solicitors.CacheBuild.csproj create mode 100644 backend/libs/Solicitors.CacheBuild/SolicitorsDotCom/Consts.cs create mode 100644 backend/libs/Solicitors.CacheBuild/SolicitorsDotCom/SolicitorBuilder.cs create mode 100644 backend/libs/Solicitors.CacheBuild/SolicitorsDotCom/SolicitorParser.cs create mode 100644 backend/libs/Solicitors.CacheBuild/StaleDataRemover.cs create mode 100644 backend/libs/Solicitors.Core/DIExtensions.cs create mode 100644 backend/libs/Solicitors.Core/Data/IRatingsProviderRepository.cs create mode 100644 backend/libs/Solicitors.Core/Data/IReadOnlySolicitorRepository.cs create mode 100644 backend/libs/Solicitors.Core/Data/ISolicitorRepository.cs create mode 100644 backend/libs/Solicitors.Core/IRatingsProviderService.cs create mode 100644 backend/libs/Solicitors.Core/IReadOnlyCitiesService.cs create mode 100644 backend/libs/Solicitors.Core/IReadOnlySolicitorService.cs create mode 100644 backend/libs/Solicitors.Core/ISolicitorService.cs create mode 100644 backend/libs/Solicitors.Core/Misc/EnumerableExtensions.cs create mode 100644 backend/libs/Solicitors.Core/Misc/IFilter.cs create mode 100644 backend/libs/Solicitors.Core/Misc/Pagination.cs create mode 100644 backend/libs/Solicitors.Core/Models/City.cs create mode 100644 backend/libs/Solicitors.Core/Models/Imports/Location.cs create mode 100644 backend/libs/Solicitors.Core/Models/Imports/Rating.cs create mode 100644 backend/libs/Solicitors.Core/Models/Imports/SolicitorData.cs create mode 100644 backend/libs/Solicitors.Core/Models/Solicitor.cs create mode 100644 backend/libs/Solicitors.Core/Models/SolicitorInfo.cs create mode 100644 backend/libs/Solicitors.Core/Models/SolicitorLocation.cs create mode 100644 backend/libs/Solicitors.Core/Models/SolicitorLocationRating.cs create mode 100644 backend/libs/Solicitors.Core/Models/SolicitorRating.cs create mode 100644 backend/libs/Solicitors.Core/Models/View/LocationInfo.cs create mode 100644 backend/libs/Solicitors.Core/Models/View/RatingInfo.cs create mode 100644 backend/libs/Solicitors.Core/Models/View/SolicitorSummary.cs create mode 100644 backend/libs/Solicitors.Core/Ordering/DefaultSolicitorDataOrdering.cs create mode 100644 backend/libs/Solicitors.Core/Ordering/ISolicitorComparerFactory.cs create mode 100644 backend/libs/Solicitors.Core/Ordering/NameComparer.cs create mode 100644 backend/libs/Solicitors.Core/Ordering/OrderingType.cs create mode 100644 backend/libs/Solicitors.Core/Ordering/RatingComparer.cs create mode 100644 backend/libs/Solicitors.Core/Ordering/SolicitorComparerFactory.cs create mode 100644 backend/libs/Solicitors.Core/PaginationResponse.cs create mode 100644 backend/libs/Solicitors.Core/RatingsProviderService.cs create mode 100644 backend/libs/Solicitors.Core/ReadOnlyCitiesService.cs create mode 100644 backend/libs/Solicitors.Core/SolicitorService.cs create mode 100644 backend/libs/Solicitors.Core/Solicitors.Core.csproj create mode 100644 backend/libs/Solicitors.Data/DIExtensions.cs create mode 100644 backend/libs/Solicitors.Data/RepositorySetup/IRepoSetupOptions.cs create mode 100644 backend/libs/Solicitors.Data/RepositorySetup/IRepoSetupService.cs create mode 100644 backend/libs/Solicitors.Data/RepositorySetup/InMemory/InMemoryDbSetupOptions.cs create mode 100644 backend/libs/Solicitors.Data/RepositorySetup/InMemory/InMemorySetupService.cs create mode 100644 backend/libs/Solicitors.Data/RepositorySetup/Sqlite/SqliteDbSetupOptions.cs create mode 100644 backend/libs/Solicitors.Data/RepositorySetup/Sqlite/SqliteSetupService.cs create mode 100644 backend/libs/Solicitors.Data/Solicitors.Data.csproj create mode 100644 backend/libs/Solicitors.Data/SolicitorsRepository.cs create mode 100644 backend/libs/Solicitors.HtmlParsing/DIExtensions.cs create mode 100644 backend/libs/Solicitors.HtmlParsing/HtmlParser.cs create mode 100644 backend/libs/Solicitors.HtmlParsing/IHtmlParser.cs create mode 100644 backend/libs/Solicitors.HtmlParsing/Models/HtmlAttribute.cs create mode 100644 backend/libs/Solicitors.HtmlParsing/Models/HtmlNode.cs create mode 100644 backend/libs/Solicitors.HtmlParsing/Models/HtmlValueAttribute.cs create mode 100644 backend/libs/Solicitors.HtmlParsing/Models/IHtmlAttribute.cs create mode 100644 backend/libs/Solicitors.HtmlParsing/Models/IHtmlNode.cs create mode 100644 backend/libs/Solicitors.HtmlParsing/Models/ParentHtmlNode.cs create mode 100644 backend/libs/Solicitors.HtmlParsing/Models/StringNode.cs create mode 100644 backend/libs/Solicitors.HtmlParsing/Solicitors.HtmlParsing.csproj create mode 100644 backend/tests/Solicitors.Core.Tests/SolicitorServiceTests.cs create mode 100644 backend/tests/Solicitors.Core.Tests/Solicitors.Core.Tests.csproj create mode 100644 frontend/.gitignore create mode 100644 frontend/.yarn/install-state.gz create mode 100644 frontend/.yarnrc.yml create mode 100644 frontend/Dockerfile create mode 100644 frontend/README.md create mode 100644 frontend/index.html create mode 100644 frontend/package.json create mode 100644 frontend/public/vite.svg create mode 100644 frontend/src/assets/preact.svg create mode 100644 frontend/src/components/detail.tsx create mode 100644 frontend/src/components/header.tsx create mode 100644 frontend/src/components/numberField.tsx create mode 100644 frontend/src/components/result.tsx create mode 100644 frontend/src/components/results.tsx create mode 100644 frontend/src/components/resultsList.tsx create mode 100644 frontend/src/components/sidebar.tsx create mode 100644 frontend/src/functions/axios.ts create mode 100644 frontend/src/functions/capitaliseFirstLetter.ts create mode 100644 frontend/src/functions/getCities.ts create mode 100644 frontend/src/functions/getRatingsProviders.ts create mode 100644 frontend/src/functions/getSolicitor.ts create mode 100644 frontend/src/functions/getSolicitors.ts create mode 100644 frontend/src/index.tsx create mode 100644 frontend/src/models/filterState.ts create mode 100644 frontend/src/models/paginationResponse.ts create mode 100644 frontend/src/models/results.ts create mode 100644 frontend/src/models/solicitorSummary.ts create mode 100644 frontend/tsconfig.json create mode 100644 frontend/vite.config.ts create mode 100644 frontend/yarn.lock diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..0808c4a --- /dev/null +++ b/.gitignore @@ -0,0 +1,482 @@ +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. +## +## Get latest from `dotnet new gitignore` + +# dotenv files +.env + +# User-specific files +*.rsuser +*.suo +*.user +*.userosscache +*.sln.docstates + +# User-specific files (MonoDevelop/Xamarin Studio) +*.userprefs + +# Mono auto generated files +mono_crash.* + +# Build results +[Dd]ebug/ +[Dd]ebugPublic/ +[Rr]elease/ +[Rr]eleases/ +x64/ +x86/ +[Ww][Ii][Nn]32/ +[Aa][Rr][Mm]/ +[Aa][Rr][Mm]64/ +bld/ +[Bb]in/ +[Oo]bj/ +[Ll]og/ +[Ll]ogs/ + +# Visual Studio 2015/2017 cache/options directory +.vs/ +# Uncomment if you have tasks that create the project's static files in wwwroot +#wwwroot/ + +# Visual Studio 2017 auto generated files +Generated\ Files/ + +# MSTest test Results +[Tt]est[Rr]esult*/ +[Bb]uild[Ll]og.* + +# NUnit +*.VisualState.xml +TestResult.xml +nunit-*.xml + +# Build Results of an ATL Project +[Dd]ebugPS/ +[Rr]eleasePS/ +dlldata.c + +# Benchmark Results +BenchmarkDotNet.Artifacts/ + +# .NET +project.lock.json +project.fragment.lock.json +artifacts/ + +# Tye +.tye/ + +# ASP.NET Scaffolding +ScaffoldingReadMe.txt + +# StyleCop +StyleCopReport.xml + +# Files built by Visual Studio +*_i.c +*_p.c +*_h.h +*.ilk +*.meta +*.obj +*.iobj +*.pch +*.pdb +*.ipdb +*.pgc +*.pgd +*.rsp +# but not Directory.Build.rsp, as it configures directory-level build defaults +!Directory.Build.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.tmp_proj +*_wpftmp.csproj +*.log +*.tlog +*.vspscc +*.vssscc +.builds +*.pidb +*.svclog +*.scc + +# Chutzpah Test files +_Chutzpah* + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opendb +*.opensdf +*.sdf +*.cachefile +*.VC.db +*.VC.VC.opendb + +# Visual Studio profiler +*.psess +*.vsp +*.vspx +*.sap + +# Visual Studio Trace Files +*.e2e + +# TFS 2012 Local Workspace +$tf/ + +# Guidance Automation Toolkit +*.gpState + +# ReSharper is a .NET coding add-in +_ReSharper*/ +*.[Rr]e[Ss]harper +*.DotSettings.user + +# TeamCity is a build add-in +_TeamCity* + +# DotCover is a Code Coverage Tool +*.dotCover + +# AxoCover is a Code Coverage Tool +.axoCover/* +!.axoCover/settings.json + +# Coverlet is a free, cross platform Code Coverage Tool +coverage*.json +coverage*.xml +coverage*.info + +# Visual Studio code coverage results +*.coverage +*.coveragexml + +# NCrunch +_NCrunch_* +.*crunch*.local.xml +nCrunchTemp_* + +# MightyMoose +*.mm.* +AutoTest.Net/ + +# Web workbench (sass) +.sass-cache/ + +# Installshield output folder +[Ee]xpress/ + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish/ + +# Publish Web Output +*.[Pp]ublish.xml +*.azurePubxml +# Note: Comment the next line if you want to checkin your web deploy settings, +# but database connection strings (with potential passwords) will be unencrypted +*.pubxml +*.publishproj + +# Microsoft Azure Web App publish settings. Comment the next line if you want to +# checkin your Azure Web App publish settings, but sensitive information contained +# in these scripts will be unencrypted +PublishScripts/ + +# NuGet Packages +*.nupkg +# NuGet Symbol Packages +*.snupkg +# The packages folder can be ignored because of Package Restore +**/[Pp]ackages/* +# except build/, which is used as an MSBuild target. +!**/[Pp]ackages/build/ +# Uncomment if necessary however generally it will be regenerated when needed +#!**/[Pp]ackages/repositories.config +# NuGet v3's project.json files produces more ignorable files +*.nuget.props +*.nuget.targets + +# Microsoft Azure Build Output +csx/ +*.build.csdef + +# Microsoft Azure Emulator +ecf/ +rcf/ + +# Windows Store app package directories and files +AppPackages/ +BundleArtifacts/ +Package.StoreAssociation.xml +_pkginfo.txt +*.appx +*.appxbundle +*.appxupload + +# Visual Studio cache files +# files ending in .cache can be ignored +*.[Cc]ache +# but keep track of directories ending in .cache +!?*.[Cc]ache/ + +# Others +ClientBin/ +~$* +*~ +*.dbmdl +*.dbproj.schemaview +*.jfm +*.pfx +*.publishsettings +orleans.codegen.cs + +# Including strong name files can present a security risk +# (https://github.com/github/gitignore/pull/2483#issue-259490424) +#*.snk + +# Since there are multiple workflows, uncomment next line to ignore bower_components +# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) +#bower_components/ + +# RIA/Silverlight projects +Generated_Code/ + +# Backup & report files from converting an old project file +# to a newer Visual Studio version. Backup files are not needed, +# because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML +UpgradeLog*.htm +ServiceFabricBackup/ +*.rptproj.bak + +# SQL Server files +*.mdf +*.ldf +*.ndf + +# Business Intelligence projects +*.rdl.data +*.bim.layout +*.bim_*.settings +*.rptproj.rsuser +*- [Bb]ackup.rdl +*- [Bb]ackup ([0-9]).rdl +*- [Bb]ackup ([0-9][0-9]).rdl + +# Microsoft Fakes +FakesAssemblies/ + +# GhostDoc plugin setting file +*.GhostDoc.xml + +# Node.js Tools for Visual Studio +.ntvs_analysis.dat +node_modules/ + +# Visual Studio 6 build log +*.plg + +# Visual Studio 6 workspace options file +*.opt + +# Visual Studio 6 auto-generated workspace file (contains which files were open etc.) +*.vbw + +# Visual Studio 6 auto-generated project file (contains which files were open etc.) +*.vbp + +# Visual Studio 6 workspace and project file (working project files containing files to include in project) +*.dsw +*.dsp + +# Visual Studio 6 technical files +*.ncb +*.aps + +# Visual Studio LightSwitch build output +**/*.HTMLClient/GeneratedArtifacts +**/*.DesktopClient/GeneratedArtifacts +**/*.DesktopClient/ModelManifest.xml +**/*.Server/GeneratedArtifacts +**/*.Server/ModelManifest.xml +_Pvt_Extensions + +# Paket dependency manager +.paket/paket.exe +paket-files/ + +# FAKE - F# Make +.fake/ + +# CodeRush personal settings +.cr/personal + +# Python Tools for Visual Studio (PTVS) +__pycache__/ +*.pyc + +# Cake - Uncomment if you are using it +# tools/** +# !tools/packages.config + +# Tabs Studio +*.tss + +# Telerik's JustMock configuration file +*.jmconfig + +# BizTalk build output +*.btp.cs +*.btm.cs +*.odx.cs +*.xsd.cs + +# OpenCover UI analysis results +OpenCover/ + +# Azure Stream Analytics local run output +ASALocalRun/ + +# MSBuild Binary and Structured Log +*.binlog + +# NVidia Nsight GPU debugger configuration file +*.nvuser + +# MFractors (Xamarin productivity tool) working folder +.mfractor/ + +# Local History for Visual Studio +.localhistory/ + +# Visual Studio History (VSHistory) files +.vshistory/ + +# BeatPulse healthcheck temp database +healthchecksdb + +# Backup folder for Package Reference Convert tool in Visual Studio 2017 +MigrationBackup/ + +# Ionide (cross platform F# VS Code tools) working folder +.ionide/ + +# Fody - auto-generated XML schema +FodyWeavers.xsd + +# VS Code files for those working on multiple tools +.vscode/* +!.vscode/settings.json +!.vscode/tasks.json +!.vscode/launch.json +!.vscode/extensions.json +*.code-workspace + +# Local History for Visual Studio Code +.history/ + +# Windows Installer files from build outputs +*.cab +*.msi +*.msix +*.msm +*.msp + +# JetBrains Rider +*.sln.iml +.idea/ + +## +## Visual studio for Mac +## + + +# globs +Makefile.in +*.userprefs +*.usertasks +config.make +config.status +aclocal.m4 +install-sh +autom4te.cache/ +*.tar.gz +tarballs/ +test-results/ + +# content below from: https://github.com/github/gitignore/blob/main/Global/macOS.gitignore +# General +.DS_Store +.AppleDouble +.LSOverride + +# Icon must end with two \r +Icon + + +# Thumbnails +._* + +# Files that might appear in the root of a volume +.DocumentRevisions-V100 +.fseventsd +.Spotlight-V100 +.TemporaryItems +.Trashes +.VolumeIcon.icns +.com.apple.timemachine.donotpresent + +# Directories potentially created on remote AFP share +.AppleDB +.AppleDesktop +Network Trash Folder +Temporary Items +.apdisk + +# content below from: https://github.com/github/gitignore/blob/main/Global/Windows.gitignore +# Windows thumbnail cache files +Thumbs.db +ehthumbs.db +ehthumbs_vista.db + +# Dump file +*.stackdump + +# Folder config file +[Dd]esktop.ini + +# Recycle Bin used on file shares +$RECYCLE.BIN/ + +# Windows Installer files +*.cab +*.msi +*.msix +*.msm +*.msp + +# Windows shortcuts +*.lnk + +# Vim temporary swap files +*.swp diff --git a/README.md b/README.md new file mode 100644 index 0000000..364fc86 --- /dev/null +++ b/README.md @@ -0,0 +1,113 @@ +# README +This repo contains Fox's submission for InfoTrack's development project. The backend (found in `/backend`) is a dotnet 10 minimal api, and the frontend is a single-page webapp made using preact and vite. + +A sample of this project will be deployed [here](http://solicitors.starfahx.com) for the next few weeks, should the steps [below](#running-the-project) not work on your machine. + +## Using the App +The frontend project provides a quick way to search through the cached data. The list of firms can be filtered by name (case-insensitive, matches any part of the name) to quickly find a desired firm. Additional fields allow the user to filter results by: +- City: this field is a multi-select, and will return firms in any of the cities selected; if none are selected, it returns firms from all cities. +- Rating: this field allows the user to select a minimum rating, and a rating provider to filter by. Only firms who have a rating provided by the selected provider will be returned, unless the minimum rating field is de-selected. + +These fields are disabled if the option to search by name only is selected. + +Finally, the user can change the ordering of results and the number displayed per page. + +Clicking on a result brings up a modal display of all the relevant ratings and contact information available for the firm. + +## Running the Project +The project is designed to be run using `docker compose`. Clone the project, and add a `compose.yaml` file in the root directory. A sample compose file might look like this: + +```yaml +services: + frontend: + build: + context: ./frontend + args: + VITE_API_URL: http://localhost:5123 + ports: + - "5124:80" + + backend: + build: + context: ./backend + ports: + - "5123:8080" + volumes: + - "/path/to/data:/data" + +``` + +The backend container requires a volume mapped to `/data`, which contains an `apiSettings.json` configuration file, necessary for configuring the api. A sample config file might look like this: + +```json +{ + "Database": { + "Type": "sqlite", + "DbPath": "/data/solicitors.db" + }, + "Imports": { + "ImportMinutes": 5, + "RemoveMinutes": 120, + "StaleMinutes": 60 + } +} +``` + +The `Database` node must contain a `Type` field, which must have the value `"sqlite"` or `"inmemory"`, to configure a database of the appropriate kind. + +For a Sqlite database, the field `"DbPath"`specifies the path to the .db file. It is recommended to choose a file in `/data`, as this is a volume already mounted and can be examined outside the container. + +For an In Memory database, the field `"DbName"` specifies the name to give to the database. + +The `Imports` node must contain the following fields: +- `"ImportMinutes"`: an integer number of minutes on which to run the cache import job. The target website, solicitors.com, does not provide consistent search results, so frequent searches will ensure the most complete cache possible. +- `"RemoveMinutes"`: an integer number of minutes on which to run the cache cleanup job. This job removes stale items from the cache. It is recommended that this job run much less often than the import, for the reason above. +- `"StaleMinutes"`: an integer number of minutes since modified beyond which a cached item is considered stale, and removed by the cleanup job. + +With both the configuration file and the compose file in place, running `docker compose up -d` will start the containerised applications. They can be shut down with `docker compose down`. If you've pulled a newer version of the source code, `docker compose up -d --build` should be used to relaunch the applications. + +## Additional Notes on Implementation +I _somewhat_ exceeded the 1-2 hours mentioned in the document, if the amount of code here + my aversion to AI doesn't make that clear, but given in the interview it was suggested that this could take a couple of weeks I figured that was a guideline and since I didn't have much better to do for this last week I decided to put a bit of effort in. Hope that's okay! It's taken roughly a workweek to get this together, excluding time spent filing bug reports with Fresh (my first choice for a frontend framework). + +I've written some notes on things I've enjoyed doing + want to show off, as well as things that have suffered for the time constraints. I then looked at how much I wrote and realised it was rather a lot. Sorry! Feel free to skim it. + +### HTML Parsing +For the web-scraping part of this project, I've done my best to avoid third-party libraries as requested. To achieve this, I've written an _extremely limited_ HTML parsing library, as I wasn't able to find an easy equivalent in the standard libraries for dotnet. This library uses a design I've borrowed from compiler design (I'm currently working my way through a textbook on compiler design so that was quite handy!) where first the HTML is lexed into tokens and then those tokens are parsed in a pseudo-grammar to form a nested tree of nodes. + +I made use of a C# feature here that I made use of while working through that textbook: by leveraging deferred execution, I'm able to effectively perform a single-pass parsing. I'm not sure this actually has much of a performance improvement, but it seems silly to build up a list of nodes just to immediately enumerate through it again. + +Due to the time constratints, this is really quite messy code and I'm not happy with the api it provides for actually scanning through the HTML tree, but it works for now. I'd love to come back and revisit this at some point, honestly, it was a really fun little project. + +### Cache Store +I've used EFCore as my ORM of choice, because it's super easy to use, and this project finally gave me the opportunity to implement something I've never had an opportunity to do in the past: runtime switching of EFCore providers! I've wanted to build an app that allows the user to define (in a compose file or similar) where the data is stored for a long time, so I'm very glad I got a chance to do that here. + +It's good to know that `EnsureCreatedAsync` works the way I expected for making a new sqlite db, and avoids messing around with migrations too much. Obviously, that's only possible because the schema for this project is pretty static: solving that problem for an actively-developed version of this app, and one that uses a SQL Server or Postgres provider, would probably require a fair bit more engineering. + +### General Architecture +Broadly I try to architect my projects (as can be seen here) into libraries which expose abstractions publicly and keep implementations internal, registering them with a DI container. I think this approach is cleaner than having a bunch of .Abstractions projects lying around when those aren't absolutely necessary! + +The original idea was that the `Solicitors.Core` library would contain service abstractions that could be referenced by libraries for the cache store and for the cache build separately, which seems to have done the trick. This approach got a little confusing at times with the models namespaces, though, so I could probably do a better job of keeping those clean. + +There's also some things that ended up in Core (e.g. the comparers for ordering results) that I don't think really belonged there, which was the result of not really having a place for API-level abstractions to belong. + +Running the imports on a timer within the api is probably not how I'd want to architect this project if it were going to be developed further, but I've gone with that based on the time constraints. In an ideal world there'd be a read-only REST api app + another service app that could be scheduled by the OS. I settled on Quartz.Net to provide scheduling functionality for the import only because I'd heard of it and knew it would work, though I think it's a bit overkill for what I'm trying to do here. + +### API Design +A weak point of this project, which is a shame because it's something I care quite a bit about. I'd love to take the time to do up the API nicely, handle errors + validate input etc etc, but it really seemed quite unnecessary for this project, especially since the API exists only to be consumed by the UI. + +### Frontend Frameworks +As mentioned, I was going to use Deno + Fresh as my frontend framework of choice: I love preact as a lightweight, fast alternative to react, and Fresh using it by default has really won me over. Fresh's approach to server-side rendering is really fun, and I'd spent a while on this project learning all about Fresh's Partials system, which I intended to use for the results display. + +Unfortunately, there's a bug in Fresh that I'd occasionally run into before that means using css/scss modules is deeply inconsistent, which is my go-to pattern if I'm not using a component library. I'm not a big fan of tailwind, and because Deno and Fresh are fairly immature it's quite hard to find a non-tailwind component/styling library that works with them. + +In the end I fell back on regular preact, hosted by vite (not because I know it very well. It's just what Fresh uses under the hood for some things so I thought porting my work would be easy. It wasn't.) I've used MUI as a component library because after losing all that time I just wanted to get it done quickly, and it's a framework I've used before with some success. It's a bit dated but it gets the job done! + +### (Unit) Testing +I really did not have time for this. I _should_ have absolutely done this as TDD, but given I started with the problem of the HTML Parsing and was just writing that out in a scratchpad to make something that even stood a chance of working I ended up skipping that. + +I've added a couple of unit tests more to demonstrate ability and comfort with them than anything else. + +I've done some reasonably thorough manual testing, and pestered friends and family to try to break the site to make sure I hadn't missed anything obvious. I'm pretty confident it'll work! But this is my first time making an app designed to be consumed by `docker compose` so it might just fall apart for you. I've tested deployment both on my desktop and on one of my servers, using various different configurations and on a couple of different Linux distributions. + +## Closing Remarks +Sorry if I took too long over this. It's been nice to have something serious to work on for the last week, so I wanted to enjoy it while it lasted! Thanks for considering me for the role and I hope I get to speak with you soon. \ No newline at end of file diff --git a/backend/Dockerfile b/backend/Dockerfile new file mode 100644 index 0000000..4fa5927 --- /dev/null +++ b/backend/Dockerfile @@ -0,0 +1,16 @@ +FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build +WORKDIR /App + +# Copy everything +COPY . ./ +# Restore as distinct layers +RUN dotnet restore +# Build and publish a release +RUN dotnet publish -o out + +# Build runtime image +FROM mcr.microsoft.com/dotnet/aspnet:10.0 +VOLUME /data +WORKDIR /App +COPY --from=build /App/out . +ENTRYPOINT ["dotnet", "Solicitors.Api.dll"] \ No newline at end of file diff --git a/backend/SolicitorsApi.slnx b/backend/SolicitorsApi.slnx new file mode 100644 index 0000000..40ac908 --- /dev/null +++ b/backend/SolicitorsApi.slnx @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + diff --git a/backend/app/Solicitors.Api/Endpoints/CitiesEndpoints.cs b/backend/app/Solicitors.Api/Endpoints/CitiesEndpoints.cs new file mode 100644 index 0000000..76f3cc3 --- /dev/null +++ b/backend/app/Solicitors.Api/Endpoints/CitiesEndpoints.cs @@ -0,0 +1,17 @@ +using Microsoft.AspNetCore.Mvc; +using Solicitors.Core; + +namespace Solicitors.Api.Endpoints; + +public static class CitiesEndpoints +{ + public static void MapCities(this IEndpointRouteBuilder app) + { + app.MapGet( + "/cities", + ( + [FromServices] IReadOnlyCitiesService citiesService, + CancellationToken cancellationToken + ) => citiesService.GetAllCitiesAsync(cancellationToken)); + } +} \ No newline at end of file diff --git a/backend/app/Solicitors.Api/Endpoints/RatingsProvidersEndpoints.cs b/backend/app/Solicitors.Api/Endpoints/RatingsProvidersEndpoints.cs new file mode 100644 index 0000000..2575281 --- /dev/null +++ b/backend/app/Solicitors.Api/Endpoints/RatingsProvidersEndpoints.cs @@ -0,0 +1,17 @@ +using Microsoft.AspNetCore.Mvc; +using Solicitors.Core; + +namespace Solicitors.Api.Endpoints; + +public static class RatingsProvidersEndpoints +{ + public static void MapRatingsProviders(this IEndpointRouteBuilder app) + { + app.MapGet( + "/ratingsProviders", + ( + [FromServices] IRatingsProviderService service, + CancellationToken cancellationToken + ) => service.GetRatingsProvidersAsync(cancellationToken)); + } +} \ No newline at end of file diff --git a/backend/app/Solicitors.Api/Endpoints/SolicitorsEndpoints.cs b/backend/app/Solicitors.Api/Endpoints/SolicitorsEndpoints.cs new file mode 100644 index 0000000..6e07503 --- /dev/null +++ b/backend/app/Solicitors.Api/Endpoints/SolicitorsEndpoints.cs @@ -0,0 +1,60 @@ +using Microsoft.AspNetCore.Mvc; +using Solicitors.Core; +using Solicitors.Core.Misc; +using Solicitors.Core.Models; +using Solicitors.Core.Ordering; + +namespace Solicitors.Api.Endpoints; + +public static class SolicitorsEndpoints +{ + public static void MapSolicitors(this IEndpointRouteBuilder app) + { + app.MapGet( + "/solicitors", + ( + [FromServices] IReadOnlySolicitorService solicitorService, + [FromServices] ISolicitorComparerFactory solicitorComparerFactory, + CancellationToken cancellationToken, + [FromQuery] uint pageNumber = 1, + [FromQuery] uint pageSize = 20, + [FromQuery] string? nameFilter = null, + [FromQuery] decimal minRating = 0, + [FromQuery] string[]? cities = null, + [FromQuery] string ratingsProvider = "Solicitors.com", + [FromQuery] OrderingType? orderingType = null) => + { + IFilter? filter = null; + + if (!string.IsNullOrEmpty(nameFilter)) + filter = new WrapperFilter(filter, solicitor => solicitor.Name.Contains(nameFilter, StringComparison.CurrentCultureIgnoreCase)); + + if (cities is not null && cities.Length > 0) + filter = new WrapperFilter(filter, solicitor => cities.Any(city => solicitor.Cities.Any(solCity => solCity.Name == city))); + + if (minRating > 0) + filter = new WrapperFilter( + filter, + solicitor => solicitor.Ratings.Any(rating => rating.Provider == ratingsProvider && rating.Value / rating.Maximum >= minRating / 5.0m)); + + var ordering = solicitorComparerFactory.GetComparer(orderingType, ratingsProvider); + + return solicitorService.GetSolicitorSummariesAsync( + new Pagination(pageNumber, pageSize), + ratingsProvider, + filter, + ordering, + cancellationToken: cancellationToken); + } + ); + + app.MapGet( + "/solicitors/{id:guid}", + ( + [FromServices] IReadOnlySolicitorService solicitorService, + [FromRoute] Guid id, + CancellationToken cancellationToken + ) => solicitorService.GetSolicitorInfoByIdAsync(id, cancellationToken) + ); + } +} \ No newline at end of file diff --git a/backend/app/Solicitors.Api/Program.cs b/backend/app/Solicitors.Api/Program.cs new file mode 100644 index 0000000..774a2af --- /dev/null +++ b/backend/app/Solicitors.Api/Program.cs @@ -0,0 +1,42 @@ +using Solicitors.Api.Endpoints; +using Solicitors.CacheBuild; +using Solicitors.Core; +using Solicitors.Data; +using Solicitors.HtmlParsing; + +var builder = WebApplication.CreateBuilder(args); + +builder.Configuration.AddJsonFile("/data/apiSettings.json", optional: true); + +builder.Services.AddOpenApi(); +builder.Services.AddCore(); +builder.Services.AddData(builder.Configuration); +builder.Services.AddCacheBuild(); +builder.Services.Configure(builder.Configuration.GetSection("Imports")); +builder.Services.AddHtmlParsing(); +builder.Services.AddHttpClient(); +builder.Services.AddCors(options => +{ + options.AddDefaultPolicy(policy => policy.AllowAnyHeader().AllowAnyMethod().AllowAnyOrigin()); +}); + +var app = builder.Build(); + +// Configure the HTTP request pipeline. +if (app.Environment.IsDevelopment()) +{ + app.MapOpenApi(); +} + +app.UseHttpsRedirection(); +app.MapSolicitors(); +app.MapCities(); +app.MapRatingsProviders(); +app.UseCors(); + +using (var scope = app.Services.CreateScope()) +{ + await scope.UseCacheBuildAsync(CancellationToken.None); +} + +app.Run(); \ No newline at end of file diff --git a/backend/app/Solicitors.Api/Properties/launchSettings.json b/backend/app/Solicitors.Api/Properties/launchSettings.json new file mode 100644 index 0000000..9ac83b5 --- /dev/null +++ b/backend/app/Solicitors.Api/Properties/launchSettings.json @@ -0,0 +1,23 @@ +{ + "$schema": "https://json.schemastore.org/launchsettings.json", + "profiles": { + "http": { + "commandName": "Project", + "dotnetRunMessages": true, + "launchBrowser": false, + "applicationUrl": "http://localhost:5254", + "environmentVariables": { + "ASPNETCORE_ENVIRONMENT": "Development" + } + }, + "https": { + "commandName": "Project", + "dotnetRunMessages": true, + "launchBrowser": false, + "applicationUrl": "https://localhost:7226;http://localhost:5254", + "environmentVariables": { + "ASPNETCORE_ENVIRONMENT": "Development" + } + } + } +} diff --git a/backend/app/Solicitors.Api/Solicitors.Api.csproj b/backend/app/Solicitors.Api/Solicitors.Api.csproj new file mode 100644 index 0000000..4765b66 --- /dev/null +++ b/backend/app/Solicitors.Api/Solicitors.Api.csproj @@ -0,0 +1,22 @@ + + + + net10.0 + enable + enable + + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + + + + + diff --git a/backend/app/Solicitors.Api/Solicitors.Api.http b/backend/app/Solicitors.Api/Solicitors.Api.http new file mode 100644 index 0000000..a8e024f --- /dev/null +++ b/backend/app/Solicitors.Api/Solicitors.Api.http @@ -0,0 +1,6 @@ +@Solicitors.Api_HostAddress = http://localhost:5254 + +GET {{Solicitors.Api_HostAddress}}/weatherforecast/ +Accept: application/json + +### diff --git a/backend/app/Solicitors.Api/appsettings.json b/backend/app/Solicitors.Api/appsettings.json new file mode 100644 index 0000000..149cb09 --- /dev/null +++ b/backend/app/Solicitors.Api/appsettings.json @@ -0,0 +1,9 @@ +{ + "Logging": { + "LogLevel": { + "Default": "Information", + "Microsoft.AspNetCore": "Warning" + } + }, + "AllowedHosts": "*" +} \ No newline at end of file diff --git a/backend/libs/Solicitors.CacheBuild/DIExtensions.cs b/backend/libs/Solicitors.CacheBuild/DIExtensions.cs new file mode 100644 index 0000000..37f832c --- /dev/null +++ b/backend/libs/Solicitors.CacheBuild/DIExtensions.cs @@ -0,0 +1,54 @@ +using System.Diagnostics.CodeAnalysis; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Options; +using Quartz; + +namespace Solicitors.CacheBuild; + +[SuppressMessage("ReSharper", "InconsistentNaming")] +public static class DIExtensions +{ + public static IServiceCollection AddCacheBuild(this IServiceCollection services) + { + return services + .AddScoped() + .AddScoped() + .AddQuartz() + .AddQuartzHostedService(opt => opt.WaitForJobsToComplete = true); + } + + public static async Task UseCacheBuildAsync(this IServiceScope scope, CancellationToken cancellationToken) + { + var factory = scope.ServiceProvider.GetRequiredService(); + var options = scope.ServiceProvider.GetRequiredService>().Value; + var scheduler = await factory.GetScheduler(cancellationToken); + + var importJob = JobBuilder.Create() + .WithIdentity("ImportJob", "ImportGroup") + .Build(); + + var importTrigger = TriggerBuilder.Create() + .WithIdentity("ImportRunner", "ImportGroup") + .StartNow() + .WithSimpleSchedule(builder => builder + .WithIntervalInMinutes(options.ImportMinutes) + .RepeatForever()) + .Build(); + + await scheduler.ScheduleJob(importJob, importTrigger, cancellationToken); + + var staleJob = JobBuilder.Create() + .WithIdentity("StaleDataRemover", "RemoveGroup") + .Build(); + + var staleTrigger = TriggerBuilder.Create() + .WithIdentity("StaleDataTrigger", "RemoveGroup") + .StartNow() + .WithSimpleSchedule(builder => builder + .WithIntervalInMinutes(options.RemoveMinutes) + .RepeatForever()) + .Build(); + + await scheduler.ScheduleJob(staleJob, staleTrigger, cancellationToken); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.CacheBuild/ISolicitorImporter.cs b/backend/libs/Solicitors.CacheBuild/ISolicitorImporter.cs new file mode 100644 index 0000000..791c72c --- /dev/null +++ b/backend/libs/Solicitors.CacheBuild/ISolicitorImporter.cs @@ -0,0 +1,6 @@ +namespace Solicitors.CacheBuild; + +public interface ISolicitorImporter +{ + Task RunFullImport(CancellationToken cancellationToken); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.CacheBuild/ISolicitorParser.cs b/backend/libs/Solicitors.CacheBuild/ISolicitorParser.cs new file mode 100644 index 0000000..0119a8c --- /dev/null +++ b/backend/libs/Solicitors.CacheBuild/ISolicitorParser.cs @@ -0,0 +1,9 @@ +using Solicitors.Core.Models.Imports; + +namespace Solicitors.CacheBuild; + +internal interface ISolicitorParser +{ + Task GetSolicitorsAsync( + CancellationToken cancellationToken = default); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.CacheBuild/ImportConfiguration.cs b/backend/libs/Solicitors.CacheBuild/ImportConfiguration.cs new file mode 100644 index 0000000..70a8ef6 --- /dev/null +++ b/backend/libs/Solicitors.CacheBuild/ImportConfiguration.cs @@ -0,0 +1,8 @@ +namespace Solicitors.CacheBuild; + +public class ImportConfiguration +{ + public int StaleMinutes { get; set; } + public int RemoveMinutes { get; set; } + public int ImportMinutes { get; set; } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.CacheBuild/ImportRunner.cs b/backend/libs/Solicitors.CacheBuild/ImportRunner.cs new file mode 100644 index 0000000..72cefb7 --- /dev/null +++ b/backend/libs/Solicitors.CacheBuild/ImportRunner.cs @@ -0,0 +1,15 @@ +using Quartz; +using Solicitors.Core.Data; + +namespace Solicitors.CacheBuild; + +internal class ImportRunner( + ISolicitorImporter importer, + ISolicitorRepository repository) : IJob +{ + public async Task Execute(IJobExecutionContext context) + { + await repository.EnsureCreatedAsync(context.CancellationToken); + await importer.RunFullImport(context.CancellationToken); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.CacheBuild/SolicitorImporter.cs b/backend/libs/Solicitors.CacheBuild/SolicitorImporter.cs new file mode 100644 index 0000000..220c074 --- /dev/null +++ b/backend/libs/Solicitors.CacheBuild/SolicitorImporter.cs @@ -0,0 +1,20 @@ +using Solicitors.Core.Data; +using Solicitors.Core.Models.Imports; + +namespace Solicitors.CacheBuild; + +internal class SolicitorImporter( + ISolicitorParser parser, + ISolicitorRepository repository) : ISolicitorImporter +{ + public async Task RunFullImport(CancellationToken cancellationToken) + { + foreach (var solicitor in await parser.GetSolicitorsAsync(cancellationToken)) + { + await RunImport(solicitor, cancellationToken); + } + } + + private Task RunImport(SolicitorData solicitor, CancellationToken cancellationToken) + => repository.AddOrUpdateSolicitorAsync(solicitor, cancellationToken); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.CacheBuild/Solicitors.CacheBuild.csproj b/backend/libs/Solicitors.CacheBuild/Solicitors.CacheBuild.csproj new file mode 100644 index 0000000..7e73086 --- /dev/null +++ b/backend/libs/Solicitors.CacheBuild/Solicitors.CacheBuild.csproj @@ -0,0 +1,27 @@ + + + + net10.0 + enable + enable + + + + + + + + + + + + + + + + + ..\..\..\..\..\..\..\.dotnet\shared\Microsoft.AspNetCore.App\10.0.7\Microsoft.Extensions.Hosting.Abstractions.dll + + + + diff --git a/backend/libs/Solicitors.CacheBuild/SolicitorsDotCom/Consts.cs b/backend/libs/Solicitors.CacheBuild/SolicitorsDotCom/Consts.cs new file mode 100644 index 0000000..b6c3840 --- /dev/null +++ b/backend/libs/Solicitors.CacheBuild/SolicitorsDotCom/Consts.cs @@ -0,0 +1,14 @@ +namespace Solicitors.CacheBuild.SolicitorsDotCom; + +internal static class Consts +{ + public const string BaseUrl = "https://www.solicitors.com"; + public static readonly string[] Locations = + [ + "london", "birmingham", "leeds", "manchester", "sheffield", "bradford", "liverpool", "bristol" + ]; + + public const decimal MaxRating = 5.0m; + public const string Name = "Solicitors.com"; + public const string IconPath = "/images/logo.svg"; +} \ No newline at end of file diff --git a/backend/libs/Solicitors.CacheBuild/SolicitorsDotCom/SolicitorBuilder.cs b/backend/libs/Solicitors.CacheBuild/SolicitorsDotCom/SolicitorBuilder.cs new file mode 100644 index 0000000..d7c290c --- /dev/null +++ b/backend/libs/Solicitors.CacheBuild/SolicitorsDotCom/SolicitorBuilder.cs @@ -0,0 +1,31 @@ +namespace Solicitors.CacheBuild.SolicitorsDotCom; + +internal class SolicitorBuilder +{ + private readonly HashSet _baseLocations = []; + + public SolicitorBuilder( + string name, + string path, + string? shortDesc, + string baseLocation) + { + Name = name; + ShortDescription = shortDesc; + _baseLocations.Add(baseLocation); + + Path = path; + } + + public void AddBaseLocation(string baseLocation) + { + _baseLocations.Add(baseLocation); + } + + public string Path { get; } + public string Name { get; } + + public string? ShortDescription { get; } + + public string[] BaseLocations => _baseLocations.ToArray(); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.CacheBuild/SolicitorsDotCom/SolicitorParser.cs b/backend/libs/Solicitors.CacheBuild/SolicitorsDotCom/SolicitorParser.cs new file mode 100644 index 0000000..b2a6460 --- /dev/null +++ b/backend/libs/Solicitors.CacheBuild/SolicitorsDotCom/SolicitorParser.cs @@ -0,0 +1,315 @@ +using System.Diagnostics.CodeAnalysis; +using Solicitors.Core.Misc; +using Solicitors.Core.Models.Imports; +using Solicitors.HtmlParsing; +using Solicitors.HtmlParsing.Models; + +namespace Solicitors.CacheBuild.SolicitorsDotCom; + +internal class SolicitorParser : ISolicitorParser +{ + private readonly HttpClient _client; + private readonly IHtmlParser _htmlParser; + + public SolicitorParser( + HttpClient client, + IHtmlParser htmlParser) + { + _client = client; + _client.BaseAddress = new Uri(Consts.BaseUrl); + + _htmlParser = htmlParser; + } + + public async Task GetSolicitorsAsync( + CancellationToken cancellationToken = default) + { + var builders = new Dictionary(); + + foreach (var location in Consts.Locations) + { + var httpRequest = new HttpRequestMessage(HttpMethod.Get, $"/conveyancing+{location}.html"); + httpRequest.Headers.Add("User-Agent", "Solicitors API Cache"); + var httpResponse = await _client.SendAsync(httpRequest, cancellationToken); + var html = await httpResponse.Content.ReadAsStringAsync(cancellationToken); + var nodes = _htmlParser.ParseHtml(html); + IHtmlNode? mainNode = null; + foreach (var node in nodes) + if (node.TryGetByTagName("main", out mainNode)) + break; + + if (TryGetResultSection(mainNode, out var results)) + ParseResultsSection(results, location, builders); + } + + var batches = builders.Values + .Select(builder => GetFullSolicitorDataAsync(builder, cancellationToken)) + .Batch(5); + + var solicitors = new List(); + foreach (var batch in batches) + solicitors.AddRange(await Task.WhenAll(batch)); + + return solicitors + .Where(x => x is not null) + .Cast() + .ToArray(); + } + + private bool TryGetResultSection( + IHtmlNode? mainNode, + [NotNullWhen(true)] out IEnumerable? results) + { + results = null; + + // going one level at a time helps a little with performance here, at the cost of messier code + return mainNode is not null + && mainNode.TryGetByTagNameAndClass("div", "content-holder", out var contentHolderNode) + && contentHolderNode.TryGetByTagNameAndClass("div", "container", out var containerNode) + && containerNode.TryGetByTagNameAndClass("div", "content", out var contentNode) + && contentNode.TryGetByTagNameAndClass("div", "result-section", out var resultSectionNode) + && resultSectionNode.TryGetChildren(out results); + } + + private void ParseResultsSection( + IEnumerable results, + string location, + Dictionary builders) + { + foreach (var result in results) + { + if (result.TryGetByClass("result-item", out var resultItem, true) + && TryParseToNewBuilder(resultItem, location, out var builder)) + { + if (!builders.TryAdd(builder.Path, builder)) + builders[builder.Path].AddBaseLocation(location); + } + } + } + + private bool TryParseToNewBuilder( + IHtmlNode resultItemNode, + string baseLocation, + [NotNullWhen(true)] out SolicitorBuilder? builder) + { + builder = null; + if (!resultItemNode.TryGetByTagNameAndClass("a", "link-map", out var linkMapNode) + || !linkMapNode.TryGetAttributeValue("href", out var uniqueUrl) + || !resultItemNode.TryGetByTagNameAndClass("span", "h2", out var titleNode) + || !titleNode.TryGetChildren(out var titleChildren)) + return false; + + string? name = null; + foreach (var child in titleChildren) + if (child.TryGetText(out name)) + break; + + if (name is null) + return false; + + string? shortDesc = null; + if (resultItemNode.TryGetByTagName("p", out var pNode) + && pNode.TryGetChildren(out var pChildren)) + foreach (var child in pChildren) + if (child.TryGetText(out shortDesc)) + break; + + builder = new SolicitorBuilder(name, uniqueUrl, shortDesc, baseLocation); + return true; + } + + private async Task GetFullSolicitorDataAsync( + SolicitorBuilder builder, + CancellationToken cancellationToken) + { + + var httpRequest = new HttpRequestMessage(HttpMethod.Get, builder.Path); + httpRequest.Headers.Add("User-Agent", "Solicitors API Cache"); + var httpResponse = await _client.SendAsync(httpRequest, cancellationToken); + var html = await httpResponse.Content.ReadAsStringAsync(cancellationToken); + var nodes = _htmlParser.ParseHtml(html); + IHtmlNode? mainNode = null; + foreach (var node in nodes) + if (node.TryGetByTagName("main", out mainNode)) + break; + + if (mainNode is null || !mainNode.TryGetByTagNameAndClass("div", "content-block", out var contentBlockNode)) + return null; + + Location[] offices = []; + if (contentBlockNode.TryGetByTagNameAndClass("div", "office-item", out var officeItemNode) + && officeItemNode.TryGetChildren(out var officeItems)) + { + offices = ParseOffices(officeItems); + } + + Rating[] ratings = []; + string? phone = null; + string? email = null; + string? website = null; + if (mainNode.TryGetByTagNameAndClass("div", "side-holder", out var sidebarNode) + && sidebarNode.TryGetChildren(out var sidebarChildren)) + { + ParseSidebar(sidebarChildren, out phone, out email, out website, out ratings); + } + + return new SolicitorData + { + Name = builder.Name, + UrlPath = builder.Path, + ShortDescription = builder.ShortDescription, + Phone = phone, + Email = email, + Website = website, + Ratings = ratings, + Offices = offices, + Cities = builder.BaseLocations + }; + } + + private Location[] ParseOffices(IEnumerable officeNodes) + => officeNodes + .Select(ParseOffice) + .Where(x => x is not null) + .Cast() + .ToArray(); + + private Location? ParseOffice(IHtmlNode officeNode) + { + if (!officeNode.TryGetChildren(out var officeChildren) + || !officeNode.TryGetByTagName("address", out var addressNode) + || !addressNode.TryGetChildren(out var addressLines)) + return null; + + Location? location = null; + var address = ""; + foreach (var line in addressLines) + { + if (line.TryGetText(out var lineText)) + address += lineText; + else if (line.TryGetByTagName("br", out _, true)) + address += "\n"; + } + + if (string.IsNullOrWhiteSpace(address)) + address = null; + + string? phone = null; + foreach (var child in officeChildren) + { + if (child.TryGetByTagName("a", out var anchor) + && anchor.TryGetAttributeValue("href", out var telString) + && telString.StartsWith("\"tel:") + && telString.Length > 5) + { + phone = telString.Substring(5, telString.Length - 6); + break; + } + } + + if (address is not null && phone is not null) + location = new Location(address, phone, []); + + return location; + } + + private void ParseSidebar( + IEnumerable sidebarChildren, + out string? phone, + out string? email, + out string? website, + out Rating[] ratings) + { + List ratingsList = []; + phone = null; + website = null; + email = null; + + foreach (var node in sidebarChildren) + { + var isRevCount = node.TryGetByTagNameAndClass("div", "rev-count", out _, true); + var isLinksHolder = node.TryGetByTagNameAndClass("div", "links-holder", out _, true); + if ((!isRevCount && !isLinksHolder) + || !node.TryGetChildren(out var children)) + continue; + + if (isLinksHolder) + { + if (node.TryGetByTagNameAndClass("a", "website", out var websiteNode) + && websiteNode.TryGetAttributeValue("href", out website)) + website = website.Trim('"'); + + if (node.TryGetByTagNameAndClass("a", "phone", out var phoneNode) + && phoneNode.TryGetAttributeValue("href", out var phoneStr) + && phoneStr.StartsWith("\"tel:") + && phoneStr.Length > 5) + { + phone = phoneStr.Substring(5, phoneStr.Length - 6); + } + } + + var childrenArray = children as IHtmlNode[] ?? children.ToArray(); + foreach (var child in childrenArray.Where(x => x.TryGetByClass("rev-box", out _, true))) + { + if (child.TryGetAttributeValue("title", out var ratingString) + && TryParseRatingString(ratingString, out var rating, out var maxRating) + && child.TryGetByTagNameAndClass("img", "rev-logo", out var imgNode) + && imgNode.TryGetAttributeValue("src", out var imgSrc) + && TryParseRatingSrc(imgSrc, out var ratingProvider)) + { + ratingsList.Add(new Rating(rating, maxRating, ratingProvider, imgSrc)); + } + } + + if (ratingsList.Count == 0) + { + foreach (var child in childrenArray.Where(x => !x.HasAttribute("class"))) + { + if (child.TryGetChildren(out var grandChildren)) + foreach (var grandChild in grandChildren) + if (grandChild.TryGetText(out var textContent) + && TryParseOwnRatingString(textContent, out var rating)) + ratingsList.Add(new Rating(rating, Consts.MaxRating, Consts.Name, Consts.IconPath)); + } + } + } + + ratings = ratingsList.ToArray(); + } + + + bool TryParseRatingString(string ratingString, out decimal rating, out decimal maxRating) + { + rating = 0; + maxRating = 0; + var parts = ratingString.Trim('"').Split(" / "); + if (parts.Length != 2) + return false; + + return decimal.TryParse(parts[0], out rating) && decimal.TryParse(parts[1], out maxRating); + } + + private bool TryParseRatingSrc(string imgSrc, out string provider) + { + provider = ""; + imgSrc = imgSrc.Trim('"'); + const string prefix = "/images/logo-"; + if (!imgSrc.StartsWith(prefix)) + return false; + + var providerAndExtension = imgSrc[prefix.Length..]; + provider = providerAndExtension.Split('.').First(); + return true; + } + + bool TryParseOwnRatingString(string ratingString, out decimal rating) + { + rating = 0; + const string prefix = "Average review score : "; + if (!ratingString.StartsWith(prefix)) + return false; + + var ratingPart = ratingString[prefix.Length..]; + return decimal.TryParse(ratingPart, out rating); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.CacheBuild/StaleDataRemover.cs b/backend/libs/Solicitors.CacheBuild/StaleDataRemover.cs new file mode 100644 index 0000000..66684af --- /dev/null +++ b/backend/libs/Solicitors.CacheBuild/StaleDataRemover.cs @@ -0,0 +1,19 @@ +using Microsoft.Extensions.Options; +using Quartz; +using Solicitors.Core.Data; + +namespace Solicitors.CacheBuild; + +internal class StaleDataRemover( + IOptions config, + ISolicitorRepository repository) : IJob +{ + private readonly ImportConfiguration _config = config.Value; + + public Task Execute(IJobExecutionContext context) + { + return repository.RemoveStaleEntriesAsync( + TimeSpan.FromMinutes(_config.StaleMinutes), + context.CancellationToken); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/DIExtensions.cs b/backend/libs/Solicitors.Core/DIExtensions.cs new file mode 100644 index 0000000..8111f79 --- /dev/null +++ b/backend/libs/Solicitors.Core/DIExtensions.cs @@ -0,0 +1,19 @@ +using System.Diagnostics.CodeAnalysis; +using Microsoft.Extensions.DependencyInjection; +using Solicitors.Core.Ordering; + +namespace Solicitors.Core; + +[SuppressMessage("ReSharper", "InconsistentNaming")] +public static class DIExtensions +{ + public static IServiceCollection AddCore(this IServiceCollection services) + { + return services + .AddScoped() + .AddScoped(sp => sp.GetRequiredService()) + .AddScoped() + .AddScoped() + .AddScoped(); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Data/IRatingsProviderRepository.cs b/backend/libs/Solicitors.Core/Data/IRatingsProviderRepository.cs new file mode 100644 index 0000000..1ce39af --- /dev/null +++ b/backend/libs/Solicitors.Core/Data/IRatingsProviderRepository.cs @@ -0,0 +1,6 @@ +namespace Solicitors.Core.Data; + +public interface IRatingsProviderRepository +{ + IAsyncEnumerable GetAllRatingsProvidersAsync(); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Data/IReadOnlySolicitorRepository.cs b/backend/libs/Solicitors.Core/Data/IReadOnlySolicitorRepository.cs new file mode 100644 index 0000000..d0d2293 --- /dev/null +++ b/backend/libs/Solicitors.Core/Data/IReadOnlySolicitorRepository.cs @@ -0,0 +1,14 @@ +using Solicitors.Core.Models; + +namespace Solicitors.Core.Data; + +public interface IReadOnlySolicitorRepository +{ + IAsyncEnumerable GetAllSolicitorsAsync(); + Task GetSolicitorByIdAsync(Guid id, CancellationToken cancellationToken = default); +} + +public interface IReadOnlyCitiesRepository +{ + IAsyncEnumerable GetCitiesAsync(); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Data/ISolicitorRepository.cs b/backend/libs/Solicitors.Core/Data/ISolicitorRepository.cs new file mode 100644 index 0000000..a2227e2 --- /dev/null +++ b/backend/libs/Solicitors.Core/Data/ISolicitorRepository.cs @@ -0,0 +1,10 @@ +using Solicitors.Core.Models.Imports; + +namespace Solicitors.Core.Data; + +public interface ISolicitorRepository : IReadOnlySolicitorRepository +{ + Task EnsureCreatedAsync(CancellationToken cancellationToken); + Task AddOrUpdateSolicitorAsync(SolicitorData solicitor, CancellationToken cancellationToken); + Task RemoveStaleEntriesAsync(TimeSpan staleAge, CancellationToken cancellationToken); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/IRatingsProviderService.cs b/backend/libs/Solicitors.Core/IRatingsProviderService.cs new file mode 100644 index 0000000..f8fb306 --- /dev/null +++ b/backend/libs/Solicitors.Core/IRatingsProviderService.cs @@ -0,0 +1,6 @@ +namespace Solicitors.Core; + +public interface IRatingsProviderService +{ + Task GetRatingsProvidersAsync(CancellationToken cancellationToken); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/IReadOnlyCitiesService.cs b/backend/libs/Solicitors.Core/IReadOnlyCitiesService.cs new file mode 100644 index 0000000..0322247 --- /dev/null +++ b/backend/libs/Solicitors.Core/IReadOnlyCitiesService.cs @@ -0,0 +1,6 @@ +namespace Solicitors.Core; + +public interface IReadOnlyCitiesService +{ + Task GetAllCitiesAsync(CancellationToken cancellationToken); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/IReadOnlySolicitorService.cs b/backend/libs/Solicitors.Core/IReadOnlySolicitorService.cs new file mode 100644 index 0000000..e2db2fd --- /dev/null +++ b/backend/libs/Solicitors.Core/IReadOnlySolicitorService.cs @@ -0,0 +1,17 @@ +using Solicitors.Core.Misc; +using Solicitors.Core.Models; +using Solicitors.Core.Models.View; + +namespace Solicitors.Core; + +public interface IReadOnlySolicitorService +{ + Task> GetSolicitorSummariesAsync( + Pagination pagination, + string ratingsProvider, + IFilter? filter = null, + IComparer? ordering = null, + CancellationToken cancellationToken = default); + + Task GetSolicitorInfoByIdAsync(Guid id, CancellationToken cancellationToken = default); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/ISolicitorService.cs b/backend/libs/Solicitors.Core/ISolicitorService.cs new file mode 100644 index 0000000..78aa8bb --- /dev/null +++ b/backend/libs/Solicitors.Core/ISolicitorService.cs @@ -0,0 +1,3 @@ +namespace Solicitors.Core; + +public interface ISolicitorService : IReadOnlySolicitorService; \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Misc/EnumerableExtensions.cs b/backend/libs/Solicitors.Core/Misc/EnumerableExtensions.cs new file mode 100644 index 0000000..90be174 --- /dev/null +++ b/backend/libs/Solicitors.Core/Misc/EnumerableExtensions.cs @@ -0,0 +1,21 @@ +namespace Solicitors.Core.Misc; + +public static class EnumerableExtensions +{ + public static IEnumerable Batch(this IEnumerable source, int batchSize) + { + var batch = new List(batchSize); + foreach (var item in source) + { + batch.Add(item); + if (batch.Count == batch.Capacity) + { + yield return batch.ToArray(); + batch.Clear(); + } + } + + if (batch.Count > 0) + yield return batch.ToArray(); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Misc/IFilter.cs b/backend/libs/Solicitors.Core/Misc/IFilter.cs new file mode 100644 index 0000000..c12c07b --- /dev/null +++ b/backend/libs/Solicitors.Core/Misc/IFilter.cs @@ -0,0 +1,19 @@ +namespace Solicitors.Core.Misc; + +public interface IFilter +{ + bool Filter(T item); +} + +public class WrapperFilter( + IFilter? inner, + Func filter) : IFilter +{ + public bool Filter(T item) + { + if (inner is not null) + return inner.Filter(item) && filter(item); + + return filter(item); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Misc/Pagination.cs b/backend/libs/Solicitors.Core/Misc/Pagination.cs new file mode 100644 index 0000000..ed4168c --- /dev/null +++ b/backend/libs/Solicitors.Core/Misc/Pagination.cs @@ -0,0 +1,7 @@ +namespace Solicitors.Core.Misc; + +public readonly struct Pagination(uint currentPage, uint pageSize) +{ + public uint CurrentPage { get; } = currentPage; + public uint PageSize { get; } = pageSize; +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Models/City.cs b/backend/libs/Solicitors.Core/Models/City.cs new file mode 100644 index 0000000..5ba38e1 --- /dev/null +++ b/backend/libs/Solicitors.Core/Models/City.cs @@ -0,0 +1,10 @@ +namespace Solicitors.Core.Models; + +public record City +{ + public Guid CityId { get; set; } + public required string Name { get; set; } + public DateTime LastModified { get; set; } + + public List Solicitors { get; } = []; +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Models/Imports/Location.cs b/backend/libs/Solicitors.Core/Models/Imports/Location.cs new file mode 100644 index 0000000..e70a309 --- /dev/null +++ b/backend/libs/Solicitors.Core/Models/Imports/Location.cs @@ -0,0 +1,8 @@ +namespace Solicitors.Core.Models.Imports; + +public record Location(string Address, string Phone, Rating[] LocationRatings) +{ + public string Address { get; } = Address; + public string Phone { get; } = Phone; + public Rating[] LocationRatings { get; } = LocationRatings; +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Models/Imports/Rating.cs b/backend/libs/Solicitors.Core/Models/Imports/Rating.cs new file mode 100644 index 0000000..da987e4 --- /dev/null +++ b/backend/libs/Solicitors.Core/Models/Imports/Rating.cs @@ -0,0 +1,9 @@ +namespace Solicitors.Core.Models.Imports; + +public record Rating(decimal Value, decimal MaxValue, string RatingProvider, string RatingProviderImgSrc) +{ + public decimal Value { get; } = Value; + public decimal MaxValue { get; } = MaxValue; + public string RatingProvider { get; } = RatingProvider; + public string RatingProviderImgSrc { get; } = RatingProviderImgSrc; +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Models/Imports/SolicitorData.cs b/backend/libs/Solicitors.Core/Models/Imports/SolicitorData.cs new file mode 100644 index 0000000..e3489e7 --- /dev/null +++ b/backend/libs/Solicitors.Core/Models/Imports/SolicitorData.cs @@ -0,0 +1,16 @@ +namespace Solicitors.Core.Models.Imports; + +public class SolicitorData +{ + public required string Name { get; init; } + public required string UrlPath { get; init; } + + public string? ShortDescription { get; init; } + public string? Phone { get; init; } + public string? Email { get; init; } + public string? Website { get; init; } + + public string[] Cities { get; init; } = []; + public Rating[] Ratings { get; init; } = []; + public Location[] Offices { get; init; } = []; +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Models/Solicitor.cs b/backend/libs/Solicitors.Core/Models/Solicitor.cs new file mode 100644 index 0000000..01d932a --- /dev/null +++ b/backend/libs/Solicitors.Core/Models/Solicitor.cs @@ -0,0 +1,19 @@ +namespace Solicitors.Core.Models; + +public record Solicitor +{ + public Guid SolicitorId { get; set; } + + public required string Name { get; set; } + public required string RelativeUrl { get; set; } + + public string? Phone { get; set; } + public string? Email { get; set; } + public string? Website { get; set; } + public string? ShortDescription { get; set; } + public DateTime LastModified { get; set; } + + public List Cities { get; } = []; + public List Ratings { get; } = []; + public List Locations { get; } = []; +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Models/SolicitorInfo.cs b/backend/libs/Solicitors.Core/Models/SolicitorInfo.cs new file mode 100644 index 0000000..3691859 --- /dev/null +++ b/backend/libs/Solicitors.Core/Models/SolicitorInfo.cs @@ -0,0 +1,40 @@ +using Solicitors.Core.Models.View; + +namespace Solicitors.Core.Models; + +public record SolicitorInfo +{ + internal SolicitorInfo(Solicitor solicitor) + { + Id = solicitor.SolicitorId; + Name = solicitor.Name; + ShortDescription = solicitor.ShortDescription; + Phone = solicitor.Phone; + Email = solicitor.Email; + Website = solicitor.Website; + + Cities = solicitor.Cities + .Select(city => city.Name) + .ToArray(); + + Ratings = solicitor.Ratings + .Select(rating => new RatingInfo(rating)) + .ToArray(); + + Locations = solicitor.Locations + .Select(location => new LocationInfo(location)) + .ToArray(); + } + + public string Name { get; set; } + public string? ShortDescription { get; set; } + public Guid Id { get; set; } + + public string? Phone { get; set; } + public string? Email { get; set; } + public string? Website { get; set; } + + public string[] Cities { get; set; } + public RatingInfo[] Ratings { get; set; } + public LocationInfo[] Locations { get; set; } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Models/SolicitorLocation.cs b/backend/libs/Solicitors.Core/Models/SolicitorLocation.cs new file mode 100644 index 0000000..a9e787e --- /dev/null +++ b/backend/libs/Solicitors.Core/Models/SolicitorLocation.cs @@ -0,0 +1,22 @@ +namespace Solicitors.Core.Models; + +public record SolicitorLocation +{ + public Guid SolicitorLocationId { get; set; } + + public required string Address { get; set; } + public required string Phone { get; set; } + public DateTime LastModified { get; set; } + + public List LocationRatings { get; } = []; + + public Guid SolicitorId { get; set; } + public required Solicitor Solicitor { get; set; } +} + +public interface IRating +{ + decimal Value { get; } + decimal Maximum { get; } + string Provider { get; } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Models/SolicitorLocationRating.cs b/backend/libs/Solicitors.Core/Models/SolicitorLocationRating.cs new file mode 100644 index 0000000..671035a --- /dev/null +++ b/backend/libs/Solicitors.Core/Models/SolicitorLocationRating.cs @@ -0,0 +1,14 @@ +namespace Solicitors.Core.Models; + +public record SolicitorLocationRating : IRating +{ + public Guid SolicitorLocationRatingId { get; set; } + + public required decimal Value { get; set; } + public required decimal Maximum { get; set; } + public required string Provider { get; set; } + public DateTime LastModified { get; set; } + + public Guid SolicitorLocationId { get; set; } + public required SolicitorLocation SolicitorLocation { get; set; } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Models/SolicitorRating.cs b/backend/libs/Solicitors.Core/Models/SolicitorRating.cs new file mode 100644 index 0000000..5c9a702 --- /dev/null +++ b/backend/libs/Solicitors.Core/Models/SolicitorRating.cs @@ -0,0 +1,14 @@ +namespace Solicitors.Core.Models; + +public record SolicitorRating : IRating +{ + public Guid SolicitorRatingId { get; set; } + + public required decimal Value { get; set; } + public required decimal Maximum { get; set; } + public required string Provider { get; set; } + public DateTime LastModified { get; set; } + + public Guid SolicitorId { get; set; } + public required Solicitor Solicitor { get; set; } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Models/View/LocationInfo.cs b/backend/libs/Solicitors.Core/Models/View/LocationInfo.cs new file mode 100644 index 0000000..41e3d2a --- /dev/null +++ b/backend/libs/Solicitors.Core/Models/View/LocationInfo.cs @@ -0,0 +1,18 @@ +namespace Solicitors.Core.Models.View; + +public record LocationInfo +{ + public LocationInfo(SolicitorLocation location) + { + Address = location.Address; + Phone = location.Phone; + Ratings = location.LocationRatings + .Select(rating => new RatingInfo(rating)) + .ToArray(); + } + + public string Address { get; } + public string Phone { get; } + + public RatingInfo[] Ratings { get; } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Models/View/RatingInfo.cs b/backend/libs/Solicitors.Core/Models/View/RatingInfo.cs new file mode 100644 index 0000000..aed300f --- /dev/null +++ b/backend/libs/Solicitors.Core/Models/View/RatingInfo.cs @@ -0,0 +1,15 @@ +namespace Solicitors.Core.Models.View; + +public record RatingInfo +{ + public RatingInfo(IRating rating) + { + Value = rating.Value; + Maximum = rating.Maximum; + Provider = rating.Provider; + } + + public decimal Value { get; } + public decimal Maximum { get; } + public string Provider { get; } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Models/View/SolicitorSummary.cs b/backend/libs/Solicitors.Core/Models/View/SolicitorSummary.cs new file mode 100644 index 0000000..d2ce52d --- /dev/null +++ b/backend/libs/Solicitors.Core/Models/View/SolicitorSummary.cs @@ -0,0 +1,19 @@ +namespace Solicitors.Core.Models.View; + +public record SolicitorSummary +{ + internal SolicitorSummary(Solicitor solicitor, string ratingsProvider) + { + Id = solicitor.SolicitorId; + Name = solicitor.Name; + ShortDescription = solicitor.ShortDescription; + var rating = solicitor.Ratings.FirstOrDefault(x => x.Provider == ratingsProvider); + if (rating is not null) + Rating = new RatingInfo(rating); + } + + public Guid Id { get; } + public string Name { get; } + public string? ShortDescription { get; } + public RatingInfo? Rating { get; } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Ordering/DefaultSolicitorDataOrdering.cs b/backend/libs/Solicitors.Core/Ordering/DefaultSolicitorDataOrdering.cs new file mode 100644 index 0000000..59f4b28 --- /dev/null +++ b/backend/libs/Solicitors.Core/Ordering/DefaultSolicitorDataOrdering.cs @@ -0,0 +1,23 @@ +using Solicitors.Core.Models; + +namespace Solicitors.Core.Ordering; + +internal class DefaultSolicitorDataOrdering : IComparer +{ + public static IComparer Instance { get; } = new DefaultSolicitorDataOrdering(); + + private DefaultSolicitorDataOrdering() + { + } + + public int Compare(Solicitor? x, Solicitor? y) + { + if (x is null) + return y is null ? 0 : int.MaxValue; + + else if (y is null) + return int.MinValue; + + return Comparer.Default.Compare(x.SolicitorId, y.SolicitorId); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Ordering/ISolicitorComparerFactory.cs b/backend/libs/Solicitors.Core/Ordering/ISolicitorComparerFactory.cs new file mode 100644 index 0000000..69507b4 --- /dev/null +++ b/backend/libs/Solicitors.Core/Ordering/ISolicitorComparerFactory.cs @@ -0,0 +1,10 @@ +using Solicitors.Core.Models; + +namespace Solicitors.Core.Ordering; + +public interface ISolicitorComparerFactory +{ + IComparer GetComparer( + OrderingType? orderingType, + string ratingsProvider); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Ordering/NameComparer.cs b/backend/libs/Solicitors.Core/Ordering/NameComparer.cs new file mode 100644 index 0000000..ddd9487 --- /dev/null +++ b/backend/libs/Solicitors.Core/Ordering/NameComparer.cs @@ -0,0 +1,26 @@ +using Solicitors.Core.Models; + +namespace Solicitors.Core.Ordering; + +internal class NameComparer(bool ascending) : IComparer +{ + public int Compare(Solicitor? x, Solicitor? y) + { + int compare; + if (ReferenceEquals(x, y)) + compare = 0; + else if (y is null) + compare = 1; + else if (x is null) + compare = -1; + else + { + compare = string.Compare(x.Name, y.Name, StringComparison.OrdinalIgnoreCase); + + if (!ascending) + compare *= -1; + } + + return compare; + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Ordering/OrderingType.cs b/backend/libs/Solicitors.Core/Ordering/OrderingType.cs new file mode 100644 index 0000000..1a3d38f --- /dev/null +++ b/backend/libs/Solicitors.Core/Ordering/OrderingType.cs @@ -0,0 +1,9 @@ +namespace Solicitors.Core.Ordering; + +public enum OrderingType +{ + RatingDescending, + RatingAscending, + AlphabetAscending, + AlphabetDescending +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Ordering/RatingComparer.cs b/backend/libs/Solicitors.Core/Ordering/RatingComparer.cs new file mode 100644 index 0000000..7714bd7 --- /dev/null +++ b/backend/libs/Solicitors.Core/Ordering/RatingComparer.cs @@ -0,0 +1,32 @@ +using Solicitors.Core.Models; + +namespace Solicitors.Core.Ordering; + +internal class RatingComparer(string ratingsProvider, bool ascending) : IComparer +{ + public int Compare(Solicitor? x, Solicitor? y) + { + var xRating = x?.Ratings.FirstOrDefault(r => r.Provider == ratingsProvider); + var yRating = y?.Ratings.FirstOrDefault(r => r.Provider == ratingsProvider); + + decimal compare; + + if (xRating is null) + compare = yRating is null ? 0 : 1; + else if (yRating is null) + compare = -1; + else + { + compare = (xRating.Value / xRating.Maximum) - (yRating.Value / yRating.Maximum); + + if (!ascending) + compare *= -1; + } + + if (compare >= 0) + return (int)Math.Ceiling(compare); + else + return (int)Math.Floor(compare); + + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Ordering/SolicitorComparerFactory.cs b/backend/libs/Solicitors.Core/Ordering/SolicitorComparerFactory.cs new file mode 100644 index 0000000..784ec2f --- /dev/null +++ b/backend/libs/Solicitors.Core/Ordering/SolicitorComparerFactory.cs @@ -0,0 +1,20 @@ +using Solicitors.Core.Models; + +namespace Solicitors.Core.Ordering; + +internal class SolicitorComparerFactory : ISolicitorComparerFactory +{ + public IComparer GetComparer( + OrderingType? orderingType, + string ratingsProvider) + { + return orderingType switch + { + OrderingType.RatingAscending => new RatingComparer(ratingsProvider, true), + OrderingType.RatingDescending => new RatingComparer(ratingsProvider, false), + OrderingType.AlphabetAscending => new NameComparer(true), + OrderingType.AlphabetDescending => new NameComparer(false), + _ => DefaultSolicitorDataOrdering.Instance + }; + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/PaginationResponse.cs b/backend/libs/Solicitors.Core/PaginationResponse.cs new file mode 100644 index 0000000..bd0694f --- /dev/null +++ b/backend/libs/Solicitors.Core/PaginationResponse.cs @@ -0,0 +1,7 @@ +namespace Solicitors.Core; + +public record PaginationResponse(int Total, T[] Data) +{ + public T[] Data { get; set; } = Data; + public int Total { get; set; } = Total; +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/RatingsProviderService.cs b/backend/libs/Solicitors.Core/RatingsProviderService.cs new file mode 100644 index 0000000..7fe71a5 --- /dev/null +++ b/backend/libs/Solicitors.Core/RatingsProviderService.cs @@ -0,0 +1,11 @@ +using Solicitors.Core.Data; + +namespace Solicitors.Core; + +internal class RatingsProviderService(IRatingsProviderRepository repo) : IRatingsProviderService +{ + public async Task GetRatingsProvidersAsync(CancellationToken cancellationToken) + { + return await repo.GetAllRatingsProvidersAsync().ToArrayAsync(cancellationToken); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/ReadOnlyCitiesService.cs b/backend/libs/Solicitors.Core/ReadOnlyCitiesService.cs new file mode 100644 index 0000000..19f7e61 --- /dev/null +++ b/backend/libs/Solicitors.Core/ReadOnlyCitiesService.cs @@ -0,0 +1,12 @@ +using Solicitors.Core.Data; + +namespace Solicitors.Core; + +internal class ReadOnlyCitiesService(IReadOnlyCitiesRepository repo) : IReadOnlyCitiesService +{ + public async Task GetAllCitiesAsync(CancellationToken cancellationToken) + { + var cities = repo.GetCitiesAsync(); + return await cities.ToArrayAsync(cancellationToken); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/SolicitorService.cs b/backend/libs/Solicitors.Core/SolicitorService.cs new file mode 100644 index 0000000..114ea43 --- /dev/null +++ b/backend/libs/Solicitors.Core/SolicitorService.cs @@ -0,0 +1,44 @@ +using Solicitors.Core.Data; +using Solicitors.Core.Misc; +using Solicitors.Core.Models; +using Solicitors.Core.Models.View; +using Solicitors.Core.Ordering; + +namespace Solicitors.Core; + +internal class SolicitorService(IReadOnlySolicitorRepository repo) : ISolicitorService +{ + public async Task> GetSolicitorSummariesAsync( + Pagination pagination, + string ratingsProvider, + IFilter? filter = null, + IComparer? ordering = null, + CancellationToken cancellationToken = default) + { + var allSolicitors = repo.GetAllSolicitorsAsync(); + if (filter is not null) + allSolicitors = allSolicitors.Where(filter.Filter); + + var matchingSolicitors = await allSolicitors.ToArrayAsync(cancellationToken); + + ordering ??= DefaultSolicitorDataOrdering.Instance; + + var results = matchingSolicitors + .OrderBy(x => x, ordering) + .Skip((int)((pagination.CurrentPage - 1) * pagination.PageSize)) + .Take((int)pagination.PageSize) + .Select(x => new SolicitorSummary(x, ratingsProvider)) + .ToArray(); + + return new PaginationResponse(matchingSolicitors.Length, results); + } + + public async Task GetSolicitorInfoByIdAsync(Guid id, CancellationToken cancellationToken = default) + { + var data = await repo.GetSolicitorByIdAsync(id, cancellationToken); + if (data is null) + return null; + + return new SolicitorInfo(data); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Solicitors.Core.csproj b/backend/libs/Solicitors.Core/Solicitors.Core.csproj new file mode 100644 index 0000000..777a709 --- /dev/null +++ b/backend/libs/Solicitors.Core/Solicitors.Core.csproj @@ -0,0 +1,14 @@ + + + + net10.0 + enable + enable + + + + + + + + diff --git a/backend/libs/Solicitors.Data/DIExtensions.cs b/backend/libs/Solicitors.Data/DIExtensions.cs new file mode 100644 index 0000000..0c0087a --- /dev/null +++ b/backend/libs/Solicitors.Data/DIExtensions.cs @@ -0,0 +1,48 @@ +using System.Diagnostics.CodeAnalysis; +using Microsoft.Extensions.Configuration; +using Microsoft.Extensions.DependencyInjection; +using Solicitors.Core.Data; +using Solicitors.Data.RepositorySetup; +using Solicitors.Data.RepositorySetup.InMemory; +using Solicitors.Data.RepositorySetup.Sqlite; + +namespace Solicitors.Data; + +[SuppressMessage("ReSharper", "InconsistentNaming")] +public static class DIExtensions +{ + public static IServiceCollection AddData(this IServiceCollection services, IConfiguration configuration) + { + return services + .AddScoped() + .AddScoped(sp => sp.GetRequiredService()) + .AddScoped(sp => sp.GetRequiredService()) + .AddScoped(sp => sp.GetRequiredService()) + .AddScoped(sp => sp.GetRequiredService()) + .AddSingleton(GetSetupService(configuration)); + } + + private static IRepoSetupService GetSetupService(IConfiguration configuration) + { + var options = ReadConfigForOptions(configuration); + + return options switch + { + InMemoryDbSetupOptions inMemOptions => new InMemorySetupService(inMemOptions), + SqliteDbSetupOptions sqliteOptions => new SqliteSetupService(sqliteOptions), + _ => throw new ArgumentException("Options type not supported", nameof(configuration)) + }; + } + + private static IRepoSetupOptions? ReadConfigForOptions(IConfiguration configuration) + { + var dbConfig = configuration.GetSection("Database"); + var dbType = dbConfig["Type"]?.ToLower(); + return dbType switch + { + "inmemory" => dbConfig.Get(), + "sqlite" => dbConfig.Get(), + _ => null + }; + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Data/RepositorySetup/IRepoSetupOptions.cs b/backend/libs/Solicitors.Data/RepositorySetup/IRepoSetupOptions.cs new file mode 100644 index 0000000..0077099 --- /dev/null +++ b/backend/libs/Solicitors.Data/RepositorySetup/IRepoSetupOptions.cs @@ -0,0 +1,3 @@ +namespace Solicitors.Data.RepositorySetup; + +public interface IRepoSetupOptions; \ No newline at end of file diff --git a/backend/libs/Solicitors.Data/RepositorySetup/IRepoSetupService.cs b/backend/libs/Solicitors.Data/RepositorySetup/IRepoSetupService.cs new file mode 100644 index 0000000..7e13c54 --- /dev/null +++ b/backend/libs/Solicitors.Data/RepositorySetup/IRepoSetupService.cs @@ -0,0 +1,8 @@ +using Microsoft.EntityFrameworkCore; + +namespace Solicitors.Data.RepositorySetup; + +internal interface IRepoSetupService +{ + void OnConfiguring(DbContextOptionsBuilder optionsBuilder); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Data/RepositorySetup/InMemory/InMemoryDbSetupOptions.cs b/backend/libs/Solicitors.Data/RepositorySetup/InMemory/InMemoryDbSetupOptions.cs new file mode 100644 index 0000000..3387933 --- /dev/null +++ b/backend/libs/Solicitors.Data/RepositorySetup/InMemory/InMemoryDbSetupOptions.cs @@ -0,0 +1,6 @@ +namespace Solicitors.Data.RepositorySetup.InMemory; + +public class InMemoryDbSetupOptions(string dbName) : IRepoSetupOptions +{ + public string DbName { get; } = dbName; +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Data/RepositorySetup/InMemory/InMemorySetupService.cs b/backend/libs/Solicitors.Data/RepositorySetup/InMemory/InMemorySetupService.cs new file mode 100644 index 0000000..3295f2b --- /dev/null +++ b/backend/libs/Solicitors.Data/RepositorySetup/InMemory/InMemorySetupService.cs @@ -0,0 +1,11 @@ +using Microsoft.EntityFrameworkCore; + +namespace Solicitors.Data.RepositorySetup.InMemory; + +internal class InMemorySetupService(InMemoryDbSetupOptions config) : IRepoSetupService +{ + public void OnConfiguring(DbContextOptionsBuilder options) + { + options.UseInMemoryDatabase(config.DbName); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Data/RepositorySetup/Sqlite/SqliteDbSetupOptions.cs b/backend/libs/Solicitors.Data/RepositorySetup/Sqlite/SqliteDbSetupOptions.cs new file mode 100644 index 0000000..205410c --- /dev/null +++ b/backend/libs/Solicitors.Data/RepositorySetup/Sqlite/SqliteDbSetupOptions.cs @@ -0,0 +1,6 @@ +namespace Solicitors.Data.RepositorySetup.Sqlite; + +public class SqliteDbSetupOptions(string dbPath) : IRepoSetupOptions +{ + public string DbPath { get; } = dbPath; +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Data/RepositorySetup/Sqlite/SqliteSetupService.cs b/backend/libs/Solicitors.Data/RepositorySetup/Sqlite/SqliteSetupService.cs new file mode 100644 index 0000000..d2b6a76 --- /dev/null +++ b/backend/libs/Solicitors.Data/RepositorySetup/Sqlite/SqliteSetupService.cs @@ -0,0 +1,11 @@ +using Microsoft.EntityFrameworkCore; + +namespace Solicitors.Data.RepositorySetup.Sqlite; + +internal class SqliteSetupService(SqliteDbSetupOptions config) : IRepoSetupService +{ + public void OnConfiguring(DbContextOptionsBuilder options) + { + options.UseSqlite($"Data Source={config.DbPath}"); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Data/Solicitors.Data.csproj b/backend/libs/Solicitors.Data/Solicitors.Data.csproj new file mode 100644 index 0000000..cec2d80 --- /dev/null +++ b/backend/libs/Solicitors.Data/Solicitors.Data.csproj @@ -0,0 +1,21 @@ + + + + net10.0 + enable + enable + + + + + + + + + + + + + + + diff --git a/backend/libs/Solicitors.Data/SolicitorsRepository.cs b/backend/libs/Solicitors.Data/SolicitorsRepository.cs new file mode 100644 index 0000000..6638591 --- /dev/null +++ b/backend/libs/Solicitors.Data/SolicitorsRepository.cs @@ -0,0 +1,335 @@ +using Microsoft.EntityFrameworkCore; +using Solicitors.Core.Data; +using Solicitors.Core.Models; +using Solicitors.Core.Models.Imports; +using Solicitors.Data.RepositorySetup; + +namespace Solicitors.Data; + +internal class SolicitorsRepository(IRepoSetupService setup) + : DbContext, ISolicitorRepository, IReadOnlyCitiesRepository, IRatingsProviderRepository +{ + public DbSet Solicitors { get; set; } + public DbSet SolicitorRatings { get; set; } + public DbSet SolicitorLocations { get; set; } + public DbSet SolicitorLocationRatings { get; set; } + public DbSet Cities { get; set; } + + protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) + => setup.OnConfiguring(optionsBuilder); + + public Task EnsureCreatedAsync(CancellationToken cancellationToken) + => Database.EnsureCreatedAsync(cancellationToken); + + public IAsyncEnumerable GetAllSolicitorsAsync() + => Solicitors + .Include(solicitor => solicitor.Cities) + .Include(solicitor => solicitor.Locations) + .ThenInclude(location => location.LocationRatings) + .Include(solicitor => solicitor.Ratings) + .AsAsyncEnumerable(); + + public Task GetSolicitorByIdAsync(Guid id, CancellationToken cancellationToken = default) + => Solicitors + .Include(solicitor => solicitor.Cities) + .Include(solicitor => solicitor.Locations) + .ThenInclude(location => location.LocationRatings) + .Include(solicitor => solicitor.Ratings) + .FirstOrDefaultAsync(x => x.SolicitorId == id, cancellationToken); + + public IAsyncEnumerable GetCitiesAsync() + { + return Cities + .Select(city => city.Name) + .AsAsyncEnumerable(); + } + + public IAsyncEnumerable GetAllRatingsProvidersAsync() + { + return SolicitorRatings + .Select(rating => rating.Provider) + .Distinct() + .OrderBy(x => x == "Solicitors.com" ? 0 : 1) + .ThenBy(x => x) + .AsAsyncEnumerable(); + } + + public async Task AddOrUpdateSolicitorAsync(SolicitorData solicitor, CancellationToken cancellationToken) + { + var matchingSolicitor = await Solicitors + .Include(existing => existing.Cities) + .Include(existing => existing.Locations) + .ThenInclude(location => location.LocationRatings) + .Include(existing => existing.Ratings) + .FirstOrDefaultAsync( + item => item.Name == solicitor.Name, + cancellationToken: cancellationToken); + + if (matchingSolicitor is null) + await AddNewSolicitorAsync(solicitor, cancellationToken); + else + await UpdateExistingSolicitorAsync(solicitor, matchingSolicitor, cancellationToken); + + await SaveChangesAsync(cancellationToken); + } + + public Task RemoveStaleEntriesAsync(TimeSpan staleAge, CancellationToken cancellationToken) + { + var staleTime = DateTime.UtcNow - staleAge; + + Solicitors.RemoveRange(Solicitors.Where(x => x.LastModified < staleTime)); + SolicitorLocations.RemoveRange(SolicitorLocations.Where(x => x.LastModified < staleTime)); + SolicitorRatings.RemoveRange(SolicitorRatings.Where(x => x.LastModified < staleTime)); + SolicitorLocationRatings.RemoveRange(SolicitorLocationRatings.Where(x => x.LastModified < staleTime)); + Cities.RemoveRange(Cities.Where(x => x.LastModified < staleTime)); + + return SaveChangesAsync(cancellationToken); + } + + private async Task AddNewSolicitorAsync( + SolicitorData solicitor, + CancellationToken cancellationToken) + { + var newSol = new Solicitor + { + Name = solicitor.Name, + RelativeUrl = solicitor.UrlPath + }; + UpdateSolicitorRootData(newSol, solicitor); + Solicitors.Add(newSol); + + var cityTasks = solicitor.Cities + .Distinct() + .Select(async city => + { + var matchingCity = await GetCityByNameAsync(city, cancellationToken); + + if (matchingCity is null) + AddNewCityToSolicitor(city, newSol); + else + UpdateExistingCity(matchingCity, newSol); + }); + + await Task.WhenAll(cityTasks); + + foreach (var rating in solicitor.Ratings) + AddNewRatingToSolicitor(rating, newSol); + + foreach (var location in solicitor.Offices) + AddNewLocationToSolicitor(location, newSol); + } + + private void UpdateSolicitorRootData(Solicitor solicitor, SolicitorData data) + { + solicitor.Name = data.Name; + solicitor.RelativeUrl = data.UrlPath; + solicitor.Phone = data.Phone; + solicitor.Email = data.Email; + solicitor.Website = data.Website; + solicitor.ShortDescription = data.ShortDescription; + solicitor.LastModified = DateTime.UtcNow; + } + + private void AddNewCityToSolicitor(string cityName, Solicitor solicitor) + { + var newCity = new City + { + Name = cityName + }; + Cities.Add(newCity); + UpdateExistingCity(newCity, solicitor); + } + + private void AddNewRatingToSolicitor(Rating rating, Solicitor solicitor) + { + var newRating = new SolicitorRating + { + Value = rating.Value, + Maximum = rating.MaxValue, + Provider = rating.RatingProvider, + Solicitor = solicitor, + LastModified = DateTime.UtcNow + }; + SolicitorRatings.Add(newRating); + solicitor.Ratings.Add(newRating); + } + + private void AddNewLocationToSolicitor(Location location, Solicitor solicitor) + { + var newLocation = new SolicitorLocation + { + Address = location.Address, + Phone = location.Phone, + Solicitor = solicitor, + LastModified = DateTime.UtcNow + }; + SolicitorLocations.Add(newLocation); + solicitor.Locations.Add(newLocation); + + foreach (var rating in location.LocationRatings) + AddNewRatingToLocation(rating, newLocation); + } + + private void AddNewRatingToLocation(Rating rating, SolicitorLocation location) + { + var newLocRating = new SolicitorLocationRating + { + Value = rating.Value, + Maximum = rating.MaxValue, + Provider = rating.RatingProvider, + SolicitorLocation = location, + LastModified = DateTime.UtcNow + }; + SolicitorLocationRatings.Add(newLocRating); + location.LocationRatings.Add(newLocRating); + } + + private Task UpdateExistingSolicitorAsync( + SolicitorData solicitor, + Solicitor matchingSolicitor, + CancellationToken cancellationToken) + { + UpdateSolicitorRootData(matchingSolicitor, solicitor); + var citiesUpdate = UpdateExistingCitiesAsync(solicitor, matchingSolicitor, cancellationToken); + UpdateExistingRatings(solicitor, matchingSolicitor); + UpdateExistingLocations(solicitor, matchingSolicitor); + return citiesUpdate; + } + + private async Task UpdateExistingCitiesAsync( + SolicitorData solicitor, + Solicitor matchingSolicitor, + CancellationToken cancellationToken) + { + var lostCities = matchingSolicitor.Cities + .Where(city => solicitor.Cities.All(cityName => cityName != city.Name)) + .ToArray(); + + foreach (var city in lostCities) + { + matchingSolicitor.Cities.Remove(city); + city.Solicitors.Remove(matchingSolicitor); + } + foreach (var cityName in solicitor.Cities.Distinct()) + { + var matchingCity = matchingSolicitor.Cities + .FirstOrDefault(city => cityName == city.Name); + + matchingCity ??= await GetCityByNameAsync(cityName, cancellationToken); + + if (matchingCity is null) + AddNewCityToSolicitor(cityName, matchingSolicitor); + else + UpdateExistingCity(matchingCity, matchingSolicitor); + } + } + + private void UpdateExistingRatings( + SolicitorData solicitor, + Solicitor matchingSolicitor) + { + var lostRatings = matchingSolicitor.Ratings + .Where(solicitorRating => solicitor.Ratings.All(rating => rating.RatingProvider != solicitorRating.Provider)) + .ToArray(); + + foreach (var rating in lostRatings) + { + matchingSolicitor.Ratings.Remove(rating); + SolicitorRatings.Remove(rating); + } + + foreach (var rating in solicitor.Ratings) + { + var matchingRating = matchingSolicitor.Ratings + .FirstOrDefault(solicitorRating => rating.RatingProvider == solicitorRating.Provider); + + if (matchingRating is null) + AddNewRatingToSolicitor(rating, matchingSolicitor); + else + UpdateExistingRating(rating, matchingRating); + } + } + + private void UpdateExistingRating(Rating rating, SolicitorRating existingRating) + { + existingRating.Value = rating.Value; + existingRating.Maximum = rating.MaxValue; + existingRating.LastModified = DateTime.UtcNow; + } + + private void UpdateExistingLocations( + SolicitorData solicitor, + Solicitor matchingSolicitor) + { + var lostLocations = matchingSolicitor.Locations + .Where(location => solicitor.Offices.All(office => office.Address != location.Address)) + .ToArray(); + + foreach (var location in lostLocations) + { + matchingSolicitor.Locations.Remove(location); + SolicitorLocations.Remove(location); + } + + foreach (var office in solicitor.Offices) + { + var location = matchingSolicitor.Locations + .FirstOrDefault(location => office.Address == location.Address); + + if (location is null) + AddNewLocationToSolicitor(office, matchingSolicitor); + else + UpdateExistingLocation(office, location); + } + } + + private void UpdateExistingLocation(Location location, SolicitorLocation existingLocation) + { + existingLocation.Phone = location.Phone; + existingLocation.LastModified = DateTime.UtcNow; + + var lostRatings = existingLocation.LocationRatings + .Where(locationRating => location.LocationRatings.All(rating => locationRating.Provider != rating.RatingProvider)) + .ToArray(); + + foreach (var rating in lostRatings) + { + existingLocation.LocationRatings.Remove(rating); + SolicitorLocationRatings.Remove(rating); + } + + foreach (var rating in location.LocationRatings) + { + var existingRating = existingLocation.LocationRatings + .FirstOrDefault(locationRating => locationRating.Provider == rating.RatingProvider); + + if (existingRating is null) + AddNewRatingToLocation(rating, existingLocation); + else + UpdateExistingLocationRating(rating, existingRating); + } + } + + private void UpdateExistingLocationRating(Rating rating, SolicitorLocationRating existingRating) + { + existingRating.Value = rating.Value; + existingRating.Maximum = rating.MaxValue; + existingRating.LastModified = DateTime.UtcNow; + } + + private void UpdateExistingCity(City city, Solicitor solicitor) + { + city.Solicitors.Add(solicitor); + solicitor.Cities.Add(city); + city.LastModified = DateTime.UtcNow; + } + + private Task GetCityByNameAsync(string cityName, CancellationToken cancellationToken) + { + return Cities + .Include(city => city.Solicitors) + .FirstOrDefaultAsync( + city => city.Name == cityName, + cancellationToken: cancellationToken); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.HtmlParsing/DIExtensions.cs b/backend/libs/Solicitors.HtmlParsing/DIExtensions.cs new file mode 100644 index 0000000..b12689a --- /dev/null +++ b/backend/libs/Solicitors.HtmlParsing/DIExtensions.cs @@ -0,0 +1,13 @@ +using System.Diagnostics.CodeAnalysis; +using Microsoft.Extensions.DependencyInjection; + +namespace Solicitors.HtmlParsing; + +[SuppressMessage("ReSharper", "InconsistentNaming")] +public static class DIExtensions +{ + public static IServiceCollection AddHtmlParsing(this IServiceCollection services) + { + return services.AddSingleton(); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.HtmlParsing/HtmlParser.cs b/backend/libs/Solicitors.HtmlParsing/HtmlParser.cs new file mode 100644 index 0000000..7b45a5b --- /dev/null +++ b/backend/libs/Solicitors.HtmlParsing/HtmlParser.cs @@ -0,0 +1,130 @@ +namespace Solicitors.HtmlParsing; + +using Models; + +internal class HtmlParser : IHtmlParser +{ + private readonly string[] _voidElements = + [ + "area", + "base", + "br", + "col", + "embed", + "hr", + "img", + "input", + "link", + "meta", + "source", + "track", + "wbr" + ]; + + public IEnumerable ParseHtml(string html) + { + // wanted to do this in one pass but was quite time-consuming + // so taking a little lesson from compiler development + // and lex the text into tokens before parsing :) + // deferred execution might help it still be "one pass"? + var stringEnumerator = html.GetEnumerator(); + var tokens = LexHtml(stringEnumerator); + var tokenEnumerator = tokens.GetEnumerator(); + return ParseHtml(tokenEnumerator); + } + + private IEnumerable LexHtml(CharEnumerator content) + { + var work = ""; + while (content.MoveNext()) + { + if (content.Current == '<' && !string.IsNullOrWhiteSpace(work)) + { + yield return work.Trim(); + work = ""; + } + + work += content.Current; + + if (content.Current == '>' && !string.IsNullOrWhiteSpace(work)) + { + yield return work.Trim(); + work = ""; + } + } + } + + private IEnumerable ParseHtml(IEnumerator tokens) + { + while (tokens.MoveNext()) + { + var token = tokens.Current; + if (!token.StartsWith('<')) + { + yield return new StringNode(token); + continue; + } + + var noBraces = token.Substring(1, token.Length - 2); + var split = noBraces.Split(' '); + IHtmlAttribute[] attributes = []; + if (split.Length > 1) + { + attributes = ParseAttributes(noBraces).ToArray(); + } + + if (IsVoidOrSelfClosingElement(token)) + yield return new HtmlNode(split.First(), attributes); + else if (token.StartsWith("")) + return true; + + var tagName = token.Split(' ').First()[1..]; + if (tagName.EndsWith('>')) + tagName = tagName[..^1]; + return _voidElements.Contains(tagName); + } + + private IEnumerable ParseAttributes(string tokenNoBraces) + { + var attributesString = string.Join(' ', tokenNoBraces.Split(' ').Skip(1)); + var attString = ""; + var inQuote = false; + foreach (var c in attributesString) + { + if (!inQuote && c == ' ') + { + yield return ParseAttribute(attString); + attString = ""; + } + else + { + attString += c; + if (c == '\"') + inQuote = !inQuote; + } + } + + yield return ParseAttribute(attString); + } + + private IHtmlAttribute ParseAttribute(string attString) + { + var split = attString.Split('='); + if (split.Length > 1) + return new HtmlValueAttribute(split[0], string.Join('=', split.Skip(1))); + else + return new HtmlAttribute(attString); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.HtmlParsing/IHtmlParser.cs b/backend/libs/Solicitors.HtmlParsing/IHtmlParser.cs new file mode 100644 index 0000000..199a93c --- /dev/null +++ b/backend/libs/Solicitors.HtmlParsing/IHtmlParser.cs @@ -0,0 +1,8 @@ +namespace Solicitors.HtmlParsing; + +using Models; + +public interface IHtmlParser +{ + IEnumerable ParseHtml(string html); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.HtmlParsing/Models/HtmlAttribute.cs b/backend/libs/Solicitors.HtmlParsing/Models/HtmlAttribute.cs new file mode 100644 index 0000000..70a8fea --- /dev/null +++ b/backend/libs/Solicitors.HtmlParsing/Models/HtmlAttribute.cs @@ -0,0 +1,6 @@ +namespace Solicitors.HtmlParsing.Models; + +internal class HtmlAttribute(string name) : IHtmlAttribute +{ + public string Name { get; } = name; +} \ No newline at end of file diff --git a/backend/libs/Solicitors.HtmlParsing/Models/HtmlNode.cs b/backend/libs/Solicitors.HtmlParsing/Models/HtmlNode.cs new file mode 100644 index 0000000..971014f --- /dev/null +++ b/backend/libs/Solicitors.HtmlParsing/Models/HtmlNode.cs @@ -0,0 +1,92 @@ +using System.Diagnostics.CodeAnalysis; + +namespace Solicitors.HtmlParsing.Models; + +internal class HtmlNode(string name, IHtmlAttribute[] attributes) + : IHtmlNode +{ + public virtual bool TryGetByTagName( + string tagName, + [NotNullWhen(true)] out IHtmlNode? node, + bool noChildren = false) + { + node = null; + if (tagName == name) + node = this; + + return node is not null; + } + + private string[] Classes + { + get + { + var classAttribute = attributes + .Where(a => a is HtmlValueAttribute) + .Select(a => (a as HtmlValueAttribute)!) + .FirstOrDefault(a => a.Name.Equals("class", StringComparison.CurrentCultureIgnoreCase)); + + return classAttribute is not null + ? classAttribute.Value.Substring(1, classAttribute.Value.Length - 2).Split(' ') + : []; + } + } + + public virtual bool TryGetByClass( + string className, + [NotNullWhen(true)] out IHtmlNode? node, + bool noChildren = false) + { + node = null; + + if (Classes.Contains(className, StringComparer.InvariantCultureIgnoreCase)) + node = this; + + return node is not null; + } + + public virtual bool TryGetByTagNameAndClass( + string tagName, + string className, + [NotNullWhen(true)] out IHtmlNode? node, + bool noChildren = false) + { + node = null; + if (tagName == name && Classes.Contains(className, StringComparer.InvariantCultureIgnoreCase)) + node = this; + + return node is not null; + } + + public virtual bool TryGetText([NotNullWhen(true)] out string? text) + { + text = null; + return false; + } + + public virtual bool TryGetChildren([NotNullWhen(true)] out IEnumerable? children) + { + children = null; + return false; + } + + public bool HasAttribute(string attributeName) + { + return attributes + .Any(a => a.Name.Equals(attributeName, StringComparison.InvariantCultureIgnoreCase)); + } + + public bool TryGetAttributeValue(string attributeName, [NotNullWhen(true)] out string? attributeValue) + { + attributeValue = null; + + var matchingAttribute = attributes.FirstOrDefault( + a => a.Name.Equals(attributeName, StringComparison.InvariantCultureIgnoreCase) + ); + + if (matchingAttribute is HtmlValueAttribute valueAttribute) + attributeValue = valueAttribute.Value; + + return attributeValue is not null; + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.HtmlParsing/Models/HtmlValueAttribute.cs b/backend/libs/Solicitors.HtmlParsing/Models/HtmlValueAttribute.cs new file mode 100644 index 0000000..c8ea5e4 --- /dev/null +++ b/backend/libs/Solicitors.HtmlParsing/Models/HtmlValueAttribute.cs @@ -0,0 +1,6 @@ +namespace Solicitors.HtmlParsing.Models; + +internal class HtmlValueAttribute(string name, string value) : HtmlAttribute(name) +{ + public string Value { get; } = value; +} \ No newline at end of file diff --git a/backend/libs/Solicitors.HtmlParsing/Models/IHtmlAttribute.cs b/backend/libs/Solicitors.HtmlParsing/Models/IHtmlAttribute.cs new file mode 100644 index 0000000..4240a2e --- /dev/null +++ b/backend/libs/Solicitors.HtmlParsing/Models/IHtmlAttribute.cs @@ -0,0 +1,6 @@ +namespace Solicitors.HtmlParsing.Models; + +internal interface IHtmlAttribute +{ + string Name { get; } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.HtmlParsing/Models/IHtmlNode.cs b/backend/libs/Solicitors.HtmlParsing/Models/IHtmlNode.cs new file mode 100644 index 0000000..e473d8f --- /dev/null +++ b/backend/libs/Solicitors.HtmlParsing/Models/IHtmlNode.cs @@ -0,0 +1,64 @@ +using System.Diagnostics.CodeAnalysis; + +namespace Solicitors.HtmlParsing.Models; + +public interface IHtmlNode +{ + /// + /// Searches this node and its direct children for a matching tag name. + /// + /// The tag name to match. + /// If found, the node that matches the tag name. + /// If true, only check this node, not its children. + /// True if this node, or any of its direct children, have a matching tag name; false otherwise. + bool TryGetByTagName( + string tagName, + [NotNullWhen(true)] out IHtmlNode? node, + bool noChildren = false); + + /// + /// Searches this node and its direct children for a matching class. + /// + /// The class name to match. + /// If found, the node that matches the class name. + /// If true, only check this node, not its children. + /// True if this node, or any of its direct children, have a matching class name; false otherwise. + bool TryGetByClass( + string className, + [NotNullWhen(true)] out IHtmlNode? node, + bool noChildren = false); + + /// + /// Searches this node and its direct children for a matching tag name and matching class on the same node. + /// + /// The tag name to match. + /// The class name to match. + /// If found, the node that matches the tag name and class name. + /// If true, only check this node, not its children. + /// True if this node, or any of its direct children, have a matching tag name and class name; false otherwise. + bool TryGetByTagNameAndClass( + string tagName, + string className, + [NotNullWhen(true)] out IHtmlNode? node, + bool noChildren = false); + + /// + /// Checks this node (and *not* its children) to see if it is text content. + /// + /// If found, the text content. + /// True if the node is a text node, false otherwise. + bool TryGetText([NotNullWhen(true)] out string? text); + + /// + /// Checks this node to see if it has child elements. + /// + /// If found, the child elements. + /// True if the node has child elements, false otherwise. + bool TryGetChildren([NotNullWhen(true)] out IEnumerable? children); + + bool HasAttribute(string attributeName); + + bool TryGetAttributeValue( + string attributeName, + [NotNullWhen(true)] out string? attributeValue); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.HtmlParsing/Models/ParentHtmlNode.cs b/backend/libs/Solicitors.HtmlParsing/Models/ParentHtmlNode.cs new file mode 100644 index 0000000..ae229b1 --- /dev/null +++ b/backend/libs/Solicitors.HtmlParsing/Models/ParentHtmlNode.cs @@ -0,0 +1,92 @@ +using System.Diagnostics.CodeAnalysis; + +namespace Solicitors.HtmlParsing.Models; + +internal class ParentHtmlNode(string tagName, IHtmlAttribute[] attributes, IHtmlNode[] children) + : HtmlNode(tagName, attributes) +{ + public override bool TryGetByTagName( + string tagName, + [NotNullWhen(true)] out IHtmlNode? node, + bool noChildren = false) + { + node = null; + if (!base.TryGetByTagName(tagName, out node, noChildren) && !noChildren) + { + var nodesToCheck = new Queue(children); + while (nodesToCheck.TryDequeue(out var child)) + { + if (child.TryGetByTagName(tagName, out var childNode, true)) + { + node = childNode; + break; + } + + if (child.TryGetChildren(out var grandChildren)) + foreach (var grandChild in grandChildren) + nodesToCheck.Enqueue(grandChild); + } + } + + return node is not null; + } + + public override bool TryGetByClass( + string className, + [NotNullWhen(true)] out IHtmlNode? node, + bool noChildren = false) + { + node = null; + if (!base.TryGetByClass(className, out node, noChildren) && !noChildren) + { + var nodesToCheck = new Queue(children); + while (nodesToCheck.TryDequeue(out var child)) + { + if (child.TryGetByClass(className, out var childNode, true)) + { + node = childNode; + break; + } + + if (child.TryGetChildren(out var grandChildren)) + foreach (var grandChild in grandChildren) + nodesToCheck.Enqueue(grandChild); + } + } + + return node is not null; + } + + public override bool TryGetByTagNameAndClass( + string tagName, + string className, + [NotNullWhen(true)] out IHtmlNode? node, + bool noChildren = false) + { + node = null; + if (!base.TryGetByTagNameAndClass(tagName, className, out node, noChildren) && !noChildren) + { + var nodesToCheck = new Queue(children); + while (nodesToCheck.TryDequeue(out var child)) + { + if (child.TryGetByTagNameAndClass(tagName, className, out var childNode, true)) + { + node = childNode; + break; + } + + if (child.TryGetChildren(out var grandChildren)) + foreach (var grandChild in grandChildren) + nodesToCheck.Enqueue(grandChild); + } + } + + return node is not null; + } + + public override bool TryGetChildren([NotNullWhen(true)] out IEnumerable? children1) + { + children1 = children; + return children.Length != 0; + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.HtmlParsing/Models/StringNode.cs b/backend/libs/Solicitors.HtmlParsing/Models/StringNode.cs new file mode 100644 index 0000000..6b2009c --- /dev/null +++ b/backend/libs/Solicitors.HtmlParsing/Models/StringNode.cs @@ -0,0 +1,57 @@ +using System.Diagnostics.CodeAnalysis; + +namespace Solicitors.HtmlParsing.Models; + +internal class StringNode(string content) + : IHtmlNode +{ + public bool TryGetByTagName( + string tagName, + [NotNullWhen(true)] out IHtmlNode? node, + bool noChildren = false) + { + node = null; + return false; + } + + public bool TryGetByClass( + string className, + [NotNullWhen(true)] out IHtmlNode? node, + bool noChildren = false) + { + node = null; + return false; + } + + public bool TryGetByTagNameAndClass( + string tagName, + string className, + [NotNullWhen(true)] out IHtmlNode? node, + bool noChildren = false) + { + node = null; + return false; + } + + public bool TryGetText([NotNullWhen(true)] out string? text) + { + text = content; + return !string.IsNullOrEmpty(text); + } + + public bool TryGetChildren([NotNullWhen(true)] out IEnumerable? children) + { + children = null; + return false; + } + + public bool HasAttribute(string attributeName) => false; + + public bool TryGetAttributeValue( + string attributeName, + [NotNullWhen(true)] out string? attributeValue) + { + attributeValue = null; + return false; + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.HtmlParsing/Solicitors.HtmlParsing.csproj b/backend/libs/Solicitors.HtmlParsing/Solicitors.HtmlParsing.csproj new file mode 100644 index 0000000..90bc4ed --- /dev/null +++ b/backend/libs/Solicitors.HtmlParsing/Solicitors.HtmlParsing.csproj @@ -0,0 +1,13 @@ + + + + net10.0 + enable + enable + + + + + + + diff --git a/backend/tests/Solicitors.Core.Tests/SolicitorServiceTests.cs b/backend/tests/Solicitors.Core.Tests/SolicitorServiceTests.cs new file mode 100644 index 0000000..574cf5c --- /dev/null +++ b/backend/tests/Solicitors.Core.Tests/SolicitorServiceTests.cs @@ -0,0 +1,130 @@ +using Moq; +using Solicitors.Core.Data; +using Solicitors.Core.Models; + +namespace Solicitors.Core.Tests; + +public class SolicitorServiceTests +{ + private readonly Mock _mockRepo; + private readonly SolicitorService _service; + + public SolicitorServiceTests() + { + _mockRepo = new Mock(); + _service = new SolicitorService(_mockRepo.Object); + } + + [Fact] + public async Task GetSolicitorInfoByIdAsync_Should_ReturnNull_When_NoMatchingSolicitor() + { + //arrange + var cts = new CancellationTokenSource(); + var id = Guid.NewGuid(); + _mockRepo + .Setup(x => x.GetSolicitorByIdAsync(It.IsAny(), cts.Token)) + .ReturnsAsync(default(Solicitor?)); + + //act + var result = await _service.GetSolicitorInfoByIdAsync(id, cts.Token); + + //assert + Assert.Null(result); + _mockRepo.Verify(x => x.GetSolicitorByIdAsync(id, cts.Token), Times.Once); + } + + [Fact] + public async Task GetSolicitorInfoByIdAsync_Should_ReturnMainSolicitorInfo_When_MatchingSolicitor() + { + //arrange + var cts = new CancellationTokenSource(); + var id = Guid.NewGuid(); + + var expected = new Solicitor + { + SolicitorId = id, + Name = "Solicitor", + ShortDescription = "Short Desc", + Phone = "000 0000 0000", + Email = "example@example.com", + Website = "example.com", + RelativeUrl = "/-some-solicitor.html" + }; + + _mockRepo + .Setup(x => x.GetSolicitorByIdAsync(It.IsAny(), cts.Token)) + .ReturnsAsync(expected); + + //act + var result = await _service.GetSolicitorInfoByIdAsync(id, cts.Token); + + //assert + Assert.NotNull(result); + Assert.Equal(result.Id, expected.SolicitorId); + Assert.Equal(result.Name, expected.Name); + Assert.Equal(result.ShortDescription, expected.ShortDescription); + Assert.Equal(result.Phone, expected.Phone); + Assert.Equal(result.Email, expected.Email); + Assert.Equal(result.Website, expected.Website); + } + + [Fact] + public async Task GetSolicitorInfoByIdAsync_Should_MapCities_When_CitiesArePresent() + { + //arrange + var cts = new CancellationTokenSource(); + var id = Guid.NewGuid(); + + var expected = new Solicitor + { + Name = "Solicitor", + RelativeUrl = "/-some-solicitor.html" + }; + + expected.Cities.Add(new City { Name = "London" }); + + _mockRepo + .Setup(x => x.GetSolicitorByIdAsync(It.IsAny(), cts.Token)) + .ReturnsAsync(expected); + // expected.Ratings.Add(new SolicitorRating { Provider = "Google", Value = 4, Maximum = 5, Solicitor = expected }); + + + //act + var result = await _service.GetSolicitorInfoByIdAsync(id, cts.Token); + + //assert + Assert.NotNull(result); + Assert.Collection(result.Cities, city => Assert.Equal("London", city)); + } + + [Fact] + public async Task GetSolicitorInfoByIdAsync_Should_MapRatings_When_RatingsArePresent() + { + //arrange + var cts = new CancellationTokenSource(); + var id = Guid.NewGuid(); + + var expected = new Solicitor + { + Name = "Solicitor", + RelativeUrl = "/-some-solicitor.html" + }; + expected.Ratings.Add(new SolicitorRating { Provider = "Google", Value = 4, Maximum = 5, Solicitor = expected }); + + _mockRepo + .Setup(x => x.GetSolicitorByIdAsync(It.IsAny(), cts.Token)) + .ReturnsAsync(expected); + + //act + var result = await _service.GetSolicitorInfoByIdAsync(id, cts.Token); + + //assert + Assert.NotNull(result); + Assert.Collection(result.Ratings, rating => + { + Assert.Equal("Google", rating.Provider); + Assert.Equal(4, rating.Value); + Assert.Equal(5, rating.Maximum); + }); + } +} \ No newline at end of file diff --git a/backend/tests/Solicitors.Core.Tests/Solicitors.Core.Tests.csproj b/backend/tests/Solicitors.Core.Tests/Solicitors.Core.Tests.csproj new file mode 100644 index 0000000..db4ee05 --- /dev/null +++ b/backend/tests/Solicitors.Core.Tests/Solicitors.Core.Tests.csproj @@ -0,0 +1,26 @@ + + + + net10.0 + enable + enable + false + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/frontend/.gitignore b/frontend/.gitignore new file mode 100644 index 0000000..a547bf3 --- /dev/null +++ b/frontend/.gitignore @@ -0,0 +1,24 @@ +# Logs +logs +*.log +npm-debug.log* +yarn-debug.log* +yarn-error.log* +pnpm-debug.log* +lerna-debug.log* + +node_modules +dist +dist-ssr +*.local + +# Editor directories and files +.vscode/* +!.vscode/extensions.json +.idea +.DS_Store +*.suo +*.ntvs* +*.njsproj +*.sln +*.sw? diff --git a/frontend/.yarn/install-state.gz b/frontend/.yarn/install-state.gz new file mode 100644 index 0000000000000000000000000000000000000000..1a7cf7b0e68ab584992466b45551c42bf785a885 GIT binary patch literal 408488 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 Qv2yk(|HAd@&wYw$jd33;!1rbIy0C#z&{> z5&O<-n`B2+vvaT4JJ)+9GvBISWv9>c`LOSrFyb<(H;M0?$$LhG`fK-fl=~mPhOGJB z?CQ8#hkWy~WaNxzhTH4rss0u5!%o&_KyU& z`FWj3qNmmzsr);|uNV3>Qgz-=<`SeW_Z)@|ZL9XZ6|?||N}dHz3|`D_)Ro-j+a3(A z!dpQxsz_s^3duQg*UkYKN!`)hx54XSi(g3~e$UvHF)Hkg2?79`g(ec!OmkBhkk z2D8nF?on zkKmsa!e^AzM*_j%)SGMcmR<;*L^>!4f;_-if-gQ9{8=fWg{2={s08j1Z{O$pD&N}B zdQP53UH$g6HUcBua6iO7o&9G00sFMi@kT5=g97VCXrcsxp8a`%be9IFnhtF#ypO;M zMqKZ40*48vgOUFQdk|1+(St;B1u8%e(XNf7R7xo&X1goF+56TjRI47r9P{T=a*48$>lYrw{dVwef-BLs*AU|G!8`=HqyBW zL46+WcK#iec*z&VetO6KHkmc)d_QWXJWp-& z;@ShwzpS;L%kR6qKJhu|$i-?=qIVHT)$Z4&M6-T6){k~8NxIm^LwJ>ao7Ud_tO?l= ziVyf*`N*KMw`~Iz>}FZYbnsz8ZcbA7avomX2o4reE0ZuLx35L z*eCEmMJEJ7YH?|GvFsb+#9Y zL-4!cPifk5Cb!n^Tbv@tdVivIiO`DaIF*5NGT<~_$-?`^Yqcs8n!YEf6p#YmW&>yZ#S!jvG0&)Bj_Nl#xSrRqAg zKY7}~&(IvU3*$)PbcF1@sI;GtFR*=6^Iczi`*Xd(=W>%;c;r3B5AfPz2MqlE06o<3 zS^y-}@xg&_*#6*(=*TbBgkVp&4a8{b-KTjviOg~s^t>DGc;bV)5QH-lAG5P!0p@uj zU7UT*YQKG?n&Xt>Jy;uW&+AM2(CcKsj5gQm+j|bZJ>SOmaQZE#E92Xpn7@3lBTsKlZ0mA+nL*<(^Qt81-{ulO>eiTh@w z_5`-k(srvc>KC13U$w!zHD3%q1+Dss=1hpT?WVjg$_lTyzV}vg54+ShXykQXQb+PdvB=(=C=nd!`D ze(q?*F*fQ2vO*PV!+Gm~DJQTiU(WKt6?j<^!s!Fbe@KS!qvB#-?j}IsK{Py%`LJJt zd*LChJ)q7IwEq0;)4ze((ZS(0=AG$%H~W4BU(UVZ4lC2wCaVg5;GWm;LSMgw)d(Dz z{Xz3Yds}O*ty9M>o<%;Ayv324CX2YWW6}_k1Q*NAYrfW`M6Ss++qDrm{Z&olYRh1l zHT1)W)Om!G`$KEO%DJ909b+qsT`l?ieJ^Qk_s2U}iKUZhr^UMZyt}~0=;*_dL-es2 z){jFhm)5bBdnU1a+rJrfE0ixx^rqs0B~qhT^KoB)p>|f0139x%#UaFadj>g2vgvu< zskAN5F?!p+hqt&$8IoCn++MP5J-f9RQ_kjJ*8D% z#bU@K);&Fri2CY|pRrH?+&KoknOQQ@JD`OH#D=mn@}u64S7&zXghbXX7*uo5v2}k} zQk0IJkW9{aeZmJ_M(UYAXC~8$ z_-+c;aN{v3Gn6^~tIB+9C#4v4Hn3@C9CcUd3G$x~ry+Z_$)y9RQK|88vejV*G27@v zZe-$FoCs+66h?do=jpdAJG2S6SHKC0+SxZlb^}9C( zS=aFxb~+rDo%2!RZ_30krYbfvBDJi>LhV}&U9a$`)s3)2;De-&)p!!zOm7ThB+&$h z(ra5%=F-Mxdy2P9qBZkIGJ8KQKGXYbpXg$Ci!Z3W!`v1%AKj0%tpvjaMKR7@4BD61 zpvy-XCO4Bqke`~&`lgMhVtr8ollXd)-!>pCi97Cbe|^F>IR@^uUzKl3xu0^=nzG1n zrpVcv^|v+8oxMG9Ho4GA42$YlZIV-<< zEpq?}TaEGY@v%1ot=&itAmM~Iv0cjTD-oP%j9f@6`hJA{ly*-2^!c+p(uW@C*GerxPs&DIHnLYf;S>`}D5FT#VJ7wL@Pb!EYJ- z2ng(qvB}`AHO~Kz5fK}vL2rXgKRNjVS&p)V;18ktS}UQE33%0fRs~5^hRbSG#v)mu z*uZpd44L(A{`gy z4g>2^@iS$KZ+7!Z7TWM6<_QP={S-Gjp?=&B|C!34OtYgzfO3vd26UDc!AA{^bHW$^ zULIc;#Bbrz&q*H9cl@+R+7#VPAgTPiDIW!~{1)WYWKIEj&A*-t${K@_Ngk^j6XEER zG1nq;anf*C)hyC3LDNf`c*nnMuVsxJv(K=53f-s=QQWRMi!&5Ycizv@pY7bM#f{QjANb%nW&8NlGQEF zPaYM)@?{s>h|vf+wbn`2t_=yf2B^Snb8s%4n6}}zDygC$bYTgH7W zn|KJ*IX3}y0F%c$Mou(U6~A##B0etXzY^rLX50o`Y~`GXRhAFbI#x3Dee1C^My{=l z&^qXdwUnbEfy(l=ZeR0`5tGQF%6LWEc@l4S_q(7-1{ePPXgfo6`DLADl~W&_C)^JY ze$x;FjY+c!ci8$@@*8nLmfZv{UcIXV=4yh2MrR-saoIYx-qI*GnZw3}b!bCd5+=V? zXPAB*`_%iIu~L!bbr9geEhBv`okg_EU|$4C=y>PyNHj-po5SP zUUp}7&-2fukau>cvX48Lcn{uL!j2W#{N^HHakuAt+5L_7`kUXp#zmMO^)orE;F;P_ zXYJ}iK+4^3j?oDQrhcP=2j5JJcek938xiF7u@HH7Ipz>BZjLEF4nXdf?Sy#xWP^of@aV)mRFCv)@tsV<)||<$giM_=TTz@D5!xh%AGun zx!K{OBlyTZ`Oy&j^Ci8R*9XxAM_p&fG3rMP8M$rVN7`Vu8!x_AM!M(>c^pObH51Zi z@6<1T33eU;d7LJZiKe{|0)4u@!NRcDHIR#IrNG}^&WSIvi6?6j(();bV0+t0l1=B9 zHl!G8=NoYlWVz<4I|`-gcugirkPVFbh5q*T@!cWi-Y((*?MXB|;fYRid|2mYeMdj5 zwcbJj5N`Cg+NMzBBN+&|zQ@4Q;kk;AOJZiP2;qeg#gPuS4% zZC^~Z>v_6(b8RuZuf`d!jO{#+p%L^Avw2ap>}6HIcSGn-2R>oXM>;#`fOT1zp#&W9`GB!kVI9 zkR(>8og^nH?(Y{CcBJx8%jAFlj+nghb5^Dq=7;q}-W*tGR60Zqi8K$fu z5ilYTJBPwVLOPWJ&9JSzo!fs-$4fjMkqBnyi@UIHS;Dt`8(Ad_&|YE4UVt9GNabFb zmr8VgwG<*GzX*12EIB{2&}UZ;)Z_408sR8E*}Obn0rPp^*UG3jNVY4oi>wa{8!mHE zb?y;%_Kr(Y*=K0(R)zetv{M=cI&540A+%Zug{!k-t<-ozOC&xzS)_}`VKt^$GEKpu z@&~b%N%*t7q0k+{w32Ap>N=QU#_b~?*<+nQV$972eRn0p41x`b+gi^N5!5;xoXUz96P__P*uWu;TEJeaT1`&}+R>?88KRu}AcKQG^gF|(XF)hJg;wInnG2)Tc?9Wh`AxhE5%PjmgDgX zPvV7HjD+g4T;ENpy&({P15Hgrn;y{G>zv~%ZjXqSIsFvpKlweR7VvWSFRO99XzQKD zK$ED=OI*(>mGlIS)g0;CYbmw*YJKqP%{i4R{+^!*nc17SJQp2Go3}cu=@B0j^$1ZL zY7e>G+2hW}bg%^(v0=2#mHRe!QPBQNK`GLB{#-rihKV&@H~M~;*L>f$fMhp_$jZ4u z;ruB&>Tz;0X3e&wdyUdmk8IJAKo~(*E%IjW7w26eU5&h#bvIj{yvQxs-of6ut;R^b&h@Sc@wVIX7_`*mYo^pJ^XwPW%tkq zx0a zW}08u)@I&|5GeGxkVD^Tf(8XnvjKOF+#zWweV$h)z3(_;n*bfkCp-NoFk)&7@#>vl z^DSc&M7nGEtB67i+1O5wYUHr*-Ib^<5C8OcMqARq3>*F-d@~)bwG89k+=e(hHxu-M zO?nm%scg(|z8UmcM7fWT&zu-=r zek5om5GLI;{px19of^{S-bUOY`Syg3cJ>GqOW%A!X`5b(owiupmnI7btWB#FZg?O; zezH3b5RGYPV^&fB*yyiz+y_+fLuhWsuZNI~Xz3|_XlYNQVr2Mur+=HHJTAm%@kWes zXYZ__UP>w~a33QyYnPLTnKTqw0S@zPr0%QkH|L$3QNeEH^+@068Y9_948cLw!+HK` z@hpi@qJL98ZRy4df!^RN;_p0*{hqt&n55#iO{_q@Ci!N5P(?3AblvXYiM?E)Zxe*K zrS(APODpc5#h%tUdLOjE>?gmIkIw2A6KrHxixCDQM*le%+9mF3&xnrEMe~~up#?e~ zMf4}ZpX_4$w9s7r9`d14+T42(fd`Wi#2ZHcwD0w;q&u-qPqcK$%lYdJct|x5;OA-^%@JRO z?Cw=06~0C}d&gqmI@VRLjJT(nef2`ufgY3y2FSGZuNcl2M^E5LtFLZZO+iMoa_t^9 zA}$lpt+S!!%QH_^+8`xVLRqFo2N^q}{3h`Qu^rN^RFz7&+H{vo+XX&D!baQ?|A=&RRf^Qxx<9o5Ot=vfE zZu|O(b^7NRYHpK%G}rE^%jk*bMasZXfBZR<8GHS-!PSYkm97AqOwYX$1Cl(tReGdwXH} ztiuF!wQcXvp^oT9Vi#Jp{EkeY*j@G)7pExQyV+QvI@`JF7gYw^H2FqvhYZ z&-o!Cbn}}buQYYXZZr3@@l57noN8*e7&a59)a(ecRBF8;+Ut{sRg_O9xugXhi^I`96V#%cjRxNK# z+-B=*iOUaP{2s5@kWG_fpAAcd>^F-<8!y>sk3b=^T1Ra@f|8Q?f@VZ}&-W)6RO@@c zRv4{WSX!fYdBr6B%{Jz=D-Qo_o-d+>g4Bh4<_Hw*> z3^Ry`wtGI`6urfMoi&38LEODl_9*+u{AxL?_PnrFNa;*057w*Lq_lfb46wEC%A?V~ z9IHDwvk(UJB_f@Nb@YY7k;xuza6XPXHdB^0BY5)2UR+xIX<=IONZQ>5K+ma@e7E^6 zm=sykmd*`MuXG1I;am*v-E_vD2z8lde#-tQ8T$KuR#H8~uRu!iHX}HSY!&Sby-TlS#43VYd3XlGL zlDSEX>6dU7v>j0H=bJEkvebn7zr5YDULPQysnfTiV*qgwaku4X=s|dN8q!7^Cmh?$ zMH@QB_Vm@zRH^kiUSv_t5#91K?Ov@Io6BY-w{`T-envn!AZdK*@Tx&y2lM{DUEX&< zH%uyc*9f7U_e;NHGhh{o{^8}Mkwaha`H+|kGnUP%_qmLGcAQh4rgNrFM#?)*?D0jg zudKIBTNtJ#3YWFF#YAiKtweNQdONg4W471FitD(Idm>w4=DiUBbhVSpH&P|1A?mqz zwu3x+5ys;Fh|WAC8*uu^a$gFs?G+JYPGnEQb0jv}(H0Tk+?1&E`O&Nz)wgX*^>~AL z-5N=v7Fp;E^II$5B&`)ow=^HYm)9e-rD7;*s0C>!?v#5WRfpe8-r+)7dyn~G>Q1$b zWO;lZy2V1`n=`r~WN(uQO(Zu>!qsx^Ny%$3b*su3<#F#9oc8Md%&&=f9cAswZz=zkEX)>&N1e>l z`$U)Vyq6_Dq8He+3lmpoNThim(Xbr&IPi@eu6rwb&1Ffo`YkK+u7mv#yZpq-H`~}u zUAvR)qkd76dGB8$ilFbKf|$=%JsN978}1kjBRFdaKRxNv?lgj>7Jj&giffSa!Ze4e zMAYbeq9@wqrjap%zO55|d!Av!M~p?4TcAG5KY^Jn*1NTeSCGARRl{RD?~NpRa=n?= zuYCV5_8og3kC#LYa!E42S>|l^CI;A2f4$!O`jgFa(Ewa<=kBTXT|(Sn`Q2mj#eBAv ztDo}{{dwi|k&oGA(Yldr`7ZVm;TCd&Y~uFNKF)e~^e?I^W+h*q3z3F-FKC2;$>7s5 zyexZ+Fi!R9=nr?0BpP$}ubX0|K5w0yUEXQh@abz*wA^pF&>P0(;^fyQ+F^_tm4H4l z1QGcnx^*nI&IP{M}3dt;vOjUZr{8F>=A-Di21=GPJZ zF|%4V5_=`G&a)QT0Z59G8N0;s=8Mgl^}A42+QaqLHfH@-Lh|za^tr27qwgozs|&K1 zqC)YXfC>Cp{2=t;#703=X<$xh+@+0y>wTWL?r!r;V{TeAUhcWj8ujt1FYcN_gi^fc zdZ-<>l||cYD$Xxw{$+g}ONP54nXE_W&_d2c`T`|c`c1Gl766Xes-cm zlu_6#yD#iXrRZ3-dPn>W6{V9~7%Jl#KAgu8u`L}f+Z3vEyaa0N$@@&sk7d=CeRL(o zoRGv-g#_U#JcZc!Wn*w@km)U0LD9V=wb)=;DkqRAAx5WU0dBL;(`ogx~3EDw%dd9kUj~P7* z0mnT1BAV&$-+E2vXv}M3jFY(Sd700|N`5JzKh>x7ZA*Yf`0cChc0eSMNl;MFcALp)KF^~V{ZzX1XDd^W z{~^e&#u>{nZ2K{g38;Eho_bD_z2r4jM(gGm^^6So%L<-L!dGY0q3{%mu(M7OSar{eJ z9W^GG8joQka8cUL*JU&Y0v_v#owS)1AERduIh2Sp7Kz=Qjt|J9p-|dIdQg*_Er13P zpJ*+P%(KQ_kIzEl`4BE#$QAx%kd+uWM-m-0W_B?&nTJD~5czP(AA2J=!g(mf)u7>2 zXR-V3rZ{ZIYIz8bl1Ye_5SJ%pq1$22zwew3oV>(llktua6GBjEjN>6HR|{~49%{C0 z$J2?$?QHR=c2U0Zog+7;822}JuJyUi@puAU_+paK_w*ah5}d%Cal5^9x-akxMQG|P zof29ydWd&~(1GsKMmO~wVXF#>@E9CLv^s4GGRAgQjVP$kiAZqCzU$M(_dZW{DMgxq z2mCM)#IX$`L4&I>PHQyBXC5xvzR%FgdkNoOzGFG-<*I$;BDhEYk#FGwEnQdKEih2s z8EJRCkI%!gJU(61!BH|f=UAHI=YZ0M4b%HsMUQmk3%=x|z8K?4Oh4bJhyU_6Ksr3q zoAu}TFfQXvhL9XfYt&k&wUtQ=I`qjilioa%$8n4zah*NTvR+Ku{a(@-FL||?T{tk? z{wbxtws1ckH4#bqj@gzGYt<^bm|&1B?S^_x&}~eUC8vFwqR68t?&{8OcxHY5>Wv- z;M_*KTt_?0d+%?BAY8m-cH5HiDS!)B77}Wfmwf72Aw`G|e`E+xb0BaTcc$%}bNZ@v zj-H6#>fNPnzQ@X!a$=6YcQj?w$e}?nc-pi*FoqvPT2vCxM!M?yv@C1q>HL!m?*v5= z+pDyAZ&3`V)Fc*3Cu)x)q^He0bOVYaxUmIa?$rJn)5#_Fv+p4*?!4AZ4-4yFm*7?S zZHw9cXc#^<`ZsY)VkdR;B3?Gar41mB9STud3e;;%^5(`Ob7-|dWz+0RyUnWSB-)TY zOpyi4&#NR5J{F1N&JCsr(-I1o4*JO}g|)YyuZSmnYxR-9$IScC{G7rDC~lN*Qimh< z+E;;A!B)v-t9RxDPW?pJGP%Gr(X(Ja?I;}p(HI?N&%;!)62=X_n}(u7D3kZsN7#kE zCOfCk&A}SuB9{~b!C?+PL#=SuYXOM-no6g|!Kl=zdzW%Pp|O=0I03E~ zf*3FtebP`SZ$^@f_aPw0vW+r=J=*(TVEMrc5~x(w84@MnS4S zU-Y%#oC(Ei(>}Z*2Mm^f>B|`Nt3E>&^NV;jcDo@u&w6N2At4PspAOz`C0vLJM{W19 zc^p}ltKdzz##A65^XWc)vTEsts18(GAXVM){O;3E>D>3V`^+y>d38daCoqs256a7! z6!|d~6J~FNX>7jPZJgE5&%x8aqX{qsx!387KC0H221cQF?(usXdENF_pVgBk?7ORB z@!O8!kY!m%t%Mn89)tx)JWgjWLYgP5Tj(lNYhr=K7=}vlO(MqiXFZ1H6e;`hd!xyw z771`*fr`OjT4j`z{cePCBUxHs8nZE;3NGSLZi%(2ozvdrl*M5$BMAR`_-LiqfK+JD z;luzIVYl!J%-GO+9}Bz};odojn4Z^HKf>6S3`&H3tUTiRF1f_qj^Y+3%MpP`Y@sYc z^4c0hA-CbpP~_LW7f8hFpWv3H-l2)DUW9YOjIYK&N6uurhZ#$HyE^ym+*0#~fE<|yZP3c473QH8Z1=s*5k!#! ze1e>{N+GO143XmfBqGv_NK!bU7==>Tk_p{#pV`mj7@Sqp4&~FS$*%w6QEJ~Pl5%ta zVgiBp#PV}-8C3%rfOlHpW5^dMlN!R7UXJ#tuaq!+0MoYy?c}I-n_OT@8K_!5BFVVh zY-s43D_O2-VZXrL+TxMW3e(~H(w7g!ZToQIR0s87fIUaKBQnHDM#He#oHik*@~xW_ zJXC6*ClW6;T&ly8<=akuk7LkRF9z3Nj<0j=vwXfG2X8un!n&W;_90$V2EDF*w6~c> zl47~nCrG6X-|cN%z3`f4?&e$HE2v?&U2=_C*-l}td!8_588X*HQO}ABs$h*7n=_#^ z<_Tt-qIyfvX2|K6&fPL<+ruNG!Ls?olt9JVH=%{@L*Mp}3~kl8s1Mu+%tBtT0G;r< z*!*rvyo839Gj@4{L@*$tiS37ozsJdic-g5!1lS2h`LkGV_uO@nkHzO2LzMlY2tcUS zw=F%Ru*64WU3ZYl^B2~(A89eoeQnm;qzjy9F;>sk(Tl9v=qRkWp49Y>|1W)uWV=oZ zWn?luvxjMPD|y|Tz;>);srN;ZEb{3WxIp}Nt(o~rpQFVX z2BxW{F4>8rH9ymgu6sWJU*bja5*cO9m)v*S)^S;*f9@<0GV1U-M5?mG)> zfZ2*0phdZ?zpQ$p;;1Knz8vdwAD&bVN)8aa?%qY&fq`K`OpcsIAG1(17>`O{rF-oq zVvB&)P95B)dYis&u5WnoqZ49bKsI>X&#uF{a}Pe&c=KGg_49Oi6ILCK9C%+xLhrs{ zK89}6h*_+vWTRZe^S?4G^E&Cj1Or>2fpFkipJi?}5hPsgpOhx&8Zd)D5%OZ*N*XM? zYhM5&27;1)Y%G4miV8@*{3`VL0~vgb-W?e1g&*lgTKk&N5r2e(0{XG#vpOu z9YoL{MFwrd6B_CFMr>nbz`i_2yw+du2fKZ1wRDV643+Y%9lwhMt88GKYm1Ac*gbEv zUc(K&Pc4jB=l}^+heX;B^fB*59Z%+~G6%CP`p5Py1MC%q)*CzNx&335%rb;N?e3ga zQ}1Ir^@i)@$ZqvHq{c+~kE!Y~7|FQukVx|G?D(FHGKBGs5O}z_D?jTS7z5`h@1IwO zGZ+#U=)%H_^dMa$wncOmfPTE*mragV?tP-dd%3#w^N8tedh7&*FGER{(`I8(^~Izg zXG-6|l)e{Fozc%6j~4O+ZKAtgde7%pK?w*t!MFpEENccvVQSNa$LdHAJ_*b5ug+}< zEGtE}U6SS@@sZREakr;CO6bXWP9Dz45`;^H%kSkv@4{u>Z>{t3Skhsw5_^5xSl;y! zbHd{mYfQa&J8#P+UKxdO?lDLcpM9m@webw}1zb*V-iOQ0iNGc!eSs%3$N0IpE+=-s zsP+TYYqA^Z%xGtaq&O&H1W^G6Y>a$_3eQON?;Db0h3F^v<%d8V?9X23GV5RKbMbbB zPa6agd->sWzy||?=)lxq+v--|K7xGO#1_EV@*zr(Q=_-(%$x7A4_I~=Dl3i`5R*Vb zrfPd2j%UvXCNue0c(x~Jyvk21g`1}1#z8VU*fT>|ZlAOS5A6BbQ=Xe!QOmb+{ZLK0 zf*0yO$<5&6JiaK@u22`0+?oN=S>aos^>WJ=I?xgsS7t~ z{b&rDzwx1GSG==X6@nQ91~mD0?*x%A`R&a)^(O^z6`t&e1bnu00%?ru*tC9$YBFZ4 zi;$Q3#AXkrkqZ!4yo%A={a}^JeEBjL`KBzeYOr0bp$-4{Ayz%d$4y&pB6K|nY;Bg- zxUlpWIu>>i%pX5A3l9+BEO5E9pU+RP52$AO^Yf z)SZq`UJ|>qra6-t!-y!)pMJ347c8>8eRFbvFIQopf?KBSUG~nDGIeqRP(7AEsaNhu zn&P^i_T-W`l%HuSblb?n*>Q8OiB@_QZ+9Q;Rr;dd{=TV)3vB|zSpk#$-QyDn0ISdq zeR4de?{8cds2JfCP>Tx=oBklra2|KJDKUFJqqC16uqePeW(%e$cl+SXC_ z>sa6x0?cH0Yq1&O?IV8k^D0SW8a2D@cMSC?{=q;;;dk6OYt%bpZd1{XCVHi{K55k~ zRgwnw%5$-wBAecTiRfZ&d^AyXQgjrPNA`YO=+P!+#A}7KHHd*93i=G|S=rL^fJBT! zRH3ABOrG~?y%s>F4N%`dB=uxKQ?VTF+N{ZXC1)$#J~D*@{z@JuC!{QJ?|2^2tJybF z{3i#8tDv3O(?cIzpccYvUi@?$xLBhl1sKgaG{r=qM(EPV7xb6m7{J~mhwtNn$ z4G20f{8dai?uB}(wd-qjTbmoKy@6Qcxk+I=Fb3djU1k7sHuU(#%ah)v_RF&i8#a*g zZk;z`HkXf~aL3%EVO^S01N8YRLefXYw1wx^5!-|7bi4UrD}srVTGDVeypsi`r|rJZ zou6su;V@%{DM*P7sVRD?Oy~lOZQN&IyAO-~U~FQjvzFjI%N-5oJ?-;jkqGPbWADsk zpyXWFN0?<}#})fJVu~rP-3NL~fu3N9z3(CMdo$nqpe)e+mT4aU5f3b?u>T6+X-#AH zyD-=$yH!gd5NE)od=1$_BWnYbaWo{*OnqkIEC8j5_}n_3j>v}QetLXp)7ej8A93VW z51mVYXklA@YVejD2*HX#;fh9h4BUZ`6BvGQF|FFDg?2q4~|AoAy24eoS!t>Ik#!QyVTm<(>CZ8b(ZD zeO@y!-$%9+D*)#1b(sf3KPw-wEZrZtz5M7A)P3jnK%~R?dT{-27~)%3RLmbzQ7Cf+ zY<;yQ+HQ@VlpFwHQ%S-Ajl*h8aQ)XLoq@~d!l$_nsr#}#U!~Zucbv!XqrDEsI#dl? zW_L7{SM~=-g9+R9!;>Es2n;jb9PWPwUFH;KcC$p#%kMKCbEQMF+3iW2I#)?7xnSHm4jL$h^7@trx5a05# zIEF4Q#O||>F*!FZk=*=FW=4?yfc3DCF%2Bv6v!s66H^2E=|NRt(+m%1_I4)2JRRf1 zcMGBj*?}|cuGvYo865r-%**#I;2_apTw?^4VM4t=qabxf>j zg2ZbuOdzjAj9|_=lXn-(*6n^T*{ z_$2y>XUO;9&Igl1JM{Tmn#^K~-R^N%ZXFoqcRHSrR;z_Y(CpgV!Kxib9)-yg+%pjI zCRS7adqdNLB-8b>4nFU3Ra#r|keQ)XyGK9-(n(rEbl>}Z?|aVPcGdH&WlNZgL1*Sk;6B^9W01Abn!iOm zwSg5##z50`_b6kZS?ghz;H~rYH2AS^3^WowCX9#yM_qFRbx2X<0Qjw^U=`W89C;Oz zA6B5DEM^w)s70UF)&agk#K^Qtl(Y{4FZtnfHZoV!I1Du^2tvX#po zJ1ysVT}M(b`@M&QP;cSUi8Cv|42^bJQSA9jjG+4qI?6ehmM%o$W0ngCfVLYg=0cf) z7&B)ZZ6z6pj_YbVOgJ*n_M95t z2!~gBF^93&V<0?OyAtb>*CV-Zt>66`>VOsGXFKk$ApUSmo1G{G9XZGzmh7$rHNe=Y z71kC+h{3l2O(w%^=aJj1Ml*Duv1t{B@pScw37V&Lgf)i=DJ;E;>#0rQy|SR{ol#p~ zedn?TQr#Xj4od}7mFQUj8ROn1jqc;74>`zMHds%K5j;$`4&sy5C?;8UNtrz&f;~q< zdZmLsA$K_^^&IO@*Zp#S@-~y_-ic@47l#zcXns0dnO!E85CUr;GQ5-b4q^dOs=&Wf zRH zJWp#k`j?Lx#Q|(H@95_VyDdF*q(T8oBF_^V)NG9gMm=N5CZpY5LEC=&dhr9v;|j(v z;L4D#gfoxiU>5t>1>ypsyS>8Oo=D{bw9m1+hZRxd;V}Sf@utif9l`+xJ`ES=U62d6tdO}H&_3Ja-MxU7f$y|UXFImzk6U5adzIcPoK6UwJ^+a#8@o$%E=B^C zSnS@!;M7kTcnRR;zSb>x8g!P*m`;8@kh&W& zvBB{h)bU+d+mh!A*MvDRi?#)7rxa9(uvF=T0BZCi-p;w+DpyvzdK{rwyPzrq_|a^> zigEh+qN3b3Ik@e>_raNQHSXQ<_{GKn#ay1~Eu>X^@-2A;HvFTJ`u2Zd7eM7@rva*lEjta)v8F^_q{R-3%0a zG?*cEGWTB)@>}e}EVV7ZRQ0gK2keSZt#pvf^AJN$kT6ZQo}nokr9g|BCG)bb=!ll( zChyFkyL5aoOsYiJTT-4n1STHDJW zY?wwa6v}B4liLa5;4G??Stn^udQM{j`LP&Hjbv%R<(7ipuFkCE>fC3-hv`@fL1a7w z_C$Ez`bH2|;}EFR>~7wwtB{VjmvXZrpfiG(TZF8arzVL}eVMeks&O0x(xd<+=#`kX zMJA4o;7+N9Ub~bnuKLPruT9-&mvyb|Q2J2-wg_;J${*~)Og>k-@MiaS7CtAfh&EmZ z%sOfIMYe;#5K2hxbwyuTDh{!QT?=qGQo?H&%&Mx~>M9^dGD5fRsyv=wt7CRv63#J# zW)hr4d+boydiQzyz^x+S4nWd>xY2T4HOY8$^K}q*yLxub+_N(!t8zvOa44$)$X(!J z%26Mr8!Ex)HdkS;MRjX%dn4D3QZ5Ck(Yf5--U?m}!IpHuS!JAt!vHpSqnQ1)_qhdP z#jaZ38!ne!vb_FDui&*X4yud$D=?W_rJpQ5t%f?Qj;+nCIHyfVLr-H6_s9#xUiZIJJT5F2blrE%^K?GR3tj_CKb72H+j3 zLm|w>)Q{7zHhv0d)iAO4LD9I(Dv6xHBDC|HPH?^9je|p9XM?IZb%gKh{e^X)aa&JLpRx5Ex z04-jiuS3(Rqo*cQ8Zhk3lljJIIWR8*rFEYhI6{j&;se6<>zL4Klvx(mm;JFg)+=#O zBQLaPQ+ey|Mvg2)SkVs{M+c2t~ zctdS(6wl8y_0G_9Utf?1arpA$DqFeQ1mU`QHmF!)oD)7qtwAbS3ec2%$QaSa>M~uSHW^m4)2IC>9zc1sLlGH}|B9P*t9aRwFL6Y$40jH1vRDqaW+dFMO?PzyWt z$tJk%S*SK2$=^Q6e)s~q4ic@!(;}7HgxwzYo>y}^&~|tO+(Q$s$6yrF=*qIfI}~wo ztk803Zi?(^Tg?RaD0ErMMSoS+JgK~8tdZ5-hk(xInuCP)VN4+Maz6)9OvDKY)u}^+ z|6M3y??OWW46JXQDonXw%24Tvg+&hJ*%qJ#?KzU?xm}L}S~wZQHhO+n8ix+qP}nw(-Tbo!S4mhuvHC zy-(GzUjebf?*l7Dx3UzY>({O=fz9DhUVALzN+6Qve0$=exXNo@2vn zqN_gmxx&bM;$ip!GmM?leMif9yXIo+*w9dWD^ZZ;eHp?biDZ|(_a6}rSgH#M_f=q8hZL9)*HLGjN_k0yyU93_d4CgNrjNTF;f!3~XGN{%wfLI+5 zR_dJ=C{M*mFeBTk4TQRe5vK0iMAan<78Jlf!5QB5&F^wc0@!U0Mm0umFr)|@Z(~9F z$utYdzs(4c&%-9I^v*o2^0?=yI_Jd$3RH=Ve4CC1$RZ@XFLrI7&pqww&f5yS4!qLs z-X;$|jV7)1rn}k%I2ck~$lggB%p<5ZS-hfx7Z$c08-wrCWH9{5SS-mnIqyx#=;P%l z3+N(Z8dK*~JPQJ04V0h6%K5E);@z&4x8}Z-O8>NRw0w)3A$$UA+B_b0-^KS=bqje~ zw=;Otbc!YlWCULoixnJmM$ePnYz*%gB9rmWPQf`hXNfg7c}6EK3jJuHmVT7Sz`tCa zjfY1evC^lcFJn6kkL3ex++oJCck_ z0&&gSa75|UF5_hyZs;HyFw39|pa%$W`zXdvlHw^{Xr2@A7(M%kf!C?bkG%AP*)7~$ zWE%%qLp-ULAm(8Yml;aJs@+1frY@;SADcDp1r#Ou0uW5}nke;LlZ(gG+BaU}7`={w zr6_fn8Cs$8BEYWg^&d9qhr2GdN?;+7rfIW3C>TI-yYY6!p;amI5w><1(z~G2zG?;@WE5$l0WoK)PIc{vHr-lCwh{e zjM~DKNhZ;=2|cOJ#uCj2ETf3T|rD)0J&^QcRn8Xygz?=e%~dDz_HThz9wc zwtVIVPL72D?ytSmt${9>1iYky>uIcUalOWfJF~QAZ|aE9$IcG;<|%0ymLrB_NXEW5 z)JT-~Vh$h++e6TTgpMj6<}?7rpODOeoF(YK;p@uygKCf$CY$_YGsZ-vpb}TME6#lA zu&~P)d^3PKm0_*!zXxLU@6dYcG(9k^p?$;mHHb>gtZBrtr zV-8CpumlV{S2>fec6=u;yq?ruTw4ygP$ZVaHQ0ngLlZ7lDe2y6itJebZ0o6Ms$%nN zD3?$!pfMRQDo0iEVT|v@j-1oXJ{AOv00~9I$V@LRs2C=oV@x|~5#P1|TivcXRET0?b0I;)RuX`s4LI5BU5i>s!(S_P}VGvs8O z16-o`dB`UeTLHJp)a#_K(L0A0KQTVth~YXu-}V{BYVyGz5}3F{yFU$iy5+q*D#d(? zypC~~=t*DCNzzDevwD%F*06P+82Uft}TfTY}i5C2a#6nqeM5|LiRgsYug?;YkH|sti}-3U-!3 z%;K~?>q(s_uX3C44;eKp9gQw(8X8wVg^WwWb%TSRj=Eq{t6bW<4L1*e*~GB6;(Uj4 zYmbZ?y7upI!_BjK46lqjK;~_(L%rf^1bfq}7`e*fJ3cT8RKYrHO#|(GP`JIFIvgos z%Rcq-K+wI6k5#O5GZc8F0TTZm^oKj#1n_)W8HGiyJQ& ztoQ95_Q<*S*!$D-@jfziJTnBwQ8JJR@np8N-pbyv+M6Fm{!yWd)&bJB%0~2MTy{=1G6Eh#NPK`|}k3RW7Rh)20 z2PgqO3dQnDDK1Cr8|Vu-^tm`I?Joglt=K6%*M*C;K&#+hQw(XHO{@ZX)B&jRdj%L& z^a9u!fCU1s=Gl-EySVl`)6%QV-TP)QY`1zIy=6Oo&W3Id1<^~?JJUq8LWA9`C(xop zIlj1`{eU;WNKL|gkV51~#`ppyh~|z6qhNjclQ;Psf>v2wC}cy3l;|8tPm&vW;GBxm zE0Y;S!JehSoMAuKiuS)QF-mDe&+}D@J6F}7s|&aRP9F*t-=f1XCj5qE%?TCIBOSA! zC7HrNi)=zA!eb&m&*DXY*Rz@!s%v6DGmEl2VYWs*V1X<$V_Vx_YnRB$=r7`w8zfjaK+z$f#%exLOXCme@^2wYM!c{bWgX zZhpvqoO9zzZ)B;=zre$+ed5>q-HD5jZVqNPn(-BF)k5F6V9Txsfdi81z9HSY5~xY5@ua4yT* zh5!J`SxUrGQN($PT*iS6xbOJDb<2ELWSoG6(~Q+Rx5X>>#RqVd)}d0Ph}zG;vHAeZ`vEORK<@_s&*ALu?*ySp-; zgy#2y)ae#aL@c=?vK67#mm<5KklkA3J!&Gt1iJhtG9&7K%t6c+*^6jJKiK9kF@}xs zU00lJ*DVNm7|)Nv8}HrX5^Bwh&M$JqTjQ!@b)g3^$VrDyfXsN_liGgV3kuQ<{2g4q zrs*vZE!@|&K#AH(EX)3YlTw1UL1#v~2kTA@k7lC@)p~ zWkgO5tfHo4NvC10&Oy40jPBWD^6^T5NIY$hyk``o!eA>pq1?8Wqgrp%!28|Pu>w{W zBG)6W0&5eyA|){g5s#DrLgK~;oAV0nJ{%_d{$20H#^(+tnU=kobc0n8{aMTr;3LQ0!l;50 zwHPLwoVjUF5Lx}AHvFRvSerQv#9<6uk~L%1e#G@90~C~|X`Qx_isl`W&!dQEiD=C3 z7%a>g)c7_7Vvji@pf!@;kZ!I8{e;i=HO2bRzk()j5nRJn&26vdd5y2zcw~%$n1Gir zAC5bTYaT7#tU|Gky(%|^h(_m&{K#cVzgjLUEd#BiIpZZ>V3uPEj&+`~;y*?}Hh!%j z@5x%(HN%ZGy6!}~64TE}Kp=ce_c-W+lU=5$dC(OM+Fs$2ckRs|WZ189xI^kmbhwcB zd0Y&@AiJPr1Shy-QdQZs&`y1`CQZ+xmG^6OtnbM{&DvwOGdNd|-Vo2W5C^%WOwai- zC(HKxbV?CqB#(4Qzz#l*b2W|_72B$vYui!)Lte}w1ZCKwX8Y?ks#IhUJS>QBoGF4! zBV1T$&`Y|B7uCHsO&q4oCBC~9x>bvVQITtrO`zNYHEX?MzdGSD$KfBXBsvv9s2vA(onw zmdNw-lil*tKAeU{WLGrcV^Bd-z7u#D(uJuF$9HXt@&Nq4J76wRF+S(x8R;@057yHDrXI4ycfv9M8F=fV^_eyGW$tiDT6#^yWa zLmAfdF<6|}g^~`f`;s2H>w8Z8VZAOW=qVSlHEA5yKL*+sT#uW%rRKAWAhNBS4@VCm z<63o3uA}gx+jiLh>Ieoo!hibDP_T)No*=pVh2`UYvm0KXRKi-~3iub^`S%gO(rDPw zm}ubASR+w3e4}zYyPoyURY+s>92YxOD55@g>JN%L(>5Im%$eP}FbGDg=O;!ha+X(N zu+Nb%5VY~DQzrM5KddRy&4%b|pc24)I)&f{FXNlBK2MkxQy7QagNY4s5OP*R!q2mH z#etvQ$Z#j{O?S@fud|IVd3NJ*y;ivw+dWb6+_8OR3Bh`-+aPRS7Xo*JFDO#{S>p)? zW&AL!o4Uyns2kG!K^fUS%OEGRF z^qdkIceSnC+)UUHke<|1l3#&0k%7@XH>H$a=?WcquidF47!sbcT1M)qir9%&-laTC zH@|zS27&|hli)mS>rhGQoK~o${HL9HGE1kr^W!#Q>zL^&SS~uMlBr7C_#?pB=qVg; z@q?9!2UFI4Vu$m36(+*`#K`~_QZyIvJ9_fc7N(S+-}$3-!tXW2%I`52wHflR##lx< zcXO`lrPN_$&7~2qx>LUV{&#J?9ty+Kih2BGS4;h%x$0Gz8d>?8{jv^E$u{?yyXd1g zkJtc9e}9f_&EuRC-+4eKgVg?KzMvDsvSP66vZ>W@@J#^9e_*%=>B~LeqBc0 z=p#pn>4)?)otf?;Wo39uxu-%z0epsfJjh38qYb198P>=LK1tg}0f|L!=mvpZXdtYa z5yc(-XHSNx@3RA-3Q`z`mnQpf+VilLS#w#9 zbd#OhHE_oIleZ}tsRFGjK-KzOsr5K71j8ZEUJc_;z`-?j@{`UfCTs=tQJV_xkmm*f zHYAVH9x-4taKbUFkUdVV`!`ib8Cd1LHn_B;ZOXWTJhMb98{1t{=!3PS{{L zqWhdB9M?IaL~U=^q17tWvmAjBM6q1g;gQhe8GjR%<_K>Pq?35>9@eB^Q3kwYfzscg zU%VE&^^ZrI^#oZuY(SSnzl_j@+Ri&F1&e0qY6bYxc~b$GW7lr5%lMiOyFCDJ6c1J^ zu9D1uoO=fX>}07!VJ3Y(G`BWU2EIvnus^8#fE*;Y_All5ENS}WP0}mFDkB|J4>%qw zHdYBUU}h9`W29rb3m~}}Y_F88{%n*|op6v*CF)!IVFlwwscLjft)MQlRJVqUpV%!` z=#wA5K!>EBpYE@|=c%y^97pf`fhxuA=__9`CKHHQ`qp(-N#0TOESY0T z^EM{Q$^W!kAKabM&L4jItz~LD1^az!tTsIg{`@#b8jm+I3=Q6D9J7H{k5S}LO1F@k zzAPin0NZjZl7xUDqY;LLgqnv9n)2wE2)8OfSS9w102e0E4gF`?dp`j=7pRj+3q!Z4vmm_@lfib%Fp#ENvyZ4MLl#q<+ zFg%$z%E2Lf=_>^~e*eHfxCRaqthRrHs)I;ofG4%~d=9Yg;maN^0QJmwYuxSw0kTmc zQ_9f2MyMY5GdZ_yoEsQ;RPpq=&p^jt!{Lq0u&$Uu?3A{By6b&xQiltdCUKbNSC2k; zF<4G|o6#7KJ?!e#r$2G+GDo#o+?SRx6Pt~bKIpN>S!(B&Eu4E=OC;=o%yaGbjqcO{ zf-8?_{Xb*z6z6{<b^3oNyYfZ%-0xqGZ{)!!~!i-84okiwzbfF$0;F2R!w-F4wS^ zn{LeH*?)9yl1;Vcr^sQmGX|aA(W+NK3yNsB6f?gk1_v9f@0hu2`2!qVB=ZsRSj&-0 zH>Va6)Fkmf7kO?0*}ZQny{8~zKQoJgXL9DicIJ1vUXP=Q0t!h)qn30l9s$kC2|-*r zufBs!6YnU3RHfW=1>x47N7Z7OiA>k+R8A=prd)yAmQxTeh;0JJWVQG}xXcGSEEk$A zS(`^)C{xIu?iB%Q)?-tj)`>NPj$&6ZgoLJ!Xu_QfM&MKd%v6TAMbG~=CqR!Rx*`M4 z&Asjc=jsG0fgoo&JpE)RP0bmE)veokLK5BW>~qC4lu17a;Mugiw6f%=acynS(#SUW zXfTqn29&z-d+-=Ay+%NoA#=K*Q1^7-?iuwhs#W{Zo0Z~tn#b3oTul4i3I8$Cj|I|2 ztS~u_wP&z;|1(I-RscljEd3|;E*L91*2SG*eHMhLa0jR1ct0pLa@(hd zu>7}D%)#r9$xefj3GF~}=$bmxf+IFw|KQL>NlgNk_g(?+w4f$D%@ z(57wIUWfO=s%H?uw?c1{pnBC|OO5u2D4r8zCQ|vX)!LUOyz|Go-10w>>QwOX8WSD)fbI=a+EW}jTnf+TBny?uhtb8rxZ6C2Y-4K4k4_I=#Mb!*^4uS z>TSpnB*q0`m~3C-Z6FK`R^rVeQgENq(y*SJSog{PI4ZP7?ExGX%!tNm3Oy$u`4Lf? zJ5XszFy8Q4n6Z;TRcyh3%uRRPP7c^{*;xGAz&n)Wa#pQS-fq|8JOptvwuQdMz*`Ug zW#(NFH;{^GUPKX8T)rT^^8dhg*pU%Bo&cxR+2*XI~bwt3NQLE$ki^zX73GPwU; z+j`-BLl&) z-DzK1teQ3l`W$8vwF62XlDKsG&Sg1WIWl{uO5WwyAaNH2IUGGj5evYuh+pCqK!Lfg zG(2ktYL1q_usG{*5(LaOUA1u{R%+6lAFGY$ckFv*1L7R_T-7+>BN2LQd`O%f*v@ zyAEQZw=w+(%`zy90VJc8k$}!<^~1{fG>QC|7}Y4SJW0GwHLvm*Mm{1(7mbYH_fGe@ zzm(sFq4*w2NYdzGbxQOs-g0p?ioTg^ehqKt`H41A6+B+O&EC{@fDr)zfqmnJz)|>d*%-M^#?mZxW{5Iru48tbPT8)ep+D4oK3p}Fj(F1%Mgz&LB4}O2erFrS{_!D z<27wvG47VQBmOl zHmlwRWX_kQq?Fzpf+e8Hm4jcKSHhydW$o9+jwK!%(*7q*wqB8w24+g@iNMT2VafH1 z-IxqjS3O5_(7|n88mmZOs&G)Q2l+*#ncI3Ayz_ucSfncA$Y@TlR@Te#y#Mm)F;a+) zpqhr}p|TU9&xV~#b8MA$?;G5zTh(;(6mn4ckvsZn=GR8AgU=uo%+N8eITH$kdMvBK zTTL7M>Yg-TI0)2}3p4U4jMC@WgZg#EP&Vi>IxD;seng6O8>T*Jr>kvDoN`LX5*xMr z%Szu6VvOw63R4r1GCT*Oy?2t72UdJ zGa9Fu6FUQR);m38B!OzwK&))nk{Z1@=ICFflH4bvbyS#>XgJd~BaF_5yz0hAd^YF? zf0j2}4Jg^0SAD9q9y{lsvevdhv70fx4=r=8z1fc?h{?7b`K9uVwQrG~q?V^8GPRl+ zv1;j8;>7xGqWTZ@d}29yLMn+zf*>RhR9vm}{UQr@i0)ntsUwMsOz)<+AMlupuMl`eE#xS|C_W%lp2-_f;$B{vmG% ze0(;Ue8mX037XddnoRj20ico#D?QN3>G?z5wLOBl7|+b#(lKK^4x}uB<+^K|6)4$E zP2jlUR>rrz2YUG9C{#u7En0wTbJ z8wgcXA4HImqCs0s_g1cMwRaB}BhZ^3UTI+wI2xF0t4-Eg+8KU@NOE3U`Yz>5DQ3Hu zG-9d!MnMYX*uy3@DceN;+ZD`Yv%o`Le>>?CQJ$E@)(CTCbS^ey^}$!!ti|#O39IdT z5pDv_n{;`7bQI8X%3j2%T{gIe<7o#aS|M^8_OQLN4gqz*9otM#rp7&4^Ev`pNm1lg zp~Ry)&oYuXIw(~4I2glOQQnLuEY#(^+POtAiMVuH0e&+L(KuJ#Me= zcoN7QlrcJW@YZ36S;q|6#OveA+&BewJ%euNb?D+8iqT~tp0I^v>nY_(AFi3zGGVjV-jGeI7|NxV3n>@MyWC3lkjY+r zWr!{3GMei}ux9YFd$l3FH=CO^)+deMBF(|}>2%~r-=@e=F|b<%cj!P5!!Bc{S6U%F zMA*0qZ7^0z_UW{e6~R--1X$dOaZrQgJ2Pno0U4Gi&{v?h7$QwHtUe*dhz*>n; zLe6*3&$I?V!Yv;6DI1DPi99>$x)hIO@4J?gGDrm$|5H7s#<_g0KuDL8Tx4gqG z<$%$sWitn8WigMrc~cun2sozy_N1bM-1y%0(~6tGQ=Y+eHjf2>!T_u|VG95jw}z>#ipT=?AtDzb~5c z21OIXO33MmxGNX7*Q-O2At2KR768#Z3%m_cg_gIyXwry6sTBNjaJrp-O*~jkIgW~} z_qZIeUMY`4Mz+*?J&9Im12Gf#jx$#{3hU>oJ0{>FYEGUC${OptBo7e~CD>7!1DEQ7 z9-IkMjQypz4vip^U;j$O{by%WNUs4*LyC6iFD@kqMjs^$Dq#;gUF_fT1(ZxZ1iZmv z0Wd^}c=3WMTZ2u!9V!UR%G_Vm@-J?Fx2FW4Z2l1<_@JL=Szb^zW2PXlT=h-*T%bjD z@2to?0iJMC@d@sd^8u>0dmar7XIfwaTc@Bhm(bcQ+gE6T&0!F4Z|r%Qhc_+kH1YTN z!ZlL%{T7BliZc^nFc%X*yB(JRPYZ3Ia=BR{ca82RAGL$H>3lm_;hbp)pk@9S$6pMf z%G(mFDgX%1 zc!WX#5@}&QXM@4Z64{(cf;gBl#9geOu5qbCrBVP7PmX7?aYj_2V$a_$SvVgo*J9Tz zOuNwjc9Q6<(|anWF-OYLw9BwBHu*lb9?gpejLDGAS)p?TP1#a&ztL%VZCZ$@-ypz# zA86o=q)Vf&tFOKB5rpS}uO?%O`E$4M#{k+2KLHVfZA0|Rb&lMeuMdh1>1tVZ%Z5&| z3fLVIL)h5bg~IZWjz<Xr<1OQgHwABmk{% z>3sj20`&pM)j1nZB6^2}atpsf*NvO%gi@VM$G4iiKGGI!-T1x3lC~a73JQ!Ts6rtH zN=x>af|Aa~0uRIb$AwK0_2&T4uDWI|%xj(211YW_9{4b1!>T5ZA?!6J8|qk)SvLPk zc8yi-LT%=PVX@RnU#ed*$ZH8S5OE%BZR@!C#1}@BV%2j0?yOUsC$>xvVG3aeRbZ&X zUH`HxQl)2s1X%B3zaW@z5*^>3Hq!Ty3w1vv5y^P9n!uiR0nz;l%7?7F_aHU(=X~5W zZ^CiWio4DEj2#Im)bYMj{$?)4=Jt}I3C>LRW+qBqv-4B7GfS1F6gL2jX57=@I~sN* zyZ7pP>Vn&GzcXYv>ksfXk=rp6kRxy$E|_<516?W3vYaYFh9tul5^;IC z!8_0^5^zB^wgQ6HZi3r(oAuhvFci2=d06kgiK#VTL1uoBwUAJYbzaO^9G;4Wr#nSZ zZh0;`=W?mIOZ|BLn8r=!crq5m`EDPJdM|4IOjMqe?!hv08vp}W0%S&XYeH5>LfN$N zWhaf0&ZFH!8$s=gNl2Q^& z*6Qo=3hFFx(Hb5t+^przPGq-@1u|5e9d>T8E>AAs(1U~wqh>!)q9w^l*C?QO+EX!I z|CK?duou;4f<8{IOgNN^UdLb5*sA-%@B%873YJ_o>7AZA?Y80k6!4eS7MKO7Vy!nQ zUnBVYRCZ@Hleby1Ie72F+?m8F1o~_fCzm35Hc;9~Nvy8>8*)4bqMStC!BJ3v4^NB{t?E(Xk1E%%Za_4AO zgd!B|b4HssUcqc#w@Eoi3 zRQR4hlEYLM+s%(M5=q0e)QcV8pJ0ubi!u?UDs=Zuh2UXBnGNmRzP{OZRBwSF@`}by z)Q@dSN>-Vxv*as|IfQ^qc#$EpDu2xeh4mt>TBCK=4ijY4r?k$p8K6)lUtvl(>v?T7#&%Wq zpzH%$1+y3rid?XL_I1*~#qaJ7x)`I}2VwJS0>ZT%jYU_71L(lYm8CZiV^+Yn zd7HT);+QuyP#N-Sjp`y!nq=(5*VU*6!k46Z!wqv^g~k^Q2wT8iOXn;J>R3iTW;>CD zAmX7cBHs=d1QH0PTL+m57R0|Dycv&*EBw46zmmzo65*}8-m~uJE&UwlzNwfJl#}4p zByJfaMO6X$m+0@e_F@Kctbd$T22JyTk;wQpnRu$WCMqIJDy1)ce^yR66}Wo*V=V39_ICV;l>=euSi>zf_SEVYGC z+$=wzOY5a3}yv*I!uZSG`mRC`I$YuiK0#nubW7bbJ{qMglryr5L}m zB$uxqvYKEPk%pX6$8iT-;BYusNJ-)bfEJ4JE&q4n?i}8D{ob!ZIk`M4NqN2A&H1t! z!o+|?rO$s72uWu-E?C*cqEX+D*9PYehVq+1WS<7qt~+%N9=Xy?xZVP^KxGp~+*Fh!@=q`AS(CrX((>%^ z$_Ax>_Wy8CC)-}_#83qyrl^)N62*T!SlM5D2RKPHps-P39nY}OJb7VxBB ztCj3RIkLFs6!18(bcyPjj-!<;Y8(d&;YzP-WbVr9^=f#|Avj+opyg10k$>%XJK?BS z9hJ?;%$KT69P3L1VUDu~3?Zb>rz|vtAcSv3|K04v2wvrcm4vWSg7&M3YqnG{ykEVY zdbLfbCN?cV%ouU*qgl63$XG^>Pjk&Orn2POmiO7f_YdBR;37XGMrN3!2wRuA!j!-0 zPYFXze8z@2WSSldxH-&Q^;GXcH^8WS(U(umxcnnqH{f?JZXr!7e=5NYK2)+;6~3|J z!yaj>Jx^Oh(TA6~ehl%Btv)g~&r(N8(uonJ1alw&#*$F#HUvU}#LvNc0po_8*_M)4 z_QweN!b}waVo(kpF(7Snox*Q=_4QpCXN@C2CqCsxGwhB(n6_OG7Y7s#71p)3h>_T|{GY`inc4QQRMsN^og7q0w#Kd^!6K-#80 zn^hADXS63=S>3PTKP9c%b9EK?N4 zaT*i7Stm}5rrw5Be^{n^_UgJwn;~BJC0AzG)~0-Iz5!Q(x}vmjpbpbAbZRI97&4$- zAQthsfS8Z7^LaFn2t;D$9MPp=zc!=-#^%r>r|d;i<9!Aanohd@N~-Q8KcSyl*u<4=@9VUc5?Ro1{O~Jyo3nVsfvP-9N=b6nCG3ZkFik)(li&7S>vZ zDZ$w!rpr}Oc6Y_UTG99bx`sbCnkx2~iHrhCk^`F!!c6d?WNA?DXk(r+$}_s&OpdCJ zPuiP)dy-Potahr(`Et6!T||ghURKbE&!NMPS$DPuh8p?468;+ud>JaTR}Doh2;*!; zg;Dl6t9HrHaFYZR%YZ%l`UC=5s@6Sar1F6~TDXK*8sSSHV)F~B+pJ`skQ z1r2j_jBqM?!6_No@1N(pn!c-Z9O|Z&oGGM+7`Kx6f zVRI845Mqpux+ph^s1WfU7!a|2GKOxC0!Ck`>7{iTVY`#m)5@4OT8&4ki1qIz|M=>KLS&it-tPeG3V;nDL>3-ErV@MgyuyOtMu z`W~)o*2(gyfn7qCaBk6is}<%>sy;H4XLLaO_!aZchjv$Jc0}~~lC{?Pr$ARau_Em% zBc&=$n^WrP);Btjlj`YL6zj=k&kxp3jQ-A5e?r5P1+cXikC4ViwVU5>^{Vo)j<#aQ- zRafUHO{2eb)zSLp|BnA0tV{oXhJT&)fBsH)_lK@J8o%gj{a|SPulR58zoY%4qwe!I z#!s90{~Q0A=sxSNervGztIz(cRG0r*-uw4(XV`vj_EK<3%vSl-2 z9DZUf(inQw*Vl;j z!j5O&N-Ox>8-L7XZhPi?*rg)6s#R+RHovV#Phf94*Cjau>PLuVrnGdhIxQH~JNK0i zeNC5vH++A7d{@tCa31&uv-e`UPFg(_hOL_@85e!;qrcKJ#bkq$` z<}oC%_Jh96>RvX+zssdMrusWGeN=Pr%^%JrUJE<_1biE%p5S36^EE(jf};AxpWa=_ zyFA>QCWv|KXT!s+aIdjDw%c9R{^8OS?cmyXKehkpMl08$}@N1{|ND16mau; zOY>Q~wE*8fzYcR>qX7E`VsEwCeP@N86M1(O)AG8jPSdyasf7^(>|E`VwcH5`YnHCo z2T%i0=G;Vx@Yk*IDxcQ5HoxCQ*_<};Yq65qCJRomZW zR=(^lePbS@{`S;jamfQmH;-}e+)csaM>?LuD@RP3SbI}`Q8^W8W9Nt#s)PLLgs$*c zSX=yzt<@+DWFKa3v)Ht^hXCqeR`!%=uP*KzQf_t+ysYnj%yZC?=;NC<{vKw&(RlW% zC~fD5vpHYyaONlpqKaqEBAL(%#*IF|(D9<3>mArXOVu+8PbHCzZ{pvMyMcd#+@ka# z+UT>hj7}qPJe4}2|pq&~bG2 zMAGQ=Gd#Hr@&pP#+i6oIYzAU~R`I+DYy-r?Vju=hkZzrFHs$R=8Du?8(OIR_)`(~q zcyGYG&LSWctHwh#&6_Zzt#~xT=+OlAkEW9YTUGWp~imz99+uQI7|=70UU zw+_vIfA1=c*76{iOuxcTtLRIH*ufbh_HhrVlgcx&2}$W~Fs)d+YdhZ{2vxa>=|iz@*D=oq^L2 zV$1*Z%R~IKft9~Yg3#Wf#viL7A@gPZ+d8s3o_NjRM6ShZU~UVH5Z&l?%j`i@q|=R) zL^U+my(Ia&w(HI9~kzQETZjTyJT+7I~PLrj27X zX2dQd7s6l#1DS^hYB7-keVz`oxSCRx8%u!bMVh%(7Uc#(Y|9m=!A30(1G>3@i;FaO z$;$30&aCJ`GpQrzj6JCB?)N?$3iUT3<9Mo@MsC_M`-o`;n0an!jJ{m)uPa5`c7mMJ zN11pG&(J;&5-#a9Pm{PYT8a6Kvq$3N^De(JgRfP74;{hs!1{B7|nTCeO9 zJKUX1cTa+P3D(W#8S$?FsGDvmrN^Gwd^C=t%XB*EEJAi&7qJl zqe%aB8mswuJ^3K4_=ifNIX5tMIxFj!by^W*knifo1~We16^z@mBMv%rR#XXFgmC-7 z0J)+M%~M${RT!JDVRe3OzHIPnX522&?^SB<$*G9MZj!@=-o3VktOP|8hJ3Dn3dZXO|Ix28u9f5atvNK1sZZ~bd{bLjP;m-ZkaTJ2?Y z(M<#Y8VrzW*pm`BAZ_*w1b-jw7ZEa(7~`%X>4Z)yXJFaibNJ($T%K*~=<#KrYja-- zlg)Q*a+<}>N;38zM2W)X$L^IBnjUb!#R%3vH_C0rtcV@ntt&m4Q>9PVE?10QK)ahG zWjm;r(?VYhC#F|IUHvM|!W`BYd|5J60O=fCP4zM=L&=^{uFcRz2&Q^?-?WTp{!szb zCQT^)DRXf0Obep+F&zX(aHXP5uI-wUrL78}4X%-m2F@}=J^Cr@!mA8QY#OPxez0OAWcot zHO$4kI=$4;x5EIlUYg)71?7laMQtXWHmQ7Fu`ljHf*#1fG|x-iTJmQ-OYznQJ zNylHDPui@eE~H$W>K|pS61M<(n^nPr1O3r>Y?gYbcVa|q>@_z_Br|8PMXj{jq*tYFdtV+eUZQD-8wo$QD(GGW67oSPIHhlh*>6XU? zk5N@{NQMAS)`V%@;RqVg&4riaXN8_*N)ex!^T?U9NLrE%*|sYSMlFRk0W39bZEZ}e zfaQZej_JbBz&%`RTUQ61Iz(=7&r!1pOt}uvTB^rEPA<;eg@Z<_Fs^yW$j7e={H65? z-#Zitfx24&X7y3t%eJJa5*E0%L=U7E94xg&*Vt5?-`Mnvvr7>;)k}hW2xEp&$4Q|Y zL(f+FmoC@a32mLxJ{gHwvNJ_Hq_V|DW^^}3c~+ClcQ^-Gcgb{f^k<=O*m7t$flCcr-oCa4y{KyAzBLLCfg@3CWW6 zIvO#VhehRh1?EC`=-1Op`F4jUaks}61?eFmcqmGwxk*z@M%f|ZZ9Y!L)?yl|eSf6s z`6#VtMUqO-UsAI@iSZUv&P;fV_s2$|^zW%hQ9FV^S%4HY#voswY;rc^Q-Q$uNYAVZG%m;F?w;=D9Obk0-?lrOZ57tN7!B)J|ubG-Znx@ zI~`(C19EW_rm1!U{0Z?Xrb6E&HM5u8PAB-qj%M*fLaYbj91o*+QSbNMUq@wCc!$Sv z%a~x+WRE`l-7VIw^iH?GnA0M$S$|R2;Mgj~##a0hxotJ9p>AI@Ya0tHlO<=QTn!gU zPOXyTe_i35enJ)D1VDge3J0Hr6^NjZD3U@BSZB2IRzgcKSNrlrTee>rnflmT94_#6 zAfN~(WBg^vbB^a9y$@xc!Bybz51kfOPUlMKCp^N;zYHVPl7i52QF+2fucD*Gm;OBQc90BV2yqS9PCaW&j3w&$+*e4Ho-2fT<-TwFo1ioMWd#Vrk zR}=Vo_xZvr*^tBDf7WGH_9FQHqUoPr7>QzlaqvLA)O}pVt zZ!n#PrE)s<6)t$xy(g+sMq+8kfBF?D*6Qh*KGO<%Ks^^`KU&)EK}VU3V03 zWOYQeys-`^_M_#+nr?4ik~_jrPG zJb_w;k24Gd*A5FVBS6Pl@<7m<|JK5Gmp|y}`g7cij%B{3eDoJ@4|OU_cTJe}%vlr# zAYxsrYO{*Qy-R8;W7KBMijtX0W)LqTUAtl52<~t&0S_{ zPLiN>>*7@4w=}+Q@x#8NR|++~UNDM}`R~FNcNZjFd0y%AnkE4N<#0ovS;6g$2np|F z@({6jcTO~#tWhhzc`8s09ltd_^DhW+bS(IO*obmGgig+F#rv zACu%~To!6-F(|?uT_~p^MQ$N0eoJHv@>zZBfkq#b9O006%VG-q_KI zC+PXq(;=5TRX~kjX^b>M?8UfzR-I{D8SQZ1V7b}4wB}y$3$jN1iuZ9fz)vmEdrM#k z_VXCJFBEvpV~y1Nc3-N;Iz%GzJZ-2hxHvV zJ(h)5Os@3mV{VX;;`mmDCvCsKytAQTS{>U&;Qy~F(Iwra8hLQ6vd~)o(P^MuSfkb_ zSKM*5=4xS1lluvWMCjw?@z&DgY3m%cF(s5gc;<8Tr<-7GAk7}uz z1z~YBclcPU5;i=OTPb`++=fkFwunsjku3TtBw+Xq@vNDK1v^H6#(wtLCPnhz!V*Cz ze?I1hN`ml=*X@AH(ya_QFeg%(=`3N&6iG`w5#_4AG$%gRjy)Mr9c}hXxIpQ@rhqVH zqT79ocC5_MEy)*LKDAUbP5YH8^ZoYbX+I)@Wb69g+jU#G=IcC}wz~pm+zjW;x3piH z2V@Z!tZ_VXvZTNolO?A+NV**8yUZ_U#|#${JYi0QUBMlf};d%`WH|(}K9)CD(Z#hR$!;8Zf(4oUZEPT|e+^QL74?w!Y;Ep4B-d&Xf)Y! z#OynBDFoyuh~mDjI+|+lC|F%Le8=eYxnA_`sD8OM$dy0F&Q2Yum7D z@~KX;sPFw2>zx%75$0BDr9U@8g~DVyXyeU@%KBgm=}jCOC1^f32pP`?vu{-fbdC3L z@Nj=w+MH(Qf#z%KGn3aH&}co{WszI^!x|?f8Qt|PI;ACXyHAWqyIqu^{@1*=EU0kk z*R8kZI);jb?q)45-vyVrlVPeG`SNtddH8VBc1mxkWj2fu^~axwVgosa;|DLZ11lyb!$@Af zchV$Y7q{3+4sEeFO10cMyv_B|0V}N+d$RRJY#P2^XA^DFhMpO_*k}h%e0RC6VtYl| z&XTnoLG$k3(x-e_>^1{|T7C4!CoQ)AF)%4tlQAvk_Fp1vtCL5kwdaiPKk;cCz80NZ zg@HcLHxmI{zN_6E(+})%ijp^Ck9@FBK^$m((c1JFKNy-;U><260kvSI6~Rm|yAJQ#YDgJ_U<0N#x{r68d9f&o(R|D)6Sc_$gM?_~z znuv8NjnJl;PqJ`8__5QaC9;$~ve(gD z5FFVogDMj%7aL1|;Hf1;H1{f2og~>K88JLVhh411^KsoTLN?TW9F1*ZQUy5fAbqagJ1g}M&97LFO)onV zKQmoim;7qHjJ)_Y7+fYGyGXSmC6>*q)1}Mf0Q!n^&~*>OU`YtyW}~!~U5st28-7i8Xq5OF35`pus|q z@X^gtJzPL8$UY2ib5dFgV@e?gYF^8x#?ZrHu!Pl3;|ZO~m2P({1>WCIUkhCxy8b-R zTfVxl`#AP|at{0iecot)PPblf{hK}%{>=DLF-ZS>#w&RySwg8d2=se=3S38V+*%#} zd_d{>{Pgm}`7Wm(Ii<4GyH(EJ$_`zgm4W4<1k|_;h}Yc02WPkX4VWQ>E_LH$su!$6 z5|||Tfs5KsR2myT$=X4LZLO$h%_WbqTq`-865d!`aV_h!kHyfvQ4)z=pX-3J^0iy* zg2<>lDNk96n#+uqqz<>5xOg7?lT!tXQCW|cA6wtNPq#BRr1J`LDM<$N2oY26`A?ojzh3`udC( z&)1ax-rLkxsRoqRPhNnlV}wfY@R!8`GTYP$&al=F9>T4h5FffzJfh;+#=|Oj0mma# z_XBY(VN5lFl~c$tu{r9kSEapI;meujWJ0hvo!8o7}mLD>qhIT!e5xnClt&sgS z%&~mziHcaRC;52Zd%xAZp8j~&3--On@>AIfAU;;V7%y%e6_7>Ole;k6JX}Dmx7A?6 z3s=MF&0cv>jfYD2V6mk+7NS@-$IaC@*9TO`6RI^o+1C*xMSo+ZuK~AK({kwWYh8EV z${s<%;p-%F!LMDqGO+wz>?*;2kz+A1hg{lWDF5@$2tSZpbC2CWZ^;$v1OXH0%Hi8nB)m1S(Td45rAtte{c zF}7A{6PiOq4U>o2d`?_doGFDr#&k!0J8_vBDeAd+mZ?q1sE6e7iEU+Re$mW>2C|85 z*^gVg5OpD|v@iM3wJ>JG1GPT)2=AW%?OZfTey<^oB8G!b_pptLR83bJj+Lw99sbe76gvnWDiZd_A*aI*?-Q; z$2#0pf241^T|}n%Ee;U0N)dGJ;)fqxhUNS2lFjP5gdjS=v2vAh)*#u2P&0F@2J2={ z$?RL$em*&??!OP@;2d9)UkD4)*L`8iTv*M3A@8QY&GA0IBTR8~{3A_@9z z`IaYX^*J;uesz0fw$S9=wPc0mZxV+Q+xF!qzQI`&O}mRWY+&=HSNzxP_){az_V@>{ z2E)tE?81J2kFV{m=fI5Xd%#DweOkuh{l6)e)H%79ar$cJ`a_-*I`N_%Uo^C7e`Kxn zD7?M9+Z}b1YPErEDbM3ZRYC#cYI648a=)dpB!kD)naZ&pcTVLouFaqd2P~y?ao3z` zyR;~L?LTU}i=22Fr>w@CYEqEr5W-HJw)`(u)OTT@$4o~yaQ)!>AZ#pJd2T21P_ z%=n~Atvuj?4S`}|Uzon|gWf=RWmwa(=Pe@d{c$nVXBWjWpWtBA8?Qj9d4Fw-__BFT zm8kv5EMw&pbImxfsrn*sMhlv$Q|YACRKlD+c)A99c|~Y8rU*@*E4s*}fM*%OYE;i$ z?x^bOCe(PquAq{|j`9t_<=*?}WXkK;afcXmyg5PAQ)EnDIn8D2xXhYOT&;RF_joh3 zh9FS~c))Vr@XF=Eiq{MmjhZ?oc#d7rppmAv5N!k+C;BJI)DLqJMFv*QXnbjt0%29}!>A z$q3<|O_r$wp?r|zKHSMtFAmde-T}+K$d4 zgkgv6EpQ>h;bgHBa!lvOee708a%GH5);W`U6ylr&5yl8fW~BEQnZc8eEaiJxEBzJF zueCOsQ>dk|gk%RUJfA51JZb~_xV6L6Q8IW3iy~?m;ooyOky}YsTUVbI+0vmfl2_hb zf_`l2hP5(|afEV_BY8RU)bJU|ojh0PJ=aOvjRbB?MPAZikBza&~#w-AjeF?Yir zEL#L`yX&>M24A1V62k%W!*iHTuA%z*i@UCr35GZW9u9TsAFHN&lOLlaclHt;eOq5| zA8>p1h_VgzdDH9Mo2q_R8`l!TX{{A6kajTyuOi+XnlM5T1Xl<%bD@sQi&ynpf~tdX z7?zqtmdl+pjv)Moe%(pr+?sSg)#d9%M13>pyrV%{?Xli5(gFVD+0+AvsIJIWdY)Q{VIa4MNW$xult!Sg_6ppX zeWbR^=H{|pZ0rrzSO5fT_l!!eE#Ax=#UN8Xlp`N;K}!h}r}E4!?i@R;5C%f@hmHB# zNa^ZV2=t$R%MeNl26m^-wcZI7vKiaWE6BDW0d`~m^-Kl+hHU1l+ z->Nd@wNdQIX>Xo2cyW=7<{K&Uch(}C4whF2n`wiy74m&s#jC&ro5!=ui2Hn!ZXPtt zz%OY_lcXmQ?dkQg@%`c=rX}qa%6d#LnPM0WOLUn=wd%^WI6Zecx075kv^n;y^H3n^<5Gwo5b4I?k@~yI zlNjuQHpVKA_lWXGtw=ON^3jb_bQ|i15_}Wg#vflXcQgi5paO;ZbKPFjsL6N>pyOT# z95sNMt_dq>m-IlmJ}g>x6o)n<5MIS`tMCot_eu3f@x(G zS!4&WUiy|(=vd696~EPR5I7sdk3Q9O`Tkwa-rWan8W+qJ+9sOBXt?MR)?I)dN*F$Q z%(Nm4KY?|{EIWWRPyOjiIRZ!a$8oVWJ1Jrm)21q%@e(`J;yS_ur-k*XCsbizoM2@yYtBD#R`e3P&SS&; zNaP`IUZEyGtQwnURwjYWJ58R8Rq17me$IG-YE+-Jb#Q@?AMKZ2_f?z7d&1{Cu~C5v zbnxE=NP?PoMvC$$(`wQ*X4w&|8`D>L!wxvlnNBlFL7FPJXv}}+jG>+?qBS8WJPkLa z+Y_3S>!~WSLlhT$!uXW(d0^?~-uW=SDxX(Q8gfEgivLZ+f_1Q>&Ty2IBg)$wR^T>= zaM<&ulo+_6=n~ax6Kyg52vpbu=th4-heJt%+^*nbXCnafbo98_yxsk`+vV?}ZuZR%~&0PxD@q`5MTvTv<|4r-pJTtBo3K&r>5Y$|(mA9?SXo^I&FkY& z5xPW|e1ILnlARJs#Adw5HgFBaQS0Ei%g@uGqr7-?nEye#1KC>6uMjeuRJuP_fj>Dj_=uAo^2E@PZ3ho5sp=D* z`FJf*q{cjG4iX}4AbIep0tj){EOb8`i(-^7B&m8-7GWk^t8~vGC}di-8HEqVGOH#! zqE8zvU>5JAq%7Lr7G#P+9FfLARkEZzyTGz7==aRK^phx7l%L>I zm*4Asa^SZ~aqWOT#!ZUh;;WQSuqI+6c#5t$5a*hEy}5*R7Y~$_U#bR+3M)VGj^JIh z$&oQ2US&bFmm&kuJPFEZ+|e7gQ#oYkO{p6&$*&s^L8Z)IN zc+SA_mns{$%SRR>ym^y1KCv%A|5T+OOMyQnR^Yx=#oA!m67C9kALu+Lp5d=w&j3}t zHU>Bt$vqQ?I)46UCzbTgC5jg@ivrVbR!Lvuetu%10zG%LUQne-VD!4IGGCCgLR9%H28Zzds2@dHvYq}Dui z&Gt|uD;!?-y9_(UjJgpi%Sn>p_qrQC;6o*w$FThm)SsEt?(1ojNSw!M!I4&c zs`vTGES28)KHTwxsfisoK7FgrZw@Pl9%b<{;#} zOun}lYdg!kYyKycoiWj0u#eFBZR zE2Y=voSY>_i7T-JfbWMg$7;Z7%)_tFtP& z0R$`#Gux3b0td)--3$LF5*1=^q(-t{Q*h{kq5ZuG=)G%8Sd^=0Iz|-pg=D@8dliQZ zj2NtHyTq6ejQzW?kl+uv+L$e0qvIfV_g$-8fCh;-$i$-s3|SA#m|XZRwth13!|MXX zvX%QCWg3)t4U9H4$T&DW-dsd*Ry6s>+R3f>gb-clJP1wE z*1geNl6)nc)I{7Ua|!dWI*eGkn<**|OyY+6??dhwZ3ze~|l3}g(8#qv-GLN2G97ayR)N*m5gKR5bB1tMBx`o|@`xiOzyY5RQ z8zOHhA-T4Xcai>k3`Fpz?`5|@YFd`PPmK#0E*qFI#U-(8`uIK(n{5)}8HQ>5mnkLY zb!)Vd_QWXyIIgD-8+As_a7pfyJ;4_dJn^F{a#T1ba+&wZ;hU>3i_}@DQ<`qU8rDCzdMzlCJ@P#EAX!`%N~YjWB~qX!5l{e80L^eDE*abQ2{tKFS?|Z_ z{-7ku?9sRQbxZCYq1w4{QCG?OZyoq!wu+`yG~M6rcQ~uHmZ*=G zzr`SzT6CqCXhrr;HZn`u4s8CimV3K5%ZJg?T5sL2ZoU@~mtsej39S_vTr5BBI*U!` zUJI-@wB1(;d1v2`KX`d6{Bp%2&vHpI={9lw_%8VTE@$eyK;}6I!3TBeeF%2Z6b^>U8kaU6#kz4L{M(RMY15^ z)qgXHcJue>`Mer`|C-MV3re!J--~@<=x!j;L!pJ*%8GQhB-M3Kpqs3}oNoSZRW}3X&d?{VcW(H<^ zH1i}Z`q6gAYp5ZENfGkHs5DX`dI)P_dmT#rL)!7v$pz{2$@K9$b4(Zd^IWJt0+r$J zxSHrD8=>>6-oI{AAYq}of+)BI-+%Q1pbb~w>o3VAGe7g0_~2KbKQw%F zpgMu4@K-lDmB#-XFZB9YV*#f zTE%=w*1(+dk4KDt?_uG6&*eO_S+1#lXKx+ZvNxfi)z8=jVDQ% zwfj`!ZH?L3Y1!xn3S46D=ReA!DRwYyj#;p3WfZD^8%~qYdF44l_*-vhTdS47Wc37# zMTR^qQhvDf!=rKzyO-3JKx`0?iTUutEM*6`I(=s{<}Z!KsX{1Q{AFiVV76y%10KG7 zstIwW&5;sJqp=*-0*;sXjg~&ouxSn^(fEE%H(v>v*(Vwv+G;6h^PQx7V{`cIS|#=m@OE$cAv83z@It! z6i4@;W5Md)ar`kq%ibkZhhO*4`uJn{A~YU7Pvd4SUD=zt_!1Sa%GBnI3DJr1x~!Tb zg%|(BUY#X*7v;5Q7Z?2;D??fmO3mn`gWd_}7v6EkSDpzD?>y3;fH_lubX7E3tj#F= zE43s=2ZlkMUe@5R&9D1?Wq-`WfZLPV{1`D~`IpC12l-FAUw*>c2I|u{CtT- zn#E1Ijfs=!M)c$xu;4R46W&F6U7jZBxdH~Yo_&AkY~Gao{+<1ql!58b`#WkulTj_k z+GIm!5XQto^}dpBpS(FpPr55-6J-{KDXXsc2~31)IgL|&D7MN0-TSa^@Xneb#uxnx z;Cg<}knz32Qdp2zqz&lBi&mLTy=~grIK!2ok(|MX!VQ(I$w;L9+^#MslEO&~CvxPG zYa7d{kw~ELwz7m!@BfH}pGPrR=KH8yyWq&I`iM}IGfjto-Q`gLdN{r~-S_jK^dmH^4wn|w~?35iJPC!Z2|6(1(z&#mi7i#pbmLt zPu}D**K=AP>vC(-0%{||JJ`^Z^22AElp&yKqe=|7e2mp-m2#ga7W}SlB{8>9A+uLS zt(PbO;3=|c75~WMq3|5O{T|~BWbY%t??BgFur>9%=JdP7#(#1ZK99K0zgOAzUhQ5P zl`KoVSEO%*<377uVrqf^P{lL@iR3ppwqvizq++WZIv?8E zTFR?qa4&XoYdR+v<-F}WK}dBNOtBAN4mFIwT$pmw9i^`@G@JNJG}nqwR#UP}xgB-% zBU=eo@dqKm6ZprLPeHdZ+-XD-vFcsjPx^3deQ3kofpgfN6R)|)qmwga+JpKdLlLJW z;rjA20>Sati{QWW9e8seasRrznREOb4rH)tiJw?NnkSvxwR-Ufo1N&-K%y^sAB0}B zOA6Wk>mDHmYHhuEypy!M?Vjid(MCH!t%x@L(=7Xw@Hx)^2DW zI-2Pc?+0P_%&~Z8bt6fs#)Xh7ih-GQj?pZUH>g%9 z=X>%&PG71($H|{1*F3X#bbq>a;L&?jx54a&pKswm7dt^TTLmcFpRTNJ{4Co{-`fM8 zbP1{wyCq08DAx?E522B+!O)gdHX=`-Y+0LrVhh3s-hmZJo>>W= z22G9qk)k6-yITa87FXQ&<+TyHX|p%BIqVGSzVsd(bD9r zD*4cZIoF#_Tz~vCpXnyp{n_0>Ps|V{{TCvgekDzZt~I%h>ra1Vdn$kweQ0VBX}aMK z^+!)Vi`oP0gmeW!#6?eM_dl50!xHP&+&ef`@wxExY_(Skyuw_bo>v{~lg zDIb1A$mqxI09v({ zTKZ{b--^y@dqH!sKOIh!k>mtw){aDcjKWvH!pZoIerH&M6hMBa%M7jdx0H0l6M6S~>u&bj#7 zKi1Nghv_O=MGyXzC9c6VbbP%rIpCjL-7;~iF34fTKZca8mj!tvkhXO$?dnL-0XCcV z%U`U_IP98L1tuR{*KQ6N?`6SKflh|GwgncMor8YfR?a-3_eLVABkxQg5ghd*j48zF z<3yiq{869g;8@SU4uzL31h2Q|fF+$+-r^-be9Sr5@R6VjDFJD1?;%rpJNa|z_UdEq z#>w_CLS7fM{^%~FsxNd4%-As1BIcNBFNU*3_lF-J8yny$<(&4kt;U<5Y^4Q<22s(a zp86{>grZX(p19drHhucqOAiUBkf-wjAO9vGH9^zM<{|JlGkRU=g7 zL{M!`UA)!lvH;3GlDN})}R9j=mv(R+$p?_Ah;(K2r?BXeC}=x8Q$z|CL` z5ZTh@mRYb?4EKIekBO$a5;-8rC-dPAYK$@bGk0hOEn949H-yb4!p~F-wOZifHrLJ2 zT?FtmIb%)>9LrVh%lm^izN&^SD4=EFpT!9HB-Xw|2z=gOUq(41p*06x7pOOG z`7-sSPf&*i(On?gTj@XzRu@EnXH0-Z21Gv0d(L~8JPg<}i7^(JrT1!iOii)de+hgk zLfP1M{1fD`UU}GN`*1p{ity%S!OhwW4)scKgK*cPDHa_vtkk=QR4;3JSd>c%4kDRB zUugpI+BT@vbuh>dc8gYgDQo4bna(b$Wy{!+<+afY|&O}2g&vlB4DG* zG%F5+54ZKPDKS(ZEAU(=RJ9JlP}Givz}P+`bwsz*-=UfUk#C9$_SS0K$DKxo*OWqc zVWVLG!2aZBvLESlakr*rkEnI}%elKZaSdYyR8~){=-}E6 z{Zd`KD~r=e)N%R=(-~IG^;Zfu6O~!29!YcC+)^LuUokJ~FH>LhJG`JZ&a|vE3Ceva zrMleoeh?pVW_s@sRqAq(Ml{p#85qyRGrDV zx~e*;GlMbVSa;$rApdnBXt%)mW5f3)f6zEUg0hq6jvimrL^@~P!>_kxi3rlhYsU`i zfi;#|prh)njj#j})C|UsCZ;p04o0lA9Q=|Esv53c6xR$R75$^W8**oUy%HwzT&q&1 z^dMd0KDN?Xwt6?RM4A1C!o`AMJB0-xAKEYQcG3U1PC61>0>E5=sc`wRkTz)|BCHD2 zYE%uCM!J53{Q>XyYcM_i^mQ~LWp$VWG!Hy=M)h_7Fw~#sV| z#+&~mC8~qtwm&>1x>T{|f6DSLrzv!Oz0)4IGD9xk90mIumysUgkkNuqW;w@c{7yRQ z3n5?Y{a_;IMO<4Q&PQfOGCLP9otj z;)v7*u;)m1-dVSqam>EvfN+(Ru9L`@%tV`$L99mFVFX@?pV{K(ZNrhKQ zn6M^$+~NA>^>GAo7;uU1ciqydjMJJ?kP;<*m;4vAhQzS?Qr`#CFw0{7PlT(od)c{40jNP{{y>x|lU-{sld0f^(% zR9d5n4m3_sS-QvczT~D$Cz|6dk!qNUI?*nbOkNQ?4(`- z9vUnSGUK>(T`07iIFChfXaA`3#x3ZjAve71D1`mZgmagVwU?)Wnpd{zjI7@`?bX0! zn#@&P{7RtrOsI2=X3LX}XQQK%+yNBBd=5+1ArDsIY9`#$#72Yj7X!^ji>!KzKmcLw zvVZS!b6)WxbuyaWrcUEW2=cCP{RYPJlqD*2bgKdTLx*cyPhJ-6Rq}wnVD%aGoUiT~ za&=`aGPH0_^FW($8U_O5=E_Y@9X0rffxLXNM{+&vFKfBDIwi44(G<2jsxzRu`p%~i z;v|}nXO6VfIw4W)ptMeCRwelNCUuBhf6WbofFlFcpkZt46Nh8Q2?1Nn3hRAJ$?Ib? zg{p6!iCEfNflRA3+rdKPm*%IM5*OpwhJv8PE#Jd#7^Et$JO$2JME*9-5$Fff-(D3Z zMBSPb3!K-x%o#C9h-p)VVxxLc?QCVl_ffz3r}KgxZfupy;;sGWn-wPlDs6IpA+fPK z2ss*7Yrho@@39x>(%Iu>gCF!JNnR2q&h$g)(v-$5E0yjml6~)sOq_u1{Q*im0zA>r zHoz(!5b8G(rcnVa%%&H=%deu_Kd3xi+CFYyM0`JAT;GSwiWgj7?*TywsS^l!WMrR; zOZgvhKdW_IjLDDiaR{EGn}&ANQn;)$Ni&J6>RGwRscEDJWcroCEf~J^?$c3i;OV|f zp<6d^N&H@(*Q}Eitmw*-0@_1qs&qLM+biUjX4z>-OJVzr`~0<`xFl`AG4k`UFA1;X z%$9!?vS?(u^L)7y0-b%k@3mpf`{&&BdvG(>^TKPgDe+t_+&kgyD`4;Q$DyrX7Q z)rhu8Y*8i;E~?_Re`^=~rid)Rx=(9=XJsnyz`A+(33n&*h&MG9X@98J#;;RUN-;k> zOqN#9QbRvS65@~N+;T86o$c=> zo9QS<>X2Mcz+-noGhE>P(PGa1Bk|yuS6JHj)7+cUN(GN#V>_2AZ0b}cxhBOUBhRWb zVOAsZO+kT@V32dXmNkMWNuxRP#%)e5f=Da)!9tw2&YPJOf<|Di>*;e(;bG*>(YOGTh`(Vf-a6)K{E9oRjpa{ZZDO-ZVr>gB^qZ%8s7o8QCAG7kHgc)X5mS>~zz2T`l4XOcE) zswqgT6>7}@tT(lb0w;(@3_qy588$V!Ry|1mXZvIwtG;O#xAcu4dTvC2YttriSV}8e zwO2p>l-e7>BO+g7^IA-Xoen?Pa4qbtE^1Z6ud>z*p|RUi=_FY+%D@_k^@Q4bbOJ?y zEv+ciH2a(0o822TF|n^aW-VB6(aMGy{XPaiycpnX8<=~Tvr^ESJ;;(shwdoaDKYq* zjWgn-#p}6-NJUT&mgn@EBY1e|gSx~lMnf|Dk%&tJMj(Q{`O_%|A6a=Pb%QFC{^7Wv zi3RhA(&@>ta%rf!Cst&oUO{S=dexuf8(sC@3%a*Zcn@{CL;_J#?@*;QGDFt!SoN1A z;!=4<9Ss42_q)3hptmkB(`y5Paq~{louIswZ|=Snm7tT+JwDi8GxcMIb7>7|e1)p> zL7=Vhm|Y9FR3yLdog6OP&ug45S(Hyy)dhnI7I@3%p-?`x0_Lso#3#$CAdThm#ez7%@Lv0}z`NsRqoZV80TTw1coU$^aCSlw}Wp7k`>sv%e6 zq%o}B;-O60o<+GJdZwXx6dH?Z7|>Mvc{b_l>wV4TtJ5sht?7F>Bpzv5iN$Vr9h6d* zhEWO5>q2zSNg-}lukZraNR6z~l!)csd7-3`s69;h9y_ZbzaGH=_sCO}C=oMS#Sb7n zwqJf?yicbrLg=E?cDpQD@|h}%+m+O=tqaS{eh6xr%Y5j$XI%1;C_YYGU1Zfw%eSS2 zpYuw^2)l1_vz=FrM)O8tXLd)C=YH{Z8BglWuRnbWd=ezN&SJgcuisK-``qvAbnOXm z_E(frX{tJ2pvqY$Pu|VEm}R$msENh?_e~0xaS3+7Qj(<-_K#E1HjaOY{uS0-Xp-@E z^>tND_vMp$GeUC-hw8oC`T-7-T60{!{B4)wq^77t1akHy?s&!$pA3K}cigrP0SE7V z?$Z@eWQY!@MLVoAV0MBf$H`cjov{?4fhAv#j~+JvO8BGsWSLz$@Nr;WlfkIPDrA8;(wVe`}mbFGfr#zFl*6ISy72u*lRidu*;FeZdEiRA`X{DJj0w7&nKJpuEs*Q`I`3WQo;-}Xw$76w}kAt%Y}`2bqc@n z7sD3EF$5?K>cr9B1qg)5iG$SHZ8b4-_v0_W+$GZ3-dN|B1wWN0!b9BeM5R3ScRCsM zt8pActL;!DDL$Z!jIMx1hD=W3>00Gw;AIr1ubBKXau8yCan8ankLD9MZw{G1v8}|= zD^I?`XEq6qa@H*|T1RNujKI_pvMigS5B!1(w?lH1)PXX{5&qdX5y^Ey?m)=DPu_=J znD2_Q+{BI$j>Z%`l!YgcyJ}KS`auu>dz)0l77ZOve~!{>W|F$hfKv+obfSaziseP@ zG0#RPYklgt_G9vTtLN@|ie&nH`t9A3xc=`(EGV?#T@TCmxTOn7*s2%}U&PmXppi@G zcpOVnV)7_9XmQbw@JvSbh{Hgz=}lgsXtc6V ziH&FUHc3Y_`I4HpT`GXcqsqfuP1w5j-;o4h?d z_yoOIQ?7mQ@8GNz;FkP>ls$8d9~BQSZ5gz)Q49H-?jT;(9K=H*ep6u8;2@ z<4~Wyus`cMDn!L^{`8XVqJZshLypFPePy=Vu6viqqHekX)`3LD&g=k=Z8+X=r6_aw z<41=lReWD>!{z3yW#|sgG{m@fUFGUXV^rVU`!GUv*T%UU>1h;uB?D%*8dK2_q#r;O z=sV`=TMOZTdo_|P{B_viVP%6tjygdXf61(A?J-;0WpPiQJY@TtvjFG=zc{yS9c{

#q;t)K6Z-*XFe$dAK~KnpZQQBY?sX$7e+0-iINg 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%0AsnbENp#_HIPeL9sV=RL$gCe*iR+$S>H^R|G~?8 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

ckp4}T9lW4y4)BpCXU;b-f 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 + + + +

Get started using Preact and Vite!

+ +## Getting Started + +- `yarn dev` - Starts a dev server at http://localhost:5173/ + +- `yarn build` - Builds for production, emitting to `dist/` + +- `yarn preview` - Starts a server at http://localhost:4173/ to test production build locally diff --git a/frontend/index.html b/frontend/index.html new file mode 100644 index 0000000..170c101 --- /dev/null +++ b/frontend/index.html @@ -0,0 +1,17 @@ + + + + + + + + + + Vite + Preact + + + +
+ + + diff --git a/frontend/package.json b/frontend/package.json new file mode 100644 index 0000000..75419b2 --- /dev/null +++ b/frontend/package.json @@ -0,0 +1,31 @@ +{ + "private": true, + "type": "module", + "scripts": { + "dev": "vite", + "build": "vite build", + "preview": "vite preview" + }, + "dependencies": { + "@babel/core": "^8.0.1", + "@base-ui/react": "^1.6.0", + "@emotion/react": "^11.14.0", + "@emotion/styled": "^11.14.1", + "@fontsource/roboto": "^5.2.10", + "@mui/icons-material": "^9.1.1", + "@mui/material": "^9.1.2", + "axios": "^1.18.1", + "preact": "^10.26.9" + }, + "devDependencies": { + "@preact/preset-vite": "^2.10.2", + "eslint": "^10.5.0", + "eslint-config-preact": "^2.0.0", + "typescript": "^6.0.3", + "vite": "^7.0.4" + }, + "eslintConfig": { + "extends": "preact" + }, + "packageManager": "yarn@4.17.0" +} diff --git a/frontend/public/vite.svg b/frontend/public/vite.svg new file mode 100644 index 0000000..ffcb6bc --- /dev/null +++ b/frontend/public/vite.svg @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + diff --git a/frontend/src/assets/preact.svg b/frontend/src/assets/preact.svg new file mode 100644 index 0000000..f34e939 --- /dev/null +++ b/frontend/src/assets/preact.svg @@ -0,0 +1,6 @@ + + + + + + diff --git a/frontend/src/components/detail.tsx b/frontend/src/components/detail.tsx new file mode 100644 index 0000000..4ab3d2b --- /dev/null +++ b/frontend/src/components/detail.tsx @@ -0,0 +1,138 @@ +import Box from "@mui/material/Box"; +import Modal from "@mui/material/Modal"; +import { forwardRef, useEffect, useState } from "react"; +import { SolicitorInfo } from "../models/solicitorSummary"; +import getSolicitor from "../functions/getSolicitor"; +import Card from "@mui/material/Card"; +import { Grid, Rating, Typography } from "@mui/material"; +import capitaliseFirstLetter from "../functions/capitaliseFirstLetter"; + +interface ClosedProps { + open : false; +} + +interface OpenProps { + open : true; + id : string; +} + +export type DetailInfo = OpenProps | ClosedProps; +type DetailProps = DetailInfo & { onClose : (error? : string) => void }; + + +export default function Detail(props : DetailProps) { + const [data, setData] = useState('loading'); + + const handleResult = (result : SolicitorInfo | undefined) => { + if (data == 'loading' && props.open && props.id == result?.id) { + setData(result); + } else if (!result) { + handleClose('An error occurred loading the solicitor'); + } + } + + const handleClose = (error? : string) => { + props.onClose(error); + setData('loading'); + } + + useEffect(() => { + if (props.open && data == 'loading') { + getSolicitor(props.id) + .then(result => handleResult(result)); + } + }, [props.open]); + + useEffect(() => {}, [data]) + + return ( + handleClose()} + > + + + + ); +} + +const style = { + position: 'absolute', + top: '50%', + left: '50%', + transform: 'translate(-50%, -50%)', + width: 800, + maxWidth: '60%', + maxHeight: '80%', + bgcolor: 'background.default', + overflow: 'scroll', + p: 4, +}; + +const DetailDisplay = forwardRef((props : {data : SolicitorInfo | 'loading'}) => { + if (props.data === 'loading') { + return ( + + Waiting... + + ); + } else { + return ( + + {props.data.name} + {props.data.shortDescription} + {props.data.ratings && + (<> +
+ Ratings + + {props.data.ratings.map(rating => ( + + + {capitaliseFirstLetter(rating.provider)} + + + + ))} + + ) + } + {props.data.locations && + (<> +
+ Offices + + {props.data.locations.map(office => ( + + + {office.address.split('\n').map(line => ({line}))} + {office.phone && <>
tel: {office.phone}} + {office.ratings && office.ratings.map(rating => + (<> + {capitaliseFirstLetter(rating.provider)} + + ) + )} + + + ))} + + ) + } + + + ); + } +}); \ No newline at end of file diff --git a/frontend/src/components/header.tsx b/frontend/src/components/header.tsx new file mode 100644 index 0000000..41cd118 --- /dev/null +++ b/frontend/src/components/header.tsx @@ -0,0 +1,42 @@ +import DarkMode from "@mui/icons-material/DarkMode"; +import LightMode from "@mui/icons-material/LightMode"; +import { AppBar, IconButton, Toolbar, Tooltip, Typography } from "@mui/material"; +import { Theme } from "@mui/material/styles"; + +export interface ThemeWrapper { + theme : Theme, + value : 'dark' | 'light'; +} + +interface HeaderProps { + theme : ThemeWrapper; + toggleTheme : () => void; +} + +export default function Header(props : HeaderProps) { + return ( + + + + Conveyancing Search + + + + { + props.theme.value === 'dark' + ? + : + } + + + + + ); +} \ No newline at end of file diff --git a/frontend/src/components/numberField.tsx b/frontend/src/components/numberField.tsx new file mode 100644 index 0000000..75794f9 --- /dev/null +++ b/frontend/src/components/numberField.tsx @@ -0,0 +1,114 @@ +import * as React from 'react'; +import { NumberField as BaseNumberField } from '@base-ui/react/number-field'; +import IconButton from '@mui/material/IconButton'; +import FormControl from '@mui/material/FormControl'; +import FormHelperText from '@mui/material/FormHelperText'; +import OutlinedInput from '@mui/material/OutlinedInput'; +import InputAdornment from '@mui/material/InputAdornment'; +import InputLabel from '@mui/material/InputLabel'; +import KeyboardArrowUpIcon from '@mui/icons-material/KeyboardArrowUp'; +import KeyboardArrowDownIcon from '@mui/icons-material/KeyboardArrowDown'; + +/** + * This component is a placeholder for FormControl to correctly set the shrink label state on SSR. + */ +function SSRInitialFilled(_: BaseNumberField.Root.Props) { + return null; +} +SSRInitialFilled.muiName = 'Input'; + +export default function NumberField({ + id: idProp, + label, + error, + size = 'medium', + ...other +}: BaseNumberField.Root.Props & { + label?: React.ReactNode; + size?: 'small' | 'medium'; + error?: boolean; +}) { + let id = React.useId(); + if (idProp) { + id = idProp; + } + return ( + ( + + {props.children} + + )} + > + + {label} + ( + + } + > + + + + } + > + + + + } + sx={{ pr: 0 }} + /> + )} + /> + + Enter value between 10 and 40 + + + ); +} \ No newline at end of file diff --git a/frontend/src/components/result.tsx b/frontend/src/components/result.tsx new file mode 100644 index 0000000..aebd0f8 --- /dev/null +++ b/frontend/src/components/result.tsx @@ -0,0 +1,44 @@ +import ListItemText from "@mui/material/ListItemText"; +import SolicitorSummary from "../models/solicitorSummary"; +import ListItemButton from "@mui/material/ListItemButton"; +import Typography from "@mui/material/Typography"; +import Rating from "@mui/material/Rating"; +import Divider from "@mui/material/Divider"; + +type ResultProps = SolicitorSummary & { last : boolean, onClick: () => void }; + +export default function Result(props : ResultProps) { + return ( + <> + + + + {props.name} + + {props.rating && + + } + + } + secondary={props.shortDescription} + /> + + {props.last || } + + ); +} \ No newline at end of file diff --git a/frontend/src/components/results.tsx b/frontend/src/components/results.tsx new file mode 100644 index 0000000..4085579 --- /dev/null +++ b/frontend/src/components/results.tsx @@ -0,0 +1,46 @@ +import { useEffect, useState } from "preact/hooks"; +import GetSolicitors from "../functions/getSolicitors"; +import Grid from "@mui/material/Grid"; +import Sidebar from "./sidebar"; +import FilterState from "../models/filterState"; +import { default as ResultsType, waitingResults } from "../models/results"; +import ResultsList from "./resultsList"; + +export default function Results() { + const [results, setResults] = useState(waitingResults); + const [filters, setFilters] = useState({ + cities: [], + minRating: 3, + resultsPerPage: 20, + currentPage: 1, + ratingsProvider: 'Solicitors.com', + sortBy: 'RatingDescending', + namePart: '', + nameOnly: false}); + + useEffect(() => { + if (results.type == 'Waiting') { + GetSolicitors(filters) + .then(result => setResults({type: 'Success', data: result})); + } + }, [results]); + + useEffect(() => { + setResults({type: 'Waiting'}); + }, [filters]); + + return ( + + + + + + + + + ); +} + diff --git a/frontend/src/components/resultsList.tsx b/frontend/src/components/resultsList.tsx new file mode 100644 index 0000000..7b911bb --- /dev/null +++ b/frontend/src/components/resultsList.tsx @@ -0,0 +1,42 @@ +import List from "@mui/material/List"; +import Pagination from "@mui/material/Pagination"; +import FilterState from "../models/filterState"; +import Results from "../models/results"; +import Result from "./result"; +import Detail, { DetailInfo } from "./detail"; +import { useState } from "react"; + +interface ResultsListProps { + results : Results; + filters : FilterState; + setFilters : (state : FilterState) => void; +} + +export default function ResultsList(props : ResultsListProps) { + const [detail, setDetail] = useState({open: false}); + + switch (props.results.type) { + case 'Success': + let data = props.results.data.data; + return ( + <> + + {data.map((r, i) => ( setDetail({open : true, id : r.id})} last={i == data.length - 1} />))} + + setDetail({open: false})} /> + props.setFilters(Object.assign({}, {...props.filters}, {currentPage: page}))} + /> + + ); + case 'Waiting': + return
Waiting...
; + case 'Error': + return
Error...
; + case 'Warning': + return
Warning...
; + } +} \ No newline at end of file diff --git a/frontend/src/components/sidebar.tsx b/frontend/src/components/sidebar.tsx new file mode 100644 index 0000000..a651fd0 --- /dev/null +++ b/frontend/src/components/sidebar.tsx @@ -0,0 +1,159 @@ +import { Autocomplete, Box, Divider, Grid, InputLabel, MenuItem, Paper, Rating, Select, SelectChangeEvent, Switch, TextField, ToggleButton, Typography } from "@mui/material"; +import getCities from "../functions/getCities"; +import FilterState from "../models/filterState"; +import { useEffect, useState } from "react"; +import NumberField from "./numberField"; +import getRatingsProviders from "../functions/getRatingsProviders"; +import capitaliseFirstLetter from "../functions/capitaliseFirstLetter"; + +interface SidebarProps { + filters : FilterState; + onChange : (filters : FilterState) => void; +} + +export default function Sidebar(props : SidebarProps) { + const [cities, setCities] = useState([]); + const [ratingsProviders, setRatingsProviders] = useState(['Solicitors.com']); + + useEffect(() => { + if (cities.length === 0) { + getCities().then((results) => setCities(results)); + } + }, [cities.length]); + + useEffect(() => { + if (cities.length === 0) { + getRatingsProviders().then((results) => setRatingsProviders(results)); + } + }, [cities.length]); + + return ( + + + Filter Conveyancers + + + Firm Name + props.onChange(Object.assign({}, {...props.filters}, {namePart: (e.target as any).value, currentPage: 1}))} + /> + + + + Search by Firm Name Only + props.onChange(Object.assign({}, {...props.filters}, {nameOnly: value, currentPage: 1}))} + /> + + + {!props.filters.nameOnly && + <> + + Cities + props.onChange(Object.assign({}, {...props.filters}, {cities: value, currentPage: 1}))} + renderInput={(params) => ( + + )} + /> + + + + + + Min. Rating + props.onChange(Object.assign({}, {...props.filters}, {minRating: value, currentPage: 1}))} + /> + + + Rating Provider + + + + + + } + + Results per Page + props.onChange(Object.assign({}, {...props.filters}, {resultsPerPage: value, currentPage: 1}))} + min={10} + max={40} + /> + + + + Sort By + + + + ) +} + +const sortingOptions = [ + { + value: 'RatingDescending', + name: 'Rating (descending)' + }, + { + value: 'RatingAscending', + name: 'Rating (ascending)' + }, + { + value: 'AlphabetAscending', + name: 'Alphabetical (ascending)' + }, + { + value: 'AlphabetDescending', + name: 'Alphabetical (descending)' + } +] \ No newline at end of file diff --git a/frontend/src/functions/axios.ts b/frontend/src/functions/axios.ts new file mode 100644 index 0000000..a801971 --- /dev/null +++ b/frontend/src/functions/axios.ts @@ -0,0 +1,7 @@ +import axios from 'axios'; + +const api = axios.create({ + baseURL: import.meta.env.VITE_API_URL +}); + +export default api; \ No newline at end of file diff --git a/frontend/src/functions/capitaliseFirstLetter.ts b/frontend/src/functions/capitaliseFirstLetter.ts new file mode 100644 index 0000000..33b0f19 --- /dev/null +++ b/frontend/src/functions/capitaliseFirstLetter.ts @@ -0,0 +1,3 @@ +export default function capitaliseFirstLetter(val : string) { + return String(val).charAt(0).toUpperCase() + String(val).slice(1); +} \ No newline at end of file diff --git a/frontend/src/functions/getCities.ts b/frontend/src/functions/getCities.ts new file mode 100644 index 0000000..0d1a36e --- /dev/null +++ b/frontend/src/functions/getCities.ts @@ -0,0 +1,6 @@ +import api from "./axios"; + +export default async function GetCiries() { + const response = await api.get('/cities'); + return response.data as string[]; +} \ No newline at end of file diff --git a/frontend/src/functions/getRatingsProviders.ts b/frontend/src/functions/getRatingsProviders.ts new file mode 100644 index 0000000..9efc592 --- /dev/null +++ b/frontend/src/functions/getRatingsProviders.ts @@ -0,0 +1,6 @@ +import api from "./axios"; + +export default async function GetCiries() { + const response = await api.get('/ratingsProviders'); + return response.data as string[]; +} \ No newline at end of file diff --git a/frontend/src/functions/getSolicitor.ts b/frontend/src/functions/getSolicitor.ts new file mode 100644 index 0000000..6c32363 --- /dev/null +++ b/frontend/src/functions/getSolicitor.ts @@ -0,0 +1,7 @@ +import { SolicitorInfo } from "../models/solicitorSummary"; +import api from "./axios"; + +export default async function GetSolicitor(id : string) : Promise { + const response = await api.get(`/solicitors/${id}`); + return response.data as SolicitorInfo; +} \ No newline at end of file diff --git a/frontend/src/functions/getSolicitors.ts b/frontend/src/functions/getSolicitors.ts new file mode 100644 index 0000000..1121610 --- /dev/null +++ b/frontend/src/functions/getSolicitors.ts @@ -0,0 +1,32 @@ +import SolicitorSummary from "../models/solicitorSummary"; +import PaginationResponse from "../models/paginationResponse"; +import FilterState from "../models/filterState"; +import api from "./axios"; + +export default async function GetSolicitors(filters : FilterState) { + + let queryString = `pageSize=${filters.resultsPerPage}&pageNumber=${filters.currentPage}`; + + if (filters.namePart != null && filters.namePart !== '') { + queryString += `&nameFilter=${filters.namePart}`; + } + + if (!filters.nameOnly) { + var minRating = filters.minRating; + if (minRating == null) { + minRating = 0; + } + queryString += `&minRating=${minRating}&ratingsProvider=${filters.ratingsProvider}`; + + if (filters.cities.length > 0) { + queryString += '&cities=' + filters.cities.join('&cities='); + } + } + + if (filters.sortBy != null) { + queryString += `&orderingType=${filters.sortBy}`; + } + + const response = await api.get(`/solicitors?${queryString}`); + return response.data as PaginationResponse; +} \ No newline at end of file diff --git a/frontend/src/index.tsx b/frontend/src/index.tsx new file mode 100644 index 0000000..89568a2 --- /dev/null +++ b/frontend/src/index.tsx @@ -0,0 +1,129 @@ +import { render } from 'preact'; +import Button from '@mui/material/Button'; +import AppBar from '@mui/material/AppBar'; +import Toolbar from '@mui/material/Toolbar'; +import IconButton from '@mui/material/IconButton'; +import Typography from '@mui/material/Typography'; +import Container from '@mui/material/Container'; +import { useState } from 'preact/compat'; +import { createTheme, Theme, ThemeProvider } from '@mui/material/styles'; +import DarkMode from '@mui/icons-material/DarkMode'; +import LightMode from '@mui/icons-material/LightMode'; +import { CssBaseline, Tooltip } from '@mui/material'; +import Header, { ThemeWrapper } from './components/header'; +import Results from './components/results'; + +function prefersDarkMode() { + const darkModeMql = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)'); + return darkModeMql && darkModeMql.matches; +} + +const darkTheme = createTheme({ + palette: { + mode: 'dark', + primary: { + light: '#B79AD5', + main: '#A27EC9', + dark: '#8D61BD' + }, + secondary: { + light: '#70DBFF', + main: '#47D1FF', + dark: '#1FC7FF' + }, + error: { + light: '#E73936', + main: '#DD1C1A', + dark: '#B71815' + }, + warning: { + light: '#FA804C', + main: '#F9611F', + dark: '#EF4C06' + }, + info : { + light: '#FFEB99', + main: '#FFE066', + dark: '#FFDA47' + }, + success: { + light: '#6ADC98', + main: '#48D480', + dark: '#2FC66B' + }, + background: { + default: '#1D2535', + paper: '#242E42' + } + } +}); + +const lightTheme = createTheme({ + palette: { + mode: 'light', + primary: { + light: '#B79AD5', + main: '#A27EC9', + dark: '#8D61BD' + }, + secondary: { + light: '#70DBFF', + main: '#47D1FF', + dark: '#1FC7FF' + }, + error: { + light: '#E73936', + main: '#DD1C1A', + dark: '#B71815' + }, + warning: { + light: '#FA804C', + main: '#F9611F', + dark: '#EF4C06' + }, + info : { + light: '#FFEB99', + main: '#FFE066', + dark: '#FFDA47' + }, + success: { + light: '#6ADC98', + main: '#48D480', + dark: '#2FC66B' + }, + background: { + default: '#EFFFFF', + paper: '#e8f1f1' + } + } +}); + +export function App() { + const [value, setValue] = useState(0); + const [theme, setTheme] = useState({ + theme : prefersDarkMode() ? darkTheme : lightTheme, + value : prefersDarkMode() ? 'dark' : 'light' + }); + + const handleChange = (event: any, newValue: number) => { + setValue(newValue); + }; + + const toggleTheme = () => { + setTheme(theme.value == 'dark' + ? { theme : lightTheme, value : 'light' } + : { theme : darkTheme, value : 'dark' }); + } + + return ( + + +
+ + + + + ); +} + +render(, document.getElementById('app')); diff --git a/frontend/src/models/filterState.ts b/frontend/src/models/filterState.ts new file mode 100644 index 0000000..25e351f --- /dev/null +++ b/frontend/src/models/filterState.ts @@ -0,0 +1,10 @@ +export default interface FilterState { + cities : string[]; + minRating : number; + resultsPerPage : number; + currentPage : number; + ratingsProvider : string; + sortBy : string; + namePart : string; + nameOnly : boolean; +}; \ No newline at end of file diff --git a/frontend/src/models/paginationResponse.ts b/frontend/src/models/paginationResponse.ts new file mode 100644 index 0000000..c7dc57e --- /dev/null +++ b/frontend/src/models/paginationResponse.ts @@ -0,0 +1,4 @@ +export default interface PaginationResponse { + data : T[]; + total : number; +} \ No newline at end of file diff --git a/frontend/src/models/results.ts b/frontend/src/models/results.ts new file mode 100644 index 0000000..20381b7 --- /dev/null +++ b/frontend/src/models/results.ts @@ -0,0 +1,25 @@ +import PaginationResponse from "./paginationResponse"; +import SolicitorSummary from "./solicitorSummary"; + +type Results = SuccessResults | ErrorResults | WaitingResults; + +interface SuccessResults { + type : 'Success', + data : PaginationResponse +}; + +interface ErrorResults { + type : 'Error' | 'Warning', + message : string +}; + +interface WaitingResults { + type : 'Waiting' +}; + +const waitingResults : WaitingResults = { + type : 'Waiting' +}; + +export default Results; +export {waitingResults}; \ No newline at end of file diff --git a/frontend/src/models/solicitorSummary.ts b/frontend/src/models/solicitorSummary.ts new file mode 100644 index 0000000..f56b5b9 --- /dev/null +++ b/frontend/src/models/solicitorSummary.ts @@ -0,0 +1,30 @@ +export default interface SolicitorSummary { + name : string, + shortDescription : string | null, + id : string, + rating : Rating | null +}; + +export interface Rating { + value : number, + maximum : number, + provider : string +} + +export interface Location { + address : string, + phone : string, + ratings : Rating[] +} + +export interface SolicitorInfo { + name : string, + shortDescription : string | null, + id : string, + phone? : string, + email? : string, + website? : string, + + ratings : Rating[], + locations : Location[] +} \ No newline at end of file diff --git a/frontend/tsconfig.json b/frontend/tsconfig.json new file mode 100644 index 0000000..12bb30b --- /dev/null +++ b/frontend/tsconfig.json @@ -0,0 +1,20 @@ +{ + "compilerOptions": { + "target": "ES2020", + "module": "ESNext", + "moduleResolution": "bundler", + "noEmit": true, + "allowJs": true, + "checkJs": true, + + /* Preact Config */ + "jsx": "react-jsx", + "jsxImportSource": "preact", + "skipLibCheck": true, + "paths": { + "react": ["./node_modules/preact/compat/"], + "react-dom": ["./node_modules/preact/compat/"] + } + }, + "include": ["node_modules/vite/client.d.ts", "**/*"] +} diff --git a/frontend/vite.config.ts b/frontend/vite.config.ts new file mode 100644 index 0000000..0e309b2 --- /dev/null +++ b/frontend/vite.config.ts @@ -0,0 +1,7 @@ +import { defineConfig } from 'vite'; +import preact from '@preact/preset-vite'; + +// https://vitejs.dev/config/ +export default defineConfig({ + plugins: [preact()], +}); diff --git a/frontend/yarn.lock b/frontend/yarn.lock new file mode 100644 index 0000000..160358a --- /dev/null +++ b/frontend/yarn.lock @@ -0,0 +1,4693 @@ +# This file is generated by running "yarn install" inside your project. +# Manual changes might be lost - proceed with caution! + +__metadata: + version: 10 + cacheKey: 10c0 + +"@babel/code-frame@npm:^7.0.0, @babel/code-frame@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/code-frame@npm:7.29.7" + dependencies: + "@babel/helper-validator-identifier": "npm:^7.29.7" + js-tokens: "npm:^4.0.0" + picocolors: "npm:^1.1.1" + checksum: 10c0/169fc2080169a40c1760155eaaaf739bcb882df0bec76a83adbda5493645bc17270a3434b8848c494b1933e96fe1d147370001e3cda09a39f43ae30f08ef2069 + languageName: node + linkType: hard + +"@babel/code-frame@npm:^8.0.0": + version: 8.0.0 + resolution: "@babel/code-frame@npm:8.0.0" + dependencies: + "@babel/helper-validator-identifier": "npm:^8.0.0" + js-tokens: "npm:^10.0.0" + checksum: 10c0/2ea8614018bcd8c86358ab6aa930508115d2205e5e111f736d355b150453818bdf487850f6dec5ec92a10bf27ba4536f4b3b8ad9204514e43d8d68ff2e542443 + languageName: node + linkType: hard + +"@babel/compat-data@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/compat-data@npm:7.29.7" + checksum: 10c0/47913f05e08a45a1c9df38c02b4b49e391005085b489432647a1abe112e5d9c75e3be8ea5972b7f6da4ec5d1339922ceb9ea02b8a25d4ed1cb8636e5261f344e + languageName: node + linkType: hard + +"@babel/compat-data@npm:^8.0.0": + version: 8.0.0 + resolution: "@babel/compat-data@npm:8.0.0" + checksum: 10c0/8d934415a308cf6c893d815b1dbb79faf7678c1e489934e81025c61673bf98ef88770b42297492bbd4c014978688012aa635e855bf8553b96ec8287bddfbae89 + languageName: node + linkType: hard + +"@babel/core@npm:^7.13.16, @babel/core@npm:^7.22.1": + version: 7.29.7 + resolution: "@babel/core@npm:7.29.7" + dependencies: + "@babel/code-frame": "npm:^7.29.7" + "@babel/generator": "npm:^7.29.7" + "@babel/helper-compilation-targets": "npm:^7.29.7" + "@babel/helper-module-transforms": "npm:^7.29.7" + "@babel/helpers": "npm:^7.29.7" + "@babel/parser": "npm:^7.29.7" + "@babel/template": "npm:^7.29.7" + "@babel/traverse": "npm:^7.29.7" + "@babel/types": "npm:^7.29.7" + "@jridgewell/remapping": "npm:^2.3.5" + convert-source-map: "npm:^2.0.0" + debug: "npm:^4.1.0" + gensync: "npm:^1.0.0-beta.2" + json5: "npm:^2.2.3" + semver: "npm:^6.3.1" + checksum: 10c0/112fb09c24de7a1de64d1de2c31fe65c4e6af4cb2fb6e6d99ea5373e6fc51e75b88581c0efae4c4c68f119a02a988c7106e95011a41530a2fb8ed793c7eaa07b + languageName: node + linkType: hard + +"@babel/core@npm:^8.0.1": + version: 8.0.1 + resolution: "@babel/core@npm:8.0.1" + dependencies: + "@babel/code-frame": "npm:^8.0.0" + "@babel/generator": "npm:^8.0.0" + "@babel/helper-compilation-targets": "npm:^8.0.0" + "@babel/helpers": "npm:^8.0.0" + "@babel/parser": "npm:^8.0.0" + "@babel/template": "npm:^8.0.0" + "@babel/traverse": "npm:^8.0.0" + "@babel/types": "npm:^8.0.0" + "@types/gensync": "npm:^1.0.5" + convert-source-map: "npm:^2.0.0" + empathic: "npm:^2.0.1" + gensync: "npm:^1.0.0-beta.2" + import-meta-resolve: "npm:^4.2.0" + json5: "npm:^2.2.3" + obug: "npm:^2.1.1" + semver: "npm:^7.7.3" + checksum: 10c0/e7fd9266d22906132fb052383a624358f54268dade31d50264416afeab6e5648cd23c7e845a89a501d270b80601d6e89abc67de0a9f1f55133f4abd8ac745be7 + languageName: node + linkType: hard + +"@babel/eslint-parser@npm:^7.27.5": + version: 7.29.7 + resolution: "@babel/eslint-parser@npm:7.29.7" + dependencies: + "@nicolo-ribaudo/eslint-scope-5-internals": "npm:5.1.1-v1" + eslint-visitor-keys: "npm:^2.1.0" + semver: "npm:^6.3.1" + peerDependencies: + "@babel/core": ^7.11.0 + eslint: ^7.5.0 || ^8.0.0 || ^9.0.0 + checksum: 10c0/c24dcd941b0a149b197a9e9c3297a01d621775ac71cdf2e1134b1097c1691b46ce969355e1be3676d83b88f62c43ed33cf3a499da21ea11a5eb07339ce64ac20 + languageName: node + linkType: hard + +"@babel/generator@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/generator@npm:7.29.7" + dependencies: + "@babel/parser": "npm:^7.29.7" + "@babel/types": "npm:^7.29.7" + "@jridgewell/gen-mapping": "npm:^0.3.12" + "@jridgewell/trace-mapping": "npm:^0.3.28" + jsesc: "npm:^3.0.2" + checksum: 10c0/9bf72b01b5bd0ea5b1288a0e37dbd360bff2f2b1ce73342c0d40fb3db2ec3dc004ada5ffa925c5e12939a416eed59e600d562b8ecd938ce0d27dfd0eb6c6c2b7 + languageName: node + linkType: hard + +"@babel/generator@npm:^8.0.0": + version: 8.0.0 + resolution: "@babel/generator@npm:8.0.0" + dependencies: + "@babel/parser": "npm:^8.0.0" + "@babel/types": "npm:^8.0.0" + "@jridgewell/gen-mapping": "npm:^0.3.12" + "@jridgewell/trace-mapping": "npm:^0.3.28" + "@types/jsesc": "npm:^2.5.0" + jsesc: "npm:^3.0.2" + checksum: 10c0/2b2d171beaedcacca62164f0f39bc8962df5f9700a54c5515174276ea20b3a53933e9804e0b35c2be1059108a764447d99d0c5beb63ecbbf8c66035ca6c003c4 + languageName: node + linkType: hard + +"@babel/helper-annotate-as-pure@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/helper-annotate-as-pure@npm:7.29.7" + dependencies: + "@babel/types": "npm:^7.29.7" + checksum: 10c0/c56536b52d17632d89d49db2063ed6102f0e3bbadf6a0ccb74e6599d6a77173b644c7fe8c3ef17c7a162709d55b75ee5145ef6db917d16ba7f375fbffcf2e942 + languageName: node + linkType: hard + +"@babel/helper-compilation-targets@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/helper-compilation-targets@npm:7.29.7" + dependencies: + "@babel/compat-data": "npm:^7.29.7" + "@babel/helper-validator-option": "npm:^7.29.7" + browserslist: "npm:^4.24.0" + lru-cache: "npm:^5.1.1" + semver: "npm:^6.3.1" + checksum: 10c0/4c15fd4c69a0a7047799a28a88460c19cede0a0ee8af994ea169114986f4af48b92c7393a4a3fee0456c11a656eece3448a6ed06354453d6c27cccf17195453b + languageName: node + linkType: hard + +"@babel/helper-compilation-targets@npm:^8.0.0": + version: 8.0.0 + resolution: "@babel/helper-compilation-targets@npm:8.0.0" + dependencies: + "@babel/compat-data": "npm:^8.0.0" + "@babel/helper-validator-option": "npm:^8.0.0" + browserslist: "npm:^4.24.0" + lru-cache: "npm:^11.0.0" + semver: "npm:^7.7.3" + checksum: 10c0/871876b4a9de1a2be68f2ec6c7576933dd9a8452bfb3c02ebcc16939791b8f2ab7467686e40060c6abfbb44bd76f898972e53034c3e7626a686a656f3a8d3bc9 + languageName: node + linkType: hard + +"@babel/helper-globals@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/helper-globals@npm:7.29.7" + checksum: 10c0/f38417c40b1129a1b2b519ca961b9040c8827d1444fd74068702286b91b77089431dc76b6b9d5c1496e5da2a4f3ad329c6946e688ba3fa0d1d0b3d2b4f34f36a + languageName: node + linkType: hard + +"@babel/helper-globals@npm:^8.0.0": + version: 8.0.0 + resolution: "@babel/helper-globals@npm:8.0.0" + checksum: 10c0/c53a9fcf451df5c8d3aa72f282d1f058e2874e2ccbbdbb5572a805595d75a9355461822d01a6cac3128f5d9ab9a3a99538c6be4ebd728068afb20a65a4d1d986 + languageName: node + linkType: hard + +"@babel/helper-module-imports@npm:^7.16.7, @babel/helper-module-imports@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/helper-module-imports@npm:7.29.7" + dependencies: + "@babel/traverse": "npm:^7.29.7" + "@babel/types": "npm:^7.29.7" + checksum: 10c0/6adf60d97356027413342a092f818d9678c4f5caff716a33e3284b5ae14e47a9e88059d421dde4ee4894691260039a12602c0e7becadc175602194b40dfa345d + languageName: node + linkType: hard + +"@babel/helper-module-transforms@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/helper-module-transforms@npm:7.29.7" + dependencies: + "@babel/helper-module-imports": "npm:^7.29.7" + "@babel/helper-validator-identifier": "npm:^7.29.7" + "@babel/traverse": "npm:^7.29.7" + peerDependencies: + "@babel/core": ^7.0.0 + checksum: 10c0/ee5a2172c24a42be696836f4b0d947489c9729d8adf5821885cf77d1ad5333e3c447368e9a71f67df1099570490553dccf9f888ef0a92a48aa63cb086bd8c7e1 + languageName: node + linkType: hard + +"@babel/helper-plugin-utils@npm:^7.12.13, @babel/helper-plugin-utils@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/helper-plugin-utils@npm:7.29.7" + checksum: 10c0/380477a06133274a2759f9355929cb60a95e8b8fee624a1ae1fa349e1d1645b89daca456f72833f6d1062bffa12ee4271c5bf0cc5a61c0166cdc24c7591e2408 + languageName: node + linkType: hard + +"@babel/helper-string-parser@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/helper-string-parser@npm:7.29.7" + checksum: 10c0/194bc0f1716e396d5ffde56ad6119745fb9557662c98611590e5e454906783a4ccb21ce93056b8eb69a4909044834e45d96e50ac695bbe9e3221648fe033c06c + languageName: node + linkType: hard + +"@babel/helper-string-parser@npm:^8.0.0": + version: 8.0.0 + resolution: "@babel/helper-string-parser@npm:8.0.0" + checksum: 10c0/b2272a9eaa63a1bc9ce2673d580e69620fd79786f3e3cf1891f406801f8211810f194f2739fef920f01a97ae06ae465b2dfd238ab8037a3182d0869939ca9a5d + languageName: node + linkType: hard + +"@babel/helper-validator-identifier@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/helper-validator-identifier@npm:7.29.7" + checksum: 10c0/4795354e7ae0dcafa72de1cd04ec51252dc1498517170beaf019e03effc5b7bf13c6b21a3949a77e07b8125be7f106ed1131350d8ebd4566ae874094a726d62b + languageName: node + linkType: hard + +"@babel/helper-validator-identifier@npm:^8.0.0": + version: 8.0.2 + resolution: "@babel/helper-validator-identifier@npm:8.0.2" + checksum: 10c0/629eda2a0a99442a1628bbef5f9fd8e26c1aa21ddbf02760d1c482b737932b1bb21fb1f89aacf9c3cf0642b481b810e39f94b8ae9aa44fc4f5516ebec6798b7b + languageName: node + linkType: hard + +"@babel/helper-validator-option@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/helper-validator-option@npm:7.29.7" + checksum: 10c0/d2a06c6d0ac40ba4a2f219fc2cab249c7a94bacdb2686273b7f9598571c908809b48468ff588915a346e6cc7296f60b581023d1d498b747fed06f779d335c2cc + languageName: node + linkType: hard + +"@babel/helper-validator-option@npm:^8.0.0": + version: 8.0.0 + resolution: "@babel/helper-validator-option@npm:8.0.0" + checksum: 10c0/eb466b464479f75c15ba06f6c53862f10d90740350c9203b3d81c6f33d4193bf0a7b7b89de901f256fb639a1346475b48616734af89906d6b4fcf9a856d9f1f1 + languageName: node + linkType: hard + +"@babel/helpers@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/helpers@npm:7.29.7" + dependencies: + "@babel/template": "npm:^7.29.7" + "@babel/types": "npm:^7.29.7" + checksum: 10c0/218e8d10953647c9f44775f5a022b227a182674853b5ea8631889deb7e1a3e4bc870388aaecf59bb8bd92a87f9a96220ed3f70a35bffec6bcf9169ecb67891ac + languageName: node + linkType: hard + +"@babel/helpers@npm:^8.0.0": + version: 8.0.0 + resolution: "@babel/helpers@npm:8.0.0" + dependencies: + "@babel/template": "npm:^8.0.0" + "@babel/types": "npm:^8.0.0" + checksum: 10c0/5d649bf2cfc37b76b8c9dd7d2992fa0503a6081c2439cd4de16b56abb778f3bb391441d687594f3e08af5ef3f59c8b93a77ae81f9e5f831989ebfd3443851189 + languageName: node + linkType: hard + +"@babel/parser@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/parser@npm:7.29.7" + dependencies: + "@babel/types": "npm:^7.29.7" + bin: + parser: ./bin/babel-parser.js + checksum: 10c0/65133038f80b54a714d6027cb77cee3f9a6b5c4c6842ce674301e13947cbcbfa8055e63acaf1b84c085d34226a14425b2c2b97b829e0e226d2e8f1299942a51d + languageName: node + linkType: hard + +"@babel/parser@npm:^8.0.0": + version: 8.0.0 + resolution: "@babel/parser@npm:8.0.0" + dependencies: + "@babel/types": "npm:^8.0.0" + bin: + parser: ./bin/babel-parser.js + checksum: 10c0/f10665bf3289f4bdc43bc58c482d6baa9fc4e306460d1bc57b059486dc9f23ed4463e746f62d721396466e2a2e0b32d856648b8c30dedbf6b69787b430f21e75 + languageName: node + linkType: hard + +"@babel/plugin-syntax-class-properties@npm:^7.12.13": + version: 7.12.13 + resolution: "@babel/plugin-syntax-class-properties@npm:7.12.13" + dependencies: + "@babel/helper-plugin-utils": "npm:^7.12.13" + peerDependencies: + "@babel/core": ^7.0.0-0 + checksum: 10c0/95168fa186416195280b1264fb18afcdcdcea780b3515537b766cb90de6ce042d42dd6a204a39002f794ae5845b02afb0fd4861a3308a861204a55e68310a120 + languageName: node + linkType: hard + +"@babel/plugin-syntax-jsx@npm:^7.12.13, @babel/plugin-syntax-jsx@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/plugin-syntax-jsx@npm:7.29.7" + dependencies: + "@babel/helper-plugin-utils": "npm:^7.29.7" + peerDependencies: + "@babel/core": ^7.0.0-0 + checksum: 10c0/1736000de183538ba8eef34520105508860e48b0c763254ba9158af5e814ed8bbceeedbb4281fbda33de787ae5b3870e92f60c6ae7131e7d322e451d57387896 + languageName: node + linkType: hard + +"@babel/plugin-transform-react-jsx-development@npm:^7.27.1": + version: 7.29.7 + resolution: "@babel/plugin-transform-react-jsx-development@npm:7.29.7" + dependencies: + "@babel/plugin-transform-react-jsx": "npm:^7.29.7" + peerDependencies: + "@babel/core": ^7.0.0-0 + checksum: 10c0/a2d44d068d35f8e6bc0437ba0da86526d4473491a43108caf77cba467a3ab522cbd09bcd8184b7a49f3d2b52e0883ad797ed2f91c090b857a80a6f383e88f449 + languageName: node + linkType: hard + +"@babel/plugin-transform-react-jsx@npm:^7.27.1, @babel/plugin-transform-react-jsx@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/plugin-transform-react-jsx@npm:7.29.7" + dependencies: + "@babel/helper-annotate-as-pure": "npm:^7.29.7" + "@babel/helper-module-imports": "npm:^7.29.7" + "@babel/helper-plugin-utils": "npm:^7.29.7" + "@babel/plugin-syntax-jsx": "npm:^7.29.7" + "@babel/types": "npm:^7.29.7" + peerDependencies: + "@babel/core": ^7.0.0-0 + checksum: 10c0/ae6487c3deafcffda8a2c1b1eb77e0b7121630fa1a9646cecd73dbbdd8271532a0f7f0e8c01f69b6d39a36d8d79eb67e2d51031369c9055f18f7d8e70d9b5446 + languageName: node + linkType: hard + +"@babel/runtime@npm:^7.12.5, @babel/runtime@npm:^7.18.3, @babel/runtime@npm:^7.29.2, @babel/runtime@npm:^7.5.5, @babel/runtime@npm:^7.8.7": + version: 7.29.7 + resolution: "@babel/runtime@npm:7.29.7" + checksum: 10c0/ca11572f7146b21e0bde6a9ed4bb6a89eafbee5f0944c7eb54d0d8a2dac962c33638a1d611e14faa71dfbb92b4b5f9236232208568a6b7d5c6f3f39ddb91771e + languageName: node + linkType: hard + +"@babel/template@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/template@npm:7.29.7" + dependencies: + "@babel/code-frame": "npm:^7.29.7" + "@babel/parser": "npm:^7.29.7" + "@babel/types": "npm:^7.29.7" + checksum: 10c0/8bb7f900dcab0e9e1c5ffbc33ca10e0d26b7b2e2ca804becb73ee771b9c4ed6e2908a4ae4a14c08560febb45d2b6b9a173955e42ad404d05f8b04840a14d9c58 + languageName: node + linkType: hard + +"@babel/template@npm:^8.0.0": + version: 8.0.0 + resolution: "@babel/template@npm:8.0.0" + dependencies: + "@babel/code-frame": "npm:^8.0.0" + "@babel/parser": "npm:^8.0.0" + "@babel/types": "npm:^8.0.0" + checksum: 10c0/8a5e5687299517cc6b0efff3a6342cf4c4256aeeffa14753cc8d08106aaf0ba1916707c0e1f385b511a7b42c6c87806fecaecd4fe06316207475e0d4d1148e2c + languageName: node + linkType: hard + +"@babel/traverse@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/traverse@npm:7.29.7" + dependencies: + "@babel/code-frame": "npm:^7.29.7" + "@babel/generator": "npm:^7.29.7" + "@babel/helper-globals": "npm:^7.29.7" + "@babel/parser": "npm:^7.29.7" + "@babel/template": "npm:^7.29.7" + "@babel/types": "npm:^7.29.7" + debug: "npm:^4.3.1" + checksum: 10c0/e256a1fbdb956555b76f3c285b1e453f6bedec8b3afb61751d99d933efd11c7d79caf5ddf2493570058a9f7deaa1b48324380d7c1aa1443fd9508becbf56331a + languageName: node + linkType: hard + +"@babel/traverse@npm:^8.0.0": + version: 8.0.0 + resolution: "@babel/traverse@npm:8.0.0" + dependencies: + "@babel/code-frame": "npm:^8.0.0" + "@babel/generator": "npm:^8.0.0" + "@babel/helper-globals": "npm:^8.0.0" + "@babel/parser": "npm:^8.0.0" + "@babel/template": "npm:^8.0.0" + "@babel/types": "npm:^8.0.0" + obug: "npm:^2.1.1" + checksum: 10c0/de5e5c144c72a2949d75ea8baf5dd2926a6410512397ac28692719df45e31e70e26415e10cacfe2c1c1dd73e7276c6a8fc832754c8b14202627d64e1aa1a9393 + languageName: node + linkType: hard + +"@babel/types@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/types@npm:7.29.7" + dependencies: + "@babel/helper-string-parser": "npm:^7.29.7" + "@babel/helper-validator-identifier": "npm:^7.29.7" + checksum: 10c0/b6623994c69717fa27294f5fa46d59140338e2d86c6c1c13085c84ef7d53086ee357fbf4fe9abe3dd3da75734dc77c4c0df2f90fb29e667558bb3b3fb705e88f + languageName: node + linkType: hard + +"@babel/types@npm:^8.0.0": + version: 8.0.0 + resolution: "@babel/types@npm:8.0.0" + dependencies: + "@babel/helper-string-parser": "npm:^8.0.0" + "@babel/helper-validator-identifier": "npm:^8.0.0" + checksum: 10c0/f4130b88818cf9fd0fb653dd35459f58794018416bc0cee0eccefd364c2d146ae90611ae3ae19d91c2f0bbd1e0e440840832baf9a3d5eb5fed077a52f0bcc001 + languageName: node + linkType: hard + +"@base-ui/react@npm:^1.6.0": + version: 1.6.0 + resolution: "@base-ui/react@npm:1.6.0" + dependencies: + "@babel/runtime": "npm:^7.29.2" + "@base-ui/utils": "npm:0.3.1" + "@floating-ui/react-dom": "npm:^2.1.8" + "@floating-ui/utils": "npm:^0.2.11" + use-sync-external-store: "npm:^1.6.0" + peerDependencies: + "@date-fns/tz": ^1.2.0 + "@types/react": ^17 || ^18 || ^19 + date-fns: ^4.0.0 + react: ^17 || ^18 || ^19 + react-dom: ^17 || ^18 || ^19 + peerDependenciesMeta: + "@date-fns/tz": + optional: true + "@types/react": + optional: true + date-fns: + optional: true + checksum: 10c0/5e5994dc782710eac900d68cc0691aea70a47fabc6ef8d2ea943103d9aa96c4b44f9fd76ba65d29fa2667a5fbd7ea7a1cc02fe111c4bf639d4e3e65a1c281118 + languageName: node + linkType: hard + +"@base-ui/utils@npm:0.3.1": + version: 0.3.1 + resolution: "@base-ui/utils@npm:0.3.1" + dependencies: + "@babel/runtime": "npm:^7.29.2" + "@floating-ui/utils": "npm:^0.2.11" + reselect: "npm:^5.2.0" + use-sync-external-store: "npm:^1.6.0" + peerDependencies: + "@types/react": ^17 || ^18 || ^19 + react: ^17 || ^18 || ^19 + react-dom: ^17 || ^18 || ^19 + peerDependenciesMeta: + "@types/react": + optional: true + checksum: 10c0/4de858c3e2c8a4486a549d51c5e887bba6921e5a7f8db54439ba558feaf1656c3592a873928aee8a1711ee9210be3a65ca43b26713e97f649695ed2fa8c3af2c + languageName: node + linkType: hard + +"@emotion/babel-plugin@npm:^11.13.5": + version: 11.13.5 + resolution: "@emotion/babel-plugin@npm:11.13.5" + dependencies: + "@babel/helper-module-imports": "npm:^7.16.7" + "@babel/runtime": "npm:^7.18.3" + "@emotion/hash": "npm:^0.9.2" + "@emotion/memoize": "npm:^0.9.0" + "@emotion/serialize": "npm:^1.3.3" + babel-plugin-macros: "npm:^3.1.0" + convert-source-map: "npm:^1.5.0" + escape-string-regexp: "npm:^4.0.0" + find-root: "npm:^1.1.0" + source-map: "npm:^0.5.7" + stylis: "npm:4.2.0" + checksum: 10c0/8ccbfec7defd0e513cb8a1568fa179eac1e20c35fda18aed767f6c59ea7314363ebf2de3e9d2df66c8ad78928dc3dceeded84e6fa8059087cae5c280090aeeeb + languageName: node + linkType: hard + +"@emotion/cache@npm:^11.14.0": + version: 11.14.0 + resolution: "@emotion/cache@npm:11.14.0" + dependencies: + "@emotion/memoize": "npm:^0.9.0" + "@emotion/sheet": "npm:^1.4.0" + "@emotion/utils": "npm:^1.4.2" + "@emotion/weak-memoize": "npm:^0.4.0" + stylis: "npm:4.2.0" + checksum: 10c0/3fa3e7a431ab6f8a47c67132a00ac8358f428c1b6c8421d4b20de9df7c18e95eec04a5a6ff5a68908f98d3280044f247b4965ac63df8302d2c94dba718769724 + languageName: node + linkType: hard + +"@emotion/hash@npm:^0.9.2": + version: 0.9.2 + resolution: "@emotion/hash@npm:0.9.2" + checksum: 10c0/0dc254561a3cc0a06a10bbce7f6a997883fd240c8c1928b93713f803a2e9153a257a488537012efe89dbe1246f2abfe2add62cdb3471a13d67137fcb808e81c2 + languageName: node + linkType: hard + +"@emotion/is-prop-valid@npm:^1.3.0": + version: 1.4.0 + resolution: "@emotion/is-prop-valid@npm:1.4.0" + dependencies: + "@emotion/memoize": "npm:^0.9.0" + checksum: 10c0/5f857814ec7d8c7e727727346dfb001af6b1fb31d621a3ce9c3edf944a484d8b0d619546c30899ae3ade2f317c76390ba4394449728e9bf628312defc2c41ac3 + languageName: node + linkType: hard + +"@emotion/memoize@npm:^0.9.0": + version: 0.9.0 + resolution: "@emotion/memoize@npm:0.9.0" + checksum: 10c0/13f474a9201c7f88b543e6ea42f55c04fb2fdc05e6c5a3108aced2f7e7aa7eda7794c56bba02985a46d8aaa914fcdde238727a98341a96e2aec750d372dadd15 + languageName: node + linkType: hard + +"@emotion/react@npm:^11.14.0": + version: 11.14.0 + resolution: "@emotion/react@npm:11.14.0" + dependencies: + "@babel/runtime": "npm:^7.18.3" + "@emotion/babel-plugin": "npm:^11.13.5" + "@emotion/cache": "npm:^11.14.0" + "@emotion/serialize": "npm:^1.3.3" + "@emotion/use-insertion-effect-with-fallbacks": "npm:^1.2.0" + "@emotion/utils": "npm:^1.4.2" + "@emotion/weak-memoize": "npm:^0.4.0" + hoist-non-react-statics: "npm:^3.3.1" + peerDependencies: + react: ">=16.8.0" + peerDependenciesMeta: + "@types/react": + optional: true + checksum: 10c0/d0864f571a9f99ec643420ef31fde09e2006d3943a6aba079980e4d5f6e9f9fecbcc54b8f617fe003c00092ff9d5241179149ffff2810cb05cf72b4620cfc031 + languageName: node + linkType: hard + +"@emotion/serialize@npm:^1.3.3": + version: 1.3.3 + resolution: "@emotion/serialize@npm:1.3.3" + dependencies: + "@emotion/hash": "npm:^0.9.2" + "@emotion/memoize": "npm:^0.9.0" + "@emotion/unitless": "npm:^0.10.0" + "@emotion/utils": "npm:^1.4.2" + csstype: "npm:^3.0.2" + checksum: 10c0/b28cb7de59de382021de2b26c0c94ebbfb16967a1b969a56fdb6408465a8993df243bfbd66430badaa6800e1834724e84895f5a6a9d97d0d224de3d77852acb4 + languageName: node + linkType: hard + +"@emotion/sheet@npm:^1.4.0": + version: 1.4.0 + resolution: "@emotion/sheet@npm:1.4.0" + checksum: 10c0/3ca72d1650a07d2fbb7e382761b130b4a887dcd04e6574b2d51ce578791240150d7072a9bcb4161933abbcd1e38b243a6fb4464a7fe991d700c17aa66bb5acc7 + languageName: node + linkType: hard + +"@emotion/styled@npm:^11.14.1": + version: 11.14.1 + resolution: "@emotion/styled@npm:11.14.1" + dependencies: + "@babel/runtime": "npm:^7.18.3" + "@emotion/babel-plugin": "npm:^11.13.5" + "@emotion/is-prop-valid": "npm:^1.3.0" + "@emotion/serialize": "npm:^1.3.3" + "@emotion/use-insertion-effect-with-fallbacks": "npm:^1.2.0" + "@emotion/utils": "npm:^1.4.2" + peerDependencies: + "@emotion/react": ^11.0.0-rc.0 + react: ">=16.8.0" + peerDependenciesMeta: + "@types/react": + optional: true + checksum: 10c0/2bbf8451df49c967e41fbcf8111a7f6dafe6757f0cc113f2f6e287206c45ac1d54dc8a95a483b7c0cee8614b8a8d08155bded6453d6721de1f8cc8d5b9216963 + languageName: node + linkType: hard + +"@emotion/unitless@npm:^0.10.0": + version: 0.10.0 + resolution: "@emotion/unitless@npm:0.10.0" + checksum: 10c0/150943192727b7650eb9a6851a98034ddb58a8b6958b37546080f794696141c3760966ac695ab9af97efe10178690987aee4791f9f0ad1ff76783cdca83c1d49 + languageName: node + linkType: hard + +"@emotion/use-insertion-effect-with-fallbacks@npm:^1.2.0": + version: 1.2.0 + resolution: "@emotion/use-insertion-effect-with-fallbacks@npm:1.2.0" + peerDependencies: + react: ">=16.8.0" + checksum: 10c0/074dbc92b96bdc09209871070076e3b0351b6b47efefa849a7d9c37ab142130767609ca1831da0055988974e3b895c1de7606e4c421fecaa27c3e56a2afd3b08 + languageName: node + linkType: hard + +"@emotion/utils@npm:^1.4.2": + version: 1.4.2 + resolution: "@emotion/utils@npm:1.4.2" + checksum: 10c0/7d0010bf60a2a8c1a033b6431469de4c80e47aeb8fd856a17c1d1f76bbc3a03161a34aeaa78803566e29681ca551e7bf9994b68e9c5f5c796159923e44f78d9a + languageName: node + linkType: hard + +"@emotion/weak-memoize@npm:^0.4.0": + version: 0.4.0 + resolution: "@emotion/weak-memoize@npm:0.4.0" + checksum: 10c0/64376af11f1266042d03b3305c30b7502e6084868e33327e944b539091a472f089db307af69240f7188f8bc6b319276fd7b141a36613f1160d73d12a60f6ca1a + languageName: node + linkType: hard + +"@esbuild/aix-ppc64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/aix-ppc64@npm:0.27.7" + conditions: os=aix & cpu=ppc64 + languageName: node + linkType: hard + +"@esbuild/android-arm64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/android-arm64@npm:0.27.7" + conditions: os=android & cpu=arm64 + languageName: node + linkType: hard + +"@esbuild/android-arm@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/android-arm@npm:0.27.7" + conditions: os=android & cpu=arm + languageName: node + linkType: hard + +"@esbuild/android-x64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/android-x64@npm:0.27.7" + conditions: os=android & cpu=x64 + languageName: node + linkType: hard + +"@esbuild/darwin-arm64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/darwin-arm64@npm:0.27.7" + conditions: os=darwin & cpu=arm64 + languageName: node + linkType: hard + +"@esbuild/darwin-x64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/darwin-x64@npm:0.27.7" + conditions: os=darwin & cpu=x64 + languageName: node + linkType: hard + +"@esbuild/freebsd-arm64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/freebsd-arm64@npm:0.27.7" + conditions: os=freebsd & cpu=arm64 + languageName: node + linkType: hard + +"@esbuild/freebsd-x64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/freebsd-x64@npm:0.27.7" + conditions: os=freebsd & cpu=x64 + languageName: node + linkType: hard + +"@esbuild/linux-arm64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/linux-arm64@npm:0.27.7" + conditions: os=linux & cpu=arm64 + languageName: node + linkType: hard + +"@esbuild/linux-arm@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/linux-arm@npm:0.27.7" + conditions: os=linux & cpu=arm + languageName: node + linkType: hard + +"@esbuild/linux-ia32@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/linux-ia32@npm:0.27.7" + conditions: os=linux & cpu=ia32 + languageName: node + linkType: hard + +"@esbuild/linux-loong64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/linux-loong64@npm:0.27.7" + conditions: os=linux & cpu=loong64 + languageName: node + linkType: hard + +"@esbuild/linux-mips64el@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/linux-mips64el@npm:0.27.7" + conditions: os=linux & cpu=mips64el + languageName: node + linkType: hard + +"@esbuild/linux-ppc64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/linux-ppc64@npm:0.27.7" + conditions: os=linux & cpu=ppc64 + languageName: node + linkType: hard + +"@esbuild/linux-riscv64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/linux-riscv64@npm:0.27.7" + conditions: os=linux & cpu=riscv64 + languageName: node + linkType: hard + +"@esbuild/linux-s390x@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/linux-s390x@npm:0.27.7" + conditions: os=linux & cpu=s390x + languageName: node + linkType: hard + +"@esbuild/linux-x64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/linux-x64@npm:0.27.7" + conditions: os=linux & cpu=x64 + languageName: node + linkType: hard + +"@esbuild/netbsd-arm64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/netbsd-arm64@npm:0.27.7" + conditions: os=netbsd & cpu=arm64 + languageName: node + linkType: hard + +"@esbuild/netbsd-x64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/netbsd-x64@npm:0.27.7" + conditions: os=netbsd & cpu=x64 + languageName: node + linkType: hard + +"@esbuild/openbsd-arm64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/openbsd-arm64@npm:0.27.7" + conditions: os=openbsd & cpu=arm64 + languageName: node + linkType: hard + +"@esbuild/openbsd-x64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/openbsd-x64@npm:0.27.7" + conditions: os=openbsd & cpu=x64 + languageName: node + linkType: hard + +"@esbuild/openharmony-arm64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/openharmony-arm64@npm:0.27.7" + conditions: os=openharmony & cpu=arm64 + languageName: node + linkType: hard + +"@esbuild/sunos-x64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/sunos-x64@npm:0.27.7" + conditions: os=sunos & cpu=x64 + languageName: node + linkType: hard + +"@esbuild/win32-arm64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/win32-arm64@npm:0.27.7" + conditions: os=win32 & cpu=arm64 + languageName: node + linkType: hard + +"@esbuild/win32-ia32@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/win32-ia32@npm:0.27.7" + conditions: os=win32 & cpu=ia32 + languageName: node + linkType: hard + +"@esbuild/win32-x64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/win32-x64@npm:0.27.7" + conditions: os=win32 & cpu=x64 + languageName: node + linkType: hard + +"@eslint-community/eslint-utils@npm:^4.8.0": + version: 4.9.1 + resolution: "@eslint-community/eslint-utils@npm:4.9.1" + dependencies: + eslint-visitor-keys: "npm:^3.4.3" + peerDependencies: + eslint: ^6.0.0 || ^7.0.0 || >=8.0.0 + checksum: 10c0/dc4ab5e3e364ef27e33666b11f4b86e1a6c1d7cbf16f0c6ff87b1619b3562335e9201a3d6ce806221887ff780ec9d828962a290bb910759fd40a674686503f02 + languageName: node + linkType: hard + +"@eslint-community/regexpp@npm:^4.12.2": + version: 4.12.2 + resolution: "@eslint-community/regexpp@npm:4.12.2" + checksum: 10c0/fddcbc66851b308478d04e302a4d771d6917a0b3740dc351513c0da9ca2eab8a1adf99f5e0aa7ab8b13fa0df005c81adeee7e63a92f3effd7d367a163b721c2d + languageName: node + linkType: hard + +"@eslint/config-array@npm:^0.23.5": + version: 0.23.5 + resolution: "@eslint/config-array@npm:0.23.5" + dependencies: + "@eslint/object-schema": "npm:^3.0.5" + debug: "npm:^4.3.1" + minimatch: "npm:^10.2.4" + checksum: 10c0/b24833c4c76e78ee075d306cd3f095db46b2db0f90cc13a6ee6e4275f9889731c05bf5403ab5fefb79c756e07ac9184ed0e04570341382f9eccbccc80e6d1a0c + languageName: node + linkType: hard + +"@eslint/config-helpers@npm:^0.6.0": + version: 0.6.0 + resolution: "@eslint/config-helpers@npm:0.6.0" + dependencies: + "@eslint/core": "npm:^1.2.1" + checksum: 10c0/f9af20e8b60b0ba27edb74b8eb40c0c5d51a9bf9baf9e053bb57833a87cb0a1c49b4dfaad88fc24d49c907ad1324c8a0b668684fa9c321351dac4bc9155ec10a + languageName: node + linkType: hard + +"@eslint/core@npm:^1.2.1": + version: 1.2.1 + resolution: "@eslint/core@npm:1.2.1" + dependencies: + "@types/json-schema": "npm:^7.0.15" + checksum: 10c0/10979b40588ecfef771fcb5013a542a35fb30692cc95a65f3481b0b36fbd89f5679efeb30d57f4eed35203d859aabace2a620177d6c536f71b299a1af2f3398f + languageName: node + linkType: hard + +"@eslint/js@npm:^9.29.0": + version: 9.39.4 + resolution: "@eslint/js@npm:9.39.4" + checksum: 10c0/5aa7dea2cbc5decf7f5e3b0c6f86a084ccee0f792d288ca8e839f8bc1b64e03e227068968e49b26096e6f71fd857ab6e42691d1b993826b9a3883f1bdd7a0e46 + languageName: node + linkType: hard + +"@eslint/object-schema@npm:^3.0.5": + version: 3.0.5 + resolution: "@eslint/object-schema@npm:3.0.5" + checksum: 10c0/1db337431f520b99e9edda64ef5fafd7ec6a029843eeb608753025125b6649d861d843cffafafd3c4e37926d7d5f9ec0c6a8e3665c13c3da2144e8132892e92e + languageName: node + linkType: hard + +"@eslint/plugin-kit@npm:^0.7.2": + version: 0.7.2 + resolution: "@eslint/plugin-kit@npm:0.7.2" + dependencies: + "@eslint/core": "npm:^1.2.1" + levn: "npm:^0.4.1" + checksum: 10c0/aafba08077bcd6d7dde6c2e21db18086046a88f914f29971a84cac9ad2d48952ded1b293e665e523805297eff756522dafa16f0062195e2c7143dcd1d47d11ed + languageName: node + linkType: hard + +"@floating-ui/core@npm:^1.7.5": + version: 1.7.5 + resolution: "@floating-ui/core@npm:1.7.5" + dependencies: + "@floating-ui/utils": "npm:^0.2.11" + checksum: 10c0/f9c52205e198b231d63a387b09c659aab08c46a1899e0b0bbe147b8b4f048b546f15ba17cb5d2a471da9534f1883d979425e13e5c4ceee67be63e4b0abd4db5d + languageName: node + linkType: hard + +"@floating-ui/dom@npm:^1.7.6": + version: 1.7.6 + resolution: "@floating-ui/dom@npm:1.7.6" + dependencies: + "@floating-ui/core": "npm:^1.7.5" + "@floating-ui/utils": "npm:^0.2.11" + checksum: 10c0/5c098e0d7b58c9bc769f276cca1766994c2c9c70c92d091a61bba8b3e9be53c011e0a79a8457fc2fb2f3d91697a26eb52e0a4962ef936dc963b45f58613c212f + languageName: node + linkType: hard + +"@floating-ui/react-dom@npm:^2.1.8": + version: 2.1.8 + resolution: "@floating-ui/react-dom@npm:2.1.8" + dependencies: + "@floating-ui/dom": "npm:^1.7.6" + peerDependencies: + react: ">=16.8.0" + react-dom: ">=16.8.0" + checksum: 10c0/26260ca4bb23b57c73b824062505abf977a008ce6e0463bdacca74f7e49853c4cd1d2bbf1a77c6caa17fa37dfffda2c6c4cd07a8737ebd7474aaff7818401d75 + languageName: node + linkType: hard + +"@floating-ui/utils@npm:^0.2.11": + version: 0.2.11 + resolution: "@floating-ui/utils@npm:0.2.11" + checksum: 10c0/f4bcea1559bdbb721ecc8e8ead423ac58d6a5b6e70b602cf0810ba6ad4ed1c77211b207faa88b278a9042f0c743133de08a203ed6741c1b6443423332884d5b3 + languageName: node + linkType: hard + +"@fontsource/roboto@npm:^5.2.10": + version: 5.2.10 + resolution: "@fontsource/roboto@npm:5.2.10" + checksum: 10c0/abadfcaefbe2196bbd36d9258b336063f721894a3624a9639da00792583c565bfd0748ef978f91a38c3c0de8d247615c9be92a763184c085c630fa43f04b1cd9 + languageName: node + linkType: hard + +"@humanfs/core@npm:^0.19.2": + version: 0.19.2 + resolution: "@humanfs/core@npm:0.19.2" + dependencies: + "@humanfs/types": "npm:^0.15.0" + checksum: 10c0/d0a1d52d7b30c27d49475a53072d1510b81c5803e44b342fb8faf3887f1aa27593a1e6dc76a45268e7892d3f4e198146659281f6b6d55eacf3fd5a38bac30c5c + languageName: node + linkType: hard + +"@humanfs/node@npm:^0.16.6": + version: 0.16.8 + resolution: "@humanfs/node@npm:0.16.8" + dependencies: + "@humanfs/core": "npm:^0.19.2" + "@humanfs/types": "npm:^0.15.0" + "@humanwhocodes/retry": "npm:^0.4.0" + checksum: 10c0/56140579db811af4e160b195d45d0f29acf644d192c93fe24c9e594ebf06f19dfc157494a07c84540b8a071c0e4b37209c2362765d31734f4d0be869c2422e25 + languageName: node + linkType: hard + +"@humanfs/types@npm:^0.15.0": + version: 0.15.0 + resolution: "@humanfs/types@npm:0.15.0" + checksum: 10c0/fc26b9a024b0e55f7eaf64036df94345bf5d36d6a41ef80ef38e78f1f7430ce26cf435af736adae58913baae18eac3f38c18739054a3d379102015978eae862e + languageName: node + linkType: hard + +"@humanwhocodes/module-importer@npm:^1.0.1": + version: 1.0.1 + resolution: "@humanwhocodes/module-importer@npm:1.0.1" + checksum: 10c0/909b69c3b86d482c26b3359db16e46a32e0fb30bd306a3c176b8313b9e7313dba0f37f519de6aa8b0a1921349e505f259d19475e123182416a506d7f87e7f529 + languageName: node + linkType: hard + +"@humanwhocodes/retry@npm:^0.4.0, @humanwhocodes/retry@npm:^0.4.2": + version: 0.4.3 + resolution: "@humanwhocodes/retry@npm:0.4.3" + checksum: 10c0/3775bb30087d4440b3f7406d5a057777d90e4b9f435af488a4923ef249e93615fb78565a85f173a186a076c7706a81d0d57d563a2624e4de2c5c9c66c486ce42 + languageName: node + linkType: hard + +"@isaacs/fs-minipass@npm:^4.0.0": + version: 4.0.1 + resolution: "@isaacs/fs-minipass@npm:4.0.1" + dependencies: + minipass: "npm:^7.0.4" + checksum: 10c0/c25b6dc1598790d5b55c0947a9b7d111cfa92594db5296c3b907e2f533c033666f692a3939eadac17b1c7c40d362d0b0635dc874cbfe3e70db7c2b07cc97a5d2 + languageName: node + linkType: hard + +"@jridgewell/gen-mapping@npm:^0.3.12, @jridgewell/gen-mapping@npm:^0.3.5": + version: 0.3.13 + resolution: "@jridgewell/gen-mapping@npm:0.3.13" + dependencies: + "@jridgewell/sourcemap-codec": "npm:^1.5.0" + "@jridgewell/trace-mapping": "npm:^0.3.24" + checksum: 10c0/9a7d65fb13bd9aec1fbab74cda08496839b7e2ceb31f5ab922b323e94d7c481ce0fc4fd7e12e2610915ed8af51178bdc61e168e92a8c8b8303b030b03489b13b + languageName: node + linkType: hard + +"@jridgewell/remapping@npm:^2.3.5": + version: 2.3.5 + resolution: "@jridgewell/remapping@npm:2.3.5" + dependencies: + "@jridgewell/gen-mapping": "npm:^0.3.5" + "@jridgewell/trace-mapping": "npm:^0.3.24" + checksum: 10c0/3de494219ffeb2c5c38711d0d7bb128097edf91893090a2dbc8ee0b55d092bb7347b1fd0f478486c5eab010e855c73927b1666f2107516d472d24a73017d1194 + languageName: node + linkType: hard + +"@jridgewell/resolve-uri@npm:^3.1.0": + version: 3.1.2 + resolution: "@jridgewell/resolve-uri@npm:3.1.2" + checksum: 10c0/d502e6fb516b35032331406d4e962c21fe77cdf1cbdb49c6142bcbd9e30507094b18972778a6e27cbad756209cfe34b1a27729e6fa08a2eb92b33943f680cf1e + languageName: node + linkType: hard + +"@jridgewell/sourcemap-codec@npm:^1.4.14, @jridgewell/sourcemap-codec@npm:^1.5.0, @jridgewell/sourcemap-codec@npm:^1.5.5": + version: 1.5.5 + resolution: "@jridgewell/sourcemap-codec@npm:1.5.5" + checksum: 10c0/f9e538f302b63c0ebc06eecb1dd9918dd4289ed36147a0ddce35d6ea4d7ebbda243cda7b2213b6a5e1d8087a298d5cf630fb2bd39329cdecb82017023f6081a0 + languageName: node + linkType: hard + +"@jridgewell/trace-mapping@npm:^0.3.24, @jridgewell/trace-mapping@npm:^0.3.28": + version: 0.3.31 + resolution: "@jridgewell/trace-mapping@npm:0.3.31" + dependencies: + "@jridgewell/resolve-uri": "npm:^3.1.0" + "@jridgewell/sourcemap-codec": "npm:^1.4.14" + checksum: 10c0/4b30ec8cd56c5fd9a661f088230af01e0c1a3888d11ffb6b47639700f71225be21d1f7e168048d6d4f9449207b978a235c07c8f15c07705685d16dc06280e9d9 + languageName: node + linkType: hard + +"@mdn/browser-compat-data@npm:^5.6.19": + version: 5.7.6 + resolution: "@mdn/browser-compat-data@npm:5.7.6" + checksum: 10c0/918df768e734115bee0a43fb2eceaf6438cb9b294c27e13d0ac8a19ab9f00f59e4f306fc38c498b62bdec2d726d4f3874826fa2afccd2a29d50d306f687bfdff + languageName: node + linkType: hard + +"@mdn/browser-compat-data@npm:^6.1.1": + version: 6.1.5 + resolution: "@mdn/browser-compat-data@npm:6.1.5" + checksum: 10c0/a2d8ef7cdb3268c72540909755d4d56ae5a8674ddd8216a3bd4a40e4d1497c01b0205a29a8fd6bf4599e091cbc8a90d9a3a52836a8439d66b0af00886f68e7b9 + languageName: node + linkType: hard + +"@mui/core-downloads-tracker@npm:^9.1.2": + version: 9.1.2 + resolution: "@mui/core-downloads-tracker@npm:9.1.2" + checksum: 10c0/787f9bf6bc178cf405252bbd7ab8fd24375cb203fe36beedc29165eea432bf120e1fdf61b22de0037b6e2db6702c9f348c8f45164a5c367a3f3dbacea6f1fe04 + languageName: node + linkType: hard + +"@mui/icons-material@npm:^9.1.1": + version: 9.1.1 + resolution: "@mui/icons-material@npm:9.1.1" + dependencies: + "@babel/runtime": "npm:^7.29.2" + peerDependencies: + "@mui/material": ^9.1.1 + "@types/react": ^17.0.0 || ^18.0.0 || ^19.0.0 + react: ^17.0.0 || ^18.0.0 || ^19.0.0 + peerDependenciesMeta: + "@types/react": + optional: true + checksum: 10c0/bb7719221fed6258be9959538986aa9525370a0db25ca4acf3d58adb85a119ebc98ca519054789efffb3813aeea9c83d120b3e0358f7b67e88f73997ef33c986 + languageName: node + linkType: hard + +"@mui/material@npm:^9.1.2": + version: 9.1.2 + resolution: "@mui/material@npm:9.1.2" + dependencies: + "@babel/runtime": "npm:^7.29.2" + "@mui/core-downloads-tracker": "npm:^9.1.2" + "@mui/system": "npm:^9.1.2" + "@mui/types": "npm:^9.1.1" + "@mui/utils": "npm:^9.1.1" + "@popperjs/core": "npm:^2.11.8" + "@types/react-transition-group": "npm:^4.4.12" + clsx: "npm:^2.1.1" + csstype: "npm:^3.2.3" + prop-types: "npm:^15.8.1" + react-is: "npm:^19.2.6" + react-transition-group: "npm:^4.4.5" + peerDependencies: + "@emotion/react": ^11.5.0 + "@emotion/styled": ^11.3.0 + "@mui/material-pigment-css": ^9.1.1 + "@types/react": ^17.0.0 || ^18.0.0 || ^19.0.0 + react: ^17.0.0 || ^18.0.0 || ^19.0.0 + react-dom: ^17.0.0 || ^18.0.0 || ^19.0.0 + peerDependenciesMeta: + "@emotion/react": + optional: true + "@emotion/styled": + optional: true + "@mui/material-pigment-css": + optional: true + "@types/react": + optional: true + checksum: 10c0/b3279d4b8f2df6c6de88b51bb236b8f800dbc83d37eb168c4525bef01990a1e4016f65868a68e0244fd01113bba9b297e9fc10c41499b1b540c4c3778b61da5e + languageName: node + linkType: hard + +"@mui/private-theming@npm:^9.1.1": + version: 9.1.1 + resolution: "@mui/private-theming@npm:9.1.1" + dependencies: + "@babel/runtime": "npm:^7.29.2" + "@mui/utils": "npm:^9.1.1" + prop-types: "npm:^15.8.1" + peerDependencies: + "@types/react": ^17.0.0 || ^18.0.0 || ^19.0.0 + react: ^17.0.0 || ^18.0.0 || ^19.0.0 + peerDependenciesMeta: + "@types/react": + optional: true + checksum: 10c0/edf9cd75aee97a6b95e2ea98cbb4c8d3f72db48db909c445f3129a6a5fad00ca917ec1bfdd1d107481ecc20b9c9d9560298cb588102f069c0b0a5a9c7198eb49 + languageName: node + linkType: hard + +"@mui/styled-engine@npm:^9.1.1": + version: 9.1.1 + resolution: "@mui/styled-engine@npm:9.1.1" + dependencies: + "@babel/runtime": "npm:^7.29.2" + "@emotion/cache": "npm:^11.14.0" + "@emotion/serialize": "npm:^1.3.3" + "@emotion/sheet": "npm:^1.4.0" + csstype: "npm:^3.2.3" + prop-types: "npm:^15.8.1" + peerDependencies: + "@emotion/react": ^11.4.1 + "@emotion/styled": ^11.3.0 + react: ^17.0.0 || ^18.0.0 || ^19.0.0 + peerDependenciesMeta: + "@emotion/react": + optional: true + "@emotion/styled": + optional: true + checksum: 10c0/250bb2a94ac3399a3a9c2ba81871419100fed51b823b87a935215c50781aace3022585697039898073964e661e749abd9e30a6a241ce7567ad5eec47ef082467 + languageName: node + linkType: hard + +"@mui/system@npm:^9.1.2": + version: 9.1.2 + resolution: "@mui/system@npm:9.1.2" + dependencies: + "@babel/runtime": "npm:^7.29.2" + "@mui/private-theming": "npm:^9.1.1" + "@mui/styled-engine": "npm:^9.1.1" + "@mui/types": "npm:^9.1.1" + "@mui/utils": "npm:^9.1.1" + clsx: "npm:^2.1.1" + csstype: "npm:^3.2.3" + prop-types: "npm:^15.8.1" + peerDependencies: + "@emotion/react": ^11.5.0 + "@emotion/styled": ^11.3.0 + "@types/react": ^17.0.0 || ^18.0.0 || ^19.0.0 + react: ^17.0.0 || ^18.0.0 || ^19.0.0 + peerDependenciesMeta: + "@emotion/react": + optional: true + "@emotion/styled": + optional: true + "@types/react": + optional: true + checksum: 10c0/9f274cf009e4235a9bbb9a6524aa2de6ba59a3fc01e91157004be1a4d5c6d4db5f16d91dfe95d3c3acb36fa355a8ac7d811b146a547f3b9292c2a1c981adb707 + languageName: node + linkType: hard + +"@mui/types@npm:^9.1.1": + version: 9.1.1 + resolution: "@mui/types@npm:9.1.1" + dependencies: + "@babel/runtime": "npm:^7.29.2" + peerDependencies: + "@types/react": ^17.0.0 || ^18.0.0 || ^19.0.0 + peerDependenciesMeta: + "@types/react": + optional: true + checksum: 10c0/83cb89cafba0c55c909a8a89bd165550a71f92a67bbd191823b6ec304e5f59b43438052fecc4f69cc27e4e557c6bce3d5a073b9f5d5787d62d8cdc055e479905 + languageName: node + linkType: hard + +"@mui/utils@npm:^9.1.1": + version: 9.1.1 + resolution: "@mui/utils@npm:9.1.1" + dependencies: + "@babel/runtime": "npm:^7.29.2" + "@mui/types": "npm:^9.1.1" + "@types/prop-types": "npm:^15.7.15" + clsx: "npm:^2.1.1" + prop-types: "npm:^15.8.1" + react-is: "npm:^19.2.6" + peerDependencies: + "@types/react": ^17.0.0 || ^18.0.0 || ^19.0.0 + react: ^17.0.0 || ^18.0.0 || ^19.0.0 + peerDependenciesMeta: + "@types/react": + optional: true + checksum: 10c0/a39936fa287ba3f53c47ef3072b813b797a75b43ed95212e817e9d3828e2de8079ae834061fc7e76b096eb0ceddd39468f4f0423ac25b6ac39aa77d70945966b + languageName: node + linkType: hard + +"@nicolo-ribaudo/eslint-scope-5-internals@npm:5.1.1-v1": + version: 5.1.1-v1 + resolution: "@nicolo-ribaudo/eslint-scope-5-internals@npm:5.1.1-v1" + dependencies: + eslint-scope: "npm:5.1.1" + checksum: 10c0/75dda3e623b8ad7369ca22552d6beee337a814b2d0e8a32d23edd13fcb65c8082b32c5d86e436f3860dd7ade30d91d5db55d4ef9a08fb5a976c718ecc0d88a74 + languageName: node + linkType: hard + +"@popperjs/core@npm:^2.11.8": + version: 2.11.8 + resolution: "@popperjs/core@npm:2.11.8" + checksum: 10c0/4681e682abc006d25eb380d0cf3efc7557043f53b6aea7a5057d0d1e7df849a00e281cd8ea79c902a35a414d7919621fc2ba293ecec05f413598e0b23d5a1e63 + languageName: node + linkType: hard + +"@preact/preset-vite@npm:^2.10.2": + version: 2.10.5 + resolution: "@preact/preset-vite@npm:2.10.5" + dependencies: + "@babel/plugin-transform-react-jsx": "npm:^7.27.1" + "@babel/plugin-transform-react-jsx-development": "npm:^7.27.1" + "@prefresh/vite": "npm:^2.4.11" + "@rollup/pluginutils": "npm:^5.0.0" + babel-plugin-transform-hook-names: "npm:^1.0.2" + debug: "npm:^4.4.3" + magic-string: "npm:^0.30.21" + picocolors: "npm:^1.1.1" + vite-prerender-plugin: "npm:^0.5.8" + zimmerframe: "npm:^1.1.4" + peerDependencies: + "@babel/core": 7.x + vite: 2.x || 3.x || 4.x || 5.x || 6.x || 7.x || 8.x + checksum: 10c0/fb548ffa0f7a90699ddc909b318d70d1f6f255a26193628578ef81517258d63d50d412b9dc87a5a4d9b13c4a62d47e9688aeee575bc8cdeeeefe5145e62ea741 + languageName: node + linkType: hard + +"@prefresh/babel-plugin@npm:^0.5.2": + version: 0.5.3 + resolution: "@prefresh/babel-plugin@npm:0.5.3" + checksum: 10c0/59cb7bde2dac2265f28f18c8fc3799efd75ebb117c7df19c7fea597a03db4af973ee56a21e9fa2588f707a3ef8a90ddc19e95d1d151641a068d98a690b0bc6ea + languageName: node + linkType: hard + +"@prefresh/core@npm:^1.5.0": + version: 1.5.10 + resolution: "@prefresh/core@npm:1.5.10" + peerDependencies: + preact: ^10.0.0 || ^11.0.0-0 + checksum: 10c0/61320c197b8075f0a2895b2cde75d9600b471b4241eb4a5855547fdef20298f732480e27522bb6e9ca64d47d645dd45717d9c0571446523c5b0701063c486c60 + languageName: node + linkType: hard + +"@prefresh/utils@npm:^1.2.0": + version: 1.2.1 + resolution: "@prefresh/utils@npm:1.2.1" + checksum: 10c0/d36bcc8995128ee9028e2c48cb7812c7736a0c8e228ded586de4595f587b239ec9daac2c82221a476ffd341412dbb62082d09f7191d3ee7f5d0b8a99a45f01a8 + languageName: node + linkType: hard + +"@prefresh/vite@npm:^2.4.11": + version: 2.4.12 + resolution: "@prefresh/vite@npm:2.4.12" + dependencies: + "@babel/core": "npm:^7.22.1" + "@prefresh/babel-plugin": "npm:^0.5.2" + "@prefresh/core": "npm:^1.5.0" + "@prefresh/utils": "npm:^1.2.0" + "@rollup/pluginutils": "npm:^4.2.1" + peerDependencies: + preact: ^10.4.0 || ^11.0.0-0 + vite: ">=2.0.0" + checksum: 10c0/b3e9957a6821831c294457fd0b5063fa83828fc9837b01472a377c858d3335a3c88920e99ce77381de3a63f8394459423d812e973d9afd32950b4e0db66970df + languageName: node + linkType: hard + +"@rollup/pluginutils@npm:^4.2.1": + version: 4.2.1 + resolution: "@rollup/pluginutils@npm:4.2.1" + dependencies: + estree-walker: "npm:^2.0.1" + picomatch: "npm:^2.2.2" + checksum: 10c0/3ee56b2c8f1ed8dfd0a92631da1af3a2dfdd0321948f089b3752b4de1b54dc5076701eadd0e5fc18bd191b77af594ac1db6279e83951238ba16bf8a414c64c48 + languageName: node + linkType: hard + +"@rollup/pluginutils@npm:^5.0.0": + version: 5.4.0 + resolution: "@rollup/pluginutils@npm:5.4.0" + dependencies: + "@types/estree": "npm:^1.0.0" + estree-walker: "npm:^2.0.2" + picomatch: "npm:^4.0.2" + peerDependencies: + rollup: ^1.20.0||^2.0.0||^3.0.0||^4.0.0 + peerDependenciesMeta: + rollup: + optional: true + checksum: 10c0/ccc2cbd3a05df642df60ab05ffb81b2e564bd945e2a118bb8a474ea75b941033c8f44273133d4865643cca1492d0c80b14de1281f74779a64285a80fc3a194d8 + languageName: node + linkType: hard + +"@rollup/rollup-android-arm-eabi@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-android-arm-eabi@npm:4.62.2" + conditions: os=android & cpu=arm + languageName: node + linkType: hard + +"@rollup/rollup-android-arm64@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-android-arm64@npm:4.62.2" + conditions: os=android & cpu=arm64 + languageName: node + linkType: hard + +"@rollup/rollup-darwin-arm64@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-darwin-arm64@npm:4.62.2" + conditions: os=darwin & cpu=arm64 + languageName: node + linkType: hard + +"@rollup/rollup-darwin-x64@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-darwin-x64@npm:4.62.2" + conditions: os=darwin & cpu=x64 + languageName: node + linkType: hard + +"@rollup/rollup-freebsd-arm64@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-freebsd-arm64@npm:4.62.2" + conditions: os=freebsd & cpu=arm64 + languageName: node + linkType: hard + +"@rollup/rollup-freebsd-x64@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-freebsd-x64@npm:4.62.2" + conditions: os=freebsd & cpu=x64 + languageName: node + linkType: hard + +"@rollup/rollup-linux-arm-gnueabihf@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-linux-arm-gnueabihf@npm:4.62.2" + conditions: os=linux & cpu=arm & libc=glibc + languageName: node + linkType: hard + +"@rollup/rollup-linux-arm-musleabihf@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-linux-arm-musleabihf@npm:4.62.2" + conditions: os=linux & cpu=arm & libc=musl + languageName: node + linkType: hard + +"@rollup/rollup-linux-arm64-gnu@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-linux-arm64-gnu@npm:4.62.2" + conditions: os=linux & cpu=arm64 & libc=glibc + languageName: node + linkType: hard + +"@rollup/rollup-linux-arm64-musl@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-linux-arm64-musl@npm:4.62.2" + conditions: os=linux & cpu=arm64 & libc=musl + languageName: node + linkType: hard + +"@rollup/rollup-linux-loong64-gnu@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-linux-loong64-gnu@npm:4.62.2" + conditions: os=linux & cpu=loong64 & libc=glibc + languageName: node + linkType: hard + +"@rollup/rollup-linux-loong64-musl@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-linux-loong64-musl@npm:4.62.2" + conditions: os=linux & cpu=loong64 & libc=musl + languageName: node + linkType: hard + +"@rollup/rollup-linux-ppc64-gnu@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-linux-ppc64-gnu@npm:4.62.2" + conditions: os=linux & cpu=ppc64 & libc=glibc + languageName: node + linkType: hard + +"@rollup/rollup-linux-ppc64-musl@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-linux-ppc64-musl@npm:4.62.2" + conditions: os=linux & cpu=ppc64 & libc=musl + languageName: node + linkType: hard + +"@rollup/rollup-linux-riscv64-gnu@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-linux-riscv64-gnu@npm:4.62.2" + conditions: os=linux & cpu=riscv64 & libc=glibc + languageName: node + linkType: hard + +"@rollup/rollup-linux-riscv64-musl@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-linux-riscv64-musl@npm:4.62.2" + conditions: os=linux & cpu=riscv64 & libc=musl + languageName: node + linkType: hard + +"@rollup/rollup-linux-s390x-gnu@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-linux-s390x-gnu@npm:4.62.2" + conditions: os=linux & cpu=s390x & libc=glibc + languageName: node + linkType: hard + +"@rollup/rollup-linux-x64-gnu@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-linux-x64-gnu@npm:4.62.2" + conditions: os=linux & cpu=x64 & libc=glibc + languageName: node + linkType: hard + +"@rollup/rollup-linux-x64-musl@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-linux-x64-musl@npm:4.62.2" + conditions: os=linux & cpu=x64 & libc=musl + languageName: node + linkType: hard + +"@rollup/rollup-openbsd-x64@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-openbsd-x64@npm:4.62.2" + conditions: os=openbsd & cpu=x64 + languageName: node + linkType: hard + +"@rollup/rollup-openharmony-arm64@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-openharmony-arm64@npm:4.62.2" + conditions: os=openharmony & cpu=arm64 + languageName: node + linkType: hard + +"@rollup/rollup-win32-arm64-msvc@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-win32-arm64-msvc@npm:4.62.2" + conditions: os=win32 & cpu=arm64 + languageName: node + linkType: hard + +"@rollup/rollup-win32-ia32-msvc@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-win32-ia32-msvc@npm:4.62.2" + conditions: os=win32 & cpu=ia32 + languageName: node + linkType: hard + +"@rollup/rollup-win32-x64-gnu@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-win32-x64-gnu@npm:4.62.2" + conditions: os=win32 & cpu=x64 + languageName: node + linkType: hard + +"@rollup/rollup-win32-x64-msvc@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-win32-x64-msvc@npm:4.62.2" + conditions: os=win32 & cpu=x64 + languageName: node + linkType: hard + +"@types/esrecurse@npm:^4.3.1": + version: 4.3.1 + resolution: "@types/esrecurse@npm:4.3.1" + checksum: 10c0/90dad74d5da3ad27606d8e8e757322f33171cfeaa15ad558b615cf71bb2a516492d18f55f4816384685a3eb2412142e732bbae9a4a7cd2cf3deb7572aa4ebe03 + languageName: node + linkType: hard + +"@types/estree@npm:1.0.9, @types/estree@npm:^1.0.0, @types/estree@npm:^1.0.6, @types/estree@npm:^1.0.8": + version: 1.0.9 + resolution: "@types/estree@npm:1.0.9" + checksum: 10c0/3ad3286ca2988cd550dafb8f2ad599c8474868e954fa601a36655bdfefd8039f7c714b8c1c7f2ae219ffbd58bd4660e66fa7479a0120fc02d4777057d4865387 + languageName: node + linkType: hard + +"@types/gensync@npm:^1.0.5": + version: 1.0.5 + resolution: "@types/gensync@npm:1.0.5" + checksum: 10c0/7c37c8fc3b1a49efd8889f635a6204008f1c1cc86a09ac6a96e219cf3fc52cf1ff091c4dddc3160e93261d6e599fbba39f5fb698fbf936518d1c410289cdd640 + languageName: node + linkType: hard + +"@types/jsesc@npm:^2.5.0": + version: 2.5.1 + resolution: "@types/jsesc@npm:2.5.1" + checksum: 10c0/12ba7bf5968aeeb36408269f4b5a39718efc6411fa197cf0f5e967ba36ad7b7d555b78787fc480db43ce63ebe6ab0ffe5fd9f64b1ea3b0d073877f0747491b30 + languageName: node + linkType: hard + +"@types/json-schema@npm:^7.0.15": + version: 7.0.15 + resolution: "@types/json-schema@npm:7.0.15" + checksum: 10c0/a996a745e6c5d60292f36731dd41341339d4eeed8180bb09226e5c8d23759067692b1d88e5d91d72ee83dfc00d3aca8e7bd43ea120516c17922cbcb7c3e252db + languageName: node + linkType: hard + +"@types/parse-json@npm:^4.0.0": + version: 4.0.2 + resolution: "@types/parse-json@npm:4.0.2" + checksum: 10c0/b1b863ac34a2c2172fbe0807a1ec4d5cb684e48d422d15ec95980b81475fac4fdb3768a8b13eef39130203a7c04340fc167bae057c7ebcafd7dec9fe6c36aeb1 + languageName: node + linkType: hard + +"@types/prop-types@npm:^15.7.15": + version: 15.7.15 + resolution: "@types/prop-types@npm:15.7.15" + checksum: 10c0/b59aad1ad19bf1733cf524fd4e618196c6c7690f48ee70a327eb450a42aab8e8a063fbe59ca0a5701aebe2d92d582292c0fb845ea57474f6a15f6994b0e260b2 + languageName: node + linkType: hard + +"@types/react-transition-group@npm:^4.4.12": + version: 4.4.12 + resolution: "@types/react-transition-group@npm:4.4.12" + peerDependencies: + "@types/react": "*" + checksum: 10c0/0441b8b47c69312c89ec0760ba477ba1a0808a10ceef8dc1c64b1013ed78517332c30f18681b0ec0b53542731f1ed015169fed1d127cc91222638ed955478ec7 + languageName: node + linkType: hard + +"abbrev@npm:^5.0.0": + version: 5.0.0 + resolution: "abbrev@npm:5.0.0" + checksum: 10c0/8e88f5c798ea4562d28c5a3e9ad69e3879890bc5d695d8f2dffb8609be4c890aacc8f80ef4553fdd2c6a62d70c2ce8bc57b38074e383beb7487bdafa9ed42ea5 + languageName: node + linkType: hard + +"acorn-jsx@npm:^5.3.2": + version: 5.3.2 + resolution: "acorn-jsx@npm:5.3.2" + peerDependencies: + acorn: ^6.0.0 || ^7.0.0 || ^8.0.0 + checksum: 10c0/4c54868fbef3b8d58927d5e33f0a4de35f59012fe7b12cf9dfbb345fb8f46607709e1c4431be869a23fb63c151033d84c4198fa9f79385cec34fcb1dd53974c1 + languageName: node + linkType: hard + +"acorn@npm:^8.16.0": + version: 8.17.0 + resolution: "acorn@npm:8.17.0" + bin: + acorn: bin/acorn + checksum: 10c0/5dcefea5f8f023b6cc24cbe71fb5a8112b601d36c4fa07d14e4e6ffc2ee47383332c46b36c766d9437725aa6660156eae50efa0c838719823b50d7c327c4ed42 + languageName: node + linkType: hard + +"agent-base@npm:6": + version: 6.0.2 + resolution: "agent-base@npm:6.0.2" + dependencies: + debug: "npm:4" + checksum: 10c0/dc4f757e40b5f3e3d674bc9beb4f1048f4ee83af189bae39be99f57bf1f48dde166a8b0a5342a84b5944ee8e6ed1e5a9d801858f4ad44764e84957122fe46261 + languageName: node + linkType: hard + +"ajv@npm:^6.14.0": + version: 6.15.0 + resolution: "ajv@npm:6.15.0" + dependencies: + fast-deep-equal: "npm:^3.1.1" + fast-json-stable-stringify: "npm:^2.0.0" + json-schema-traverse: "npm:^0.4.1" + uri-js: "npm:^4.2.2" + checksum: 10c0/67966499dd272ecde1c2e467084411132891523d057487587879d39ac04207f4351b7b2324c83198013967fbfa632c1612adc960114a30770fbe07a0773b32c2 + languageName: node + linkType: hard + +"array-buffer-byte-length@npm:^1.0.1, array-buffer-byte-length@npm:^1.0.2": + version: 1.0.2 + resolution: "array-buffer-byte-length@npm:1.0.2" + dependencies: + call-bound: "npm:^1.0.3" + is-array-buffer: "npm:^3.0.5" + checksum: 10c0/74e1d2d996941c7a1badda9cabb7caab8c449db9086407cad8a1b71d2604cc8abf105db8ca4e02c04579ec58b7be40279ddb09aea4784832984485499f48432d + languageName: node + linkType: hard + +"array-includes@npm:^3.1.6, array-includes@npm:^3.1.8": + version: 3.1.9 + resolution: "array-includes@npm:3.1.9" + dependencies: + call-bind: "npm:^1.0.8" + call-bound: "npm:^1.0.4" + define-properties: "npm:^1.2.1" + es-abstract: "npm:^1.24.0" + es-object-atoms: "npm:^1.1.1" + get-intrinsic: "npm:^1.3.0" + is-string: "npm:^1.1.1" + math-intrinsics: "npm:^1.1.0" + checksum: 10c0/0235fa69078abeac05ac4250699c44996bc6f774a9cbe45db48674ce6bd142f09b327d31482ff75cf03344db4ea03eae23edb862d59378b484b47ed842574856 + languageName: node + linkType: hard + +"array.prototype.findlast@npm:^1.2.5": + version: 1.2.5 + resolution: "array.prototype.findlast@npm:1.2.5" + dependencies: + call-bind: "npm:^1.0.7" + define-properties: "npm:^1.2.1" + es-abstract: "npm:^1.23.2" + es-errors: "npm:^1.3.0" + es-object-atoms: "npm:^1.0.0" + es-shim-unscopables: "npm:^1.0.2" + checksum: 10c0/ddc952b829145ab45411b9d6adcb51a8c17c76bf89c9dd64b52d5dffa65d033da8c076ed2e17091779e83bc892b9848188d7b4b33453c5565e65a92863cb2775 + languageName: node + linkType: hard + +"array.prototype.flat@npm:^1.3.1": + version: 1.3.3 + resolution: "array.prototype.flat@npm:1.3.3" + dependencies: + call-bind: "npm:^1.0.8" + define-properties: "npm:^1.2.1" + es-abstract: "npm:^1.23.5" + es-shim-unscopables: "npm:^1.0.2" + checksum: 10c0/d90e04dfbc43bb96b3d2248576753d1fb2298d2d972e29ca7ad5ec621f0d9e16ff8074dae647eac4f31f4fb7d3f561a7ac005fb01a71f51705a13b5af06a7d8a + languageName: node + linkType: hard + +"array.prototype.flatmap@npm:^1.3.3": + version: 1.3.3 + resolution: "array.prototype.flatmap@npm:1.3.3" + dependencies: + call-bind: "npm:^1.0.8" + define-properties: "npm:^1.2.1" + es-abstract: "npm:^1.23.5" + es-shim-unscopables: "npm:^1.0.2" + checksum: 10c0/ba899ea22b9dc9bf276e773e98ac84638ed5e0236de06f13d63a90b18ca9e0ec7c97d622d899796e3773930b946cd2413d098656c0c5d8cc58c6f25c21e6bd54 + languageName: node + linkType: hard + +"array.prototype.tosorted@npm:^1.1.4": + version: 1.1.4 + resolution: "array.prototype.tosorted@npm:1.1.4" + dependencies: + call-bind: "npm:^1.0.7" + define-properties: "npm:^1.2.1" + es-abstract: "npm:^1.23.3" + es-errors: "npm:^1.3.0" + es-shim-unscopables: "npm:^1.0.2" + checksum: 10c0/eb3c4c4fc0381b0bf6dba2ea4d48d367c2827a0d4236a5718d97caaccc6b78f11f4cadf090736e86301d295a6aa4967ed45568f92ced51be8cbbacd9ca410943 + languageName: node + linkType: hard + +"arraybuffer.prototype.slice@npm:^1.0.4": + version: 1.0.4 + resolution: "arraybuffer.prototype.slice@npm:1.0.4" + dependencies: + array-buffer-byte-length: "npm:^1.0.1" + call-bind: "npm:^1.0.8" + define-properties: "npm:^1.2.1" + es-abstract: "npm:^1.23.5" + es-errors: "npm:^1.3.0" + get-intrinsic: "npm:^1.2.6" + is-array-buffer: "npm:^3.0.4" + checksum: 10c0/2f2459caa06ae0f7f615003f9104b01f6435cc803e11bd2a655107d52a1781dc040532dc44d93026b694cc18793993246237423e13a5337e86b43ed604932c06 + languageName: node + linkType: hard + +"ast-metadata-inferer@npm:^0.8.1": + version: 0.8.1 + resolution: "ast-metadata-inferer@npm:0.8.1" + dependencies: + "@mdn/browser-compat-data": "npm:^5.6.19" + checksum: 10c0/4bfa6c268951f31123c2ea902d13d8fda5a226679a028eab7ccc063b5cc10964b07a30f075c3876fadaec315df9a894490ed24e6cb5c185afd373da42fff7a4f + languageName: node + linkType: hard + +"async-function@npm:^1.0.0": + version: 1.0.0 + resolution: "async-function@npm:1.0.0" + checksum: 10c0/669a32c2cb7e45091330c680e92eaeb791bc1d4132d827591e499cd1f776ff5a873e77e5f92d0ce795a8d60f10761dec9ddfe7225a5de680f5d357f67b1aac73 + languageName: node + linkType: hard + +"asynckit@npm:^0.4.0": + version: 0.4.0 + resolution: "asynckit@npm:0.4.0" + checksum: 10c0/d73e2ddf20c4eb9337e1b3df1a0f6159481050a5de457c55b14ea2e5cb6d90bb69e004c9af54737a5ee0917fcf2c9e25de67777bbe58261847846066ba75bc9d + languageName: node + linkType: hard + +"available-typed-arrays@npm:^1.0.7": + version: 1.0.7 + resolution: "available-typed-arrays@npm:1.0.7" + dependencies: + possible-typed-array-names: "npm:^1.0.0" + checksum: 10c0/d07226ef4f87daa01bd0fe80f8f310982e345f372926da2e5296aecc25c41cab440916bbaa4c5e1034b453af3392f67df5961124e4b586df1e99793a1374bdb2 + languageName: node + linkType: hard + +"axios@npm:^1.18.1": + version: 1.18.1 + resolution: "axios@npm:1.18.1" + dependencies: + follow-redirects: "npm:^1.16.0" + form-data: "npm:^4.0.5" + https-proxy-agent: "npm:^5.0.1" + proxy-from-env: "npm:^2.1.0" + checksum: 10c0/9d9378a3af0d0ad730a52ad9d15ec7201f3926ad6e7e8bbffc5ae21ca2835ad11d1d9598698f5dd9718917486039f55ea1d7dc23d8e44fa827a55cc3262c02fc + languageName: node + linkType: hard + +"babel-plugin-macros@npm:^3.1.0": + version: 3.1.0 + resolution: "babel-plugin-macros@npm:3.1.0" + dependencies: + "@babel/runtime": "npm:^7.12.5" + cosmiconfig: "npm:^7.0.0" + resolve: "npm:^1.19.0" + checksum: 10c0/c6dfb15de96f67871d95bd2e8c58b0c81edc08b9b087dc16755e7157f357dc1090a8dc60ebab955e92587a9101f02eba07e730adc253a1e4cf593ca3ebd3839c + languageName: node + linkType: hard + +"babel-plugin-transform-hook-names@npm:^1.0.2": + version: 1.0.2 + resolution: "babel-plugin-transform-hook-names@npm:1.0.2" + peerDependencies: + "@babel/core": ^7.12.10 + checksum: 10c0/517b85fe0611d742b3fffad5d0e119fcbd29bf69f95c6970b9ede4cb66453c7106a2d3bf048b35255b78a9d6a9565ad37e73b46c0be1fe557e941c792fad79f0 + languageName: node + linkType: hard + +"balanced-match@npm:^1.0.0": + version: 1.0.2 + resolution: "balanced-match@npm:1.0.2" + checksum: 10c0/9308baf0a7e4838a82bbfd11e01b1cb0f0cf2893bc1676c27c2a8c0e70cbae1c59120c3268517a8ae7fb6376b4639ef81ca22582611dbee4ed28df945134aaee + languageName: node + linkType: hard + +"balanced-match@npm:^4.0.2": + version: 4.0.4 + resolution: "balanced-match@npm:4.0.4" + checksum: 10c0/07e86102a3eb2ee2a6a1a89164f29d0dbaebd28f2ca3f5ca786f36b8b23d9e417eb3be45a4acf754f837be5ac0a2317de90d3fcb7f4f4dc95720a1f36b26a17b + languageName: node + linkType: hard + +"baseline-browser-mapping@npm:^2.10.12": + version: 2.10.38 + resolution: "baseline-browser-mapping@npm:2.10.38" + bin: + baseline-browser-mapping: dist/cli.cjs + checksum: 10c0/44bbea61ec54df6845f5f6f149c99057370081f1041d6e8dbc92835630ce37da9adc102528ebebd37f563342da2a5eea525d24698ced6674cdcfadb2ed613136 + languageName: node + linkType: hard + +"boolbase@npm:^1.0.0": + version: 1.0.0 + resolution: "boolbase@npm:1.0.0" + checksum: 10c0/e4b53deb4f2b85c52be0e21a273f2045c7b6a6ea002b0e139c744cb6f95e9ec044439a52883b0d74dedd1ff3da55ed140cfdddfed7fb0cccbed373de5dce1bcf + languageName: node + linkType: hard + +"brace-expansion@npm:^1.1.7": + version: 1.1.15 + resolution: "brace-expansion@npm:1.1.15" + dependencies: + balanced-match: "npm:^1.0.0" + concat-map: "npm:0.0.1" + checksum: 10c0/648e273f57cfa9ed67d8a77bdb15b408205465d33da9331808ee3c188d8b55674c9cdbf1f320b65bc562e485e1263360ae62ad355e128e0435891f6430e795d7 + languageName: node + linkType: hard + +"brace-expansion@npm:^5.0.5": + version: 5.0.6 + resolution: "brace-expansion@npm:5.0.6" + dependencies: + balanced-match: "npm:^4.0.2" + checksum: 10c0/8c919869b90f61d533b341d3340be5ee4413232ea89b8246cbc2f38eb014f1d8182785c98a006eaf6111d02dc9eeffefdc240d5ac158625b2ed084dccd4bbf9b + languageName: node + linkType: hard + +"browserslist@npm:^4.24.0, browserslist@npm:^4.25.2": + version: 4.28.2 + resolution: "browserslist@npm:4.28.2" + dependencies: + baseline-browser-mapping: "npm:^2.10.12" + caniuse-lite: "npm:^1.0.30001782" + electron-to-chromium: "npm:^1.5.328" + node-releases: "npm:^2.0.36" + update-browserslist-db: "npm:^1.2.3" + bin: + browserslist: cli.js + checksum: 10c0/c0228b6330f785b7fa59d2d360124ec6d9322f96ed9f3ee1f873e33ecc9503a6f0ffc3b71191a28c4ff6e930b753b30043da1c33844a9548f3018d491f09ce60 + languageName: node + linkType: hard + +"call-bind-apply-helpers@npm:^1.0.1, call-bind-apply-helpers@npm:^1.0.2": + version: 1.0.2 + resolution: "call-bind-apply-helpers@npm:1.0.2" + dependencies: + es-errors: "npm:^1.3.0" + function-bind: "npm:^1.1.2" + checksum: 10c0/47bd9901d57b857590431243fea704ff18078b16890a6b3e021e12d279bbf211d039155e27d7566b374d49ee1f8189344bac9833dec7a20cdec370506361c938 + languageName: node + linkType: hard + +"call-bind@npm:^1.0.7, call-bind@npm:^1.0.8, call-bind@npm:^1.0.9": + version: 1.0.9 + resolution: "call-bind@npm:1.0.9" + dependencies: + call-bind-apply-helpers: "npm:^1.0.2" + es-define-property: "npm:^1.0.1" + get-intrinsic: "npm:^1.3.0" + set-function-length: "npm:^1.2.2" + checksum: 10c0/a6621f6da1444481919ce3b4983dff725691e0754d3507ae483ce56e54985f2da7d6f1df512c56dbf28660745cf1ca52553f1fc9aef5557f3ce353ef14fab714 + languageName: node + linkType: hard + +"call-bound@npm:^1.0.2, call-bound@npm:^1.0.3, call-bound@npm:^1.0.4": + version: 1.0.4 + resolution: "call-bound@npm:1.0.4" + dependencies: + call-bind-apply-helpers: "npm:^1.0.2" + get-intrinsic: "npm:^1.3.0" + checksum: 10c0/f4796a6a0941e71c766aea672f63b72bc61234c4f4964dc6d7606e3664c307e7d77845328a8f3359ce39ddb377fed67318f9ee203dea1d47e46165dcf2917644 + languageName: node + linkType: hard + +"callsites@npm:^3.0.0": + version: 3.1.0 + resolution: "callsites@npm:3.1.0" + checksum: 10c0/fff92277400eb06c3079f9e74f3af120db9f8ea03bad0e84d9aede54bbe2d44a56cccb5f6cf12211f93f52306df87077ecec5b712794c5a9b5dac6d615a3f301 + languageName: node + linkType: hard + +"caniuse-lite@npm:^1.0.30001782": + version: 1.0.30001799 + resolution: "caniuse-lite@npm:1.0.30001799" + checksum: 10c0/f24f9834edc7b60188f368ce44714695c3901bc4acb7f2a977dd9b7b697e39ddc0f9947fad6224a955b789f36a73432cb888d620aa7280d728f582d3bd8927a7 + languageName: node + linkType: hard + +"chownr@npm:^3.0.0": + version: 3.0.0 + resolution: "chownr@npm:3.0.0" + checksum: 10c0/43925b87700f7e3893296c8e9c56cc58f926411cce3a6e5898136daaf08f08b9a8eb76d37d3267e707d0dcc17aed2e2ebdf5848c0c3ce95cf910a919935c1b10 + languageName: node + linkType: hard + +"clsx@npm:^2.1.1": + version: 2.1.1 + resolution: "clsx@npm:2.1.1" + checksum: 10c0/c4c8eb865f8c82baab07e71bfa8897c73454881c4f99d6bc81585aecd7c441746c1399d08363dc096c550cceaf97bd4ce1e8854e1771e9998d9f94c4fe075839 + languageName: node + linkType: hard + +"combined-stream@npm:^1.0.8": + version: 1.0.8 + resolution: "combined-stream@npm:1.0.8" + dependencies: + delayed-stream: "npm:~1.0.0" + checksum: 10c0/0dbb829577e1b1e839fa82b40c07ffaf7de8a09b935cadd355a73652ae70a88b4320db322f6634a4ad93424292fa80973ac6480986247f1734a1137debf271d5 + languageName: node + linkType: hard + +"concat-map@npm:0.0.1": + version: 0.0.1 + resolution: "concat-map@npm:0.0.1" + checksum: 10c0/c996b1cfdf95b6c90fee4dae37e332c8b6eb7d106430c17d538034c0ad9a1630cb194d2ab37293b1bdd4d779494beee7786d586a50bd9376fd6f7bcc2bd4c98f + languageName: node + linkType: hard + +"convert-source-map@npm:^1.5.0": + version: 1.9.0 + resolution: "convert-source-map@npm:1.9.0" + checksum: 10c0/281da55454bf8126cbc6625385928c43479f2060984180c42f3a86c8b8c12720a24eac260624a7d1e090004028d2dee78602330578ceec1a08e27cb8bb0a8a5b + languageName: node + linkType: hard + +"convert-source-map@npm:^2.0.0": + version: 2.0.0 + resolution: "convert-source-map@npm:2.0.0" + checksum: 10c0/8f2f7a27a1a011cc6cc88cc4da2d7d0cfa5ee0369508baae3d98c260bb3ac520691464e5bbe4ae7cdf09860c1d69ecc6f70c63c6e7c7f7e3f18ec08484dc7d9b + languageName: node + linkType: hard + +"cosmiconfig@npm:^7.0.0": + version: 7.1.0 + resolution: "cosmiconfig@npm:7.1.0" + dependencies: + "@types/parse-json": "npm:^4.0.0" + import-fresh: "npm:^3.2.1" + parse-json: "npm:^5.0.0" + path-type: "npm:^4.0.0" + yaml: "npm:^1.10.0" + checksum: 10c0/b923ff6af581638128e5f074a5450ba12c0300b71302398ea38dbeabd33bbcaa0245ca9adbedfcf284a07da50f99ede5658c80bb3e39e2ce770a99d28a21ef03 + languageName: node + linkType: hard + +"cross-spawn@npm:^7.0.6": + version: 7.0.6 + resolution: "cross-spawn@npm:7.0.6" + dependencies: + path-key: "npm:^3.1.0" + shebang-command: "npm:^2.0.0" + which: "npm:^2.0.1" + checksum: 10c0/053ea8b2135caff68a9e81470e845613e374e7309a47731e81639de3eaeb90c3d01af0e0b44d2ab9d50b43467223b88567dfeb3262db942dc063b9976718ffc1 + languageName: node + linkType: hard + +"css-select@npm:^5.1.0": + version: 5.2.2 + resolution: "css-select@npm:5.2.2" + dependencies: + boolbase: "npm:^1.0.0" + css-what: "npm:^6.1.0" + domhandler: "npm:^5.0.2" + domutils: "npm:^3.0.1" + nth-check: "npm:^2.0.1" + checksum: 10c0/d79fffa97106007f2802589f3ed17b8c903f1c961c0fc28aa8a051eee0cbad394d8446223862efd4c1b40445a6034f626bb639cf2035b0bfc468544177593c99 + languageName: node + linkType: hard + +"css-what@npm:^6.1.0": + version: 6.2.2 + resolution: "css-what@npm:6.2.2" + checksum: 10c0/91e24c26fb977b4ccef30d7007d2668c1c10ac0154cc3f42f7304410e9594fb772aea4f30c832d2993b132ca8d99338050866476210316345ec2e7d47b248a56 + languageName: node + linkType: hard + +"csstype@npm:^3.0.2, csstype@npm:^3.2.3": + version: 3.2.3 + resolution: "csstype@npm:3.2.3" + checksum: 10c0/cd29c51e70fa822f1cecd8641a1445bed7063697469d35633b516e60fe8c1bde04b08f6c5b6022136bb669b64c63d4173af54864510fbb4ee23281801841a3ce + languageName: node + linkType: hard + +"data-view-buffer@npm:^1.0.2": + version: 1.0.2 + resolution: "data-view-buffer@npm:1.0.2" + dependencies: + call-bound: "npm:^1.0.3" + es-errors: "npm:^1.3.0" + is-data-view: "npm:^1.0.2" + checksum: 10c0/7986d40fc7979e9e6241f85db8d17060dd9a71bd53c894fa29d126061715e322a4cd47a00b0b8c710394854183d4120462b980b8554012acc1c0fa49df7ad38c + languageName: node + linkType: hard + +"data-view-byte-length@npm:^1.0.2": + version: 1.0.2 + resolution: "data-view-byte-length@npm:1.0.2" + dependencies: + call-bound: "npm:^1.0.3" + es-errors: "npm:^1.3.0" + is-data-view: "npm:^1.0.2" + checksum: 10c0/f8a4534b5c69384d95ac18137d381f18a5cfae1f0fc1df0ef6feef51ef0d568606d970b69e02ea186c6c0f0eac77fe4e6ad96fec2569cc86c3afcc7475068c55 + languageName: node + linkType: hard + +"data-view-byte-offset@npm:^1.0.1": + version: 1.0.1 + resolution: "data-view-byte-offset@npm:1.0.1" + dependencies: + call-bound: "npm:^1.0.2" + es-errors: "npm:^1.3.0" + is-data-view: "npm:^1.0.1" + checksum: 10c0/fa7aa40078025b7810dcffc16df02c480573b7b53ef1205aa6a61533011005c1890e5ba17018c692ce7c900212b547262d33279fde801ad9843edc0863bf78c4 + languageName: node + linkType: hard + +"debug@npm:4, debug@npm:^4.1.0, debug@npm:^4.3.1, debug@npm:^4.3.2, debug@npm:^4.4.3": + version: 4.4.3 + resolution: "debug@npm:4.4.3" + dependencies: + ms: "npm:^2.1.3" + peerDependenciesMeta: + supports-color: + optional: true + checksum: 10c0/d79136ec6c83ecbefd0f6a5593da6a9c91ec4d7ddc4b54c883d6e71ec9accb5f67a1a5e96d00a328196b5b5c86d365e98d8a3a70856aaf16b4e7b1985e67f5a6 + languageName: node + linkType: hard + +"deep-is@npm:^0.1.3": + version: 0.1.4 + resolution: "deep-is@npm:0.1.4" + checksum: 10c0/7f0ee496e0dff14a573dc6127f14c95061b448b87b995fc96c017ce0a1e66af1675e73f1d6064407975bc4ea6ab679497a29fff7b5b9c4e99cb10797c1ad0b4c + languageName: node + linkType: hard + +"define-data-property@npm:^1.0.1, define-data-property@npm:^1.1.4": + version: 1.1.4 + resolution: "define-data-property@npm:1.1.4" + dependencies: + es-define-property: "npm:^1.0.0" + es-errors: "npm:^1.3.0" + gopd: "npm:^1.0.1" + checksum: 10c0/dea0606d1483eb9db8d930d4eac62ca0fa16738b0b3e07046cddfacf7d8c868bbe13fa0cb263eb91c7d0d527960dc3f2f2471a69ed7816210307f6744fe62e37 + languageName: node + linkType: hard + +"define-properties@npm:^1.1.3, define-properties@npm:^1.2.1": + version: 1.2.1 + resolution: "define-properties@npm:1.2.1" + dependencies: + define-data-property: "npm:^1.0.1" + has-property-descriptors: "npm:^1.0.0" + object-keys: "npm:^1.1.1" + checksum: 10c0/88a152319ffe1396ccc6ded510a3896e77efac7a1bfbaa174a7b00414a1747377e0bb525d303794a47cf30e805c2ec84e575758512c6e44a993076d29fd4e6c3 + languageName: node + linkType: hard + +"delayed-stream@npm:~1.0.0": + version: 1.0.0 + resolution: "delayed-stream@npm:1.0.0" + checksum: 10c0/d758899da03392e6712f042bec80aa293bbe9e9ff1b2634baae6a360113e708b91326594c8a486d475c69d6259afb7efacdc3537bfcda1c6c648e390ce601b19 + languageName: node + linkType: hard + +"doctrine@npm:^2.1.0": + version: 2.1.0 + resolution: "doctrine@npm:2.1.0" + dependencies: + esutils: "npm:^2.0.2" + checksum: 10c0/b6416aaff1f380bf56c3b552f31fdf7a69b45689368deca72d28636f41c16bb28ec3ebc40ace97db4c1afc0ceeb8120e8492fe0046841c94c2933b2e30a7d5ac + languageName: node + linkType: hard + +"dom-helpers@npm:^5.0.1": + version: 5.2.1 + resolution: "dom-helpers@npm:5.2.1" + dependencies: + "@babel/runtime": "npm:^7.8.7" + csstype: "npm:^3.0.2" + checksum: 10c0/f735074d66dd759b36b158fa26e9d00c9388ee0e8c9b16af941c38f014a37fc80782de83afefd621681b19ac0501034b4f1c4a3bff5caa1b8667f0212b5e124c + languageName: node + linkType: hard + +"dom-serializer@npm:^2.0.0": + version: 2.0.0 + resolution: "dom-serializer@npm:2.0.0" + dependencies: + domelementtype: "npm:^2.3.0" + domhandler: "npm:^5.0.2" + entities: "npm:^4.2.0" + checksum: 10c0/d5ae2b7110ca3746b3643d3ef60ef823f5f078667baf530cec096433f1627ec4b6fa8c072f09d079d7cda915fd2c7bc1b7b935681e9b09e591e1e15f4040b8e2 + languageName: node + linkType: hard + +"domelementtype@npm:^2.3.0": + version: 2.3.0 + resolution: "domelementtype@npm:2.3.0" + checksum: 10c0/686f5a9ef0fff078c1412c05db73a0dce096190036f33e400a07e2a4518e9f56b1e324f5c576a0a747ef0e75b5d985c040b0d51945ce780c0dd3c625a18cd8c9 + languageName: node + linkType: hard + +"domhandler@npm:^5.0.2, domhandler@npm:^5.0.3": + version: 5.0.3 + resolution: "domhandler@npm:5.0.3" + dependencies: + domelementtype: "npm:^2.3.0" + checksum: 10c0/bba1e5932b3e196ad6862286d76adc89a0dbf0c773e5ced1eb01f9af930c50093a084eff14b8de5ea60b895c56a04d5de8bbc4930c5543d029091916770b2d2a + languageName: node + linkType: hard + +"domutils@npm:^3.0.1": + version: 3.2.2 + resolution: "domutils@npm:3.2.2" + dependencies: + dom-serializer: "npm:^2.0.0" + domelementtype: "npm:^2.3.0" + domhandler: "npm:^5.0.3" + checksum: 10c0/47938f473b987ea71cd59e59626eb8666d3aa8feba5266e45527f3b636c7883cca7e582d901531961f742c519d7514636b7973353b648762b2e3bedbf235fada + languageName: node + linkType: hard + +"dunder-proto@npm:^1.0.0, dunder-proto@npm:^1.0.1": + version: 1.0.1 + resolution: "dunder-proto@npm:1.0.1" + dependencies: + call-bind-apply-helpers: "npm:^1.0.1" + es-errors: "npm:^1.3.0" + gopd: "npm:^1.2.0" + checksum: 10c0/199f2a0c1c16593ca0a145dbf76a962f8033ce3129f01284d48c45ed4e14fea9bbacd7b3610b6cdc33486cef20385ac054948fefc6272fcce645c09468f93031 + languageName: node + linkType: hard + +"electron-to-chromium@npm:^1.5.328": + version: 1.5.376 + resolution: "electron-to-chromium@npm:1.5.376" + checksum: 10c0/c57e306ef12ad258e427218f90e14d155dfba68b23699674d7b66e528ce41ff69b46a78f38545ee7690d080d25d3ebb98338282e95d65510e8fa5fd4f7455a86 + languageName: node + linkType: hard + +"empathic@npm:^2.0.1": + version: 2.0.1 + resolution: "empathic@npm:2.0.1" + checksum: 10c0/577f2868bfcad4ffbf911b57c75016125eb8cc8a7d32cf2d3e9fbcb31bfe6e9e6b66d9457ac34ccb2cd38bff353b3af34287899e0360b8c561ff6d4a048aca62 + languageName: node + linkType: hard + +"entities@npm:^4.2.0": + version: 4.5.0 + resolution: "entities@npm:4.5.0" + checksum: 10c0/5b039739f7621f5d1ad996715e53d964035f75ad3b9a4d38c6b3804bb226e282ffeae2443624d8fdd9c47d8e926ae9ac009c54671243f0c3294c26af7cc85250 + languageName: node + linkType: hard + +"env-paths@npm:^2.2.0": + version: 2.2.1 + resolution: "env-paths@npm:2.2.1" + checksum: 10c0/285325677bf00e30845e330eec32894f5105529db97496ee3f598478e50f008c5352a41a30e5e72ec9de8a542b5a570b85699cd63bd2bc646dbcb9f311d83bc4 + languageName: node + linkType: hard + +"error-ex@npm:^1.3.1": + version: 1.3.4 + resolution: "error-ex@npm:1.3.4" + dependencies: + is-arrayish: "npm:^0.2.1" + checksum: 10c0/b9e34ff4778b8f3b31a8377e1c654456f4c41aeaa3d10a1138c3b7635d8b7b2e03eb2475d46d8ae055c1f180a1063e100bffabf64ea7e7388b37735df5328664 + languageName: node + linkType: hard + +"es-abstract-get@npm:^1.0.0": + version: 1.0.0 + resolution: "es-abstract-get@npm:1.0.0" + dependencies: + es-errors: "npm:^1.3.0" + es-object-atoms: "npm:^1.1.2" + is-callable: "npm:^1.2.7" + object-inspect: "npm:^1.13.4" + checksum: 10c0/f9b4838ae719752207383a6d95a74590f891122bf26b92f5e72eeedbe53771029e4561f1cf75ea19330b71bcf3d4f536fb0c8f7e2b601fe24d284f46e488c7e3 + languageName: node + linkType: hard + +"es-abstract@npm:^1.17.5, es-abstract@npm:^1.23.2, es-abstract@npm:^1.23.3, es-abstract@npm:^1.23.5, es-abstract@npm:^1.23.6, es-abstract@npm:^1.23.9, es-abstract@npm:^1.24.0, es-abstract@npm:^1.24.2": + version: 1.24.2 + resolution: "es-abstract@npm:1.24.2" + dependencies: + array-buffer-byte-length: "npm:^1.0.2" + arraybuffer.prototype.slice: "npm:^1.0.4" + available-typed-arrays: "npm:^1.0.7" + call-bind: "npm:^1.0.8" + call-bound: "npm:^1.0.4" + data-view-buffer: "npm:^1.0.2" + data-view-byte-length: "npm:^1.0.2" + data-view-byte-offset: "npm:^1.0.1" + es-define-property: "npm:^1.0.1" + es-errors: "npm:^1.3.0" + es-object-atoms: "npm:^1.1.1" + es-set-tostringtag: "npm:^2.1.0" + es-to-primitive: "npm:^1.3.0" + function.prototype.name: "npm:^1.1.8" + get-intrinsic: "npm:^1.3.0" + get-proto: "npm:^1.0.1" + get-symbol-description: "npm:^1.1.0" + globalthis: "npm:^1.0.4" + gopd: "npm:^1.2.0" + has-property-descriptors: "npm:^1.0.2" + has-proto: "npm:^1.2.0" + has-symbols: "npm:^1.1.0" + hasown: "npm:^2.0.2" + internal-slot: "npm:^1.1.0" + is-array-buffer: "npm:^3.0.5" + is-callable: "npm:^1.2.7" + is-data-view: "npm:^1.0.2" + is-negative-zero: "npm:^2.0.3" + is-regex: "npm:^1.2.1" + is-set: "npm:^2.0.3" + is-shared-array-buffer: "npm:^1.0.4" + is-string: "npm:^1.1.1" + is-typed-array: "npm:^1.1.15" + is-weakref: "npm:^1.1.1" + math-intrinsics: "npm:^1.1.0" + object-inspect: "npm:^1.13.4" + object-keys: "npm:^1.1.1" + object.assign: "npm:^4.1.7" + own-keys: "npm:^1.0.1" + regexp.prototype.flags: "npm:^1.5.4" + safe-array-concat: "npm:^1.1.3" + safe-push-apply: "npm:^1.0.0" + safe-regex-test: "npm:^1.1.0" + set-proto: "npm:^1.0.0" + stop-iteration-iterator: "npm:^1.1.0" + string.prototype.trim: "npm:^1.2.10" + string.prototype.trimend: "npm:^1.0.9" + string.prototype.trimstart: "npm:^1.0.8" + typed-array-buffer: "npm:^1.0.3" + typed-array-byte-length: "npm:^1.0.3" + typed-array-byte-offset: "npm:^1.0.4" + typed-array-length: "npm:^1.0.7" + unbox-primitive: "npm:^1.1.0" + which-typed-array: "npm:^1.1.19" + checksum: 10c0/67a5bf21ef5c7d775e6f6131a836323900b4d87194cf544394ac68fe31c57fa53828b978af4a4f551ef307f83a2f910a16b6b982760ad3ddc3dc471f98d5fd1b + languageName: node + linkType: hard + +"es-define-property@npm:^1.0.0, es-define-property@npm:^1.0.1": + version: 1.0.1 + resolution: "es-define-property@npm:1.0.1" + checksum: 10c0/3f54eb49c16c18707949ff25a1456728c883e81259f045003499efba399c08bad00deebf65cccde8c0e07908c1a225c9d472b7107e558f2a48e28d530e34527c + languageName: node + linkType: hard + +"es-errors@npm:^1.3.0": + version: 1.3.0 + resolution: "es-errors@npm:1.3.0" + checksum: 10c0/0a61325670072f98d8ae3b914edab3559b6caa980f08054a3b872052640d91da01d38df55df797fcc916389d77fc92b8d5906cf028f4db46d7e3003abecbca85 + languageName: node + linkType: hard + +"es-iterator-helpers@npm:^1.2.1": + version: 1.3.3 + resolution: "es-iterator-helpers@npm:1.3.3" + dependencies: + call-bind: "npm:^1.0.9" + call-bound: "npm:^1.0.4" + define-properties: "npm:^1.2.1" + es-abstract: "npm:^1.24.2" + es-errors: "npm:^1.3.0" + es-set-tostringtag: "npm:^2.1.0" + function-bind: "npm:^1.1.2" + get-intrinsic: "npm:^1.3.0" + globalthis: "npm:^1.0.4" + gopd: "npm:^1.2.0" + has-property-descriptors: "npm:^1.0.2" + has-proto: "npm:^1.2.0" + has-symbols: "npm:^1.1.0" + internal-slot: "npm:^1.1.0" + iterator.prototype: "npm:^1.1.5" + math-intrinsics: "npm:^1.1.0" + checksum: 10c0/14d45ce96c1eeec1dfb76607f4277163c847cc799a417c69346bfd2a9cce04b1d1426e34cb867dbc3266d2ca516084259ff1836cd2da6bc70b3e25e02f3532a9 + languageName: node + linkType: hard + +"es-object-atoms@npm:^1.0.0, es-object-atoms@npm:^1.1.1, es-object-atoms@npm:^1.1.2": + version: 1.1.2 + resolution: "es-object-atoms@npm:1.1.2" + dependencies: + es-errors: "npm:^1.3.0" + checksum: 10c0/1772861f094f739d6f41b579cfb9a18579daffeb434552a370a5fbef50a32d22227e27b63fdbb757b7ddd429d1b42fe52ccae7966d9302a2ec221b6f1b41bbc4 + languageName: node + linkType: hard + +"es-set-tostringtag@npm:^2.1.0": + version: 2.1.0 + resolution: "es-set-tostringtag@npm:2.1.0" + dependencies: + es-errors: "npm:^1.3.0" + get-intrinsic: "npm:^1.2.6" + has-tostringtag: "npm:^1.0.2" + hasown: "npm:^2.0.2" + checksum: 10c0/ef2ca9ce49afe3931cb32e35da4dcb6d86ab02592cfc2ce3e49ced199d9d0bb5085fc7e73e06312213765f5efa47cc1df553a6a5154584b21448e9fb8355b1af + languageName: node + linkType: hard + +"es-shim-unscopables@npm:^1.0.2": + version: 1.1.0 + resolution: "es-shim-unscopables@npm:1.1.0" + dependencies: + hasown: "npm:^2.0.2" + checksum: 10c0/1b9702c8a1823fc3ef39035a4e958802cf294dd21e917397c561d0b3e195f383b978359816b1732d02b255ccf63e1e4815da0065b95db8d7c992037be3bbbcdb + languageName: node + linkType: hard + +"es-to-primitive@npm:^1.3.0": + version: 1.3.1 + resolution: "es-to-primitive@npm:1.3.1" + dependencies: + es-abstract-get: "npm:^1.0.0" + es-errors: "npm:^1.3.0" + is-callable: "npm:^1.2.7" + is-date-object: "npm:^1.1.0" + is-symbol: "npm:^1.1.1" + checksum: 10c0/288ec25e5d08c2718bab9faa87924e11f42f2b0b59854fc241f1fbbedcadf2682ab3a9a9fb4676fa40c483ce563ea63cfd3e33777cbb53833e94d5f60a851cde + languageName: node + linkType: hard + +"esbuild@npm:^0.27.0": + version: 0.27.7 + resolution: "esbuild@npm:0.27.7" + dependencies: + "@esbuild/aix-ppc64": "npm:0.27.7" + "@esbuild/android-arm": "npm:0.27.7" + "@esbuild/android-arm64": "npm:0.27.7" + "@esbuild/android-x64": "npm:0.27.7" + "@esbuild/darwin-arm64": "npm:0.27.7" + "@esbuild/darwin-x64": "npm:0.27.7" + "@esbuild/freebsd-arm64": "npm:0.27.7" + "@esbuild/freebsd-x64": "npm:0.27.7" + "@esbuild/linux-arm": "npm:0.27.7" + "@esbuild/linux-arm64": "npm:0.27.7" + "@esbuild/linux-ia32": "npm:0.27.7" + "@esbuild/linux-loong64": "npm:0.27.7" + "@esbuild/linux-mips64el": "npm:0.27.7" + "@esbuild/linux-ppc64": "npm:0.27.7" + "@esbuild/linux-riscv64": "npm:0.27.7" + "@esbuild/linux-s390x": "npm:0.27.7" + "@esbuild/linux-x64": "npm:0.27.7" + "@esbuild/netbsd-arm64": "npm:0.27.7" + "@esbuild/netbsd-x64": "npm:0.27.7" + "@esbuild/openbsd-arm64": "npm:0.27.7" + "@esbuild/openbsd-x64": "npm:0.27.7" + "@esbuild/openharmony-arm64": "npm:0.27.7" + "@esbuild/sunos-x64": "npm:0.27.7" + "@esbuild/win32-arm64": "npm:0.27.7" + "@esbuild/win32-ia32": "npm:0.27.7" + "@esbuild/win32-x64": "npm:0.27.7" + dependenciesMeta: + "@esbuild/aix-ppc64": + optional: true + "@esbuild/android-arm": + optional: true + "@esbuild/android-arm64": + optional: true + "@esbuild/android-x64": + optional: true + "@esbuild/darwin-arm64": + optional: true + "@esbuild/darwin-x64": + optional: true + "@esbuild/freebsd-arm64": + optional: true + "@esbuild/freebsd-x64": + optional: true + "@esbuild/linux-arm": + optional: true + "@esbuild/linux-arm64": + optional: true + "@esbuild/linux-ia32": + optional: true + "@esbuild/linux-loong64": + optional: true + "@esbuild/linux-mips64el": + optional: true + "@esbuild/linux-ppc64": + optional: true + "@esbuild/linux-riscv64": + optional: true + "@esbuild/linux-s390x": + optional: true + "@esbuild/linux-x64": + optional: true + "@esbuild/netbsd-arm64": + optional: true + "@esbuild/netbsd-x64": + optional: true + "@esbuild/openbsd-arm64": + optional: true + "@esbuild/openbsd-x64": + optional: true + "@esbuild/openharmony-arm64": + optional: true + "@esbuild/sunos-x64": + optional: true + "@esbuild/win32-arm64": + optional: true + "@esbuild/win32-ia32": + optional: true + "@esbuild/win32-x64": + optional: true + bin: + esbuild: bin/esbuild + checksum: 10c0/ccd51f0555708bc9ff4ec9dc3ac92d3daacd45ecaac949ca8645984c5c323bf8cefe98c2df307418685e0b4ce37f9a3bdbfe8e3651fe632a0059a436195a17d4 + languageName: node + linkType: hard + +"escalade@npm:^3.2.0": + version: 3.2.0 + resolution: "escalade@npm:3.2.0" + checksum: 10c0/ced4dd3a78e15897ed3be74e635110bbf3b08877b0a41be50dcb325ee0e0b5f65fc2d50e9845194d7c4633f327e2e1c6cce00a71b617c5673df0374201d67f65 + languageName: node + linkType: hard + +"escape-string-regexp@npm:^4.0.0": + version: 4.0.0 + resolution: "escape-string-regexp@npm:4.0.0" + checksum: 10c0/9497d4dd307d845bd7f75180d8188bb17ea8c151c1edbf6b6717c100e104d629dc2dfb687686181b0f4b7d732c7dfdc4d5e7a8ff72de1b0ca283a75bbb3a9cd9 + languageName: node + linkType: hard + +"eslint-config-preact@npm:^2.0.0": + version: 2.0.0 + resolution: "eslint-config-preact@npm:2.0.0" + dependencies: + "@babel/core": "npm:^7.13.16" + "@babel/eslint-parser": "npm:^7.27.5" + "@babel/plugin-syntax-class-properties": "npm:^7.12.13" + "@babel/plugin-syntax-jsx": "npm:^7.12.13" + "@eslint/js": "npm:^9.29.0" + eslint-plugin-compat: "npm:^6.0.2" + eslint-plugin-react: "npm:^7.37.5" + eslint-plugin-react-hooks: "npm:^5.2.0" + globals: "npm:^16.2.0" + peerDependencies: + eslint: ^8.57.1 || ^9.0.0 + checksum: 10c0/aebc4b09eb48d8b8b152d76cec56df59840397c497ea7bb0017d4855c94bb5b87fb211cc386acbddacade50011aa745169fff255893c3e8f23fde9981cb00012 + languageName: node + linkType: hard + +"eslint-plugin-compat@npm:^6.0.2": + version: 6.2.1 + resolution: "eslint-plugin-compat@npm:6.2.1" + dependencies: + "@mdn/browser-compat-data": "npm:^6.1.1" + ast-metadata-inferer: "npm:^0.8.1" + browserslist: "npm:^4.25.2" + find-up: "npm:^5.0.0" + globals: "npm:^15.7.0" + lodash.memoize: "npm:^4.1.2" + semver: "npm:^7.6.2" + peerDependencies: + eslint: ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0 || ^9.0.0 || ^10.0.0 + checksum: 10c0/08dc5ea7c46eed9cd2e656bfc32318fb2d3e5ba661bbd1b88633b316e5ab3ab898f7987353645f5b525c6b9ffa81d47b8c7d4f77b24fed9991c206b156d9a1ae + languageName: node + linkType: hard + +"eslint-plugin-react-hooks@npm:^5.2.0": + version: 5.2.0 + resolution: "eslint-plugin-react-hooks@npm:5.2.0" + peerDependencies: + eslint: ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0 + checksum: 10c0/1c8d50fa5984c6dea32470651807d2922cc3934cf3425e78f84a24c2dfd972e7f019bee84aefb27e0cf2c13fea0ac1d4473267727408feeb1c56333ca1489385 + languageName: node + linkType: hard + +"eslint-plugin-react@npm:^7.37.5": + version: 7.37.5 + resolution: "eslint-plugin-react@npm:7.37.5" + dependencies: + array-includes: "npm:^3.1.8" + array.prototype.findlast: "npm:^1.2.5" + array.prototype.flatmap: "npm:^1.3.3" + array.prototype.tosorted: "npm:^1.1.4" + doctrine: "npm:^2.1.0" + es-iterator-helpers: "npm:^1.2.1" + estraverse: "npm:^5.3.0" + hasown: "npm:^2.0.2" + jsx-ast-utils: "npm:^2.4.1 || ^3.0.0" + minimatch: "npm:^3.1.2" + object.entries: "npm:^1.1.9" + object.fromentries: "npm:^2.0.8" + object.values: "npm:^1.2.1" + prop-types: "npm:^15.8.1" + resolve: "npm:^2.0.0-next.5" + semver: "npm:^6.3.1" + string.prototype.matchall: "npm:^4.0.12" + string.prototype.repeat: "npm:^1.0.0" + peerDependencies: + eslint: ^3 || ^4 || ^5 || ^6 || ^7 || ^8 || ^9.7 + checksum: 10c0/c850bfd556291d4d9234f5ca38db1436924a1013627c8ab1853f77cac73ec19b020e861e6c7b783436a48b6ffcdfba4547598235a37ad4611b6739f65fd8ad57 + languageName: node + linkType: hard + +"eslint-scope@npm:5.1.1": + version: 5.1.1 + resolution: "eslint-scope@npm:5.1.1" + dependencies: + esrecurse: "npm:^4.3.0" + estraverse: "npm:^4.1.1" + checksum: 10c0/d30ef9dc1c1cbdece34db1539a4933fe3f9b14e1ffb27ecc85987902ee663ad7c9473bbd49a9a03195a373741e62e2f807c4938992e019b511993d163450e70a + languageName: node + linkType: hard + +"eslint-scope@npm:^9.1.2": + version: 9.1.2 + resolution: "eslint-scope@npm:9.1.2" + dependencies: + "@types/esrecurse": "npm:^4.3.1" + "@types/estree": "npm:^1.0.8" + esrecurse: "npm:^4.3.0" + estraverse: "npm:^5.2.0" + checksum: 10c0/9fb8bca5a73e5741efb6cec84467027b6cb6f4203ff9b43a938e272c5cd30800bde46a5c20dfd1609f840225f0b62b7673be391b20acadf8658ca9fa4729b3dd + languageName: node + linkType: hard + +"eslint-visitor-keys@npm:^2.1.0": + version: 2.1.0 + resolution: "eslint-visitor-keys@npm:2.1.0" + checksum: 10c0/9f0e3a2db751d84067d15977ac4b4472efd6b303e369e6ff241a99feac04da758f46d5add022c33d06b53596038dbae4b4aceb27c7e68b8dfc1055b35e495787 + languageName: node + linkType: hard + +"eslint-visitor-keys@npm:^3.4.3": + version: 3.4.3 + resolution: "eslint-visitor-keys@npm:3.4.3" + checksum: 10c0/92708e882c0a5ffd88c23c0b404ac1628cf20104a108c745f240a13c332a11aac54f49a22d5762efbffc18ecbc9a580d1b7ad034bf5f3cc3307e5cbff2ec9820 + languageName: node + linkType: hard + +"eslint-visitor-keys@npm:^5.0.1": + version: 5.0.1 + resolution: "eslint-visitor-keys@npm:5.0.1" + checksum: 10c0/16190bdf2cbae40a1109384c94450c526a79b0b9c3cb21e544256ed85ac48a4b84db66b74a6561d20fe6ab77447f150d711c2ad5ad74df4fcc133736bce99678 + languageName: node + linkType: hard + +"eslint@npm:^10.5.0": + version: 10.5.0 + resolution: "eslint@npm:10.5.0" + dependencies: + "@eslint-community/eslint-utils": "npm:^4.8.0" + "@eslint-community/regexpp": "npm:^4.12.2" + "@eslint/config-array": "npm:^0.23.5" + "@eslint/config-helpers": "npm:^0.6.0" + "@eslint/core": "npm:^1.2.1" + "@eslint/plugin-kit": "npm:^0.7.2" + "@humanfs/node": "npm:^0.16.6" + "@humanwhocodes/module-importer": "npm:^1.0.1" + "@humanwhocodes/retry": "npm:^0.4.2" + "@types/estree": "npm:^1.0.6" + ajv: "npm:^6.14.0" + cross-spawn: "npm:^7.0.6" + debug: "npm:^4.3.2" + escape-string-regexp: "npm:^4.0.0" + eslint-scope: "npm:^9.1.2" + eslint-visitor-keys: "npm:^5.0.1" + espree: "npm:^11.2.0" + esquery: "npm:^1.7.0" + esutils: "npm:^2.0.2" + fast-deep-equal: "npm:^3.1.3" + file-entry-cache: "npm:^8.0.0" + find-up: "npm:^5.0.0" + glob-parent: "npm:^6.0.2" + ignore: "npm:^5.2.0" + imurmurhash: "npm:^0.1.4" + is-glob: "npm:^4.0.0" + json-stable-stringify-without-jsonify: "npm:^1.0.1" + minimatch: "npm:^10.2.4" + natural-compare: "npm:^1.4.0" + optionator: "npm:^0.9.3" + peerDependencies: + jiti: "*" + peerDependenciesMeta: + jiti: + optional: true + bin: + eslint: bin/eslint.js + checksum: 10c0/e1f7a1d442027e5478945cb07b6a382adc3f149fbfd3dbc14951a7a9fa312546b27fb35b0556897ca1d04539ad16ee85bda75ad9f724873e1153d1fbca0d6145 + languageName: node + linkType: hard + +"espree@npm:^11.2.0": + version: 11.2.0 + resolution: "espree@npm:11.2.0" + dependencies: + acorn: "npm:^8.16.0" + acorn-jsx: "npm:^5.3.2" + eslint-visitor-keys: "npm:^5.0.1" + checksum: 10c0/cf87e18ffd9dc113eb8d16588e7757701bc10c9934a71cce8b89c2611d51672681a918307bd6b19ac3ccd0e7ba1cbccc2f815b36b52fa7e73097b251014c3d81 + languageName: node + linkType: hard + +"esquery@npm:^1.7.0": + version: 1.7.0 + resolution: "esquery@npm:1.7.0" + dependencies: + estraverse: "npm:^5.1.0" + checksum: 10c0/77d5173db450b66f3bc685d11af4c90cffeedb340f34a39af96d43509a335ce39c894fd79233df32d38f5e4e219fa0f7076f6ec90bae8320170ba082c0db4793 + languageName: node + linkType: hard + +"esrecurse@npm:^4.3.0": + version: 4.3.0 + resolution: "esrecurse@npm:4.3.0" + dependencies: + estraverse: "npm:^5.2.0" + checksum: 10c0/81a37116d1408ded88ada45b9fb16dbd26fba3aadc369ce50fcaf82a0bac12772ebd7b24cd7b91fc66786bf2c1ac7b5f196bc990a473efff972f5cb338877cf5 + languageName: node + linkType: hard + +"estraverse@npm:^4.1.1": + version: 4.3.0 + resolution: "estraverse@npm:4.3.0" + checksum: 10c0/9cb46463ef8a8a4905d3708a652d60122a0c20bb58dec7e0e12ab0e7235123d74214fc0141d743c381813e1b992767e2708194f6f6e0f9fd00c1b4e0887b8b6d + languageName: node + linkType: hard + +"estraverse@npm:^5.1.0, estraverse@npm:^5.2.0, estraverse@npm:^5.3.0": + version: 5.3.0 + resolution: "estraverse@npm:5.3.0" + checksum: 10c0/1ff9447b96263dec95d6d67431c5e0771eb9776427421260a3e2f0fdd5d6bd4f8e37a7338f5ad2880c9f143450c9b1e4fc2069060724570a49cf9cf0312bd107 + languageName: node + linkType: hard + +"estree-walker@npm:^2.0.1, estree-walker@npm:^2.0.2": + version: 2.0.2 + resolution: "estree-walker@npm:2.0.2" + checksum: 10c0/53a6c54e2019b8c914dc395890153ffdc2322781acf4bd7d1a32d7aedc1710807bdcd866ac133903d5629ec601fbb50abe8c2e5553c7f5a0afdd9b6af6c945af + languageName: node + linkType: hard + +"esutils@npm:^2.0.2": + version: 2.0.3 + resolution: "esutils@npm:2.0.3" + checksum: 10c0/9a2fe69a41bfdade834ba7c42de4723c97ec776e40656919c62cbd13607c45e127a003f05f724a1ea55e5029a4cf2de444b13009f2af71271e42d93a637137c7 + languageName: node + linkType: hard + +"exponential-backoff@npm:^3.1.1": + version: 3.1.3 + resolution: "exponential-backoff@npm:3.1.3" + checksum: 10c0/77e3ae682b7b1f4972f563c6dbcd2b0d54ac679e62d5d32f3e5085feba20483cf28bd505543f520e287a56d4d55a28d7874299941faf637e779a1aa5994d1267 + languageName: node + linkType: hard + +"fast-deep-equal@npm:^3.1.1, fast-deep-equal@npm:^3.1.3": + version: 3.1.3 + resolution: "fast-deep-equal@npm:3.1.3" + checksum: 10c0/40dedc862eb8992c54579c66d914635afbec43350afbbe991235fdcb4e3a8d5af1b23ae7e79bef7d4882d0ecee06c3197488026998fb19f72dc95acff1d1b1d0 + languageName: node + linkType: hard + +"fast-json-stable-stringify@npm:^2.0.0": + version: 2.1.0 + resolution: "fast-json-stable-stringify@npm:2.1.0" + checksum: 10c0/7f081eb0b8a64e0057b3bb03f974b3ef00135fbf36c1c710895cd9300f13c94ba809bb3a81cf4e1b03f6e5285610a61abbd7602d0652de423144dfee5a389c9b + languageName: node + linkType: hard + +"fast-levenshtein@npm:^2.0.6": + version: 2.0.6 + resolution: "fast-levenshtein@npm:2.0.6" + checksum: 10c0/111972b37338bcb88f7d9e2c5907862c280ebf4234433b95bc611e518d192ccb2d38119c4ac86e26b668d75f7f3894f4ff5c4982899afced7ca78633b08287c4 + languageName: node + linkType: hard + +"fdir@npm:^6.5.0": + version: 6.5.0 + resolution: "fdir@npm:6.5.0" + peerDependencies: + picomatch: ^3 || ^4 + peerDependenciesMeta: + picomatch: + optional: true + checksum: 10c0/e345083c4306b3aed6cb8ec551e26c36bab5c511e99ea4576a16750ddc8d3240e63826cc624f5ae17ad4dc82e68a253213b60d556c11bfad064b7607847ed07f + languageName: node + linkType: hard + +"file-entry-cache@npm:^8.0.0": + version: 8.0.0 + resolution: "file-entry-cache@npm:8.0.0" + dependencies: + flat-cache: "npm:^4.0.0" + checksum: 10c0/9e2b5938b1cd9b6d7e3612bdc533afd4ac17b2fc646569e9a8abbf2eb48e5eb8e316bc38815a3ef6a1b456f4107f0d0f055a614ca613e75db6bf9ff4d72c1638 + languageName: node + linkType: hard + +"find-root@npm:^1.1.0": + version: 1.1.0 + resolution: "find-root@npm:1.1.0" + checksum: 10c0/1abc7f3bf2f8d78ff26d9e00ce9d0f7b32e5ff6d1da2857bcdf4746134c422282b091c672cde0572cac3840713487e0a7a636af9aa1b74cb11894b447a521efa + languageName: node + linkType: hard + +"find-up@npm:^5.0.0": + version: 5.0.0 + resolution: "find-up@npm:5.0.0" + dependencies: + locate-path: "npm:^6.0.0" + path-exists: "npm:^4.0.0" + checksum: 10c0/062c5a83a9c02f53cdd6d175a37ecf8f87ea5bbff1fdfb828f04bfa021441bc7583e8ebc0872a4c1baab96221fb8a8a275a19809fb93fbc40bd69ec35634069a + languageName: node + linkType: hard + +"flat-cache@npm:^4.0.0": + version: 4.0.1 + resolution: "flat-cache@npm:4.0.1" + dependencies: + flatted: "npm:^3.2.9" + keyv: "npm:^4.5.4" + checksum: 10c0/2c59d93e9faa2523e4fda6b4ada749bed432cfa28c8e251f33b25795e426a1c6dbada777afb1f74fcfff33934fdbdea921ee738fcc33e71adc9d6eca984a1cfc + languageName: node + linkType: hard + +"flatted@npm:^3.2.9": + version: 3.4.2 + resolution: "flatted@npm:3.4.2" + checksum: 10c0/a65b67aae7172d6cdf63691be7de6c5cd5adbdfdfe2e9da1a09b617c9512ed794037741ee53d93114276bff3f93cd3b0d97d54f9b316e1e4885dde6e9ffdf7ed + languageName: node + linkType: hard + +"follow-redirects@npm:^1.16.0": + version: 1.16.0 + resolution: "follow-redirects@npm:1.16.0" + peerDependenciesMeta: + debug: + optional: true + checksum: 10c0/a1e2900163e6f1b4d1ed5c221b607f41decbab65534c63fe7e287e40a5d552a6496e7d9d7d976fa4ba77b4c51c11e5e9f683f10b43011ea11e442ff128d0e181 + languageName: node + linkType: hard + +"for-each@npm:^0.3.3, for-each@npm:^0.3.5": + version: 0.3.5 + resolution: "for-each@npm:0.3.5" + dependencies: + is-callable: "npm:^1.2.7" + checksum: 10c0/0e0b50f6a843a282637d43674d1fb278dda1dd85f4f99b640024cfb10b85058aac0cc781bf689d5fe50b4b7f638e91e548560723a4e76e04fe96ae35ef039cee + languageName: node + linkType: hard + +"form-data@npm:^4.0.5": + version: 4.0.6 + resolution: "form-data@npm:4.0.6" + dependencies: + asynckit: "npm:^0.4.0" + combined-stream: "npm:^1.0.8" + es-set-tostringtag: "npm:^2.1.0" + hasown: "npm:^2.0.4" + mime-types: "npm:^2.1.35" + checksum: 10c0/43947a77bf0ff45c6ceed789778982d47a3f3e720a74b71721174ebf3310a5f1a8be1d6b38a3ee3688e8a18a2c4273073ec0844cd37efda3eaf46d41c9c318ff + languageName: node + linkType: hard + +"fsevents@npm:~2.3.2, fsevents@npm:~2.3.3": + version: 2.3.3 + resolution: "fsevents@npm:2.3.3" + dependencies: + node-gyp: "npm:latest" + checksum: 10c0/a1f0c44595123ed717febbc478aa952e47adfc28e2092be66b8ab1635147254ca6cfe1df792a8997f22716d4cbafc73309899ff7bfac2ac3ad8cf2e4ecc3ec60 + conditions: os=darwin + languageName: node + linkType: hard + +"fsevents@patch:fsevents@npm%3A~2.3.2#optional!builtin, fsevents@patch:fsevents@npm%3A~2.3.3#optional!builtin": + version: 2.3.3 + resolution: "fsevents@patch:fsevents@npm%3A2.3.3#optional!builtin::version=2.3.3&hash=df0bf1" + dependencies: + node-gyp: "npm:latest" + conditions: os=darwin + languageName: node + linkType: hard + +"function-bind@npm:^1.1.2": + version: 1.1.2 + resolution: "function-bind@npm:1.1.2" + checksum: 10c0/d8680ee1e5fcd4c197e4ac33b2b4dce03c71f4d91717292785703db200f5c21f977c568d28061226f9b5900cbcd2c84463646134fd5337e7925e0942bc3f46d5 + languageName: node + linkType: hard + +"function.prototype.name@npm:^1.1.6, function.prototype.name@npm:^1.1.8": + version: 1.2.0 + resolution: "function.prototype.name@npm:1.2.0" + dependencies: + call-bind: "npm:^1.0.9" + call-bound: "npm:^1.0.4" + es-define-property: "npm:^1.0.1" + es-errors: "npm:^1.3.0" + functions-have-names: "npm:^1.2.3" + has-property-descriptors: "npm:^1.0.2" + hasown: "npm:^2.0.4" + is-callable: "npm:^1.2.7" + is-document.all: "npm:^1.0.0" + checksum: 10c0/b20e6370ef4f7d56d0bedf5719f6684a517a8dd3334209b4d9f51e8834859302a584187156bf024cda9f50ba2479e4d6764ac34af9532ea47d2f4d9fa6bcf90d + languageName: node + linkType: hard + +"functions-have-names@npm:^1.2.3": + version: 1.2.3 + resolution: "functions-have-names@npm:1.2.3" + checksum: 10c0/33e77fd29bddc2d9bb78ab3eb854c165909201f88c75faa8272e35899e2d35a8a642a15e7420ef945e1f64a9670d6aa3ec744106b2aa42be68ca5114025954ca + languageName: node + linkType: hard + +"generator-function@npm:^2.0.0": + version: 2.0.1 + resolution: "generator-function@npm:2.0.1" + checksum: 10c0/8a9f59df0f01cfefafdb3b451b80555e5cf6d76487095db91ac461a0e682e4ff7a9dbce15f4ecec191e53586d59eece01949e05a4b4492879600bbbe8e28d6b8 + languageName: node + linkType: hard + +"gensync@npm:^1.0.0-beta.2": + version: 1.0.0-beta.2 + resolution: "gensync@npm:1.0.0-beta.2" + checksum: 10c0/782aba6cba65b1bb5af3b095d96249d20edbe8df32dbf4696fd49be2583faf676173bf4809386588828e4dd76a3354fcbeb577bab1c833ccd9fc4577f26103f8 + languageName: node + linkType: hard + +"get-intrinsic@npm:^1.2.4, get-intrinsic@npm:^1.2.5, get-intrinsic@npm:^1.2.6, get-intrinsic@npm:^1.2.7, get-intrinsic@npm:^1.3.0": + version: 1.3.0 + resolution: "get-intrinsic@npm:1.3.0" + dependencies: + call-bind-apply-helpers: "npm:^1.0.2" + es-define-property: "npm:^1.0.1" + es-errors: "npm:^1.3.0" + es-object-atoms: "npm:^1.1.1" + function-bind: "npm:^1.1.2" + get-proto: "npm:^1.0.1" + gopd: "npm:^1.2.0" + has-symbols: "npm:^1.1.0" + hasown: "npm:^2.0.2" + math-intrinsics: "npm:^1.1.0" + checksum: 10c0/52c81808af9a8130f581e6a6a83e1ba4a9f703359e7a438d1369a5267a25412322f03dcbd7c549edaef0b6214a0630a28511d7df0130c93cfd380f4fa0b5b66a + languageName: node + linkType: hard + +"get-proto@npm:^1.0.0, get-proto@npm:^1.0.1": + version: 1.0.1 + resolution: "get-proto@npm:1.0.1" + dependencies: + dunder-proto: "npm:^1.0.1" + es-object-atoms: "npm:^1.0.0" + checksum: 10c0/9224acb44603c5526955e83510b9da41baf6ae73f7398875fba50edc5e944223a89c4a72b070fcd78beb5f7bdda58ecb6294adc28f7acfc0da05f76a2399643c + languageName: node + linkType: hard + +"get-symbol-description@npm:^1.1.0": + version: 1.1.0 + resolution: "get-symbol-description@npm:1.1.0" + dependencies: + call-bound: "npm:^1.0.3" + es-errors: "npm:^1.3.0" + get-intrinsic: "npm:^1.2.6" + checksum: 10c0/d6a7d6afca375779a4b307738c9e80dbf7afc0bdbe5948768d54ab9653c865523d8920e670991a925936eb524b7cb6a6361d199a760b21d0ca7620194455aa4b + languageName: node + linkType: hard + +"glob-parent@npm:^6.0.2": + version: 6.0.2 + resolution: "glob-parent@npm:6.0.2" + dependencies: + is-glob: "npm:^4.0.3" + checksum: 10c0/317034d88654730230b3f43bb7ad4f7c90257a426e872ea0bf157473ac61c99bf5d205fad8f0185f989be8d2fa6d3c7dce1645d99d545b6ea9089c39f838e7f8 + languageName: node + linkType: hard + +"globals@npm:^15.7.0": + version: 15.15.0 + resolution: "globals@npm:15.15.0" + checksum: 10c0/f9ae80996392ca71316495a39bec88ac43ae3525a438b5626cd9d5ce9d5500d0a98a266409605f8cd7241c7acf57c354a48111ea02a767ba4f374b806d6861fe + languageName: node + linkType: hard + +"globals@npm:^16.2.0": + version: 16.5.0 + resolution: "globals@npm:16.5.0" + checksum: 10c0/615241dae7851c8012f5aa0223005b1ed6607713d6813de0741768bd4ddc39353117648f1a7086b4b0fa45eae733f1c0a0fe369aa4e543bb63f8de8990178ea9 + languageName: node + linkType: hard + +"globalthis@npm:^1.0.4": + version: 1.0.4 + resolution: "globalthis@npm:1.0.4" + dependencies: + define-properties: "npm:^1.2.1" + gopd: "npm:^1.0.1" + checksum: 10c0/9d156f313af79d80b1566b93e19285f481c591ad6d0d319b4be5e03750d004dde40a39a0f26f7e635f9007a3600802f53ecd85a759b86f109e80a5f705e01846 + languageName: node + linkType: hard + +"gopd@npm:^1.0.1, gopd@npm:^1.2.0": + version: 1.2.0 + resolution: "gopd@npm:1.2.0" + checksum: 10c0/50fff1e04ba2b7737c097358534eacadad1e68d24cccee3272e04e007bed008e68d2614f3987788428fd192a5ae3889d08fb2331417e4fc4a9ab366b2043cead + languageName: node + linkType: hard + +"graceful-fs@npm:^4.2.6": + version: 4.2.11 + resolution: "graceful-fs@npm:4.2.11" + checksum: 10c0/386d011a553e02bc594ac2ca0bd6d9e4c22d7fa8cfbfc448a6d148c59ea881b092db9dbe3547ae4b88e55f1b01f7c4a2ecc53b310c042793e63aa44cf6c257f2 + languageName: node + linkType: hard + +"has-bigints@npm:^1.0.2": + version: 1.1.0 + resolution: "has-bigints@npm:1.1.0" + checksum: 10c0/2de0cdc4a1ccf7a1e75ffede1876994525ac03cc6f5ae7392d3415dd475cd9eee5bceec63669ab61aa997ff6cceebb50ef75561c7002bed8988de2b9d1b40788 + languageName: node + linkType: hard + +"has-property-descriptors@npm:^1.0.0, has-property-descriptors@npm:^1.0.2": + version: 1.0.2 + resolution: "has-property-descriptors@npm:1.0.2" + dependencies: + es-define-property: "npm:^1.0.0" + checksum: 10c0/253c1f59e80bb476cf0dde8ff5284505d90c3bdb762983c3514d36414290475fe3fd6f574929d84de2a8eec00d35cf07cb6776205ff32efd7c50719125f00236 + languageName: node + linkType: hard + +"has-proto@npm:^1.2.0": + version: 1.2.0 + resolution: "has-proto@npm:1.2.0" + dependencies: + dunder-proto: "npm:^1.0.0" + checksum: 10c0/46538dddab297ec2f43923c3d35237df45d8c55a6fc1067031e04c13ed8a9a8f94954460632fd4da84c31a1721eefee16d901cbb1ae9602bab93bb6e08f93b95 + languageName: node + linkType: hard + +"has-symbols@npm:^1.0.3, has-symbols@npm:^1.1.0": + version: 1.1.0 + resolution: "has-symbols@npm:1.1.0" + checksum: 10c0/dde0a734b17ae51e84b10986e651c664379018d10b91b6b0e9b293eddb32f0f069688c841fb40f19e9611546130153e0a2a48fd7f512891fb000ddfa36f5a20e + languageName: node + linkType: hard + +"has-tostringtag@npm:^1.0.2": + version: 1.0.2 + resolution: "has-tostringtag@npm:1.0.2" + dependencies: + has-symbols: "npm:^1.0.3" + checksum: 10c0/a8b166462192bafe3d9b6e420a1d581d93dd867adb61be223a17a8d6dad147aa77a8be32c961bb2f27b3ef893cae8d36f564ab651f5e9b7938ae86f74027c48c + languageName: node + linkType: hard + +"hasown@npm:^2.0.2, hasown@npm:^2.0.3, hasown@npm:^2.0.4": + version: 2.0.4 + resolution: "hasown@npm:2.0.4" + dependencies: + function-bind: "npm:^1.1.2" + checksum: 10c0/2d8de939e270b70618f8cebb69746620db10617dbb495bc66ddad326955ea24d3ca4af133aff3eb7c1853e0218f867bc2b050ec26fe02e3aea58f880ffc5e506 + languageName: node + linkType: hard + +"he@npm:1.2.0": + version: 1.2.0 + resolution: "he@npm:1.2.0" + bin: + he: bin/he + checksum: 10c0/a27d478befe3c8192f006cdd0639a66798979dfa6e2125c6ac582a19a5ebfec62ad83e8382e6036170d873f46e4536a7e795bf8b95bf7c247f4cc0825ccc8c17 + languageName: node + linkType: hard + +"hoist-non-react-statics@npm:^3.3.1": + version: 3.3.2 + resolution: "hoist-non-react-statics@npm:3.3.2" + dependencies: + react-is: "npm:^16.7.0" + checksum: 10c0/fe0889169e845d738b59b64badf5e55fa3cf20454f9203d1eb088df322d49d4318df774828e789898dcb280e8a5521bb59b3203385662ca5e9218a6ca5820e74 + languageName: node + linkType: hard + +"https-proxy-agent@npm:^5.0.1": + version: 5.0.1 + resolution: "https-proxy-agent@npm:5.0.1" + dependencies: + agent-base: "npm:6" + debug: "npm:4" + checksum: 10c0/6dd639f03434003577c62b27cafdb864784ef19b2de430d8ae2a1d45e31c4fd60719e5637b44db1a88a046934307da7089e03d6089ec3ddacc1189d8de8897d1 + languageName: node + linkType: hard + +"ignore@npm:^5.2.0": + version: 5.3.2 + resolution: "ignore@npm:5.3.2" + checksum: 10c0/f9f652c957983634ded1e7f02da3b559a0d4cc210fca3792cb67f1b153623c9c42efdc1c4121af171e295444459fc4a9201101fb041b1104a3c000bccb188337 + languageName: node + linkType: hard + +"import-fresh@npm:^3.2.1": + version: 3.3.1 + resolution: "import-fresh@npm:3.3.1" + dependencies: + parent-module: "npm:^1.0.0" + resolve-from: "npm:^4.0.0" + checksum: 10c0/bf8cc494872fef783249709385ae883b447e3eb09db0ebd15dcead7d9afe7224dad7bd7591c6b73b0b19b3c0f9640eb8ee884f01cfaf2887ab995b0b36a0cbec + languageName: node + linkType: hard + +"import-meta-resolve@npm:^4.2.0": + version: 4.2.0 + resolution: "import-meta-resolve@npm:4.2.0" + checksum: 10c0/3ee8aeecb61d19b49d2703987f977e9d1c7d4ba47db615a570eaa02fe414f40dfa63f7b953e842cbe8470d26df6371332bfcf21b2fd92b0112f9fea80dde2c4c + languageName: node + linkType: hard + +"imurmurhash@npm:^0.1.4": + version: 0.1.4 + resolution: "imurmurhash@npm:0.1.4" + checksum: 10c0/8b51313850dd33605c6c9d3fd9638b714f4c4c40250cff658209f30d40da60f78992fb2df5dabee4acf589a6a82bbc79ad5486550754bd9ec4e3fc0d4a57d6a6 + languageName: node + linkType: hard + +"internal-slot@npm:^1.1.0": + version: 1.1.0 + resolution: "internal-slot@npm:1.1.0" + dependencies: + es-errors: "npm:^1.3.0" + hasown: "npm:^2.0.2" + side-channel: "npm:^1.1.0" + checksum: 10c0/03966f5e259b009a9bf1a78d60da920df198af4318ec004f57b8aef1dd3fe377fbc8cce63a96e8c810010302654de89f9e19de1cd8ad0061d15be28a695465c7 + languageName: node + linkType: hard + +"is-array-buffer@npm:^3.0.4, is-array-buffer@npm:^3.0.5": + version: 3.0.5 + resolution: "is-array-buffer@npm:3.0.5" + dependencies: + call-bind: "npm:^1.0.8" + call-bound: "npm:^1.0.3" + get-intrinsic: "npm:^1.2.6" + checksum: 10c0/c5c9f25606e86dbb12e756694afbbff64bc8b348d1bc989324c037e1068695131930199d6ad381952715dad3a9569333817f0b1a72ce5af7f883ce802e49c83d + languageName: node + linkType: hard + +"is-arrayish@npm:^0.2.1": + version: 0.2.1 + resolution: "is-arrayish@npm:0.2.1" + checksum: 10c0/e7fb686a739068bb70f860b39b67afc62acc62e36bb61c5f965768abce1873b379c563e61dd2adad96ebb7edf6651111b385e490cf508378959b0ed4cac4e729 + languageName: node + linkType: hard + +"is-async-function@npm:^2.0.0": + version: 2.1.1 + resolution: "is-async-function@npm:2.1.1" + dependencies: + async-function: "npm:^1.0.0" + call-bound: "npm:^1.0.3" + get-proto: "npm:^1.0.1" + has-tostringtag: "npm:^1.0.2" + safe-regex-test: "npm:^1.1.0" + checksum: 10c0/d70c236a5e82de6fc4d44368ffd0c2fee2b088b893511ce21e679da275a5ecc6015ff59a7d7e1bdd7ca39f71a8dbdd253cf8cce5c6b3c91cdd5b42b5ce677298 + languageName: node + linkType: hard + +"is-bigint@npm:^1.1.0": + version: 1.1.0 + resolution: "is-bigint@npm:1.1.0" + dependencies: + has-bigints: "npm:^1.0.2" + checksum: 10c0/f4f4b905ceb195be90a6ea7f34323bf1c18e3793f18922e3e9a73c684c29eeeeff5175605c3a3a74cc38185fe27758f07efba3dbae812e5c5afbc0d2316b40e4 + languageName: node + linkType: hard + +"is-boolean-object@npm:^1.2.1": + version: 1.2.2 + resolution: "is-boolean-object@npm:1.2.2" + dependencies: + call-bound: "npm:^1.0.3" + has-tostringtag: "npm:^1.0.2" + checksum: 10c0/36ff6baf6bd18b3130186990026f5a95c709345c39cd368468e6c1b6ab52201e9fd26d8e1f4c066357b4938b0f0401e1a5000e08257787c1a02f3a719457001e + languageName: node + linkType: hard + +"is-callable@npm:^1.2.7": + version: 1.2.7 + resolution: "is-callable@npm:1.2.7" + checksum: 10c0/ceebaeb9d92e8adee604076971dd6000d38d6afc40bb843ea8e45c5579b57671c3f3b50d7f04869618242c6cee08d1b67806a8cb8edaaaf7c0748b3720d6066f + languageName: node + linkType: hard + +"is-core-module@npm:^2.16.1, is-core-module@npm:^2.16.2": + version: 2.16.2 + resolution: "is-core-module@npm:2.16.2" + dependencies: + hasown: "npm:^2.0.3" + checksum: 10c0/14b4258390283709c15476d023ec173e27458d5d014ccdb8ed39d576e551c3fa45498b7c9fe178f1529c4cb2648ddd58852a6a62107a019f6e349529f277518a + languageName: node + linkType: hard + +"is-data-view@npm:^1.0.1, is-data-view@npm:^1.0.2": + version: 1.0.2 + resolution: "is-data-view@npm:1.0.2" + dependencies: + call-bound: "npm:^1.0.2" + get-intrinsic: "npm:^1.2.6" + is-typed-array: "npm:^1.1.13" + checksum: 10c0/ef3548a99d7e7f1370ce21006baca6d40c73e9f15c941f89f0049c79714c873d03b02dae1c64b3f861f55163ecc16da06506c5b8a1d4f16650b3d9351c380153 + languageName: node + linkType: hard + +"is-date-object@npm:^1.1.0": + version: 1.1.0 + resolution: "is-date-object@npm:1.1.0" + dependencies: + call-bound: "npm:^1.0.2" + has-tostringtag: "npm:^1.0.2" + checksum: 10c0/1a4d199c8e9e9cac5128d32e6626fa7805175af9df015620ac0d5d45854ccf348ba494679d872d37301032e35a54fc7978fba1687e8721b2139aea7870cafa2f + languageName: node + linkType: hard + +"is-document.all@npm:^1.0.0": + version: 1.0.0 + resolution: "is-document.all@npm:1.0.0" + dependencies: + call-bound: "npm:^1.0.4" + checksum: 10c0/955c20ed5bf01d49da8243b4c714947a6ff64b6d9ba0e12bdbfa654a3e7c47f72cc01c6cd2905e85512d02bc3a1290edd73857bca8842566ff9dcfb7c3f92dae + languageName: node + linkType: hard + +"is-extglob@npm:^2.1.1": + version: 2.1.1 + resolution: "is-extglob@npm:2.1.1" + checksum: 10c0/5487da35691fbc339700bbb2730430b07777a3c21b9ebaecb3072512dfd7b4ba78ac2381a87e8d78d20ea08affb3f1971b4af629173a6bf435ff8a4c47747912 + languageName: node + linkType: hard + +"is-finalizationregistry@npm:^1.1.0": + version: 1.1.1 + resolution: "is-finalizationregistry@npm:1.1.1" + dependencies: + call-bound: "npm:^1.0.3" + checksum: 10c0/818dff679b64f19e228a8205a1e2d09989a98e98def3a817f889208cfcbf918d321b251aadf2c05918194803ebd2eb01b14fc9d0b2bea53d984f4137bfca5e97 + languageName: node + linkType: hard + +"is-generator-function@npm:^1.0.10": + version: 1.1.2 + resolution: "is-generator-function@npm:1.1.2" + dependencies: + call-bound: "npm:^1.0.4" + generator-function: "npm:^2.0.0" + get-proto: "npm:^1.0.1" + has-tostringtag: "npm:^1.0.2" + safe-regex-test: "npm:^1.1.0" + checksum: 10c0/83da102e89c3e3b71d67b51d47c9f9bc862bceb58f87201727e27f7fa19d1d90b0ab223644ecaee6fc6e3d2d622bb25c966fbdaf87c59158b01ce7c0fe2fa372 + languageName: node + linkType: hard + +"is-glob@npm:^4.0.0, is-glob@npm:^4.0.3": + version: 4.0.3 + resolution: "is-glob@npm:4.0.3" + dependencies: + is-extglob: "npm:^2.1.1" + checksum: 10c0/17fb4014e22be3bbecea9b2e3a76e9e34ff645466be702f1693e8f1ee1adac84710d0be0bd9f967d6354036fd51ab7c2741d954d6e91dae6bb69714de92c197a + languageName: node + linkType: hard + +"is-map@npm:^2.0.3": + version: 2.0.3 + resolution: "is-map@npm:2.0.3" + checksum: 10c0/2c4d431b74e00fdda7162cd8e4b763d6f6f217edf97d4f8538b94b8702b150610e2c64961340015fe8df5b1fcee33ccd2e9b62619c4a8a3a155f8de6d6d355fc + languageName: node + linkType: hard + +"is-negative-zero@npm:^2.0.3": + version: 2.0.3 + resolution: "is-negative-zero@npm:2.0.3" + checksum: 10c0/bcdcf6b8b9714063ffcfa9929c575ac69bfdabb8f4574ff557dfc086df2836cf07e3906f5bbc4f2a5c12f8f3ba56af640c843cdfc74da8caed86c7c7d66fd08e + languageName: node + linkType: hard + +"is-number-object@npm:^1.1.1": + version: 1.1.1 + resolution: "is-number-object@npm:1.1.1" + dependencies: + call-bound: "npm:^1.0.3" + has-tostringtag: "npm:^1.0.2" + checksum: 10c0/97b451b41f25135ff021d85c436ff0100d84a039bb87ffd799cbcdbea81ef30c464ced38258cdd34f080be08fc3b076ca1f472086286d2aa43521d6ec6a79f53 + languageName: node + linkType: hard + +"is-regex@npm:^1.2.1": + version: 1.2.1 + resolution: "is-regex@npm:1.2.1" + dependencies: + call-bound: "npm:^1.0.2" + gopd: "npm:^1.2.0" + has-tostringtag: "npm:^1.0.2" + hasown: "npm:^2.0.2" + checksum: 10c0/1d3715d2b7889932349241680032e85d0b492cfcb045acb75ffc2c3085e8d561184f1f7e84b6f8321935b4aea39bc9c6ba74ed595b57ce4881a51dfdbc214e04 + languageName: node + linkType: hard + +"is-set@npm:^2.0.3": + version: 2.0.3 + resolution: "is-set@npm:2.0.3" + checksum: 10c0/f73732e13f099b2dc879c2a12341cfc22ccaca8dd504e6edae26484bd5707a35d503fba5b4daad530a9b088ced1ae6c9d8200fd92e09b428fe14ea79ce8080b7 + languageName: node + linkType: hard + +"is-shared-array-buffer@npm:^1.0.4": + version: 1.0.4 + resolution: "is-shared-array-buffer@npm:1.0.4" + dependencies: + call-bound: "npm:^1.0.3" + checksum: 10c0/65158c2feb41ff1edd6bbd6fd8403a69861cf273ff36077982b5d4d68e1d59278c71691216a4a64632bd76d4792d4d1d2553901b6666d84ade13bba5ea7bc7db + languageName: node + linkType: hard + +"is-string@npm:^1.1.1": + version: 1.1.1 + resolution: "is-string@npm:1.1.1" + dependencies: + call-bound: "npm:^1.0.3" + has-tostringtag: "npm:^1.0.2" + checksum: 10c0/2f518b4e47886bb81567faba6ffd0d8a8333cf84336e2e78bf160693972e32ad00fe84b0926491cc598dee576fdc55642c92e62d0cbe96bf36f643b6f956f94d + languageName: node + linkType: hard + +"is-symbol@npm:^1.1.1": + version: 1.1.1 + resolution: "is-symbol@npm:1.1.1" + dependencies: + call-bound: "npm:^1.0.2" + has-symbols: "npm:^1.1.0" + safe-regex-test: "npm:^1.1.0" + checksum: 10c0/f08f3e255c12442e833f75a9e2b84b2d4882fdfd920513cf2a4a2324f0a5b076c8fd913778e3ea5d258d5183e9d92c0cd20e04b03ab3df05316b049b2670af1e + languageName: node + linkType: hard + +"is-typed-array@npm:^1.1.13, is-typed-array@npm:^1.1.14, is-typed-array@npm:^1.1.15": + version: 1.1.15 + resolution: "is-typed-array@npm:1.1.15" + dependencies: + which-typed-array: "npm:^1.1.16" + checksum: 10c0/415511da3669e36e002820584e264997ffe277ff136643a3126cc949197e6ca3334d0f12d084e83b1994af2e9c8141275c741cf2b7da5a2ff62dd0cac26f76c4 + languageName: node + linkType: hard + +"is-weakmap@npm:^2.0.2": + version: 2.0.2 + resolution: "is-weakmap@npm:2.0.2" + checksum: 10c0/443c35bb86d5e6cc5929cd9c75a4024bb0fff9586ed50b092f94e700b89c43a33b186b76dbc6d54f3d3d09ece689ab38dcdc1af6a482cbe79c0f2da0a17f1299 + languageName: node + linkType: hard + +"is-weakref@npm:^1.0.2, is-weakref@npm:^1.1.1": + version: 1.1.1 + resolution: "is-weakref@npm:1.1.1" + dependencies: + call-bound: "npm:^1.0.3" + checksum: 10c0/8e0a9c07b0c780949a100e2cab2b5560a48ecd4c61726923c1a9b77b6ab0aa0046c9e7fb2206042296817045376dee2c8ab1dabe08c7c3dfbf195b01275a085b + languageName: node + linkType: hard + +"is-weakset@npm:^2.0.3": + version: 2.0.4 + resolution: "is-weakset@npm:2.0.4" + dependencies: + call-bound: "npm:^1.0.3" + get-intrinsic: "npm:^1.2.6" + checksum: 10c0/6491eba08acb8dc9532da23cb226b7d0192ede0b88f16199e592e4769db0a077119c1f5d2283d1e0d16d739115f70046e887e477eb0e66cd90e1bb29f28ba647 + languageName: node + linkType: hard + +"isarray@npm:^2.0.5": + version: 2.0.5 + resolution: "isarray@npm:2.0.5" + checksum: 10c0/4199f14a7a13da2177c66c31080008b7124331956f47bca57dd0b6ea9f11687aa25e565a2c7a2b519bc86988d10398e3049a1f5df13c9f6b7664154690ae79fd + languageName: node + linkType: hard + +"isexe@npm:^2.0.0": + version: 2.0.0 + resolution: "isexe@npm:2.0.0" + checksum: 10c0/228cfa503fadc2c31596ab06ed6aa82c9976eec2bfd83397e7eaf06d0ccf42cd1dfd6743bf9aeb01aebd4156d009994c5f76ea898d2832c1fe342da923ca457d + languageName: node + linkType: hard + +"isexe@npm:^4.0.0": + version: 4.0.0 + resolution: "isexe@npm:4.0.0" + checksum: 10c0/5884815115bceac452877659a9c7726382531592f43dc29e5d48b7c4100661aed54018cb90bd36cb2eaeba521092570769167acbb95c18d39afdccbcca06c5ce + languageName: node + linkType: hard + +"iterator.prototype@npm:^1.1.5": + version: 1.1.5 + resolution: "iterator.prototype@npm:1.1.5" + dependencies: + define-data-property: "npm:^1.1.4" + es-object-atoms: "npm:^1.0.0" + get-intrinsic: "npm:^1.2.6" + get-proto: "npm:^1.0.0" + has-symbols: "npm:^1.1.0" + set-function-name: "npm:^2.0.2" + checksum: 10c0/f7a262808e1b41049ab55f1e9c29af7ec1025a000d243b83edf34ce2416eedd56079b117fa59376bb4a724110690f13aa8427f2ee29a09eec63a7e72367626d0 + languageName: node + linkType: hard + +"js-tokens@npm:^10.0.0": + version: 10.0.0 + resolution: "js-tokens@npm:10.0.0" + checksum: 10c0/a93498747812ba3e0c8626f95f75ab29319f2a13613a0de9e610700405760931624433a0de59eb7c27ff8836e526768fb20783861b86ef89be96676f2c996b64 + languageName: node + linkType: hard + +"js-tokens@npm:^3.0.0 || ^4.0.0, js-tokens@npm:^4.0.0": + version: 4.0.0 + resolution: "js-tokens@npm:4.0.0" + checksum: 10c0/e248708d377aa058eacf2037b07ded847790e6de892bbad3dac0abba2e759cb9f121b00099a65195616badcb6eca8d14d975cb3e89eb1cfda644756402c8aeed + languageName: node + linkType: hard + +"jsesc@npm:^3.0.2": + version: 3.1.0 + resolution: "jsesc@npm:3.1.0" + bin: + jsesc: bin/jsesc + checksum: 10c0/531779df5ec94f47e462da26b4cbf05eb88a83d9f08aac2ba04206508fc598527a153d08bd462bae82fc78b3eaa1a908e1a4a79f886e9238641c4cdefaf118b1 + languageName: node + linkType: hard + +"json-buffer@npm:3.0.1": + version: 3.0.1 + resolution: "json-buffer@npm:3.0.1" + checksum: 10c0/0d1c91569d9588e7eef2b49b59851f297f3ab93c7b35c7c221e288099322be6b562767d11e4821da500f3219542b9afd2e54c5dc573107c1126ed1080f8e96d7 + languageName: node + linkType: hard + +"json-parse-even-better-errors@npm:^2.3.0": + version: 2.3.1 + resolution: "json-parse-even-better-errors@npm:2.3.1" + checksum: 10c0/140932564c8f0b88455432e0f33c4cb4086b8868e37524e07e723f4eaedb9425bdc2bafd71bd1d9765bd15fd1e2d126972bc83990f55c467168c228c24d665f3 + languageName: node + linkType: hard + +"json-schema-traverse@npm:^0.4.1": + version: 0.4.1 + resolution: "json-schema-traverse@npm:0.4.1" + checksum: 10c0/108fa90d4cc6f08243aedc6da16c408daf81793bf903e9fd5ab21983cda433d5d2da49e40711da016289465ec2e62e0324dcdfbc06275a607fe3233fde4942ce + languageName: node + linkType: hard + +"json-stable-stringify-without-jsonify@npm:^1.0.1": + version: 1.0.1 + resolution: "json-stable-stringify-without-jsonify@npm:1.0.1" + checksum: 10c0/cb168b61fd4de83e58d09aaa6425ef71001bae30d260e2c57e7d09a5fd82223e2f22a042dedaab8db23b7d9ae46854b08bb1f91675a8be11c5cffebef5fb66a5 + languageName: node + linkType: hard + +"json5@npm:^2.2.3": + version: 2.2.3 + resolution: "json5@npm:2.2.3" + bin: + json5: lib/cli.js + checksum: 10c0/5a04eed94810fa55c5ea138b2f7a5c12b97c3750bc63d11e511dcecbfef758003861522a070c2272764ee0f4e3e323862f386945aeb5b85b87ee43f084ba586c + languageName: node + linkType: hard + +"jsx-ast-utils@npm:^2.4.1 || ^3.0.0": + version: 3.3.5 + resolution: "jsx-ast-utils@npm:3.3.5" + dependencies: + array-includes: "npm:^3.1.6" + array.prototype.flat: "npm:^1.3.1" + object.assign: "npm:^4.1.4" + object.values: "npm:^1.1.6" + checksum: 10c0/a32679e9cb55469cb6d8bbc863f7d631b2c98b7fc7bf172629261751a6e7bc8da6ae374ddb74d5fbd8b06cf0eb4572287b259813d92b36e384024ed35e4c13e1 + languageName: node + linkType: hard + +"keyv@npm:^4.5.4": + version: 4.5.4 + resolution: "keyv@npm:4.5.4" + dependencies: + json-buffer: "npm:3.0.1" + checksum: 10c0/aa52f3c5e18e16bb6324876bb8b59dd02acf782a4b789c7b2ae21107fab95fab3890ed448d4f8dba80ce05391eeac4bfabb4f02a20221342982f806fa2cf271e + languageName: node + linkType: hard + +"kolorist@npm:^1.6.0, kolorist@npm:^1.8.0": + version: 1.8.0 + resolution: "kolorist@npm:1.8.0" + checksum: 10c0/73075db44a692bf6c34a649f3b4b3aea4993b84f6b754cbf7a8577e7c7db44c0bad87752bd23b0ce533f49de2244ce2ce03b7b1b667a85ae170a94782cc50f9b + languageName: node + linkType: hard + +"levn@npm:^0.4.1": + version: 0.4.1 + resolution: "levn@npm:0.4.1" + dependencies: + prelude-ls: "npm:^1.2.1" + type-check: "npm:~0.4.0" + checksum: 10c0/effb03cad7c89dfa5bd4f6989364bfc79994c2042ec5966cb9b95990e2edee5cd8969ddf42616a0373ac49fac1403437deaf6e9050fbbaa3546093a59b9ac94e + languageName: node + linkType: hard + +"lines-and-columns@npm:^1.1.6": + version: 1.2.4 + resolution: "lines-and-columns@npm:1.2.4" + checksum: 10c0/3da6ee62d4cd9f03f5dc90b4df2540fb85b352081bee77fe4bbcd12c9000ead7f35e0a38b8d09a9bb99b13223446dd8689ff3c4959807620726d788701a83d2d + languageName: node + linkType: hard + +"locate-path@npm:^6.0.0": + version: 6.0.0 + resolution: "locate-path@npm:6.0.0" + dependencies: + p-locate: "npm:^5.0.0" + checksum: 10c0/d3972ab70dfe58ce620e64265f90162d247e87159b6126b01314dd67be43d50e96a50b517bce2d9452a79409c7614054c277b5232377de50416564a77ac7aad3 + languageName: node + linkType: hard + +"lodash.memoize@npm:^4.1.2": + version: 4.1.2 + resolution: "lodash.memoize@npm:4.1.2" + checksum: 10c0/c8713e51eccc650422716a14cece1809cfe34bc5ab5e242b7f8b4e2241c2483697b971a604252807689b9dd69bfe3a98852e19a5b89d506b000b4187a1285df8 + languageName: node + linkType: hard + +"loose-envify@npm:^1.4.0": + version: 1.4.0 + resolution: "loose-envify@npm:1.4.0" + dependencies: + js-tokens: "npm:^3.0.0 || ^4.0.0" + bin: + loose-envify: cli.js + checksum: 10c0/655d110220983c1a4b9c0c679a2e8016d4b67f6e9c7b5435ff5979ecdb20d0813f4dec0a08674fcbdd4846a3f07edbb50a36811fd37930b94aaa0d9daceb017e + languageName: node + linkType: hard + +"lru-cache@npm:^11.0.0": + version: 11.5.1 + resolution: "lru-cache@npm:11.5.1" + checksum: 10c0/7b341cea79a8efe9c6a6f20c8757a77eca5b25d7ff983ccf4e11e547b81f6787824baa1c84705251dff84ab4ffac85717ac354b9d02e465f86a9f8b166409979 + languageName: node + linkType: hard + +"lru-cache@npm:^5.1.1": + version: 5.1.1 + resolution: "lru-cache@npm:5.1.1" + dependencies: + yallist: "npm:^3.0.2" + checksum: 10c0/89b2ef2ef45f543011e38737b8a8622a2f8998cddf0e5437174ef8f1f70a8b9d14a918ab3e232cb3ba343b7abddffa667f0b59075b2b80e6b4d63c3de6127482 + languageName: node + linkType: hard + +"magic-string@npm:0.x >= 0.26.0, magic-string@npm:^0.30.21": + version: 0.30.21 + resolution: "magic-string@npm:0.30.21" + dependencies: + "@jridgewell/sourcemap-codec": "npm:^1.5.5" + checksum: 10c0/299378e38f9a270069fc62358522ddfb44e94244baa0d6a8980ab2a9b2490a1d03b236b447eee309e17eb3bddfa482c61259d47960eb018a904f0ded52780c4a + languageName: node + linkType: hard + +"math-intrinsics@npm:^1.1.0": + version: 1.1.0 + resolution: "math-intrinsics@npm:1.1.0" + checksum: 10c0/7579ff94e899e2f76ab64491d76cf606274c874d8f2af4a442c016bd85688927fcfca157ba6bf74b08e9439dc010b248ce05b96cc7c126a354c3bae7fcb48b7f + languageName: node + linkType: hard + +"mime-db@npm:1.52.0": + version: 1.52.0 + resolution: "mime-db@npm:1.52.0" + checksum: 10c0/0557a01deebf45ac5f5777fe7740b2a5c309c6d62d40ceab4e23da9f821899ce7a900b7ac8157d4548ddbb7beffe9abc621250e6d182b0397ec7f10c7b91a5aa + languageName: node + linkType: hard + +"mime-types@npm:^2.1.35": + version: 2.1.35 + resolution: "mime-types@npm:2.1.35" + dependencies: + mime-db: "npm:1.52.0" + checksum: 10c0/82fb07ec56d8ff1fc999a84f2f217aa46cb6ed1033fefaabd5785b9a974ed225c90dc72fff460259e66b95b73648596dbcc50d51ed69cdf464af2d237d3149b2 + languageName: node + linkType: hard + +"minimatch@npm:^10.2.4": + version: 10.2.5 + resolution: "minimatch@npm:10.2.5" + dependencies: + brace-expansion: "npm:^5.0.5" + checksum: 10c0/6bb058bd6324104b9ec2f763476a35386d05079c1f5fe4fbf1f324a25237cd4534d6813ecd71f48208f4e635c1221899bef94c3c89f7df55698fe373aaae20fd + languageName: node + linkType: hard + +"minimatch@npm:^3.1.2": + version: 3.1.5 + resolution: "minimatch@npm:3.1.5" + dependencies: + brace-expansion: "npm:^1.1.7" + checksum: 10c0/2ecbdc0d33f07bddb0315a8b5afbcb761307a8778b48f0b312418ccbced99f104a2d17d8aca7573433c70e8ccd1c56823a441897a45e384ea76ef401a26ace70 + languageName: node + linkType: hard + +"minipass@npm:^7.0.4, minipass@npm:^7.1.2": + version: 7.1.3 + resolution: "minipass@npm:7.1.3" + checksum: 10c0/539da88daca16533211ea5a9ee98dc62ff5742f531f54640dd34429e621955e91cc280a91a776026264b7f9f6735947629f920944e9c1558369e8bf22eb33fbb + languageName: node + linkType: hard + +"minizlib@npm:^3.1.0": + version: 3.1.0 + resolution: "minizlib@npm:3.1.0" + dependencies: + minipass: "npm:^7.1.2" + checksum: 10c0/5aad75ab0090b8266069c9aabe582c021ae53eb33c6c691054a13a45db3b4f91a7fb1bd79151e6b4e9e9a86727b522527c0a06ec7d45206b745d54cd3097bcec + languageName: node + linkType: hard + +"ms@npm:^2.1.3": + version: 2.1.3 + resolution: "ms@npm:2.1.3" + checksum: 10c0/d924b57e7312b3b63ad21fc5b3dc0af5e78d61a1fc7cfb5457edaf26326bf62be5307cc87ffb6862ef1c2b33b0233cdb5d4f01c4c958cc0d660948b65a287a48 + languageName: node + linkType: hard + +"nanoid@npm:^3.3.12": + version: 3.3.13 + resolution: "nanoid@npm:3.3.13" + bin: + nanoid: bin/nanoid.cjs + checksum: 10c0/e913cd6d081e3b646788aa36e686964f2746f15935759425c98344053676b9444efedff4d87915bfb38b1626057e66c788f59ee7746b48c2b7886a4b049ca2ac + languageName: node + linkType: hard + +"natural-compare@npm:^1.4.0": + version: 1.4.0 + resolution: "natural-compare@npm:1.4.0" + checksum: 10c0/f5f9a7974bfb28a91afafa254b197f0f22c684d4a1731763dda960d2c8e375b36c7d690e0d9dc8fba774c537af14a7e979129bca23d88d052fbeb9466955e447 + languageName: node + linkType: hard + +"node-exports-info@npm:^1.6.0": + version: 1.6.0 + resolution: "node-exports-info@npm:1.6.0" + dependencies: + array.prototype.flatmap: "npm:^1.3.3" + es-errors: "npm:^1.3.0" + object.entries: "npm:^1.1.9" + semver: "npm:^6.3.1" + checksum: 10c0/3613f21c60b047e66f168d3499a6be0060d89fb01ddceaa7032c2fb318aff12e4b9b111449c1a9aeb3b848bfdc1d4b6bc8fab327af692319597d21a1e7063692 + languageName: node + linkType: hard + +"node-gyp@npm:latest": + version: 13.0.0 + resolution: "node-gyp@npm:13.0.0" + dependencies: + env-paths: "npm:^2.2.0" + exponential-backoff: "npm:^3.1.1" + graceful-fs: "npm:^4.2.6" + nopt: "npm:^10.0.0" + proc-log: "npm:^7.0.0" + semver: "npm:^7.3.5" + tar: "npm:^7.5.4" + tinyglobby: "npm:^0.2.12" + undici: "npm:^6.25.0" + which: "npm:^7.0.0" + bin: + node-gyp: bin/node-gyp.js + checksum: 10c0/e7525c427db2d16aa368b8947187de83083d2a8dda23e3e096a71c22ae637ac5bb8ed7cf6c871f1b9118cd2729dbfee4ff3a4245e2b79226900227b15831b492 + languageName: node + linkType: hard + +"node-html-parser@npm:^6.1.12": + version: 6.1.13 + resolution: "node-html-parser@npm:6.1.13" + dependencies: + css-select: "npm:^5.1.0" + he: "npm:1.2.0" + checksum: 10c0/ca36290507da8ec0fa131a0fd67ba62e300365c3950b5a6058b0e32b71b520ff43a5661b19e98a5c9797dbe3428b08db788b602f1f8aa62f2db5bb66e1d80782 + languageName: node + linkType: hard + +"node-releases@npm:^2.0.36": + version: 2.0.48 + resolution: "node-releases@npm:2.0.48" + checksum: 10c0/17eac8493c0be99130793e87fd67feb6291aecb9f4e473dea3b00f59c002cc8b9c0bdc923227c9aa84968da6b2e4c58e75251981503eb367ec9c742715175a34 + languageName: node + linkType: hard + +"nopt@npm:^10.0.0": + version: 10.0.1 + resolution: "nopt@npm:10.0.1" + dependencies: + abbrev: "npm:^5.0.0" + bin: + nopt: bin/nopt.js + checksum: 10c0/980d89257f9587f3e1f77877ddbf905d6aa3b738ec33e49a4fa1a059a0dd82eb28063982b150654a7ae9de386f2ead60e56172db7d37cf56de545f7392a2a26a + languageName: node + linkType: hard + +"nth-check@npm:^2.0.1": + version: 2.1.1 + resolution: "nth-check@npm:2.1.1" + dependencies: + boolbase: "npm:^1.0.0" + checksum: 10c0/5fee7ff309727763689cfad844d979aedd2204a817fbaaf0e1603794a7c20db28548d7b024692f953557df6ce4a0ee4ae46cd8ebd9b36cfb300b9226b567c479 + languageName: node + linkType: hard + +"object-assign@npm:^4.1.1": + version: 4.1.1 + resolution: "object-assign@npm:4.1.1" + checksum: 10c0/1f4df9945120325d041ccf7b86f31e8bcc14e73d29171e37a7903050e96b81323784ec59f93f102ec635bcf6fa8034ba3ea0a8c7e69fa202b87ae3b6cec5a414 + languageName: node + linkType: hard + +"object-inspect@npm:^1.13.3, object-inspect@npm:^1.13.4": + version: 1.13.4 + resolution: "object-inspect@npm:1.13.4" + checksum: 10c0/d7f8711e803b96ea3191c745d6f8056ce1f2496e530e6a19a0e92d89b0fa3c76d910c31f0aa270432db6bd3b2f85500a376a83aaba849a8d518c8845b3211692 + languageName: node + linkType: hard + +"object-keys@npm:^1.1.1": + version: 1.1.1 + resolution: "object-keys@npm:1.1.1" + checksum: 10c0/b11f7ccdbc6d406d1f186cdadb9d54738e347b2692a14439ca5ac70c225fa6db46db809711b78589866d47b25fc3e8dee0b4c722ac751e11180f9380e3d8601d + languageName: node + linkType: hard + +"object.assign@npm:^4.1.4, object.assign@npm:^4.1.7": + version: 4.1.7 + resolution: "object.assign@npm:4.1.7" + dependencies: + call-bind: "npm:^1.0.8" + call-bound: "npm:^1.0.3" + define-properties: "npm:^1.2.1" + es-object-atoms: "npm:^1.0.0" + has-symbols: "npm:^1.1.0" + object-keys: "npm:^1.1.1" + checksum: 10c0/3b2732bd860567ea2579d1567525168de925a8d852638612846bd8082b3a1602b7b89b67b09913cbb5b9bd6e95923b2ae73580baa9d99cb4e990564e8cbf5ddc + languageName: node + linkType: hard + +"object.entries@npm:^1.1.9": + version: 1.1.9 + resolution: "object.entries@npm:1.1.9" + dependencies: + call-bind: "npm:^1.0.8" + call-bound: "npm:^1.0.4" + define-properties: "npm:^1.2.1" + es-object-atoms: "npm:^1.1.1" + checksum: 10c0/d4b8c1e586650407da03370845f029aa14076caca4e4d4afadbc69cfb5b78035fd3ee7be417141abdb0258fa142e59b11923b4c44d8b1255b28f5ffcc50da7db + languageName: node + linkType: hard + +"object.fromentries@npm:^2.0.8": + version: 2.0.8 + resolution: "object.fromentries@npm:2.0.8" + dependencies: + call-bind: "npm:^1.0.7" + define-properties: "npm:^1.2.1" + es-abstract: "npm:^1.23.2" + es-object-atoms: "npm:^1.0.0" + checksum: 10c0/cd4327e6c3369cfa805deb4cbbe919bfb7d3aeebf0bcaba291bb568ea7169f8f8cdbcabe2f00b40db0c20cd20f08e11b5f3a5a36fb7dd3fe04850c50db3bf83b + languageName: node + linkType: hard + +"object.values@npm:^1.1.6, object.values@npm:^1.2.1": + version: 1.2.1 + resolution: "object.values@npm:1.2.1" + dependencies: + call-bind: "npm:^1.0.8" + call-bound: "npm:^1.0.3" + define-properties: "npm:^1.2.1" + es-object-atoms: "npm:^1.0.0" + checksum: 10c0/3c47814fdc64842ae3d5a74bc9d06bdd8d21563c04d9939bf6716a9c00596a4ebc342552f8934013d1ec991c74e3671b26710a0c51815f0b603795605ab6b2c9 + languageName: node + linkType: hard + +"obug@npm:^2.1.1": + version: 2.1.3 + resolution: "obug@npm:2.1.3" + checksum: 10c0/cb8187fed0a5fc8445507c950e89f3c1bd43895658c398b5803f6b7804dfa0c562975ecce1e67f3d9247d521452a5bfade9e0e951cc0326b7444272f7c24d25f + languageName: node + linkType: hard + +"optionator@npm:^0.9.3": + version: 0.9.4 + resolution: "optionator@npm:0.9.4" + dependencies: + deep-is: "npm:^0.1.3" + fast-levenshtein: "npm:^2.0.6" + levn: "npm:^0.4.1" + prelude-ls: "npm:^1.2.1" + type-check: "npm:^0.4.0" + word-wrap: "npm:^1.2.5" + checksum: 10c0/4afb687a059ee65b61df74dfe87d8d6815cd6883cb8b3d5883a910df72d0f5d029821f37025e4bccf4048873dbdb09acc6d303d27b8f76b1a80dd5a7d5334675 + languageName: node + linkType: hard + +"own-keys@npm:^1.0.1": + version: 1.0.1 + resolution: "own-keys@npm:1.0.1" + dependencies: + get-intrinsic: "npm:^1.2.6" + object-keys: "npm:^1.1.1" + safe-push-apply: "npm:^1.0.0" + checksum: 10c0/6dfeb3455bff92ec3f16a982d4e3e65676345f6902d9f5ded1d8265a6318d0200ce461956d6d1c70053c7fe9f9fe65e552faac03f8140d37ef0fdd108e67013a + languageName: node + linkType: hard + +"p-limit@npm:^3.0.2": + version: 3.1.0 + resolution: "p-limit@npm:3.1.0" + dependencies: + yocto-queue: "npm:^0.1.0" + checksum: 10c0/9db675949dbdc9c3763c89e748d0ef8bdad0afbb24d49ceaf4c46c02c77d30db4e0652ed36d0a0a7a95154335fab810d95c86153105bb73b3a90448e2bb14e1a + languageName: node + linkType: hard + +"p-locate@npm:^5.0.0": + version: 5.0.0 + resolution: "p-locate@npm:5.0.0" + dependencies: + p-limit: "npm:^3.0.2" + checksum: 10c0/2290d627ab7903b8b70d11d384fee714b797f6040d9278932754a6860845c4d3190603a0772a663c8cb5a7b21d1b16acb3a6487ebcafa9773094edc3dfe6009a + languageName: node + linkType: hard + +"parent-module@npm:^1.0.0": + version: 1.0.1 + resolution: "parent-module@npm:1.0.1" + dependencies: + callsites: "npm:^3.0.0" + checksum: 10c0/c63d6e80000d4babd11978e0d3fee386ca7752a02b035fd2435960ffaa7219dc42146f07069fb65e6e8bf1caef89daf9af7535a39bddf354d78bf50d8294f556 + languageName: node + linkType: hard + +"parse-json@npm:^5.0.0": + version: 5.2.0 + resolution: "parse-json@npm:5.2.0" + dependencies: + "@babel/code-frame": "npm:^7.0.0" + error-ex: "npm:^1.3.1" + json-parse-even-better-errors: "npm:^2.3.0" + lines-and-columns: "npm:^1.1.6" + checksum: 10c0/77947f2253005be7a12d858aedbafa09c9ae39eb4863adf330f7b416ca4f4a08132e453e08de2db46459256fb66afaac5ee758b44fe6541b7cdaf9d252e59585 + languageName: node + linkType: hard + +"path-exists@npm:^4.0.0": + version: 4.0.0 + resolution: "path-exists@npm:4.0.0" + checksum: 10c0/8c0bd3f5238188197dc78dced15207a4716c51cc4e3624c44fc97acf69558f5ebb9a2afff486fe1b4ee148e0c133e96c5e11a9aa5c48a3006e3467da070e5e1b + languageName: node + linkType: hard + +"path-key@npm:^3.1.0": + version: 3.1.1 + resolution: "path-key@npm:3.1.1" + checksum: 10c0/748c43efd5a569c039d7a00a03b58eecd1d75f3999f5a28303d75f521288df4823bc057d8784eb72358b2895a05f29a070bc9f1f17d28226cc4e62494cc58c4c + languageName: node + linkType: hard + +"path-parse@npm:^1.0.7": + version: 1.0.7 + resolution: "path-parse@npm:1.0.7" + checksum: 10c0/11ce261f9d294cc7a58d6a574b7f1b935842355ec66fba3c3fd79e0f036462eaf07d0aa95bb74ff432f9afef97ce1926c720988c6a7451d8a584930ae7de86e1 + languageName: node + linkType: hard + +"path-type@npm:^4.0.0": + version: 4.0.0 + resolution: "path-type@npm:4.0.0" + checksum: 10c0/666f6973f332f27581371efaf303fd6c272cc43c2057b37aa99e3643158c7e4b2626549555d88626e99ea9e046f82f32e41bbde5f1508547e9a11b149b52387c + languageName: node + linkType: hard + +"picocolors@npm:^1.1.1": + version: 1.1.1 + resolution: "picocolors@npm:1.1.1" + checksum: 10c0/e2e3e8170ab9d7c7421969adaa7e1b31434f789afb9b3f115f6b96d91945041ac3ceb02e9ec6fe6510ff036bcc0bf91e69a1772edc0b707e12b19c0f2d6bcf58 + languageName: node + linkType: hard + +"picomatch@npm:^2.2.2": + version: 2.3.2 + resolution: "picomatch@npm:2.3.2" + checksum: 10c0/a554d1709e59be97d1acb9eaedbbc700a5c03dbd4579807baed95100b00420bc729335440ef15004ae2378984e2487a7c1cebd743cfdb72b6fa9ab69223c0d61 + languageName: node + linkType: hard + +"picomatch@npm:^4.0.2, picomatch@npm:^4.0.3, picomatch@npm:^4.0.4": + version: 4.0.4 + resolution: "picomatch@npm:4.0.4" + checksum: 10c0/e2c6023372cc7b5764719a5ffb9da0f8e781212fa7ca4bd0562db929df8e117460f00dff3cb7509dacfc06b86de924b247f504d0ce1806a37fac4633081466b0 + languageName: node + linkType: hard + +"possible-typed-array-names@npm:^1.0.0, possible-typed-array-names@npm:^1.1.0": + version: 1.1.0 + resolution: "possible-typed-array-names@npm:1.1.0" + checksum: 10c0/c810983414142071da1d644662ce4caebce890203eb2bc7bf119f37f3fe5796226e117e6cca146b521921fa6531072674174a3325066ac66fce089a53e1e5196 + languageName: node + linkType: hard + +"postcss@npm:^8.5.6": + version: 8.5.15 + resolution: "postcss@npm:8.5.15" + dependencies: + nanoid: "npm:^3.3.12" + picocolors: "npm:^1.1.1" + source-map-js: "npm:^1.2.1" + checksum: 10c0/7f2e63ae22fbe43aace1bf652bd99da4e90737c64194d49e51ddc9cd0f9e51ff2861a7d734379b494deffa03a880a5c65eec70bc29ee9ebaa7136dde3eee8f31 + languageName: node + linkType: hard + +"preact@npm:^10.26.9": + version: 10.29.2 + resolution: "preact@npm:10.29.2" + checksum: 10c0/2ee161274e475804524608d42bba8c79920636b322293248796a9e5bf4c3332336f8c0eca1b1566ed09cdee95e408eb20b5b7613d95820ea6b6eb8fc090ef60a + languageName: node + linkType: hard + +"prelude-ls@npm:^1.2.1": + version: 1.2.1 + resolution: "prelude-ls@npm:1.2.1" + checksum: 10c0/b00d617431e7886c520a6f498a2e14c75ec58f6d93ba48c3b639cf241b54232d90daa05d83a9e9b9fef6baa63cb7e1e4602c2372fea5bc169668401eb127d0cd + languageName: node + linkType: hard + +"proc-log@npm:^7.0.0": + version: 7.0.0 + resolution: "proc-log@npm:7.0.0" + checksum: 10c0/b89c2d862604f35fec795477b0c7e376feab3ba0d4f4d291c4e959567442697cf451ac557d0623c1cc38af45a78128b983410f397a10c5d3a67f76c33de4754b + languageName: node + linkType: hard + +"prop-types@npm:^15.6.2, prop-types@npm:^15.8.1": + version: 15.8.1 + resolution: "prop-types@npm:15.8.1" + dependencies: + loose-envify: "npm:^1.4.0" + object-assign: "npm:^4.1.1" + react-is: "npm:^16.13.1" + checksum: 10c0/59ece7ca2fb9838031d73a48d4becb9a7cc1ed10e610517c7d8f19a1e02fa47f7c27d557d8a5702bec3cfeccddc853579832b43f449e54635803f277b1c78077 + languageName: node + linkType: hard + +"proxy-from-env@npm:^2.1.0": + version: 2.1.0 + resolution: "proxy-from-env@npm:2.1.0" + checksum: 10c0/ed01729fd4d094eab619cd7e17ce3698b3413b31eb102c4904f9875e677cd207392795d5b4adee9cec359dfd31c44d5ad7595a3a3ad51c40250e141512281c58 + languageName: node + linkType: hard + +"punycode@npm:^2.1.0": + version: 2.3.1 + resolution: "punycode@npm:2.3.1" + checksum: 10c0/14f76a8206bc3464f794fb2e3d3cc665ae416c01893ad7a02b23766eb07159144ee612ad67af5e84fa4479ccfe67678c4feb126b0485651b302babf66f04f9e9 + languageName: node + linkType: hard + +"react-is@npm:^16.13.1, react-is@npm:^16.7.0": + version: 16.13.1 + resolution: "react-is@npm:16.13.1" + checksum: 10c0/33977da7a5f1a287936a0c85639fec6ca74f4f15ef1e59a6bc20338fc73dc69555381e211f7a3529b8150a1f71e4225525b41b60b52965bda53ce7d47377ada1 + languageName: node + linkType: hard + +"react-is@npm:^19.2.6": + version: 19.2.7 + resolution: "react-is@npm:19.2.7" + checksum: 10c0/419fe54d5bd7fdf5414a5bb7bd9a1e0e36f9fae28ffb4cb73290fbe342bde15d8584a90d1db62547f6aa03018dce517b178a041abb522136cd4b4b51b4e94c83 + languageName: node + linkType: hard + +"react-transition-group@npm:^4.4.5": + version: 4.4.5 + resolution: "react-transition-group@npm:4.4.5" + dependencies: + "@babel/runtime": "npm:^7.5.5" + dom-helpers: "npm:^5.0.1" + loose-envify: "npm:^1.4.0" + prop-types: "npm:^15.6.2" + peerDependencies: + react: ">=16.6.0" + react-dom: ">=16.6.0" + checksum: 10c0/2ba754ba748faefa15f87c96dfa700d5525054a0141de8c75763aae6734af0740e77e11261a1e8f4ffc08fd9ab78510122e05c21c2d79066c38bb6861a886c82 + languageName: node + linkType: hard + +"reflect.getprototypeof@npm:^1.0.10, reflect.getprototypeof@npm:^1.0.9": + version: 1.0.10 + resolution: "reflect.getprototypeof@npm:1.0.10" + dependencies: + call-bind: "npm:^1.0.8" + define-properties: "npm:^1.2.1" + es-abstract: "npm:^1.23.9" + es-errors: "npm:^1.3.0" + es-object-atoms: "npm:^1.0.0" + get-intrinsic: "npm:^1.2.7" + get-proto: "npm:^1.0.1" + which-builtin-type: "npm:^1.2.1" + checksum: 10c0/7facec28c8008876f8ab98e80b7b9cb4b1e9224353fd4756dda5f2a4ab0d30fa0a5074777c6df24e1e0af463a2697513b0a11e548d99cf52f21f7bc6ba48d3ac + languageName: node + linkType: hard + +"regexp.prototype.flags@npm:^1.5.3, regexp.prototype.flags@npm:^1.5.4": + version: 1.5.4 + resolution: "regexp.prototype.flags@npm:1.5.4" + dependencies: + call-bind: "npm:^1.0.8" + define-properties: "npm:^1.2.1" + es-errors: "npm:^1.3.0" + get-proto: "npm:^1.0.1" + gopd: "npm:^1.2.0" + set-function-name: "npm:^2.0.2" + checksum: 10c0/83b88e6115b4af1c537f8dabf5c3744032cb875d63bc05c288b1b8c0ef37cbe55353f95d8ca817e8843806e3e150b118bc624e4279b24b4776b4198232735a77 + languageName: node + linkType: hard + +"reselect@npm:^5.2.0": + version: 5.2.0 + resolution: "reselect@npm:5.2.0" + checksum: 10c0/d0a8497e404b25a769fe792eacae88b9b576c30870450cd243d76ec9427d91a59c4a2cc00d824d283448b444c4c698a8f961d771c8ae39c759313afb31950e2e + languageName: node + linkType: hard + +"resolve-from@npm:^4.0.0": + version: 4.0.0 + resolution: "resolve-from@npm:4.0.0" + checksum: 10c0/8408eec31a3112ef96e3746c37be7d64020cda07c03a920f5024e77290a218ea758b26ca9529fd7b1ad283947f34b2291c1c0f6aa0ed34acfdda9c6014c8d190 + languageName: node + linkType: hard + +"resolve@npm:^1.19.0": + version: 1.22.12 + resolution: "resolve@npm:1.22.12" + dependencies: + es-errors: "npm:^1.3.0" + is-core-module: "npm:^2.16.1" + path-parse: "npm:^1.0.7" + supports-preserve-symlinks-flag: "npm:^1.0.0" + bin: + resolve: bin/resolve + checksum: 10c0/b16dc9b537c02e8c3388f7d3dcff9741d3071625f9a97ac1c885f2b0ca51e78df22328fb6d6ef214dd9101fb7cfc19aa2836fe3410402a94f3f7b8639c7149bf + languageName: node + linkType: hard + +"resolve@npm:^2.0.0-next.5": + version: 2.0.0-next.7 + resolution: "resolve@npm:2.0.0-next.7" + dependencies: + es-errors: "npm:^1.3.0" + is-core-module: "npm:^2.16.2" + node-exports-info: "npm:^1.6.0" + object-keys: "npm:^1.1.1" + path-parse: "npm:^1.0.7" + supports-preserve-symlinks-flag: "npm:^1.0.0" + bin: + resolve: bin/resolve + checksum: 10c0/8c6fa17ccdb826a3a52387ed8c42bf705dbc19d5494da52a86661b124b5b88fad5d8edbbb4434a1b563ecf7768368b7da9fb9489e20f36e02f7551a4ea87d707 + languageName: node + linkType: hard + +"resolve@patch:resolve@npm%3A^1.19.0#optional!builtin": + version: 1.22.12 + resolution: "resolve@patch:resolve@npm%3A1.22.12#optional!builtin::version=1.22.12&hash=c3c19d" + dependencies: + es-errors: "npm:^1.3.0" + is-core-module: "npm:^2.16.1" + path-parse: "npm:^1.0.7" + supports-preserve-symlinks-flag: "npm:^1.0.0" + bin: + resolve: bin/resolve + checksum: 10c0/fc6519984ae1f894d877c0060ba8b1f5ba3bc0e85a02f74e141929c118c23d74d9735619a9cc2965397387e514884245c65d72a40731dcb6cfc84c7bcdc8321e + languageName: node + linkType: hard + +"resolve@patch:resolve@npm%3A^2.0.0-next.5#optional!builtin": + version: 2.0.0-next.7 + resolution: "resolve@patch:resolve@npm%3A2.0.0-next.7#optional!builtin::version=2.0.0-next.7&hash=c3c19d" + dependencies: + es-errors: "npm:^1.3.0" + is-core-module: "npm:^2.16.2" + node-exports-info: "npm:^1.6.0" + object-keys: "npm:^1.1.1" + path-parse: "npm:^1.0.7" + supports-preserve-symlinks-flag: "npm:^1.0.0" + bin: + resolve: bin/resolve + checksum: 10c0/6bb6f1d8a1789f7a5b4e35d950e76bc0ba632ff7d51fe86b6f34fb5f41e1ce0f7b884ec166828cfc0728ddffeaee49527711d752d12398297f90c51acd22195e + languageName: node + linkType: hard + +"rollup@npm:^4.43.0": + version: 4.62.2 + resolution: "rollup@npm:4.62.2" + dependencies: + "@rollup/rollup-android-arm-eabi": "npm:4.62.2" + "@rollup/rollup-android-arm64": "npm:4.62.2" + "@rollup/rollup-darwin-arm64": "npm:4.62.2" + "@rollup/rollup-darwin-x64": "npm:4.62.2" + "@rollup/rollup-freebsd-arm64": "npm:4.62.2" + "@rollup/rollup-freebsd-x64": "npm:4.62.2" + "@rollup/rollup-linux-arm-gnueabihf": "npm:4.62.2" + "@rollup/rollup-linux-arm-musleabihf": "npm:4.62.2" + "@rollup/rollup-linux-arm64-gnu": "npm:4.62.2" + "@rollup/rollup-linux-arm64-musl": "npm:4.62.2" + "@rollup/rollup-linux-loong64-gnu": "npm:4.62.2" + "@rollup/rollup-linux-loong64-musl": "npm:4.62.2" + "@rollup/rollup-linux-ppc64-gnu": "npm:4.62.2" + "@rollup/rollup-linux-ppc64-musl": "npm:4.62.2" + "@rollup/rollup-linux-riscv64-gnu": "npm:4.62.2" + "@rollup/rollup-linux-riscv64-musl": "npm:4.62.2" + "@rollup/rollup-linux-s390x-gnu": "npm:4.62.2" + "@rollup/rollup-linux-x64-gnu": "npm:4.62.2" + "@rollup/rollup-linux-x64-musl": "npm:4.62.2" + "@rollup/rollup-openbsd-x64": "npm:4.62.2" + "@rollup/rollup-openharmony-arm64": "npm:4.62.2" + "@rollup/rollup-win32-arm64-msvc": "npm:4.62.2" + "@rollup/rollup-win32-ia32-msvc": "npm:4.62.2" + "@rollup/rollup-win32-x64-gnu": "npm:4.62.2" + "@rollup/rollup-win32-x64-msvc": "npm:4.62.2" + "@types/estree": "npm:1.0.9" + fsevents: "npm:~2.3.2" + dependenciesMeta: + "@rollup/rollup-android-arm-eabi": + optional: true + "@rollup/rollup-android-arm64": + optional: true + "@rollup/rollup-darwin-arm64": + optional: true + "@rollup/rollup-darwin-x64": + optional: true + "@rollup/rollup-freebsd-arm64": + optional: true + "@rollup/rollup-freebsd-x64": + optional: true + "@rollup/rollup-linux-arm-gnueabihf": + optional: true + "@rollup/rollup-linux-arm-musleabihf": + optional: true + "@rollup/rollup-linux-arm64-gnu": + optional: true + "@rollup/rollup-linux-arm64-musl": + optional: true + "@rollup/rollup-linux-loong64-gnu": + optional: true + "@rollup/rollup-linux-loong64-musl": + optional: true + "@rollup/rollup-linux-ppc64-gnu": + optional: true + "@rollup/rollup-linux-ppc64-musl": + optional: true + "@rollup/rollup-linux-riscv64-gnu": + optional: true + "@rollup/rollup-linux-riscv64-musl": + optional: true + "@rollup/rollup-linux-s390x-gnu": + optional: true + "@rollup/rollup-linux-x64-gnu": + optional: true + "@rollup/rollup-linux-x64-musl": + optional: true + "@rollup/rollup-openbsd-x64": + optional: true + "@rollup/rollup-openharmony-arm64": + optional: true + "@rollup/rollup-win32-arm64-msvc": + optional: true + "@rollup/rollup-win32-ia32-msvc": + optional: true + "@rollup/rollup-win32-x64-gnu": + optional: true + "@rollup/rollup-win32-x64-msvc": + optional: true + fsevents: + optional: true + bin: + rollup: dist/bin/rollup + checksum: 10c0/83ff5f4a1fea3fa05db2ef56beceee8c33d4a72b818e19c562f1e85c41076fe5b12aadc44048bb73e60b83336df82154b017fa6bf0186f3141643e6f215fbdcb + languageName: node + linkType: hard + +"root-workspace-0b6124@workspace:.": + version: 0.0.0-use.local + resolution: "root-workspace-0b6124@workspace:." + dependencies: + "@babel/core": "npm:^8.0.1" + "@base-ui/react": "npm:^1.6.0" + "@emotion/react": "npm:^11.14.0" + "@emotion/styled": "npm:^11.14.1" + "@fontsource/roboto": "npm:^5.2.10" + "@mui/icons-material": "npm:^9.1.1" + "@mui/material": "npm:^9.1.2" + "@preact/preset-vite": "npm:^2.10.2" + axios: "npm:^1.18.1" + eslint: "npm:^10.5.0" + eslint-config-preact: "npm:^2.0.0" + preact: "npm:^10.26.9" + typescript: "npm:^6.0.3" + vite: "npm:^7.0.4" + languageName: unknown + linkType: soft + +"safe-array-concat@npm:^1.1.3": + version: 1.1.4 + resolution: "safe-array-concat@npm:1.1.4" + dependencies: + call-bind: "npm:^1.0.9" + call-bound: "npm:^1.0.4" + get-intrinsic: "npm:^1.3.0" + has-symbols: "npm:^1.1.0" + isarray: "npm:^2.0.5" + checksum: 10c0/95fb4904ab1d9360a666fe5ba6d88f1c4a3a39682739e4512cff809fc6b5722a94bd95189211015bfb45859a7ffbc3340ea303ae22721c91c59e8946d310975a + languageName: node + linkType: hard + +"safe-push-apply@npm:^1.0.0": + version: 1.0.0 + resolution: "safe-push-apply@npm:1.0.0" + dependencies: + es-errors: "npm:^1.3.0" + isarray: "npm:^2.0.5" + checksum: 10c0/831f1c9aae7436429e7862c7e46f847dfe490afac20d0ee61bae06108dbf5c745a0de3568ada30ccdd3eeb0864ca8331b2eef703abd69bfea0745b21fd320750 + languageName: node + linkType: hard + +"safe-regex-test@npm:^1.1.0": + version: 1.1.0 + resolution: "safe-regex-test@npm:1.1.0" + dependencies: + call-bound: "npm:^1.0.2" + es-errors: "npm:^1.3.0" + is-regex: "npm:^1.2.1" + checksum: 10c0/f2c25281bbe5d39cddbbce7f86fca5ea9b3ce3354ea6cd7c81c31b006a5a9fff4286acc5450a3b9122c56c33eba69c56b9131ad751457b2b4a585825e6a10665 + languageName: node + linkType: hard + +"semver@npm:^6.3.1": + version: 6.3.1 + resolution: "semver@npm:6.3.1" + bin: + semver: bin/semver.js + checksum: 10c0/e3d79b609071caa78bcb6ce2ad81c7966a46a7431d9d58b8800cfa9cb6a63699b3899a0e4bcce36167a284578212d9ae6942b6929ba4aa5015c079a67751d42d + languageName: node + linkType: hard + +"semver@npm:^7.3.5, semver@npm:^7.7.3": + version: 7.8.5 + resolution: "semver@npm:7.8.5" + bin: + semver: bin/semver.js + checksum: 10c0/b1f3127a5be8125a94f37188b361c212466c292c6910adce3ec106cff5dc211ccaedc4739c11bb70fda59d6fc1f040a9bca289f4e093451521a2372e5231fe0c + languageName: node + linkType: hard + +"semver@npm:^7.6.2": + version: 7.8.4 + resolution: "semver@npm:7.8.4" + bin: + semver: bin/semver.js + checksum: 10c0/81b7c296fd7927b80f67fa516b75fa1017caac8167795320de28e76ccbc6f7f01763c30ecd10d6a0d8fd089708ab0548a5aebb94b0870e99c2a2b4600a46389b + languageName: node + linkType: hard + +"set-function-length@npm:^1.2.2": + version: 1.2.2 + resolution: "set-function-length@npm:1.2.2" + dependencies: + define-data-property: "npm:^1.1.4" + es-errors: "npm:^1.3.0" + function-bind: "npm:^1.1.2" + get-intrinsic: "npm:^1.2.4" + gopd: "npm:^1.0.1" + has-property-descriptors: "npm:^1.0.2" + checksum: 10c0/82850e62f412a258b71e123d4ed3873fa9377c216809551192bb6769329340176f109c2eeae8c22a8d386c76739855f78e8716515c818bcaef384b51110f0f3c + languageName: node + linkType: hard + +"set-function-name@npm:^2.0.2": + version: 2.0.2 + resolution: "set-function-name@npm:2.0.2" + dependencies: + define-data-property: "npm:^1.1.4" + es-errors: "npm:^1.3.0" + functions-have-names: "npm:^1.2.3" + has-property-descriptors: "npm:^1.0.2" + checksum: 10c0/fce59f90696c450a8523e754abb305e2b8c73586452619c2bad5f7bf38c7b6b4651895c9db895679c5bef9554339cf3ef1c329b66ece3eda7255785fbe299316 + languageName: node + linkType: hard + +"set-proto@npm:^1.0.0": + version: 1.0.0 + resolution: "set-proto@npm:1.0.0" + dependencies: + dunder-proto: "npm:^1.0.1" + es-errors: "npm:^1.3.0" + es-object-atoms: "npm:^1.0.0" + checksum: 10c0/ca5c3ccbba479d07c30460e367e66337cec825560b11e8ba9c5ebe13a2a0d6021ae34eddf94ff3dfe17a3104dc1f191519cb6c48378b503e5c3f36393938776a + languageName: node + linkType: hard + +"shebang-command@npm:^2.0.0": + version: 2.0.0 + resolution: "shebang-command@npm:2.0.0" + dependencies: + shebang-regex: "npm:^3.0.0" + checksum: 10c0/a41692e7d89a553ef21d324a5cceb5f686d1f3c040759c50aab69688634688c5c327f26f3ecf7001ebfd78c01f3c7c0a11a7c8bfd0a8bc9f6240d4f40b224e4e + languageName: node + linkType: hard + +"shebang-regex@npm:^3.0.0": + version: 3.0.0 + resolution: "shebang-regex@npm:3.0.0" + checksum: 10c0/1dbed0726dd0e1152a92696c76c7f06084eb32a90f0528d11acd764043aacf76994b2fb30aa1291a21bd019d6699164d048286309a278855ee7bec06cf6fb690 + languageName: node + linkType: hard + +"side-channel-list@npm:^1.0.1": + version: 1.0.1 + resolution: "side-channel-list@npm:1.0.1" + dependencies: + es-errors: "npm:^1.3.0" + object-inspect: "npm:^1.13.4" + checksum: 10c0/d346c787fd2f9f1c2fdea14f00e8250118db0e7596d85a6cb9faa75f105d31a73a8f7a341c93d7df2a2429098c3d37a77bd3be9e88c37094b8c01807bc77c7a2 + languageName: node + linkType: hard + +"side-channel-map@npm:^1.0.1": + version: 1.0.1 + resolution: "side-channel-map@npm:1.0.1" + dependencies: + call-bound: "npm:^1.0.2" + es-errors: "npm:^1.3.0" + get-intrinsic: "npm:^1.2.5" + object-inspect: "npm:^1.13.3" + checksum: 10c0/010584e6444dd8a20b85bc926d934424bd809e1a3af941cace229f7fdcb751aada0fb7164f60c2e22292b7fa3c0ff0bce237081fd4cdbc80de1dc68e95430672 + languageName: node + linkType: hard + +"side-channel-weakmap@npm:^1.0.2": + version: 1.0.2 + resolution: "side-channel-weakmap@npm:1.0.2" + dependencies: + call-bound: "npm:^1.0.2" + es-errors: "npm:^1.3.0" + get-intrinsic: "npm:^1.2.5" + object-inspect: "npm:^1.13.3" + side-channel-map: "npm:^1.0.1" + checksum: 10c0/71362709ac233e08807ccd980101c3e2d7efe849edc51455030327b059f6c4d292c237f94dc0685031dd11c07dd17a68afde235d6cf2102d949567f98ab58185 + languageName: node + linkType: hard + +"side-channel@npm:^1.1.0": + version: 1.1.1 + resolution: "side-channel@npm:1.1.1" + dependencies: + es-errors: "npm:^1.3.0" + object-inspect: "npm:^1.13.4" + side-channel-list: "npm:^1.0.1" + side-channel-map: "npm:^1.0.1" + side-channel-weakmap: "npm:^1.0.2" + checksum: 10c0/dc0ab81d67f61bda9247d053ce93f41c3fd8ad2bdcb9cf9d8d2f8540d488f26d87a5e99ebfc07eea49ec025867b2452b705442d974b1478f0395e69f6bfb3270 + languageName: node + linkType: hard + +"simple-code-frame@npm:^1.3.0": + version: 1.3.0 + resolution: "simple-code-frame@npm:1.3.0" + dependencies: + kolorist: "npm:^1.6.0" + checksum: 10c0/f74332d839689b30deddc079f52845c05e455160888c2076056dd070d0088b8e84a0f36b6d273d38a8698e738dc5f34bbe6ecdcc86146b9d4250c67374f975c5 + languageName: node + linkType: hard + +"source-map-js@npm:^1.2.1": + version: 1.2.1 + resolution: "source-map-js@npm:1.2.1" + checksum: 10c0/7bda1fc4c197e3c6ff17de1b8b2c20e60af81b63a52cb32ec5a5d67a20a7d42651e2cb34ebe93833c5a2a084377e17455854fee3e21e7925c64a51b6a52b0faf + languageName: node + linkType: hard + +"source-map@npm:^0.5.7": + version: 0.5.7 + resolution: "source-map@npm:0.5.7" + checksum: 10c0/904e767bb9c494929be013017380cbba013637da1b28e5943b566031e29df04fba57edf3f093e0914be094648b577372bd8ad247fa98cfba9c600794cd16b599 + languageName: node + linkType: hard + +"source-map@npm:^0.7.4": + version: 0.7.6 + resolution: "source-map@npm:0.7.6" + checksum: 10c0/59f6f05538539b274ba771d2e9e32f6c65451982510564438e048bc1352f019c6efcdc6dd07909b1968144941c14015c2c7d4369fb7c4d7d53ae769716dcc16c + languageName: node + linkType: hard + +"stack-trace@npm:^1.0.0-pre2": + version: 1.0.0 + resolution: "stack-trace@npm:1.0.0" + checksum: 10c0/630e0a95137eeed8051b5359e0978baf86ae6b12f9ad8d4056398afb39c3953e39d94e104c415f4116b930527946c03df572414f289d435bf5f778490593a9de + languageName: node + linkType: hard + +"stop-iteration-iterator@npm:^1.1.0": + version: 1.1.0 + resolution: "stop-iteration-iterator@npm:1.1.0" + dependencies: + es-errors: "npm:^1.3.0" + internal-slot: "npm:^1.1.0" + checksum: 10c0/de4e45706bb4c0354a4b1122a2b8cc45a639e86206807ce0baf390ee9218d3ef181923fa4d2b67443367c491aa255c5fbaa64bb74648e3c5b48299928af86c09 + languageName: node + linkType: hard + +"string.prototype.matchall@npm:^4.0.12": + version: 4.0.12 + resolution: "string.prototype.matchall@npm:4.0.12" + dependencies: + call-bind: "npm:^1.0.8" + call-bound: "npm:^1.0.3" + define-properties: "npm:^1.2.1" + es-abstract: "npm:^1.23.6" + es-errors: "npm:^1.3.0" + es-object-atoms: "npm:^1.0.0" + get-intrinsic: "npm:^1.2.6" + gopd: "npm:^1.2.0" + has-symbols: "npm:^1.1.0" + internal-slot: "npm:^1.1.0" + regexp.prototype.flags: "npm:^1.5.3" + set-function-name: "npm:^2.0.2" + side-channel: "npm:^1.1.0" + checksum: 10c0/1a53328ada73f4a77f1fdf1c79414700cf718d0a8ef6672af5603e709d26a24f2181208144aed7e858b1bcc1a0d08567a570abfb45567db4ae47637ed2c2f85c + languageName: node + linkType: hard + +"string.prototype.repeat@npm:^1.0.0": + version: 1.0.0 + resolution: "string.prototype.repeat@npm:1.0.0" + dependencies: + define-properties: "npm:^1.1.3" + es-abstract: "npm:^1.17.5" + checksum: 10c0/94c7978566cffa1327d470fd924366438af9b04b497c43a9805e476e2e908aa37a1fd34cc0911156c17556dab62159d12c7b92b3cc304c3e1281fe4c8e668f40 + languageName: node + linkType: hard + +"string.prototype.trim@npm:^1.2.10": + version: 1.2.11 + resolution: "string.prototype.trim@npm:1.2.11" + dependencies: + call-bind: "npm:^1.0.9" + call-bound: "npm:^1.0.4" + define-data-property: "npm:^1.1.4" + define-properties: "npm:^1.2.1" + es-abstract: "npm:^1.24.2" + es-object-atoms: "npm:^1.1.2" + has-property-descriptors: "npm:^1.0.2" + safe-regex-test: "npm:^1.1.0" + checksum: 10c0/b153cf8ed06db82ff40e27829e88e5c13f45eff9799f1d5707626e25989b488b059d6f5d57011e07f77745e28451e16735f295bc59c8ae146a4fd73a442366b0 + languageName: node + linkType: hard + +"string.prototype.trimend@npm:^1.0.9": + version: 1.0.10 + resolution: "string.prototype.trimend@npm:1.0.10" + dependencies: + call-bind: "npm:^1.0.9" + call-bound: "npm:^1.0.4" + define-properties: "npm:^1.2.1" + es-object-atoms: "npm:^1.1.2" + checksum: 10c0/cc09233181769047a5330becfd5740fec5f0c8137886e7b553626788b00f75df9f34db1159bc52dbb7fc389b8ebb6e1dab44c8c9e31eb600039729a542013286 + languageName: node + linkType: hard + +"string.prototype.trimstart@npm:^1.0.8": + version: 1.0.8 + resolution: "string.prototype.trimstart@npm:1.0.8" + dependencies: + call-bind: "npm:^1.0.7" + define-properties: "npm:^1.2.1" + es-object-atoms: "npm:^1.0.0" + checksum: 10c0/d53af1899959e53c83b64a5fd120be93e067da740e7e75acb433849aa640782fb6c7d4cd5b84c954c84413745a3764df135a8afeb22908b86a835290788d8366 + languageName: node + linkType: hard + +"stylis@npm:4.2.0": + version: 4.2.0 + resolution: "stylis@npm:4.2.0" + checksum: 10c0/a7128ad5a8ed72652c6eba46bed4f416521bc9745a460ef5741edc725252cebf36ee45e33a8615a7057403c93df0866ab9ee955960792db210bb80abd5ac6543 + languageName: node + linkType: hard + +"supports-preserve-symlinks-flag@npm:^1.0.0": + version: 1.0.0 + resolution: "supports-preserve-symlinks-flag@npm:1.0.0" + checksum: 10c0/6c4032340701a9950865f7ae8ef38578d8d7053f5e10518076e6554a9381fa91bd9c6850193695c141f32b21f979c985db07265a758867bac95de05f7d8aeb39 + languageName: node + linkType: hard + +"tar@npm:^7.5.4": + version: 7.5.16 + resolution: "tar@npm:7.5.16" + dependencies: + "@isaacs/fs-minipass": "npm:^4.0.0" + chownr: "npm:^3.0.0" + minipass: "npm:^7.1.2" + minizlib: "npm:^3.1.0" + yallist: "npm:^5.0.0" + checksum: 10c0/4f37f3c4bd2ca2755fd736a5df1d573c1a868ec1b1e893346aeafa95ac510f9e2fd1469420bd866cc7904799e5bd4ac62b5d4f03fe27747d6e1e373b44505c5c + languageName: node + linkType: hard + +"tinyglobby@npm:^0.2.12, tinyglobby@npm:^0.2.15": + version: 0.2.17 + resolution: "tinyglobby@npm:0.2.17" + dependencies: + fdir: "npm:^6.5.0" + picomatch: "npm:^4.0.4" + checksum: 10c0/7f7bb0f197c88bc4b20c231e0deca4240ca3bf313a88f5a7fee93a872b84966a4d50220947c0455ad07a60b3b360961c5b7fd979222aeb716a9f99b412002e4c + languageName: node + linkType: hard + +"type-check@npm:^0.4.0, type-check@npm:~0.4.0": + version: 0.4.0 + resolution: "type-check@npm:0.4.0" + dependencies: + prelude-ls: "npm:^1.2.1" + checksum: 10c0/7b3fd0ed43891e2080bf0c5c504b418fbb3e5c7b9708d3d015037ba2e6323a28152ec163bcb65212741fa5d2022e3075ac3c76440dbd344c9035f818e8ecee58 + languageName: node + linkType: hard + +"typed-array-buffer@npm:^1.0.3": + version: 1.0.3 + resolution: "typed-array-buffer@npm:1.0.3" + dependencies: + call-bound: "npm:^1.0.3" + es-errors: "npm:^1.3.0" + is-typed-array: "npm:^1.1.14" + checksum: 10c0/1105071756eb248774bc71646bfe45b682efcad93b55532c6ffa4518969fb6241354e4aa62af679ae83899ec296d69ef88f1f3763657cdb3a4d29321f7b83079 + languageName: node + linkType: hard + +"typed-array-byte-length@npm:^1.0.3": + version: 1.0.3 + resolution: "typed-array-byte-length@npm:1.0.3" + dependencies: + call-bind: "npm:^1.0.8" + for-each: "npm:^0.3.3" + gopd: "npm:^1.2.0" + has-proto: "npm:^1.2.0" + is-typed-array: "npm:^1.1.14" + checksum: 10c0/6ae083c6f0354f1fce18b90b243343b9982affd8d839c57bbd2c174a5d5dc71be9eb7019ffd12628a96a4815e7afa85d718d6f1e758615151d5f35df841ffb3e + languageName: node + linkType: hard + +"typed-array-byte-offset@npm:^1.0.4": + version: 1.0.4 + resolution: "typed-array-byte-offset@npm:1.0.4" + dependencies: + available-typed-arrays: "npm:^1.0.7" + call-bind: "npm:^1.0.8" + for-each: "npm:^0.3.3" + gopd: "npm:^1.2.0" + has-proto: "npm:^1.2.0" + is-typed-array: "npm:^1.1.15" + reflect.getprototypeof: "npm:^1.0.9" + checksum: 10c0/3d805b050c0c33b51719ee52de17c1cd8e6a571abdf0fffb110e45e8dd87a657e8b56eee94b776b13006d3d347a0c18a730b903cf05293ab6d92e99ff8f77e53 + languageName: node + linkType: hard + +"typed-array-length@npm:^1.0.7": + version: 1.0.8 + resolution: "typed-array-length@npm:1.0.8" + dependencies: + call-bind: "npm:^1.0.9" + for-each: "npm:^0.3.5" + gopd: "npm:^1.2.0" + is-typed-array: "npm:^1.1.15" + possible-typed-array-names: "npm:^1.1.0" + reflect.getprototypeof: "npm:^1.0.10" + checksum: 10c0/5319f740fc426a3217182c2f7c87656acb0903e046de5a938e30167337d26abf1bb3ad4b32833a72521a4cc58223aec80627b38b357d0a3d5fd64881427e77ab + languageName: node + linkType: hard + +"typescript@npm:^6.0.3": + version: 6.0.3 + resolution: "typescript@npm:6.0.3" + bin: + tsc: bin/tsc + tsserver: bin/tsserver + checksum: 10c0/4a25ff5045b984370f48f196b3a0120779b1b343d40b9a68d114ea5e5fff099809b2bb777576991a63a5cd59cf7bffd96ff6fe10afcefbcb8bd6fb96ad4b6606 + languageName: node + linkType: hard + +"typescript@patch:typescript@npm%3A^6.0.3#optional!builtin": + version: 6.0.3 + resolution: "typescript@patch:typescript@npm%3A6.0.3#optional!builtin::version=6.0.3&hash=5786d5" + bin: + tsc: bin/tsc + tsserver: bin/tsserver + checksum: 10c0/2f25c74e65663c248fa1ade2b8459d9ce5372ff9dad07067310f132966ebec1d93f6c42f0baf77a6b6a7a91460463f708e6887013aaade22111037457c6b25df + languageName: node + linkType: hard + +"unbox-primitive@npm:^1.1.0": + version: 1.1.0 + resolution: "unbox-primitive@npm:1.1.0" + dependencies: + call-bound: "npm:^1.0.3" + has-bigints: "npm:^1.0.2" + has-symbols: "npm:^1.1.0" + which-boxed-primitive: "npm:^1.1.1" + checksum: 10c0/7dbd35ab02b0e05fe07136c72cb9355091242455473ec15057c11430129bab38b7b3624019b8778d02a881c13de44d63cd02d122ee782fb519e1de7775b5b982 + languageName: node + linkType: hard + +"undici@npm:^6.25.0": + version: 6.27.0 + resolution: "undici@npm:6.27.0" + checksum: 10c0/f88c3dae3957dbf9d93cb481440aced317bd3c4941b5914fea5efba516d51138988cdb5c76006f0bb1337e41d56c3443351055d492e73af2428521c37ba2a76f + languageName: node + linkType: hard + +"update-browserslist-db@npm:^1.2.3": + version: 1.2.3 + resolution: "update-browserslist-db@npm:1.2.3" + dependencies: + escalade: "npm:^3.2.0" + picocolors: "npm:^1.1.1" + peerDependencies: + browserslist: ">= 4.21.0" + bin: + update-browserslist-db: cli.js + checksum: 10c0/13a00355ea822388f68af57410ce3255941d5fb9b7c49342c4709a07c9f230bbef7f7499ae0ca7e0de532e79a82cc0c4edbd125f1a323a1845bf914efddf8bec + languageName: node + linkType: hard + +"uri-js@npm:^4.2.2": + version: 4.4.1 + resolution: "uri-js@npm:4.4.1" + dependencies: + punycode: "npm:^2.1.0" + checksum: 10c0/4ef57b45aa820d7ac6496e9208559986c665e49447cb072744c13b66925a362d96dd5a46c4530a6b8e203e5db5fe849369444440cb22ecfc26c679359e5dfa3c + languageName: node + linkType: hard + +"use-sync-external-store@npm:^1.6.0": + version: 1.6.0 + resolution: "use-sync-external-store@npm:1.6.0" + peerDependencies: + react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 + checksum: 10c0/35e1179f872a53227bdf8a827f7911da4c37c0f4091c29b76b1e32473d1670ebe7bcd880b808b7549ba9a5605c233350f800ffab963ee4a4ee346ee983b6019b + languageName: node + linkType: hard + +"vite-prerender-plugin@npm:^0.5.8": + version: 0.5.13 + resolution: "vite-prerender-plugin@npm:0.5.13" + dependencies: + kolorist: "npm:^1.8.0" + magic-string: "npm:0.x >= 0.26.0" + node-html-parser: "npm:^6.1.12" + simple-code-frame: "npm:^1.3.0" + source-map: "npm:^0.7.4" + stack-trace: "npm:^1.0.0-pre2" + peerDependencies: + vite: 5.x || 6.x || 7.x || 8.x + checksum: 10c0/474feed1faac452f62c501330f0109e9c2a9ddac84bd27acc4ecb8ff92f1f0670abc1949ed8eff45957108ce65b94cd24f3b1ceae45cf3ffa75e11e0591f4bc4 + languageName: node + linkType: hard + +"vite@npm:^7.0.4": + version: 7.3.5 + resolution: "vite@npm:7.3.5" + dependencies: + esbuild: "npm:^0.27.0" + fdir: "npm:^6.5.0" + fsevents: "npm:~2.3.3" + picomatch: "npm:^4.0.3" + postcss: "npm:^8.5.6" + rollup: "npm:^4.43.0" + tinyglobby: "npm:^0.2.15" + peerDependencies: + "@types/node": ^20.19.0 || >=22.12.0 + jiti: ">=1.21.0" + less: ^4.0.0 + lightningcss: ^1.21.0 + sass: ^1.70.0 + sass-embedded: ^1.70.0 + stylus: ">=0.54.8" + sugarss: ^5.0.0 + terser: ^5.16.0 + tsx: ^4.8.1 + yaml: ^2.4.2 + dependenciesMeta: + fsevents: + optional: true + 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 + bin: + vite: bin/vite.js + checksum: 10c0/4ad700649ed2ebd1e726d32f3f6e41eecbec4e29bcb5977805f3d43a5659280518aa431b0fc61adc1879df4fe1978d7cfc7dbbe54cdf014022385052967721e8 + languageName: node + linkType: hard + +"which-boxed-primitive@npm:^1.1.0, which-boxed-primitive@npm:^1.1.1": + version: 1.1.1 + resolution: "which-boxed-primitive@npm:1.1.1" + dependencies: + is-bigint: "npm:^1.1.0" + is-boolean-object: "npm:^1.2.1" + is-number-object: "npm:^1.1.1" + is-string: "npm:^1.1.1" + is-symbol: "npm:^1.1.1" + checksum: 10c0/aceea8ede3b08dede7dce168f3883323f7c62272b49801716e8332ff750e7ae59a511ae088840bc6874f16c1b7fd296c05c949b0e5b357bfe3c431b98c417abe + languageName: node + linkType: hard + +"which-builtin-type@npm:^1.2.1": + version: 1.2.1 + resolution: "which-builtin-type@npm:1.2.1" + dependencies: + call-bound: "npm:^1.0.2" + function.prototype.name: "npm:^1.1.6" + has-tostringtag: "npm:^1.0.2" + is-async-function: "npm:^2.0.0" + is-date-object: "npm:^1.1.0" + is-finalizationregistry: "npm:^1.1.0" + is-generator-function: "npm:^1.0.10" + is-regex: "npm:^1.2.1" + is-weakref: "npm:^1.0.2" + isarray: "npm:^2.0.5" + which-boxed-primitive: "npm:^1.1.0" + which-collection: "npm:^1.0.2" + which-typed-array: "npm:^1.1.16" + checksum: 10c0/8dcf323c45e5c27887800df42fbe0431d0b66b1163849bb7d46b5a730ad6a96ee8bfe827d078303f825537844ebf20c02459de41239a0a9805e2fcb3cae0d471 + languageName: node + linkType: hard + +"which-collection@npm:^1.0.2": + version: 1.0.2 + resolution: "which-collection@npm:1.0.2" + dependencies: + is-map: "npm:^2.0.3" + is-set: "npm:^2.0.3" + is-weakmap: "npm:^2.0.2" + is-weakset: "npm:^2.0.3" + checksum: 10c0/3345fde20964525a04cdf7c4a96821f85f0cc198f1b2ecb4576e08096746d129eb133571998fe121c77782ac8f21cbd67745a3d35ce100d26d4e684c142ea1f2 + languageName: node + linkType: hard + +"which-typed-array@npm:^1.1.16, which-typed-array@npm:^1.1.19": + version: 1.1.22 + resolution: "which-typed-array@npm:1.1.22" + dependencies: + available-typed-arrays: "npm:^1.0.7" + call-bind: "npm:^1.0.9" + call-bound: "npm:^1.0.4" + for-each: "npm:^0.3.5" + get-proto: "npm:^1.0.1" + gopd: "npm:^1.2.0" + has-tostringtag: "npm:^1.0.2" + checksum: 10c0/e59db184a4e78b461fac3b05fafc1e7badbbedafbf04a967ee1de73717f1f9723a79699e7b5de71d449541cb5da8353efc01a4f8a72a152479850e54fa196c40 + languageName: node + linkType: hard + +"which@npm:^2.0.1": + version: 2.0.2 + resolution: "which@npm:2.0.2" + dependencies: + isexe: "npm:^2.0.0" + bin: + node-which: ./bin/node-which + checksum: 10c0/66522872a768b60c2a65a57e8ad184e5372f5b6a9ca6d5f033d4b0dc98aff63995655a7503b9c0a2598936f532120e81dd8cc155e2e92ed662a2b9377cc4374f + languageName: node + linkType: hard + +"which@npm:^7.0.0": + version: 7.0.0 + resolution: "which@npm:7.0.0" + dependencies: + isexe: "npm:^4.0.0" + bin: + node-which: bin/which.js + checksum: 10c0/ca0b54f198f78bbc4b7c02e34bda8d335cb352e0adb4cbca1c37b1a957af3a879a82c4c27ca6525bc942f548d8b64f816ef6528360af9f3de55ffb9b979b620d + languageName: node + linkType: hard + +"word-wrap@npm:^1.2.5": + version: 1.2.5 + resolution: "word-wrap@npm:1.2.5" + checksum: 10c0/e0e4a1ca27599c92a6ca4c32260e8a92e8a44f4ef6ef93f803f8ed823f486e0889fc0b93be4db59c8d51b3064951d25e43d434e95dc8c960cc3a63d65d00ba20 + languageName: node + linkType: hard + +"yallist@npm:^3.0.2": + version: 3.1.1 + resolution: "yallist@npm:3.1.1" + checksum: 10c0/c66a5c46bc89af1625476f7f0f2ec3653c1a1791d2f9407cfb4c2ba812a1e1c9941416d71ba9719876530e3340a99925f697142989371b72d93b9ee628afd8c1 + languageName: node + linkType: hard + +"yallist@npm:^5.0.0": + version: 5.0.0 + resolution: "yallist@npm:5.0.0" + checksum: 10c0/a499c81ce6d4a1d260d4ea0f6d49ab4da09681e32c3f0472dee16667ed69d01dae63a3b81745a24bd78476ec4fcf856114cb4896ace738e01da34b2c42235416 + languageName: node + linkType: hard + +"yaml@npm:^1.10.0": + version: 1.10.3 + resolution: "yaml@npm:1.10.3" + checksum: 10c0/c309ff85a0a569a981d71ab9cf0fef68672a16b9cdf40639d1c3b30034f6cd16ee428602bd6d64ecf006f8c8bee499023cac236538f79898aa99fb5db529a2ed + languageName: node + linkType: hard + +"yocto-queue@npm:^0.1.0": + version: 0.1.0 + resolution: "yocto-queue@npm:0.1.0" + checksum: 10c0/dceb44c28578b31641e13695d200d34ec4ab3966a5729814d5445b194933c096b7ced71494ce53a0e8820685d1d010df8b2422e5bf2cdea7e469d97ffbea306f + languageName: node + linkType: hard + +"zimmerframe@npm:^1.1.4": + version: 1.1.4 + resolution: "zimmerframe@npm:1.1.4" + checksum: 10c0/9470cbf22cefae975ab413c7158a119d082b354ddcf0da48a842f2f42246fa15943cd9b92c047de39db38015e3b866e32f383bc217e8e4f4192945c7d425536b + languageName: node + linkType: hard