From 0e52d24c9ff5f35208fdecf32fde75aa627c26da Mon Sep 17 00:00:00 2001 From: Matt Huntington Date: Mon, 12 Oct 2020 17:28:00 -0400 Subject: [PATCH] adding init code --- ClientApp/.gitignore | 21 + ClientApp/README.md | 2228 +++ ClientApp/package-lock.json | 15312 ++++++++++++++++ ClientApp/package.json | 52 + ClientApp/public/favicon.ico | Bin 0 -> 32038 bytes ClientApp/public/index.html | 41 + ClientApp/public/manifest.json | 15 + ClientApp/src/App.js | 22 + ClientApp/src/App.test.js | 13 + ClientApp/src/components/Counter.js | 31 + ClientApp/src/components/FetchData.js | 59 + ClientApp/src/components/Home.js | 26 + ClientApp/src/components/Layout.js | 18 + ClientApp/src/components/NavMenu.css | 18 + ClientApp/src/components/NavMenu.js | 49 + ClientApp/src/custom.css | 14 + ClientApp/src/index.js | 18 + ClientApp/src/registerServiceWorker.js | 108 + Controllers/WeatherForecastController.cs | 39 + Pages/Error.cshtml | 26 + Pages/Error.cshtml.cs | 31 + Pages/_ViewImports.cshtml | 3 + Program.cs | 26 + Properties/launchSettings.json | 27 + Startup.cs | 71 + WeatherForecast.cs | 15 + appsettings.Development.json | 9 + appsettings.json | 10 + .../Microsoft.AspNetCore.NodeServices.dll | Bin 0 -> 62328 bytes ...soft.AspNetCore.SpaServices.Extensions.dll | Bin 0 -> 65912 bytes .../Microsoft.AspNetCore.SpaServices.dll | Bin 0 -> 53112 bytes ....Extensions.Configuration.Abstractions.dll | Bin 0 -> 21368 bytes ...rosoft.Extensions.Configuration.Binder.dll | Bin 0 -> 25464 bytes .../Microsoft.Extensions.Configuration.dll | Bin 0 -> 27512 bytes ...sions.DependencyInjection.Abstractions.dll | Bin 0 -> 37752 bytes ...crosoft.Extensions.DependencyInjection.dll | Bin 0 -> 72568 bytes ....Extensions.FileProviders.Abstractions.dll | Bin 0 -> 17784 bytes ...soft.Extensions.FileProviders.Physical.dll | Bin 0 -> 35704 bytes ...icrosoft.Extensions.FileSystemGlobbing.dll | Bin 0 -> 39288 bytes ...rosoft.Extensions.Logging.Abstractions.dll | Bin 0 -> 48504 bytes ...osoft.Extensions.Logging.Configuration.dll | Bin 0 -> 20344 bytes .../Microsoft.Extensions.Logging.Console.dll | Bin 0 -> 28024 bytes .../Microsoft.Extensions.Logging.dll | Bin 0 -> 34168 bytes ...nsions.Options.ConfigurationExtensions.dll | Bin 0 -> 18296 bytes .../Microsoft.Extensions.Options.dll | Bin 0 -> 50552 bytes .../Microsoft.Extensions.Primitives.dll | Bin 0 -> 38776 bytes bin/Debug/netcoreapp3.1/Newtonsoft.Json.dll | Bin 0 -> 669608 bytes .../Properties/launchSettings.json | 27 + .../appsettings.Development.json | 9 + bin/Debug/netcoreapp3.1/appsettings.json | 10 + bin/Debug/netcoreapp3.1/contacts.Views.dll | Bin 0 -> 10240 bytes bin/Debug/netcoreapp3.1/contacts.Views.pdb | Bin 0 -> 19264 bytes bin/Debug/netcoreapp3.1/contacts.deps.json | 3646 ++++ bin/Debug/netcoreapp3.1/contacts.dll | Bin 0 -> 11776 bytes bin/Debug/netcoreapp3.1/contacts.pdb | Bin 0 -> 20836 bytes .../contacts.runtimeconfig.dev.json | 8 + .../netcoreapp3.1/contacts.runtimeconfig.json | 12 + contacts.csproj | 49 + ...CoreApp,Version=v3.1.AssemblyAttributes.cs | 4 + .../Razor/Pages/Error.cshtml.g.cs | 90 + .../Razor/Pages/_ViewImports.cshtml.g.cs | 42 + .../netcoreapp3.1/contacts.AssemblyInfo.cs | 22 + .../contacts.AssemblyInfoInputs.cache | 1 + ...acts.MvcApplicationPartsAssemblyInfo.cache | 0 ...ontacts.MvcApplicationPartsAssemblyInfo.cs | 17 + .../contacts.RazorAssemblyInfo.cache | 1 + .../contacts.RazorAssemblyInfo.cs | 16 + .../contacts.RazorCoreGenerate.cache | 1 + .../contacts.RazorTargetAssemblyInfo.cache | 1 + .../contacts.RazorTargetAssemblyInfo.cs | 24 + .../contacts.TagHelpers.input.cache | 0 .../contacts.TagHelpers.output.cache | 1 + obj/Debug/netcoreapp3.1/contacts.Views.dll | Bin 0 -> 10240 bytes obj/Debug/netcoreapp3.1/contacts.Views.pdb | Bin 0 -> 19264 bytes obj/Debug/netcoreapp3.1/contacts.assets.cache | Bin 0 -> 11521 bytes .../contacts.csproj.CopyComplete | 0 .../contacts.csproj.CoreCompileInputs.cache | 1 + .../contacts.csproj.FileListAbsolute.txt | 102 + .../contacts.csprojAssemblyReference.cache | Bin 0 -> 164929 bytes obj/Debug/netcoreapp3.1/contacts.dll | Bin 0 -> 11776 bytes .../contacts.genruntimeconfig.cache | 1 + obj/Debug/netcoreapp3.1/contacts.pdb | Bin 0 -> 20836 bytes .../contacts.StaticWebAssets.Manifest.cache | 0 .../contacts.StaticWebAssets.xml | 1 + obj/contacts.csproj.nuget.dgspec.json | 67 + obj/contacts.csproj.nuget.g.props | 18 + obj/contacts.csproj.nuget.g.targets | 6 + obj/project.assets.json | 621 + obj/project.nuget.cache | 28 + 89 files changed, 23128 insertions(+) create mode 100644 ClientApp/.gitignore create mode 100644 ClientApp/README.md create mode 100644 ClientApp/package-lock.json create mode 100644 ClientApp/package.json create mode 100644 ClientApp/public/favicon.ico create mode 100644 ClientApp/public/index.html create mode 100644 ClientApp/public/manifest.json create mode 100644 ClientApp/src/App.js create mode 100644 ClientApp/src/App.test.js create mode 100644 ClientApp/src/components/Counter.js create mode 100644 ClientApp/src/components/FetchData.js create mode 100644 ClientApp/src/components/Home.js create mode 100644 ClientApp/src/components/Layout.js create mode 100644 ClientApp/src/components/NavMenu.css create mode 100644 ClientApp/src/components/NavMenu.js create mode 100644 ClientApp/src/custom.css create mode 100644 ClientApp/src/index.js create mode 100644 ClientApp/src/registerServiceWorker.js create mode 100644 Controllers/WeatherForecastController.cs create mode 100644 Pages/Error.cshtml create mode 100644 Pages/Error.cshtml.cs create mode 100644 Pages/_ViewImports.cshtml create mode 100644 Program.cs create mode 100644 Properties/launchSettings.json create mode 100644 Startup.cs create mode 100644 WeatherForecast.cs create mode 100644 appsettings.Development.json create mode 100644 appsettings.json create mode 100755 bin/Debug/netcoreapp3.1/Microsoft.AspNetCore.NodeServices.dll create mode 100755 bin/Debug/netcoreapp3.1/Microsoft.AspNetCore.SpaServices.Extensions.dll create mode 100755 bin/Debug/netcoreapp3.1/Microsoft.AspNetCore.SpaServices.dll create mode 100755 bin/Debug/netcoreapp3.1/Microsoft.Extensions.Configuration.Abstractions.dll create mode 100755 bin/Debug/netcoreapp3.1/Microsoft.Extensions.Configuration.Binder.dll create mode 100755 bin/Debug/netcoreapp3.1/Microsoft.Extensions.Configuration.dll create mode 100755 bin/Debug/netcoreapp3.1/Microsoft.Extensions.DependencyInjection.Abstractions.dll create mode 100755 bin/Debug/netcoreapp3.1/Microsoft.Extensions.DependencyInjection.dll create mode 100755 bin/Debug/netcoreapp3.1/Microsoft.Extensions.FileProviders.Abstractions.dll create mode 100755 bin/Debug/netcoreapp3.1/Microsoft.Extensions.FileProviders.Physical.dll create mode 100755 bin/Debug/netcoreapp3.1/Microsoft.Extensions.FileSystemGlobbing.dll create mode 100755 bin/Debug/netcoreapp3.1/Microsoft.Extensions.Logging.Abstractions.dll create mode 100755 bin/Debug/netcoreapp3.1/Microsoft.Extensions.Logging.Configuration.dll create mode 100755 bin/Debug/netcoreapp3.1/Microsoft.Extensions.Logging.Console.dll create mode 100755 bin/Debug/netcoreapp3.1/Microsoft.Extensions.Logging.dll create mode 100755 bin/Debug/netcoreapp3.1/Microsoft.Extensions.Options.ConfigurationExtensions.dll create mode 100755 bin/Debug/netcoreapp3.1/Microsoft.Extensions.Options.dll create mode 100755 bin/Debug/netcoreapp3.1/Microsoft.Extensions.Primitives.dll create mode 100755 bin/Debug/netcoreapp3.1/Newtonsoft.Json.dll create mode 100644 bin/Debug/netcoreapp3.1/Properties/launchSettings.json create mode 100644 bin/Debug/netcoreapp3.1/appsettings.Development.json create mode 100644 bin/Debug/netcoreapp3.1/appsettings.json create mode 100644 bin/Debug/netcoreapp3.1/contacts.Views.dll create mode 100644 bin/Debug/netcoreapp3.1/contacts.Views.pdb create mode 100644 bin/Debug/netcoreapp3.1/contacts.deps.json create mode 100644 bin/Debug/netcoreapp3.1/contacts.dll create mode 100644 bin/Debug/netcoreapp3.1/contacts.pdb create mode 100644 bin/Debug/netcoreapp3.1/contacts.runtimeconfig.dev.json create mode 100644 bin/Debug/netcoreapp3.1/contacts.runtimeconfig.json create mode 100644 contacts.csproj create mode 100644 obj/Debug/netcoreapp3.1/.NETCoreApp,Version=v3.1.AssemblyAttributes.cs create mode 100644 obj/Debug/netcoreapp3.1/Razor/Pages/Error.cshtml.g.cs create mode 100644 obj/Debug/netcoreapp3.1/Razor/Pages/_ViewImports.cshtml.g.cs create mode 100644 obj/Debug/netcoreapp3.1/contacts.AssemblyInfo.cs create mode 100644 obj/Debug/netcoreapp3.1/contacts.AssemblyInfoInputs.cache create mode 100644 obj/Debug/netcoreapp3.1/contacts.MvcApplicationPartsAssemblyInfo.cache create mode 100644 obj/Debug/netcoreapp3.1/contacts.MvcApplicationPartsAssemblyInfo.cs create mode 100644 obj/Debug/netcoreapp3.1/contacts.RazorAssemblyInfo.cache create mode 100644 obj/Debug/netcoreapp3.1/contacts.RazorAssemblyInfo.cs create mode 100644 obj/Debug/netcoreapp3.1/contacts.RazorCoreGenerate.cache create mode 100644 obj/Debug/netcoreapp3.1/contacts.RazorTargetAssemblyInfo.cache create mode 100644 obj/Debug/netcoreapp3.1/contacts.RazorTargetAssemblyInfo.cs create mode 100644 obj/Debug/netcoreapp3.1/contacts.TagHelpers.input.cache create mode 100644 obj/Debug/netcoreapp3.1/contacts.TagHelpers.output.cache create mode 100644 obj/Debug/netcoreapp3.1/contacts.Views.dll create mode 100644 obj/Debug/netcoreapp3.1/contacts.Views.pdb create mode 100644 obj/Debug/netcoreapp3.1/contacts.assets.cache create mode 100644 obj/Debug/netcoreapp3.1/contacts.csproj.CopyComplete create mode 100644 obj/Debug/netcoreapp3.1/contacts.csproj.CoreCompileInputs.cache create mode 100644 obj/Debug/netcoreapp3.1/contacts.csproj.FileListAbsolute.txt create mode 100644 obj/Debug/netcoreapp3.1/contacts.csprojAssemblyReference.cache create mode 100644 obj/Debug/netcoreapp3.1/contacts.dll create mode 100644 obj/Debug/netcoreapp3.1/contacts.genruntimeconfig.cache create mode 100644 obj/Debug/netcoreapp3.1/contacts.pdb create mode 100644 obj/Debug/netcoreapp3.1/staticwebassets/contacts.StaticWebAssets.Manifest.cache create mode 100644 obj/Debug/netcoreapp3.1/staticwebassets/contacts.StaticWebAssets.xml create mode 100644 obj/contacts.csproj.nuget.dgspec.json create mode 100644 obj/contacts.csproj.nuget.g.props create mode 100644 obj/contacts.csproj.nuget.g.targets create mode 100644 obj/project.assets.json create mode 100644 obj/project.nuget.cache diff --git a/ClientApp/.gitignore b/ClientApp/.gitignore new file mode 100644 index 0000000..b9f2127 --- /dev/null +++ b/ClientApp/.gitignore @@ -0,0 +1,21 @@ +# See https://help.github.com/ignore-files/ for more about ignoring files. + +# dependencies +/node_modules + +# testing +/coverage + +# production +/build + +# misc +.DS_Store +.env.local +.env.development.local +.env.test.local +.env.production.local + +npm-debug.log* +yarn-debug.log* +yarn-error.log* diff --git a/ClientApp/README.md b/ClientApp/README.md new file mode 100644 index 0000000..c05a58b --- /dev/null +++ b/ClientApp/README.md @@ -0,0 +1,2228 @@ +This project was bootstrapped with [Create React App](https://github.com/facebookincubator/create-react-app). + +Below you will find some information on how to perform common tasks.
+You can find the most recent version of this guide [here](https://github.com/facebookincubator/create-react-app/blob/master/packages/react-scripts/template/README.md). + +## Table of Contents + +- [Updating to New Releases](#updating-to-new-releases) +- [Sending Feedback](#sending-feedback) +- [Folder Structure](#folder-structure) +- [Available Scripts](#available-scripts) + - [npm start](#npm-start) + - [npm test](#npm-test) + - [npm run build](#npm-run-build) + - [npm run eject](#npm-run-eject) +- [Supported Language Features and Polyfills](#supported-language-features-and-polyfills) +- [Syntax Highlighting in the Editor](#syntax-highlighting-in-the-editor) +- [Displaying Lint Output in the Editor](#displaying-lint-output-in-the-editor) +- [Debugging in the Editor](#debugging-in-the-editor) +- [Formatting Code Automatically](#formatting-code-automatically) +- [Changing the Page ``](#changing-the-page-title) +- [Installing a Dependency](#installing-a-dependency) +- [Importing a Component](#importing-a-component) +- [Code Splitting](#code-splitting) +- [Adding a Stylesheet](#adding-a-stylesheet) +- [Post-Processing CSS](#post-processing-css) +- [Adding a CSS Preprocessor (Sass, Less etc.)](#adding-a-css-preprocessor-sass-less-etc) +- [Adding Images, Fonts, and Files](#adding-images-fonts-and-files) +- [Using the `public` Folder](#using-the-public-folder) + - [Changing the HTML](#changing-the-html) + - [Adding Assets Outside of the Module System](#adding-assets-outside-of-the-module-system) + - [When to Use the `public` Folder](#when-to-use-the-public-folder) +- [Using Global Variables](#using-global-variables) +- [Adding Bootstrap](#adding-bootstrap) + - [Using a Custom Theme](#using-a-custom-theme) +- [Adding Flow](#adding-flow) +- [Adding Custom Environment Variables](#adding-custom-environment-variables) + - [Referencing Environment Variables in the HTML](#referencing-environment-variables-in-the-html) + - [Adding Temporary Environment Variables In Your Shell](#adding-temporary-environment-variables-in-your-shell) + - [Adding Development Environment Variables In `.env`](#adding-development-environment-variables-in-env) +- [Can I Use Decorators?](#can-i-use-decorators) +- [Integrating with an API Backend](#integrating-with-an-api-backend) + - [Node](#node) + - [Ruby on Rails](#ruby-on-rails) +- [Proxying API Requests in Development](#proxying-api-requests-in-development) + - ["Invalid Host Header" Errors After Configuring Proxy](#invalid-host-header-errors-after-configuring-proxy) + - [Configuring the Proxy Manually](#configuring-the-proxy-manually) + - [Configuring a WebSocket Proxy](#configuring-a-websocket-proxy) +- [Using HTTPS in Development](#using-https-in-development) +- [Generating Dynamic `<meta>` Tags on the Server](#generating-dynamic-meta-tags-on-the-server) +- [Pre-Rendering into Static HTML Files](#pre-rendering-into-static-html-files) +- [Injecting Data from the Server into the Page](#injecting-data-from-the-server-into-the-page) +- [Running Tests](#running-tests) + - [Filename Conventions](#filename-conventions) + - [Command Line Interface](#command-line-interface) + - [Version Control Integration](#version-control-integration) + - [Writing Tests](#writing-tests) + - [Testing Components](#testing-components) + - [Using Third Party Assertion Libraries](#using-third-party-assertion-libraries) + - [Initializing Test Environment](#initializing-test-environment) + - [Focusing and Excluding Tests](#focusing-and-excluding-tests) + - [Coverage Reporting](#coverage-reporting) + - [Continuous Integration](#continuous-integration) + - [Disabling jsdom](#disabling-jsdom) + - [Snapshot Testing](#snapshot-testing) + - [Editor Integration](#editor-integration) +- [Developing Components in Isolation](#developing-components-in-isolation) + - [Getting Started with Storybook](#getting-started-with-storybook) + - [Getting Started with Styleguidist](#getting-started-with-styleguidist) +- [Making a Progressive Web App](#making-a-progressive-web-app) + - [Opting Out of Caching](#opting-out-of-caching) + - [Offline-First Considerations](#offline-first-considerations) + - [Progressive Web App Metadata](#progressive-web-app-metadata) +- [Analyzing the Bundle Size](#analyzing-the-bundle-size) +- [Deployment](#deployment) + - [Static Server](#static-server) + - [Other Solutions](#other-solutions) + - [Serving Apps with Client-Side Routing](#serving-apps-with-client-side-routing) + - [Building for Relative Paths](#building-for-relative-paths) + - [Azure](#azure) + - [Firebase](#firebase) + - [GitHub Pages](#github-pages) + - [Heroku](#heroku) + - [Netlify](#netlify) + - [Now](#now) + - [S3 and CloudFront](#s3-and-cloudfront) + - [Surge](#surge) +- [Advanced Configuration](#advanced-configuration) +- [Troubleshooting](#troubleshooting) + - [`npm start` doesn’t detect changes](#npm-start-doesnt-detect-changes) + - [`npm test` hangs on macOS Sierra](#npm-test-hangs-on-macos-sierra) + - [`npm run build` exits too early](#npm-run-build-exits-too-early) + - [`npm run build` fails on Heroku](#npm-run-build-fails-on-heroku) + - [`npm run build` fails to minify](#npm-run-build-fails-to-minify) + - [Moment.js locales are missing](#momentjs-locales-are-missing) +- [Something Missing?](#something-missing) + +## Updating to New Releases + +Create React App is divided into two packages: + +* `create-react-app` is a global command-line utility that you use to create new projects. +* `react-scripts` is a development dependency in the generated projects (including this one). + +You almost never need to update `create-react-app` itself: it delegates all the setup to `react-scripts`. + +When you run `create-react-app`, it always creates the project with the latest version of `react-scripts` so you’ll get all the new features and improvements in newly created apps automatically. + +To update an existing project to a new version of `react-scripts`, [open the changelog](https://github.com/facebookincubator/create-react-app/blob/master/CHANGELOG.md), find the version you’re currently on (check `package.json` in this folder if you’re not sure), and apply the migration instructions for the newer versions. + +In most cases bumping the `react-scripts` version in `package.json` and running `npm install` in this folder should be enough, but it’s good to consult the [changelog](https://github.com/facebookincubator/create-react-app/blob/master/CHANGELOG.md) for potential breaking changes. + +We commit to keeping the breaking changes minimal so you can upgrade `react-scripts` painlessly. + +## Sending Feedback + +We are always open to [your feedback](https://github.com/facebookincubator/create-react-app/issues). + +## Folder Structure + +After creation, your project should look like this: + +``` +my-app/ + README.md + node_modules/ + package.json + public/ + index.html + favicon.ico + src/ + App.css + App.js + App.test.js + index.css + index.js + logo.svg +``` + +For the project to build, **these files must exist with exact filenames**: + +* `public/index.html` is the page template; +* `src/index.js` is the JavaScript entry point. + +You can delete or rename the other files. + +You may create subdirectories inside `src`. For faster rebuilds, only files inside `src` are processed by Webpack.<br> +You need to **put any JS and CSS files inside `src`**, otherwise Webpack won’t see them. + +Only files inside `public` can be used from `public/index.html`.<br> +Read instructions below for using assets from JavaScript and HTML. + +You can, however, create more top-level directories.<br> +They will not be included in the production build so you can use them for things like documentation. + +## Available Scripts + +In the project directory, you can run: + +### `npm start` + +Runs the app in the development mode.<br> +Open [http://localhost:3000](http://localhost:3000) to view it in the browser. + +The page will reload if you make edits.<br> +You will also see any lint errors in the console. + +### `npm test` + +Launches the test runner in the interactive watch mode.<br> +See the section about [running tests](#running-tests) for more information. + +### `npm run build` + +Builds the app for production to the `build` folder.<br> +It correctly bundles React in production mode and optimizes the build for the best performance. + +The build is minified and the filenames include the hashes.<br> +Your app is ready to be deployed! + +See the section about [deployment](#deployment) for more information. + +### `npm run eject` + +**Note: this is a one-way operation. Once you `eject`, you can’t go back!** + +If you aren’t satisfied with the build tool and configuration choices, you can `eject` at any time. This command will remove the single build dependency from your project. + +Instead, it will copy all the configuration files and the transitive dependencies (Webpack, Babel, ESLint, etc) right into your project so you have full control over them. All of the commands except `eject` will still work, but they will point to the copied scripts so you can tweak them. At this point you’re on your own. + +You don’t have to ever use `eject`. The curated feature set is suitable for small and middle deployments, and you shouldn’t feel obligated to use this feature. However we understand that this tool wouldn’t be useful if you couldn’t customize it when you are ready for it. + +## Supported Language Features and Polyfills + +This project supports a superset of the latest JavaScript standard.<br> +In addition to [ES6](https://github.com/lukehoban/es6features) syntax features, it also supports: + +* [Exponentiation Operator](https://github.com/rwaldron/exponentiation-operator) (ES2016). +* [Async/await](https://github.com/tc39/ecmascript-asyncawait) (ES2017). +* [Object Rest/Spread Properties](https://github.com/sebmarkbage/ecmascript-rest-spread) (stage 3 proposal). +* [Dynamic import()](https://github.com/tc39/proposal-dynamic-import) (stage 3 proposal) +* [Class Fields and Static Properties](https://github.com/tc39/proposal-class-public-fields) (part of stage 3 proposal). +* [JSX](https://facebook.github.io/react/docs/introducing-jsx.html) and [Flow](https://flowtype.org/) syntax. + +Learn more about [different proposal stages](https://babeljs.io/docs/plugins/#presets-stage-x-experimental-presets-). + +While we recommend using experimental proposals with some caution, Facebook heavily uses these features in the product code, so we intend to provide [codemods](https://medium.com/@cpojer/effective-javascript-codemods-5a6686bb46fb) if any of these proposals change in the future. + +Note that **the project only includes a few ES6 [polyfills](https://en.wikipedia.org/wiki/Polyfill)**: + +* [`Object.assign()`](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/assign) via [`object-assign`](https://github.com/sindresorhus/object-assign). +* [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) via [`promise`](https://github.com/then/promise). +* [`fetch()`](https://developer.mozilla.org/en/docs/Web/API/Fetch_API) via [`whatwg-fetch`](https://github.com/github/fetch). + +If you use any other ES6+ features that need **runtime support** (such as `Array.from()` or `Symbol`), make sure you are including the appropriate polyfills manually, or that the browsers you are targeting already support them. + +## Syntax Highlighting in the Editor + +To configure the syntax highlighting in your favorite text editor, head to the [relevant Babel documentation page](https://babeljs.io/docs/editors) and follow the instructions. Some of the most popular editors are covered. + +## Displaying Lint Output in the Editor + +>Note: this feature is available with `react-scripts@0.2.0` and higher.<br> +>It also only works with npm 3 or higher. + +Some editors, including Sublime Text, Atom, and Visual Studio Code, provide plugins for ESLint. + +They are not required for linting. You should see the linter output right in your terminal as well as the browser console. However, if you prefer the lint results to appear right in your editor, there are some extra steps you can do. + +You would need to install an ESLint plugin for your editor first. Then, add a file called `.eslintrc` to the project root: + +```js +{ + "extends": "react-app" +} +``` + +Now your editor should report the linting warnings. + +Note that even if you edit your `.eslintrc` file further, these changes will **only affect the editor integration**. They won’t affect the terminal and in-browser lint output. This is because Create React App intentionally provides a minimal set of rules that find common mistakes. + +If you want to enforce a coding style for your project, consider using [Prettier](https://github.com/jlongster/prettier) instead of ESLint style rules. + +## Debugging in the Editor + +**This feature is currently only supported by [Visual Studio Code](https://code.visualstudio.com) and [WebStorm](https://www.jetbrains.com/webstorm/).** + +Visual Studio Code and WebStorm support debugging out of the box with Create React App. This enables you as a developer to write and debug your React code without leaving the editor, and most importantly it enables you to have a continuous development workflow, where context switching is minimal, as you don’t have to switch between tools. + +### Visual Studio Code + +You would need to have the latest version of [VS Code](https://code.visualstudio.com) and VS Code [Chrome Debugger Extension](https://marketplace.visualstudio.com/items?itemName=msjsdiag.debugger-for-chrome) installed. + +Then add the block below to your `launch.json` file and put it inside the `.vscode` folder in your app’s root directory. + +```json +{ + "version": "0.2.0", + "configurations": [{ + "name": "Chrome", + "type": "chrome", + "request": "launch", + "url": "http://localhost:3000", + "webRoot": "${workspaceRoot}/src", + "sourceMapPathOverrides": { + "webpack:///src/*": "${webRoot}/*" + } + }] +} +``` +>Note: the URL may be different if you've made adjustments via the [HOST or PORT environment variables](#advanced-configuration). + +Start your app by running `npm start`, and start debugging in VS Code by pressing `F5` or by clicking the green debug icon. You can now write code, set breakpoints, make changes to the code, and debug your newly modified code—all from your editor. + +Having problems with VS Code Debugging? Please see their [troubleshooting guide](https://github.com/Microsoft/vscode-chrome-debug/blob/master/README.md#troubleshooting). + +### WebStorm + +You would need to have [WebStorm](https://www.jetbrains.com/webstorm/) and [JetBrains IDE Support](https://chrome.google.com/webstore/detail/jetbrains-ide-support/hmhgeddbohgjknpmjagkdomcpobmllji) Chrome extension installed. + +In the WebStorm menu `Run` select `Edit Configurations...`. Then click `+` and select `JavaScript Debug`. Paste `http://localhost:3000` into the URL field and save the configuration. + +>Note: the URL may be different if you've made adjustments via the [HOST or PORT environment variables](#advanced-configuration). + +Start your app by running `npm start`, then press `^D` on macOS or `F9` on Windows and Linux or click the green debug icon to start debugging in WebStorm. + +The same way you can debug your application in IntelliJ IDEA Ultimate, PhpStorm, PyCharm Pro, and RubyMine. + +## Formatting Code Automatically + +Prettier is an opinionated code formatter with support for JavaScript, CSS and JSON. With Prettier you can format the code you write automatically to ensure a code style within your project. See the [Prettier's GitHub page](https://github.com/prettier/prettier) for more information, and look at this [page to see it in action](https://prettier.github.io/prettier/). + +To format our code whenever we make a commit in git, we need to install the following dependencies: + +```sh +npm install --save husky lint-staged prettier +``` + +Alternatively you may use `yarn`: + +```sh +yarn add husky lint-staged prettier +``` + +* `husky` makes it easy to use githooks as if they are npm scripts. +* `lint-staged` allows us to run scripts on staged files in git. See this [blog post about lint-staged to learn more about it](https://medium.com/@okonetchnikov/make-linting-great-again-f3890e1ad6b8). +* `prettier` is the JavaScript formatter we will run before commits. + +Now we can make sure every file is formatted correctly by adding a few lines to the `package.json` in the project root. + +Add the following line to `scripts` section: + +```diff + "scripts": { ++ "precommit": "lint-staged", + "start": "react-scripts start", + "build": "react-scripts build", +``` + +Next we add a 'lint-staged' field to the `package.json`, for example: + +```diff + "dependencies": { + // ... + }, ++ "lint-staged": { ++ "src/**/*.{js,jsx,json,css}": [ ++ "prettier --single-quote --write", ++ "git add" ++ ] ++ }, + "scripts": { +``` + +Now, whenever you make a commit, Prettier will format the changed files automatically. You can also run `./node_modules/.bin/prettier --single-quote --write "src/**/*.{js,jsx}"` to format your entire project for the first time. + +Next you might want to integrate Prettier in your favorite editor. Read the section on [Editor Integration](https://github.com/prettier/prettier#editor-integration) on the Prettier GitHub page. + +## Changing the Page `<title>` + +You can find the source HTML file in the `public` folder of the generated project. You may edit the `<title>` tag in it to change the title from “React App” to anything else. + +Note that normally you wouldn’t edit files in the `public` folder very often. For example, [adding a stylesheet](#adding-a-stylesheet) is done without touching the HTML. + +If you need to dynamically update the page title based on the content, you can use the browser [`document.title`](https://developer.mozilla.org/en-US/docs/Web/API/Document/title) API. For more complex scenarios when you want to change the title from React components, you can use [React Helmet](https://github.com/nfl/react-helmet), a third party library. + +If you use a custom server for your app in production and want to modify the title before it gets sent to the browser, you can follow advice in [this section](#generating-dynamic-meta-tags-on-the-server). Alternatively, you can pre-build each page as a static HTML file which then loads the JavaScript bundle, which is covered [here](#pre-rendering-into-static-html-files). + +## Installing a Dependency + +The generated project includes React and ReactDOM as dependencies. It also includes a set of scripts used by Create React App as a development dependency. You may install other dependencies (for example, React Router) with `npm`: + +```sh +npm install --save react-router +``` + +Alternatively you may use `yarn`: + +```sh +yarn add react-router +``` + +This works for any library, not just `react-router`. + +## Importing a Component + +This project setup supports ES6 modules thanks to Babel.<br> +While you can still use `require()` and `module.exports`, we encourage you to use [`import` and `export`](http://exploringjs.com/es6/ch_modules.html) instead. + +For example: + +### `Button.js` + +```js +import React, { Component } from 'react'; + +class Button extends Component { + render() { + // ... + } +} + +export default Button; // Don’t forget to use export default! +``` + +### `DangerButton.js` + + +```js +import React, { Component } from 'react'; +import Button from './Button'; // Import a component from another file + +class DangerButton extends Component { + render() { + return <Button color="red" />; + } +} + +export default DangerButton; +``` + +Be aware of the [difference between default and named exports](http://stackoverflow.com/questions/36795819/react-native-es-6-when-should-i-use-curly-braces-for-import/36796281#36796281). It is a common source of mistakes. + +We suggest that you stick to using default imports and exports when a module only exports a single thing (for example, a component). That’s what you get when you use `export default Button` and `import Button from './Button'`. + +Named exports are useful for utility modules that export several functions. A module may have at most one default export and as many named exports as you like. + +Learn more about ES6 modules: + +* [When to use the curly braces?](http://stackoverflow.com/questions/36795819/react-native-es-6-when-should-i-use-curly-braces-for-import/36796281#36796281) +* [Exploring ES6: Modules](http://exploringjs.com/es6/ch_modules.html) +* [Understanding ES6: Modules](https://leanpub.com/understandinges6/read#leanpub-auto-encapsulating-code-with-modules) + +## Code Splitting + +Instead of downloading the entire app before users can use it, code splitting allows you to split your code into small chunks which you can then load on demand. + +This project setup supports code splitting via [dynamic `import()`](http://2ality.com/2017/01/import-operator.html#loading-code-on-demand). Its [proposal](https://github.com/tc39/proposal-dynamic-import) is in stage 3. The `import()` function-like form takes the module name as an argument and returns a [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) which always resolves to the namespace object of the module. + +Here is an example: + +### `moduleA.js` + +```js +const moduleA = 'Hello'; + +export { moduleA }; +``` +### `App.js` + +```js +import React, { Component } from 'react'; + +class App extends Component { + handleClick = () => { + import('./moduleA') + .then(({ moduleA }) => { + // Use moduleA + }) + .catch(err => { + // Handle failure + }); + }; + + render() { + return ( + <div> + <button onClick={this.handleClick}>Load</button> + </div> + ); + } +} + +export default App; +``` + +This will make `moduleA.js` and all its unique dependencies as a separate chunk that only loads after the user clicks the 'Load' button. + +You can also use it with `async` / `await` syntax if you prefer it. + +### With React Router + +If you are using React Router check out [this tutorial](http://serverless-stack.com/chapters/code-splitting-in-create-react-app.html) on how to use code splitting with it. You can find the companion GitHub repository [here](https://github.com/AnomalyInnovations/serverless-stack-demo-client/tree/code-splitting-in-create-react-app). + +## Adding a Stylesheet + +This project setup uses [Webpack](https://webpack.js.org/) for handling all assets. Webpack offers a custom way of “extending” the concept of `import` beyond JavaScript. To express that a JavaScript file depends on a CSS file, you need to **import the CSS from the JavaScript file**: + +### `Button.css` + +```css +.Button { + padding: 20px; +} +``` + +### `Button.js` + +```js +import React, { Component } from 'react'; +import './Button.css'; // Tell Webpack that Button.js uses these styles + +class Button extends Component { + render() { + // You can use them as regular CSS styles + return <div className="Button" />; + } +} +``` + +**This is not required for React** but many people find this feature convenient. You can read about the benefits of this approach [here](https://medium.com/seek-ui-engineering/block-element-modifying-your-javascript-components-d7f99fcab52b). However you should be aware that this makes your code less portable to other build tools and environments than Webpack. + +In development, expressing dependencies this way allows your styles to be reloaded on the fly as you edit them. In production, all CSS files will be concatenated into a single minified `.css` file in the build output. + +If you are concerned about using Webpack-specific semantics, you can put all your CSS right into `src/index.css`. It would still be imported from `src/index.js`, but you could always remove that import if you later migrate to a different build tool. + +## Post-Processing CSS + +This project setup minifies your CSS and adds vendor prefixes to it automatically through [Autoprefixer](https://github.com/postcss/autoprefixer) so you don’t need to worry about it. + +For example, this: + +```css +.App { + display: flex; + flex-direction: row; + align-items: center; +} +``` + +becomes this: + +```css +.App { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-direction: row; + flex-direction: row; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; +} +``` + +If you need to disable autoprefixing for some reason, [follow this section](https://github.com/postcss/autoprefixer#disabling). + +## Adding a CSS Preprocessor (Sass, Less etc.) + +Generally, we recommend that you don’t reuse the same CSS classes across different components. For example, instead of using a `.Button` CSS class in `<AcceptButton>` and `<RejectButton>` components, we recommend creating a `<Button>` component with its own `.Button` styles, that both `<AcceptButton>` and `<RejectButton>` can render (but [not inherit](https://facebook.github.io/react/docs/composition-vs-inheritance.html)). + +Following this rule often makes CSS preprocessors less useful, as features like mixins and nesting are replaced by component composition. You can, however, integrate a CSS preprocessor if you find it valuable. In this walkthrough, we will be using Sass, but you can also use Less, or another alternative. + +First, let’s install the command-line interface for Sass: + +```sh +npm install --save node-sass-chokidar +``` + +Alternatively you may use `yarn`: + +```sh +yarn add node-sass-chokidar +``` + +Then in `package.json`, add the following lines to `scripts`: + +```diff + "scripts": { ++ "build-css": "node-sass-chokidar src/ -o src/", ++ "watch-css": "npm run build-css && node-sass-chokidar src/ -o src/ --watch --recursive", + "start": "react-scripts start", + "build": "react-scripts build", + "test": "react-scripts test --env=jsdom", +``` + +>Note: To use a different preprocessor, replace `build-css` and `watch-css` commands according to your preprocessor’s documentation. + +Now you can rename `src/App.css` to `src/App.scss` and run `npm run watch-css`. The watcher will find every Sass file in `src` subdirectories, and create a corresponding CSS file next to it, in our case overwriting `src/App.css`. Since `src/App.js` still imports `src/App.css`, the styles become a part of your application. You can now edit `src/App.scss`, and `src/App.css` will be regenerated. + +To share variables between Sass files, you can use Sass imports. For example, `src/App.scss` and other component style files could include `@import "./shared.scss";` with variable definitions. + +To enable importing files without using relative paths, you can add the `--include-path` option to the command in `package.json`. + +``` +"build-css": "node-sass-chokidar --include-path ./src --include-path ./node_modules src/ -o src/", +"watch-css": "npm run build-css && node-sass-chokidar --include-path ./src --include-path ./node_modules src/ -o src/ --watch --recursive", +``` + +This will allow you to do imports like + +```scss +@import 'styles/_colors.scss'; // assuming a styles directory under src/ +@import 'nprogress/nprogress'; // importing a css file from the nprogress node module +``` + +At this point you might want to remove all CSS files from the source control, and add `src/**/*.css` to your `.gitignore` file. It is generally a good practice to keep the build products outside of the source control. + +As a final step, you may find it convenient to run `watch-css` automatically with `npm start`, and run `build-css` as a part of `npm run build`. You can use the `&&` operator to execute two scripts sequentially. However, there is no cross-platform way to run two scripts in parallel, so we will install a package for this: + +```sh +npm install --save npm-run-all +``` + +Alternatively you may use `yarn`: + +```sh +yarn add npm-run-all +``` + +Then we can change `start` and `build` scripts to include the CSS preprocessor commands: + +```diff + "scripts": { + "build-css": "node-sass-chokidar src/ -o src/", + "watch-css": "npm run build-css && node-sass-chokidar src/ -o src/ --watch --recursive", +- "start": "react-scripts start", +- "build": "react-scripts build", ++ "start-js": "react-scripts start", ++ "start": "npm-run-all -p watch-css start-js", ++ "build-js": "react-scripts build", ++ "build": "npm-run-all build-css build-js", + "test": "react-scripts test --env=jsdom", + "eject": "react-scripts eject" + } +``` + +Now running `npm start` and `npm run build` also builds Sass files. + +**Why `node-sass-chokidar`?** + +`node-sass` has been reported as having the following issues: + +- `node-sass --watch` has been reported to have *performance issues* in certain conditions when used in a virtual machine or with docker. + +- Infinite styles compiling [#1939](https://github.com/facebookincubator/create-react-app/issues/1939) + +- `node-sass` has been reported as having issues with detecting new files in a directory [#1891](https://github.com/sass/node-sass/issues/1891) + + `node-sass-chokidar` is used here as it addresses these issues. + +## Adding Images, Fonts, and Files + +With Webpack, using static assets like images and fonts works similarly to CSS. + +You can **`import` a file right in a JavaScript module**. This tells Webpack to include that file in the bundle. Unlike CSS imports, importing a file gives you a string value. This value is the final path you can reference in your code, e.g. as the `src` attribute of an image or the `href` of a link to a PDF. + +To reduce the number of requests to the server, importing images that are less than 10,000 bytes returns a [data URI](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs) instead of a path. This applies to the following file extensions: bmp, gif, jpg, jpeg, and png. SVG files are excluded due to [#1153](https://github.com/facebookincubator/create-react-app/issues/1153). + +Here is an example: + +```js +import React from 'react'; +import logo from './logo.png'; // Tell Webpack this JS file uses this image + +console.log(logo); // /logo.84287d09.png + +function Header() { + // Import result is the URL of your image + return <img src={logo} alt="Logo" />; +} + +export default Header; +``` + +This ensures that when the project is built, Webpack will correctly move the images into the build folder, and provide us with correct paths. + +This works in CSS too: + +```css +.Logo { + background-image: url(./logo.png); +} +``` + +Webpack finds all relative module references in CSS (they start with `./`) and replaces them with the final paths from the compiled bundle. If you make a typo or accidentally delete an important file, you will see a compilation error, just like when you import a non-existent JavaScript module. The final filenames in the compiled bundle are generated by Webpack from content hashes. If the file content changes in the future, Webpack will give it a different name in production so you don’t need to worry about long-term caching of assets. + +Please be advised that this is also a custom feature of Webpack. + +**It is not required for React** but many people enjoy it (and React Native uses a similar mechanism for images).<br> +An alternative way of handling static assets is described in the next section. + +## Using the `public` Folder + +>Note: this feature is available with `react-scripts@0.5.0` and higher. + +### Changing the HTML + +The `public` folder contains the HTML file so you can tweak it, for example, to [set the page title](#changing-the-page-title). +The `<script>` tag with the compiled code will be added to it automatically during the build process. + +### Adding Assets Outside of the Module System + +You can also add other assets to the `public` folder. + +Note that we normally encourage you to `import` assets in JavaScript files instead. +For example, see the sections on [adding a stylesheet](#adding-a-stylesheet) and [adding images and fonts](#adding-images-fonts-and-files). +This mechanism provides a number of benefits: + +* Scripts and stylesheets get minified and bundled together to avoid extra network requests. +* Missing files cause compilation errors instead of 404 errors for your users. +* Result filenames include content hashes so you don’t need to worry about browsers caching their old versions. + +However there is an **escape hatch** that you can use to add an asset outside of the module system. + +If you put a file into the `public` folder, it will **not** be processed by Webpack. Instead it will be copied into the build folder untouched. To reference assets in the `public` folder, you need to use a special variable called `PUBLIC_URL`. + +Inside `index.html`, you can use it like this: + +```html +<link rel="shortcut icon" href="%PUBLIC_URL%/favicon.ico"> +``` + +Only files inside the `public` folder will be accessible by `%PUBLIC_URL%` prefix. If you need to use a file from `src` or `node_modules`, you’ll have to copy it there to explicitly specify your intention to make this file a part of the build. + +When you run `npm run build`, Create React App will substitute `%PUBLIC_URL%` with a correct absolute path so your project works even if you use client-side routing or host it at a non-root URL. + +In JavaScript code, you can use `process.env.PUBLIC_URL` for similar purposes: + +```js +render() { + // Note: this is an escape hatch and should be used sparingly! + // Normally we recommend using `import` for getting asset URLs + // as described in “Adding Images and Fonts” above this section. + return <img src={process.env.PUBLIC_URL + '/img/logo.png'} />; +} +``` + +Keep in mind the downsides of this approach: + +* None of the files in `public` folder get post-processed or minified. +* Missing files will not be called at compilation time, and will cause 404 errors for your users. +* Result filenames won’t include content hashes so you’ll need to add query arguments or rename them every time they change. + +### When to Use the `public` Folder + +Normally we recommend importing [stylesheets](#adding-a-stylesheet), [images, and fonts](#adding-images-fonts-and-files) from JavaScript. +The `public` folder is useful as a workaround for a number of less common cases: + +* You need a file with a specific name in the build output, such as [`manifest.webmanifest`](https://developer.mozilla.org/en-US/docs/Web/Manifest). +* You have thousands of images and need to dynamically reference their paths. +* You want to include a small script like [`pace.js`](http://github.hubspot.com/pace/docs/welcome/) outside of the bundled code. +* Some library may be incompatible with Webpack and you have no other option but to include it as a `<script>` tag. + +Note that if you add a `<script>` that declares global variables, you also need to read the next section on using them. + +## Using Global Variables + +When you include a script in the HTML file that defines global variables and try to use one of these variables in the code, the linter will complain because it cannot see the definition of the variable. + +You can avoid this by reading the global variable explicitly from the `window` object, for example: + +```js +const $ = window.$; +``` + +This makes it obvious you are using a global variable intentionally rather than because of a typo. + +Alternatively, you can force the linter to ignore any line by adding `// eslint-disable-line` after it. + +## Adding Bootstrap + +You don’t have to use [Reactstrap](https://reactstrap.github.io/) together with React but it is a popular library for integrating Bootstrap with React apps. If you need it, you can integrate it with Create React App by following these steps: + +Install Reactstrap and Bootstrap from npm. React Bootstrap does not include Bootstrap CSS so this needs to be installed as well: + +```sh +npm install --save reactstrap bootstrap@4 +``` + +Alternatively you may use `yarn`: + +```sh +yarn add reactstrap bootstrap@4 +``` + +Import Bootstrap CSS and optionally Bootstrap theme CSS in the beginning of your ```src/index.js``` file: + +```js +import 'bootstrap/dist/css/bootstrap.css'; +// Put any other imports below so that CSS from your +// components takes precedence over default styles. +``` + +Import required React Bootstrap components within ```src/App.js``` file or your custom component files: + +```js +import { Navbar, Button } from 'reactstrap'; +``` + +Now you are ready to use the imported React Bootstrap components within your component hierarchy defined in the render method. Here is an example [`App.js`](https://gist.githubusercontent.com/gaearon/85d8c067f6af1e56277c82d19fd4da7b/raw/6158dd991b67284e9fc8d70b9d973efe87659d72/App.js) redone using React Bootstrap. + +### Using a Custom Theme + +Sometimes you might need to tweak the visual styles of Bootstrap (or equivalent package).<br> +We suggest the following approach: + +* Create a new package that depends on the package you wish to customize, e.g. Bootstrap. +* Add the necessary build steps to tweak the theme, and publish your package on npm. +* Install your own theme npm package as a dependency of your app. + +Here is an example of adding a [customized Bootstrap](https://medium.com/@tacomanator/customizing-create-react-app-aa9ffb88165) that follows these steps. + +## Adding Flow + +Flow is a static type checker that helps you write code with fewer bugs. Check out this [introduction to using static types in JavaScript](https://medium.com/@preethikasireddy/why-use-static-types-in-javascript-part-1-8382da1e0adb) if you are new to this concept. + +Recent versions of [Flow](http://flowtype.org/) work with Create React App projects out of the box. + +To add Flow to a Create React App project, follow these steps: + +1. Run `npm install --save flow-bin` (or `yarn add flow-bin`). +2. Add `"flow": "flow"` to the `scripts` section of your `package.json`. +3. Run `npm run flow init` (or `yarn flow init`) to create a [`.flowconfig` file](https://flowtype.org/docs/advanced-configuration.html) in the root directory. +4. Add `// @flow` to any files you want to type check (for example, to `src/App.js`). + +Now you can run `npm run flow` (or `yarn flow`) to check the files for type errors. +You can optionally use an IDE like [Nuclide](https://nuclide.io/docs/languages/flow/) for a better integrated experience. +In the future we plan to integrate it into Create React App even more closely. + +To learn more about Flow, check out [its documentation](https://flowtype.org/). + +## Adding Custom Environment Variables + +>Note: this feature is available with `react-scripts@0.2.3` and higher. + +Your project can consume variables declared in your environment as if they were declared locally in your JS files. By +default you will have `NODE_ENV` defined for you, and any other environment variables starting with +`REACT_APP_`. + +**The environment variables are embedded during the build time**. Since Create React App produces a static HTML/CSS/JS bundle, it can’t possibly read them at runtime. To read them at runtime, you would need to load HTML into memory on the server and replace placeholders in runtime, just like [described here](#injecting-data-from-the-server-into-the-page). Alternatively you can rebuild the app on the server anytime you change them. + +>Note: You must create custom environment variables beginning with `REACT_APP_`. Any other variables except `NODE_ENV` will be ignored to avoid accidentally [exposing a private key on the machine that could have the same name](https://github.com/facebookincubator/create-react-app/issues/865#issuecomment-252199527). Changing any environment variables will require you to restart the development server if it is running. + +These environment variables will be defined for you on `process.env`. For example, having an environment +variable named `REACT_APP_SECRET_CODE` will be exposed in your JS as `process.env.REACT_APP_SECRET_CODE`. + +There is also a special built-in environment variable called `NODE_ENV`. You can read it from `process.env.NODE_ENV`. When you run `npm start`, it is always equal to `'development'`, when you run `npm test` it is always equal to `'test'`, and when you run `npm run build` to make a production bundle, it is always equal to `'production'`. **You cannot override `NODE_ENV` manually.** This prevents developers from accidentally deploying a slow development build to production. + +These environment variables can be useful for displaying information conditionally based on where the project is +deployed or consuming sensitive data that lives outside of version control. + +First, you need to have environment variables defined. For example, let’s say you wanted to consume a secret defined +in the environment inside a `<form>`: + +```jsx +render() { + return ( + <div> + <small>You are running this application in <b>{process.env.NODE_ENV}</b> mode.</small> + <form> + <input type="hidden" defaultValue={process.env.REACT_APP_SECRET_CODE} /> + </form> + </div> + ); +} +``` + +During the build, `process.env.REACT_APP_SECRET_CODE` will be replaced with the current value of the `REACT_APP_SECRET_CODE` environment variable. Remember that the `NODE_ENV` variable will be set for you automatically. + +When you load the app in the browser and inspect the `<input>`, you will see its value set to `abcdef`, and the bold text will show the environment provided when using `npm start`: + +```html +<div> + <small>You are running this application in <b>development</b> mode.</small> + <form> + <input type="hidden" value="abcdef" /> + </form> +</div> +``` + +The above form is looking for a variable called `REACT_APP_SECRET_CODE` from the environment. In order to consume this +value, we need to have it defined in the environment. This can be done using two ways: either in your shell or in +a `.env` file. Both of these ways are described in the next few sections. + +Having access to the `NODE_ENV` is also useful for performing actions conditionally: + +```js +if (process.env.NODE_ENV !== 'production') { + analytics.disable(); +} +``` + +When you compile the app with `npm run build`, the minification step will strip out this condition, and the resulting bundle will be smaller. + +### Referencing Environment Variables in the HTML + +>Note: this feature is available with `react-scripts@0.9.0` and higher. + +You can also access the environment variables starting with `REACT_APP_` in the `public/index.html`. For example: + +```html +<title>%REACT_APP_WEBSITE_NAME% +``` + +Note that the caveats from the above section apply: + +* Apart from a few built-in variables (`NODE_ENV` and `PUBLIC_URL`), variable names must start with `REACT_APP_` to work. +* The environment variables are injected at build time. If you need to inject them at runtime, [follow this approach instead](#generating-dynamic-meta-tags-on-the-server). + +### Adding Temporary Environment Variables In Your Shell + +Defining environment variables can vary between OSes. It’s also important to know that this manner is temporary for the +life of the shell session. + +#### Windows (cmd.exe) + +```cmd +set REACT_APP_SECRET_CODE=abcdef&&npm start +``` + +(Note: the lack of whitespace is intentional.) + +#### Linux, macOS (Bash) + +```bash +REACT_APP_SECRET_CODE=abcdef npm start +``` + +### Adding Development Environment Variables In `.env` + +>Note: this feature is available with `react-scripts@0.5.0` and higher. + +To define permanent environment variables, create a file called `.env` in the root of your project: + +``` +REACT_APP_SECRET_CODE=abcdef +``` + +`.env` files **should be** checked into source control (with the exclusion of `.env*.local`). + +#### What other `.env` files can be used? + +>Note: this feature is **available with `react-scripts@1.0.0` and higher**. + +* `.env`: Default. +* `.env.local`: Local overrides. **This file is loaded for all environments except test.** +* `.env.development`, `.env.test`, `.env.production`: Environment-specific settings. +* `.env.development.local`, `.env.test.local`, `.env.production.local`: Local overrides of environment-specific settings. + +Files on the left have more priority than files on the right: + +* `npm start`: `.env.development.local`, `.env.development`, `.env.local`, `.env` +* `npm run build`: `.env.production.local`, `.env.production`, `.env.local`, `.env` +* `npm test`: `.env.test.local`, `.env.test`, `.env` (note `.env.local` is missing) + +These variables will act as the defaults if the machine does not explicitly set them.
+Please refer to the [dotenv documentation](https://github.com/motdotla/dotenv) for more details. + +>Note: If you are defining environment variables for development, your CI and/or hosting platform will most likely need +these defined as well. Consult their documentation how to do this. For example, see the documentation for [Travis CI](https://docs.travis-ci.com/user/environment-variables/) or [Heroku](https://devcenter.heroku.com/articles/config-vars). + +## Can I Use Decorators? + +Many popular libraries use [decorators](https://medium.com/google-developers/exploring-es7-decorators-76ecb65fb841) in their documentation.
+Create React App doesn’t support decorator syntax at the moment because: + +* It is an experimental proposal and is subject to change. +* The current specification version is not officially supported by Babel. +* If the specification changes, we won’t be able to write a codemod because we don’t use them internally at Facebook. + +However in many cases you can rewrite decorator-based code without decorators just as fine.
+Please refer to these two threads for reference: + +* [#214](https://github.com/facebookincubator/create-react-app/issues/214) +* [#411](https://github.com/facebookincubator/create-react-app/issues/411) + +Create React App will add decorator support when the specification advances to a stable stage. + +## Integrating with an API Backend + +These tutorials will help you to integrate your app with an API backend running on another port, +using `fetch()` to access it. + +### Node +Check out [this tutorial](https://www.fullstackreact.com/articles/using-create-react-app-with-a-server/). +You can find the companion GitHub repository [here](https://github.com/fullstackreact/food-lookup-demo). + +### Ruby on Rails + +Check out [this tutorial](https://www.fullstackreact.com/articles/how-to-get-create-react-app-to-work-with-your-rails-api/). +You can find the companion GitHub repository [here](https://github.com/fullstackreact/food-lookup-demo-rails). + +## Proxying API Requests in Development + +>Note: this feature is available with `react-scripts@0.2.3` and higher. + +People often serve the front-end React app from the same host and port as their backend implementation.
+For example, a production setup might look like this after the app is deployed: + +``` +/ - static server returns index.html with React app +/todos - static server returns index.html with React app +/api/todos - server handles any /api/* requests using the backend implementation +``` + +Such setup is **not** required. However, if you **do** have a setup like this, it is convenient to write requests like `fetch('/api/todos')` without worrying about redirecting them to another host or port during development. + +To tell the development server to proxy any unknown requests to your API server in development, add a `proxy` field to your `package.json`, for example: + +```js + "proxy": "http://localhost:4000", +``` + +This way, when you `fetch('/api/todos')` in development, the development server will recognize that it’s not a static asset, and will proxy your request to `http://localhost:4000/api/todos` as a fallback. The development server will **only** attempt to send requests without `text/html` in its `Accept` header to the proxy. + +Conveniently, this avoids [CORS issues](http://stackoverflow.com/questions/21854516/understanding-ajax-cors-and-security-considerations) and error messages like this in development: + +``` +Fetch API cannot load http://localhost:4000/api/todos. No 'Access-Control-Allow-Origin' header is present on the requested resource. Origin 'http://localhost:3000' is therefore not allowed access. If an opaque response serves your needs, set the request's mode to 'no-cors' to fetch the resource with CORS disabled. +``` + +Keep in mind that `proxy` only has effect in development (with `npm start`), and it is up to you to ensure that URLs like `/api/todos` point to the right thing in production. You don’t have to use the `/api` prefix. Any unrecognized request without a `text/html` accept header will be redirected to the specified `proxy`. + +The `proxy` option supports HTTP, HTTPS and WebSocket connections.
+If the `proxy` option is **not** flexible enough for you, alternatively you can: + +* [Configure the proxy yourself](#configuring-the-proxy-manually) +* Enable CORS on your server ([here’s how to do it for Express](http://enable-cors.org/server_expressjs.html)). +* Use [environment variables](#adding-custom-environment-variables) to inject the right server host and port into your app. + +### "Invalid Host Header" Errors After Configuring Proxy + +When you enable the `proxy` option, you opt into a more strict set of host checks. This is necessary because leaving the backend open to remote hosts makes your computer vulnerable to DNS rebinding attacks. The issue is explained in [this article](https://medium.com/webpack/webpack-dev-server-middleware-security-issues-1489d950874a) and [this issue](https://github.com/webpack/webpack-dev-server/issues/887). + +This shouldn’t affect you when developing on `localhost`, but if you develop remotely like [described here](https://github.com/facebookincubator/create-react-app/issues/2271), you will see this error in the browser after enabling the `proxy` option: + +>Invalid Host header + +To work around it, you can specify your public development host in a file called `.env.development` in the root of your project: + +``` +HOST=mypublicdevhost.com +``` + +If you restart the development server now and load the app from the specified host, it should work. + +If you are still having issues or if you’re using a more exotic environment like a cloud editor, you can bypass the host check completely by adding a line to `.env.development.local`. **Note that this is dangerous and exposes your machine to remote code execution from malicious websites:** + +``` +# NOTE: THIS IS DANGEROUS! +# It exposes your machine to attacks from the websites you visit. +DANGEROUSLY_DISABLE_HOST_CHECK=true +``` + +We don’t recommend this approach. + +### Configuring the Proxy Manually + +>Note: this feature is available with `react-scripts@1.0.0` and higher. + +If the `proxy` option is **not** flexible enough for you, you can specify an object in the following form (in `package.json`).
+You may also specify any configuration value [`http-proxy-middleware`](https://github.com/chimurai/http-proxy-middleware#options) or [`http-proxy`](https://github.com/nodejitsu/node-http-proxy#options) supports. +```js +{ + // ... + "proxy": { + "/api": { + "target": "", + "ws": true + // ... + } + } + // ... +} +``` + +All requests matching this path will be proxies, no exceptions. This includes requests for `text/html`, which the standard `proxy` option does not proxy. + +If you need to specify multiple proxies, you may do so by specifying additional entries. +Matches are regular expressions, so that you can use a regexp to match multiple paths. +```js +{ + // ... + "proxy": { + // Matches any request starting with /api + "/api": { + "target": "", + "ws": true + // ... + }, + // Matches any request starting with /foo + "/foo": { + "target": "", + "ssl": true, + "pathRewrite": { + "^/foo": "/foo/beta" + } + // ... + }, + // Matches /bar/abc.html but not /bar/sub/def.html + "/bar/[^/]*[.]html": { + "target": "", + // ... + }, + // Matches /baz/abc.html and /baz/sub/def.html + "/baz/.*/.*[.]html": { + "target": "" + // ... + } + } + // ... +} +``` + +### Configuring a WebSocket Proxy + +When setting up a WebSocket proxy, there are a some extra considerations to be aware of. + +If you’re using a WebSocket engine like [Socket.io](https://socket.io/), you must have a Socket.io server running that you can use as the proxy target. Socket.io will not work with a standard WebSocket server. Specifically, don't expect Socket.io to work with [the websocket.org echo test](http://websocket.org/echo.html). + +There’s some good documentation available for [setting up a Socket.io server](https://socket.io/docs/). + +Standard WebSockets **will** work with a standard WebSocket server as well as the websocket.org echo test. You can use libraries like [ws](https://github.com/websockets/ws) for the server, with [native WebSockets in the browser](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket). + +Either way, you can proxy WebSocket requests manually in `package.json`: + +```js +{ + // ... + "proxy": { + "/socket": { + // Your compatible WebSocket server + "target": "ws://", + // Tell http-proxy-middleware that this is a WebSocket proxy. + // Also allows you to proxy WebSocket requests without an additional HTTP request + // https://github.com/chimurai/http-proxy-middleware#external-websocket-upgrade + "ws": true + // ... + } + } + // ... +} +``` + +## Using HTTPS in Development + +>Note: this feature is available with `react-scripts@0.4.0` and higher. + +You may require the dev server to serve pages over HTTPS. One particular case where this could be useful is when using [the "proxy" feature](#proxying-api-requests-in-development) to proxy requests to an API server when that API server is itself serving HTTPS. + +To do this, set the `HTTPS` environment variable to `true`, then start the dev server as usual with `npm start`: + +#### Windows (cmd.exe) + +```cmd +set HTTPS=true&&npm start +``` + +(Note: the lack of whitespace is intentional.) + +#### Linux, macOS (Bash) + +```bash +HTTPS=true npm start +``` + +Note that the server will use a self-signed certificate, so your web browser will almost definitely display a warning upon accessing the page. + +## Generating Dynamic `` Tags on the Server + +Since Create React App doesn’t support server rendering, you might be wondering how to make `` tags dynamic and reflect the current URL. To solve this, we recommend to add placeholders into the HTML, like this: + +```html + + + + + +``` + +Then, on the server, regardless of the backend you use, you can read `index.html` into memory and replace `__OG_TITLE__`, `__OG_DESCRIPTION__`, and any other placeholders with values depending on the current URL. Just make sure to sanitize and escape the interpolated values so that they are safe to embed into HTML! + +If you use a Node server, you can even share the route matching logic between the client and the server. However duplicating it also works fine in simple cases. + +## Pre-Rendering into Static HTML Files + +If you’re hosting your `build` with a static hosting provider you can use [react-snapshot](https://www.npmjs.com/package/react-snapshot) or [react-snap](https://github.com/stereobooster/react-snap) to generate HTML pages for each route, or relative link, in your application. These pages will then seamlessly become active, or “hydrated”, when the JavaScript bundle has loaded. + +There are also opportunities to use this outside of static hosting, to take the pressure off the server when generating and caching routes. + +The primary benefit of pre-rendering is that you get the core content of each page _with_ the HTML payload—regardless of whether or not your JavaScript bundle successfully downloads. It also increases the likelihood that each route of your application will be picked up by search engines. + +You can read more about [zero-configuration pre-rendering (also called snapshotting) here](https://medium.com/superhighfives/an-almost-static-stack-6df0a2791319). + +## Injecting Data from the Server into the Page + +Similarly to the previous section, you can leave some placeholders in the HTML that inject global variables, for example: + +```js + + + + +``` + +Then, on the server, you can replace `__SERVER_DATA__` with a JSON of real data right before sending the response. The client code can then read `window.SERVER_DATA` to use it. **Make sure to [sanitize the JSON before sending it to the client](https://medium.com/node-security/the-most-common-xss-vulnerability-in-react-js-applications-2bdffbcc1fa0) as it makes your app vulnerable to XSS attacks.** + +## Running Tests + +>Note: this feature is available with `react-scripts@0.3.0` and higher.
+>[Read the migration guide to learn how to enable it in older projects!](https://github.com/facebookincubator/create-react-app/blob/master/CHANGELOG.md#migrating-from-023-to-030) + +Create React App uses [Jest](https://facebook.github.io/jest/) as its test runner. To prepare for this integration, we did a [major revamp](https://facebook.github.io/jest/blog/2016/09/01/jest-15.html) of Jest so if you heard bad things about it years ago, give it another try. + +Jest is a Node-based runner. This means that the tests always run in a Node environment and not in a real browser. This lets us enable fast iteration speed and prevent flakiness. + +While Jest provides browser globals such as `window` thanks to [jsdom](https://github.com/tmpvar/jsdom), they are only approximations of the real browser behavior. Jest is intended to be used for unit tests of your logic and your components rather than the DOM quirks. + +We recommend that you use a separate tool for browser end-to-end tests if you need them. They are beyond the scope of Create React App. + +### Filename Conventions + +Jest will look for test files with any of the following popular naming conventions: + +* Files with `.js` suffix in `__tests__` folders. +* Files with `.test.js` suffix. +* Files with `.spec.js` suffix. + +The `.test.js` / `.spec.js` files (or the `__tests__` folders) can be located at any depth under the `src` top level folder. + +We recommend to put the test files (or `__tests__` folders) next to the code they are testing so that relative imports appear shorter. For example, if `App.test.js` and `App.js` are in the same folder, the test just needs to `import App from './App'` instead of a long relative path. Colocation also helps find tests more quickly in larger projects. + +### Command Line Interface + +When you run `npm test`, Jest will launch in the watch mode. Every time you save a file, it will re-run the tests, just like `npm start` recompiles the code. + +The watcher includes an interactive command-line interface with the ability to run all tests, or focus on a search pattern. It is designed this way so that you can keep it open and enjoy fast re-runs. You can learn the commands from the “Watch Usage” note that the watcher prints after every run: + +![Jest watch mode](http://facebook.github.io/jest/img/blog/15-watch.gif) + +### Version Control Integration + +By default, when you run `npm test`, Jest will only run the tests related to files changed since the last commit. This is an optimization designed to make your tests run fast regardless of how many tests you have. However it assumes that you don’t often commit the code that doesn’t pass the tests. + +Jest will always explicitly mention that it only ran tests related to the files changed since the last commit. You can also press `a` in the watch mode to force Jest to run all tests. + +Jest will always run all tests on a [continuous integration](#continuous-integration) server or if the project is not inside a Git or Mercurial repository. + +### Writing Tests + +To create tests, add `it()` (or `test()`) blocks with the name of the test and its code. You may optionally wrap them in `describe()` blocks for logical grouping but this is neither required nor recommended. + +Jest provides a built-in `expect()` global function for making assertions. A basic test could look like this: + +```js +import sum from './sum'; + +it('sums numbers', () => { + expect(sum(1, 2)).toEqual(3); + expect(sum(2, 2)).toEqual(4); +}); +``` + +All `expect()` matchers supported by Jest are [extensively documented here](https://facebook.github.io/jest/docs/en/expect.html#content).
+You can also use [`jest.fn()` and `expect(fn).toBeCalled()`](https://facebook.github.io/jest/docs/en/expect.html#tohavebeencalled) to create “spies” or mock functions. + +### Testing Components + +There is a broad spectrum of component testing techniques. They range from a “smoke test” verifying that a component renders without throwing, to shallow rendering and testing some of the output, to full rendering and testing component lifecycle and state changes. + +Different projects choose different testing tradeoffs based on how often components change, and how much logic they contain. If you haven’t decided on a testing strategy yet, we recommend that you start with creating simple smoke tests for your components: + +```js +import React from 'react'; +import ReactDOM from 'react-dom'; +import App from './App'; + +it('renders without crashing', () => { + const div = document.createElement('div'); + ReactDOM.render(, div); +}); +``` + +This test mounts a component and makes sure that it didn’t throw during rendering. Tests like this provide a lot value with very little effort so they are great as a starting point, and this is the test you will find in `src/App.test.js`. + +When you encounter bugs caused by changing components, you will gain a deeper insight into which parts of them are worth testing in your application. This might be a good time to introduce more specific tests asserting specific expected output or behavior. + +If you’d like to test components in isolation from the child components they render, we recommend using [`shallow()` rendering API](http://airbnb.io/enzyme/docs/api/shallow.html) from [Enzyme](http://airbnb.io/enzyme/). To install it, run: + +```sh +npm install --save enzyme enzyme-adapter-react-16 react-test-renderer +``` + +Alternatively you may use `yarn`: + +```sh +yarn add enzyme enzyme-adapter-react-16 react-test-renderer +``` + +As of Enzyme 3, you will need to install Enzyme along with an Adapter corresponding to the version of React you are using. (The examples above use the adapter for React 16.) + +The adapter will also need to be configured in your [global setup file](#initializing-test-environment): + +#### `src/setupTests.js` +```js +import { configure } from 'enzyme'; +import Adapter from 'enzyme-adapter-react-16'; + +configure({ adapter: new Adapter() }); +``` + +Now you can write a smoke test with it: + +```js +import React from 'react'; +import { shallow } from 'enzyme'; +import App from './App'; + +it('renders without crashing', () => { + shallow(); +}); +``` + +Unlike the previous smoke test using `ReactDOM.render()`, this test only renders `` and doesn’t go deeper. For example, even if `` itself renders a ` + + ); + } +} diff --git a/ClientApp/src/components/FetchData.js b/ClientApp/src/components/FetchData.js new file mode 100644 index 0000000..281cabb --- /dev/null +++ b/ClientApp/src/components/FetchData.js @@ -0,0 +1,59 @@ +import React, { Component } from 'react'; + +export class FetchData extends Component { + static displayName = FetchData.name; + + constructor(props) { + super(props); + this.state = { forecasts: [], loading: true }; + } + + componentDidMount() { + this.populateWeatherData(); + } + + static renderForecastsTable(forecasts) { + return ( + + + + + + + + + + + {forecasts.map(forecast => + + + + + + + )} + +
DateTemp. (C)Temp. (F)Summary
{forecast.date}{forecast.temperatureC}{forecast.temperatureF}{forecast.summary}
+ ); + } + + render() { + let contents = this.state.loading + ?

Loading...

+ : FetchData.renderForecastsTable(this.state.forecasts); + + return ( +
+

Weather forecast

+

This component demonstrates fetching data from the server.

+ {contents} +
+ ); + } + + async populateWeatherData() { + const response = await fetch('weatherforecast'); + const data = await response.json(); + this.setState({ forecasts: data, loading: false }); + } +} diff --git a/ClientApp/src/components/Home.js b/ClientApp/src/components/Home.js new file mode 100644 index 0000000..119fc10 --- /dev/null +++ b/ClientApp/src/components/Home.js @@ -0,0 +1,26 @@ +import React, { Component } from 'react'; + +export class Home extends Component { + static displayName = Home.name; + + render () { + return ( +
+

Hello, world!

+

Welcome to your new single-page application, built with:

+ +

To help you get started, we have also set up:

+
    +
  • Client-side navigation. For example, click Counter then Back to return here.
    • +
  • Development server integration. In development mode, the development server from create-react-app runs in the background automatically, so your client-side resources are dynamically built on demand and the page refreshes when you modify any file.
    • +
  • Efficient production builds. In production mode, development-time features are disabled, and your dotnet publish configuration produces minified, efficiently bundled JavaScript files.
    • +
+

The ClientApp subdirectory is a standard React application based on the create-react-app template. If you open a command prompt in that directory, you can run npm commands such as npm test or npm install.

+
+ ); + } +} diff --git a/ClientApp/src/components/Layout.js b/ClientApp/src/components/Layout.js new file mode 100644 index 0000000..286b594 --- /dev/null +++ b/ClientApp/src/components/Layout.js @@ -0,0 +1,18 @@ +import React, { Component } from 'react'; +import { Container } from 'reactstrap'; +import { NavMenu } from './NavMenu'; + +export class Layout extends Component { + static displayName = Layout.name; + + render () { + return ( +
+ + + {this.props.children} + +
+ ); + } +} diff --git a/ClientApp/src/components/NavMenu.css b/ClientApp/src/components/NavMenu.css new file mode 100644 index 0000000..05560fe --- /dev/null +++ b/ClientApp/src/components/NavMenu.css @@ -0,0 +1,18 @@ +a.navbar-brand { + white-space: normal; + text-align: center; + word-break: break-all; +} + +html { + font-size: 14px; +} +@media (min-width: 768px) { + html { + font-size: 16px; + } +} + +.box-shadow { + box-shadow: 0 .25rem .75rem rgba(0, 0, 0, .05); +} diff --git a/ClientApp/src/components/NavMenu.js b/ClientApp/src/components/NavMenu.js new file mode 100644 index 0000000..124a725 --- /dev/null +++ b/ClientApp/src/components/NavMenu.js @@ -0,0 +1,49 @@ +import React, { Component } from 'react'; +import { Collapse, Container, Navbar, NavbarBrand, NavbarToggler, NavItem, NavLink } from 'reactstrap'; +import { Link } from 'react-router-dom'; +import './NavMenu.css'; + +export class NavMenu extends Component { + static displayName = NavMenu.name; + + constructor (props) { + super(props); + + this.toggleNavbar = this.toggleNavbar.bind(this); + this.state = { + collapsed: true + }; + } + + toggleNavbar () { + this.setState({ + collapsed: !this.state.collapsed + }); + } + + render () { + return ( +
+ + + contacts + + +
    + + Home + + + Counter + + + Fetch data + +
+ + + +
+ ); + } +} diff --git a/ClientApp/src/custom.css b/ClientApp/src/custom.css new file mode 100644 index 0000000..24a6ac4 --- /dev/null +++ b/ClientApp/src/custom.css @@ -0,0 +1,14 @@ +/* Provide sufficient contrast against white background */ +a { + color: #0366d6; +} + +code { + color: #E01A76; +} + +.btn-primary { + color: #fff; + background-color: #1b6ec2; + border-color: #1861ac; +} diff --git a/ClientApp/src/index.js b/ClientApp/src/index.js new file mode 100644 index 0000000..3ed9e66 --- /dev/null +++ b/ClientApp/src/index.js @@ -0,0 +1,18 @@ +import 'bootstrap/dist/css/bootstrap.css'; +import React from 'react'; +import ReactDOM from 'react-dom'; +import { BrowserRouter } from 'react-router-dom'; +import App from './App'; +import registerServiceWorker from './registerServiceWorker'; + +const baseUrl = document.getElementsByTagName('base')[0].getAttribute('href'); +const rootElement = document.getElementById('root'); + +ReactDOM.render( + + + , + rootElement); + +registerServiceWorker(); + diff --git a/ClientApp/src/registerServiceWorker.js b/ClientApp/src/registerServiceWorker.js new file mode 100644 index 0000000..da7c120 --- /dev/null +++ b/ClientApp/src/registerServiceWorker.js @@ -0,0 +1,108 @@ +// In production, we register a service worker to serve assets from local cache. + +// This lets the app load faster on subsequent visits in production, and gives +// it offline capabilities. However, it also means that developers (and users) +// will only see deployed updates on the "N+1" visit to a page, since previously +// cached resources are updated in the background. + +// To learn more about the benefits of this model, read https://goo.gl/KwvDNy. +// This link also includes instructions on opting out of this behavior. + +const isLocalhost = Boolean( + window.location.hostname === 'localhost' || + // [::1] is the IPv6 localhost address. + window.location.hostname === '[::1]' || + // 127.0.0.1/8 is considered localhost for IPv4. + window.location.hostname.match( + /^127(?:\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$/ + ) +); + +export default function register () { + if (process.env.NODE_ENV === 'production' && 'serviceWorker' in navigator) { + // The URL constructor is available in all browsers that support SW. + const publicUrl = new URL(process.env.PUBLIC_URL, window.location); + if (publicUrl.origin !== window.location.origin) { + // Our service worker won't work if PUBLIC_URL is on a different origin + // from what our page is served on. This might happen if a CDN is used to + // serve assets; see https://github.com/facebookincubator/create-react-app/issues/2374 + return; + } + + window.addEventListener('load', () => { + const swUrl = `${process.env.PUBLIC_URL}/service-worker.js`; + + if (isLocalhost) { + // This is running on localhost. Lets check if a service worker still exists or not. + checkValidServiceWorker(swUrl); + } else { + // Is not local host. Just register service worker + registerValidSW(swUrl); + } + }); + } +} + +function registerValidSW (swUrl) { + navigator.serviceWorker + .register(swUrl) + .then(registration => { + registration.onupdatefound = () => { + const installingWorker = registration.installing; + installingWorker.onstatechange = () => { + if (installingWorker.state === 'installed') { + if (navigator.serviceWorker.controller) { + // At this point, the old content will have been purged and + // the fresh content will have been added to the cache. + // It's the perfect time to display a "New content is + // available; please refresh." message in your web app. + console.log('New content is available; please refresh.'); + } else { + // At this point, everything has been precached. + // It's the perfect time to display a + // "Content is cached for offline use." message. + console.log('Content is cached for offline use.'); + } + } + }; + }; + }) + .catch(error => { + console.error('Error during service worker registration:', error); + }); +} + +function checkValidServiceWorker (swUrl) { + // Check if the service worker can be found. If it can't reload the page. + fetch(swUrl) + .then(response => { + // Ensure service worker exists, and that we really are getting a JS file. + if ( + response.status === 404 || + response.headers.get('content-type').indexOf('javascript') === -1 + ) { + // No service worker found. Probably a different app. Reload the page. + navigator.serviceWorker.ready.then(registration => { + registration.unregister().then(() => { + window.location.reload(); + }); + }); + } else { + // Service worker found. Proceed as normal. + registerValidSW(swUrl); + } + }) + .catch(() => { + console.log( + 'No internet connection found. App is running in offline mode.' + ); + }); +} + +export function unregister () { + if ('serviceWorker' in navigator) { + navigator.serviceWorker.ready.then(registration => { + registration.unregister(); + }); + } +} diff --git a/Controllers/WeatherForecastController.cs b/Controllers/WeatherForecastController.cs new file mode 100644 index 0000000..8477b1f --- /dev/null +++ b/Controllers/WeatherForecastController.cs @@ -0,0 +1,39 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading.Tasks; +using Microsoft.AspNetCore.Mvc; +using Microsoft.Extensions.Logging; + +namespace contacts.Controllers +{ + [ApiController] + [Route("[controller]")] + public class WeatherForecastController : ControllerBase + { + private static readonly string[] Summaries = new[] + { + "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching" + }; + + private readonly ILogger _logger; + + public WeatherForecastController(ILogger logger) + { + _logger = logger; + } + + [HttpGet] + public IEnumerable Get() + { + var rng = new Random(); + return Enumerable.Range(1, 5).Select(index => new WeatherForecast + { + Date = DateTime.Now.AddDays(index), + TemperatureC = rng.Next(-20, 55), + Summary = Summaries[rng.Next(Summaries.Length)] + }) + .ToArray(); + } + } +} diff --git a/Pages/Error.cshtml b/Pages/Error.cshtml new file mode 100644 index 0000000..09da0d2 --- /dev/null +++ b/Pages/Error.cshtml @@ -0,0 +1,26 @@ +@page +@model ErrorModel +@{ + ViewData["Title"] = "Error"; +} + +

Error.

+

An error occurred while processing your request.

+ +@if (Model.ShowRequestId) +{ +

+ Request ID: @Model.RequestId +

+} + +

Development Mode

+

+ Swapping to the Development environment displays detailed information about the error that occurred. +

+

+ The Development environment shouldn't be enabled for deployed applications. + It can result in displaying sensitive information from exceptions to end users. + For local debugging, enable the Development environment by setting the ASPNETCORE_ENVIRONMENT environment variable to Development + and restarting the app. +

diff --git a/Pages/Error.cshtml.cs b/Pages/Error.cshtml.cs new file mode 100644 index 0000000..fe6eeca --- /dev/null +++ b/Pages/Error.cshtml.cs @@ -0,0 +1,31 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Threading.Tasks; +using Microsoft.AspNetCore.Mvc; +using Microsoft.AspNetCore.Mvc.RazorPages; +using Microsoft.Extensions.Logging; + +namespace contacts.Pages +{ + [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)] + public class ErrorModel : PageModel + { + private readonly ILogger _logger; + + public ErrorModel(ILogger logger) + { + _logger = logger; + } + + public string RequestId { get; set; } + + public bool ShowRequestId => !string.IsNullOrEmpty(RequestId); + + public void OnGet() + { + RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier; + } + } +} diff --git a/Pages/_ViewImports.cshtml b/Pages/_ViewImports.cshtml new file mode 100644 index 0000000..a642210 --- /dev/null +++ b/Pages/_ViewImports.cshtml @@ -0,0 +1,3 @@ +@using contacts +@namespace contacts.Pages +@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers diff --git a/Program.cs b/Program.cs new file mode 100644 index 0000000..5035698 --- /dev/null +++ b/Program.cs @@ -0,0 +1,26 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading.Tasks; +using Microsoft.AspNetCore.Hosting; +using Microsoft.Extensions.Configuration; +using Microsoft.Extensions.Hosting; +using Microsoft.Extensions.Logging; + +namespace contacts +{ + public class Program + { + public static void Main(string[] args) + { + CreateHostBuilder(args).Build().Run(); + } + + public static IHostBuilder CreateHostBuilder(string[] args) => + Host.CreateDefaultBuilder(args) + .ConfigureWebHostDefaults(webBuilder => + { + webBuilder.UseStartup(); + }); + } +} diff --git a/Properties/launchSettings.json b/Properties/launchSettings.json new file mode 100644 index 0000000..01e0148 --- /dev/null +++ b/Properties/launchSettings.json @@ -0,0 +1,27 @@ +{ + "iisSettings": { + "windowsAuthentication": false, + "anonymousAuthentication": true, + "iisExpress": { + "applicationUrl": "http://localhost:51479", + "sslPort": 44301 + } + }, + "profiles": { + "IIS Express": { + "commandName": "IISExpress", + "launchBrowser": true, + "environmentVariables": { + "ASPNETCORE_ENVIRONMENT": "Development" + } + }, + "contacts": { + "commandName": "Project", + "launchBrowser": true, + "applicationUrl": "https://localhost:5001;http://localhost:5000", + "environmentVariables": { + "ASPNETCORE_ENVIRONMENT": "Development" + } + } + } +} diff --git a/Startup.cs b/Startup.cs new file mode 100644 index 0000000..a8ee9fc --- /dev/null +++ b/Startup.cs @@ -0,0 +1,71 @@ +using Microsoft.AspNetCore.Builder; +using Microsoft.AspNetCore.Hosting; +using Microsoft.AspNetCore.HttpsPolicy; +using Microsoft.AspNetCore.SpaServices.ReactDevelopmentServer; +using Microsoft.Extensions.Configuration; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Hosting; + +namespace contacts +{ + public class Startup + { + public Startup(IConfiguration configuration) + { + Configuration = configuration; + } + + public IConfiguration Configuration { get; } + + // This method gets called by the runtime. Use this method to add services to the container. + public void ConfigureServices(IServiceCollection services) + { + + services.AddControllersWithViews(); + + // In production, the React files will be served from this directory + services.AddSpaStaticFiles(configuration => + { + configuration.RootPath = "ClientApp/build"; + }); + } + + // This method gets called by the runtime. Use this method to configure the HTTP request pipeline. + public void Configure(IApplicationBuilder app, IWebHostEnvironment env) + { + if (env.IsDevelopment()) + { + app.UseDeveloperExceptionPage(); + } + else + { + app.UseExceptionHandler("/Error"); + // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts. + app.UseHsts(); + } + + app.UseHttpsRedirection(); + app.UseStaticFiles(); + app.UseSpaStaticFiles(); + + app.UseRouting(); + + app.UseEndpoints(endpoints => + { + endpoints.MapControllerRoute( + name: "default", + pattern: "{controller}/{action=Index}/{id?}"); + }); + + app.UseSpa(spa => + { + spa.Options.SourcePath = "ClientApp"; + + if (env.IsDevelopment()) + { + spa.UseReactDevelopmentServer(npmScript: "start"); + } + }); + } + } +} diff --git a/WeatherForecast.cs b/WeatherForecast.cs new file mode 100644 index 0000000..dff4abf --- /dev/null +++ b/WeatherForecast.cs @@ -0,0 +1,15 @@ +using System; + +namespace contacts +{ + public class WeatherForecast + { + public DateTime Date { get; set; } + + public int TemperatureC { get; set; } + + public int TemperatureF => 32 + (int)(TemperatureC / 0.5556); + + public string Summary { get; set; } + } +} diff --git a/appsettings.Development.json b/appsettings.Development.json new file mode 100644 index 0000000..dba68eb --- /dev/null +++ b/appsettings.Development.json @@ -0,0 +1,9 @@ +{ + "Logging": { + "LogLevel": { + "Default": "Information", + "Microsoft": "Warning", + "Microsoft.Hosting.Lifetime": "Information" + } + } +} diff --git a/appsettings.json b/appsettings.json new file mode 100644 index 0000000..14a1a9e --- /dev/null +++ b/appsettings.json @@ -0,0 +1,10 @@ +{ + "Logging": { + "LogLevel": { + "Default": "Information", + "Microsoft": "Warning", + "Microsoft.Hosting.Lifetime": "Information" + } + }, +"AllowedHosts": "*" +} diff --git a/bin/Debug/netcoreapp3.1/Microsoft.AspNetCore.NodeServices.dll b/bin/Debug/netcoreapp3.1/Microsoft.AspNetCore.NodeServices.dll new file mode 100755 index 0000000000000000000000000000000000000000..518835decedcbe19963d3c8552fcb285629a498c GIT binary patch literal 62328 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ʩef6tKkEfUiu?ly@z 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

OdMy;OEPMh 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 DE75ty literal 0 HcmV?d00001 diff --git a/bin/Debug/netcoreapp3.1/Microsoft.AspNetCore.SpaServices.Extensions.dll b/bin/Debug/netcoreapp3.1/Microsoft.AspNetCore.SpaServices.Extensions.dll new file mode 100755 index 0000000000000000000000000000000000000000..71a2be4c0efdcefb66c226cb0097ea52dc0501aa GIT binary patch literal 65912 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 h61!ci#M;^70Eq`>tC!GI}A zXKFt`FpWC+{^VaxKk2ut7bNy=~H)&grqY17^*?4&$u6|iE!i{%js#+79aWUN6kF)D? zbFw+Qj)%+)Ru4+>^H8P?62~3NK0Q#T20?lTNbjc^l+Qp069{fINbmfdL8wdRJqk^I z05M@YQqhCSZpL;!13LY)<2(C#TtaMoW|F$0`FVKG|{gJ#G_t`D$HR6N)hlToRF^th|F6Q*46c~IO%McVQjW2azRhLBOwbAlXK^7 z?d>uFN_H&43#WJjX5nA|d5A?ju(CMT>tdN%^M(#hvuZrtdOS7BH20B7?d(CTo)~e{V=tou}1!W8ysdBMEPK5Pxmp{qy1uAAl~zFRR0ms z0YB@v1j;XRy6G@5p77Cg=Ju~&ztKGOp&P_gwZ+|x0A+P&A8)%nXg$x=NfY%_8@-Yr ztNMqj7XMhatfLoaszl~2=Ofz8Af&N8;ax82u=>c#t26X{(Wq-^ZXX)0F&J5_a8* z47vTet zW(<LmXA|C%wR>f=(0rPi{HIbFxj`_xleR3#sB9Jr z)5?N-1F@kp88B8~`u?1b5u^;SrpCatCDPp~CoiH;_a=4O zu*?fwcWXDmOo$!WxH9heSPcTI6l}~5HR#QgM~CH#NxOTjF9Nt8y{it~!6yZ05_jif z?_>f?=k$6vBaYxXif%tCX0ziR=P|gXF0^>@mC=|qU~Ew@0D_$Z5#5SJ_cnxCJ3!oX zblk!N*tmJ*z!RXMmc(d0%TlmBOpf-WJ@*3+s?4C*0{ZsKp(BQ!{_aiCYmk7aH(1Jxt@ zo)Md-BgzqLq2O6$&9#3372FV^SAiPJ&A;B{O=EVg_JeCW3L7wUZ+i{UG&@@Wk!>V_ z3aUvu?lOSG{;bdH7wzgx;GqVN z1;Gfj)}#6fu-RYkG*&4MNt z#QEj3;o;o`9-(x_yV5-Rm1!G*Ip~=t>D}GJF#P8x-sb4noALCCgOAE=d&g1^4cGcw zaRm>Ja4~7lz58qw&>3ycK@(A|G4C5Tj>alCMMCi$)g9`p-V8P~RQ=JJiaGZEKh z?Rd-shzCVnk-0lt2l`$AY6~|{XT8n%wRbeY!Y~`!h0!@Cbx(J>)|HQ5J%Fk75Q8V|%} zeIG(ANM%#^uC^q@K1o0G#z4?RU&Gn z#$MGjJUu%bL56Rd3^?$T0@Jh_psY%0A{gGTGLkWCiAyltzIo18=LuP1HwtQj^h2xN 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 literal 0 HcmV?d00001 diff --git a/bin/Debug/netcoreapp3.1/Microsoft.AspNetCore.SpaServices.dll b/bin/Debug/netcoreapp3.1/Microsoft.AspNetCore.SpaServices.dll new file mode 100755 index 0000000000000000000000000000000000000000..f95e4b4275cdbd5331ce3d6b89a6bca6f68eb0f5 GIT binary patch literal 53112 zcmeEv2Ygh;_W#_wJw2NSq+M#3kZd*yy@wvUNdOTrY_c1&knD}S8$u|WAfgB=*su$B z?AXOdu`4R}27=17SM=$7&!_+InS1Zcw*3oQ^3G4ye{+^Er)A#qRs`mw@rhvR8;BJ&^-G09u zl4`tCpxH0^{L+M3l~SYZ@jBzR_8mqohOl;ji#zxL& z%%-OAUdPzI!x?Kr``c99i5@xPs!YaW^6|`4pV{g&hn^RUj$AxN!y3va8rM)R(X@s# zi3!FvJQFHNaT(Y$JkgS5Lo;AzjJcrNAyGD7gPB9QClCdb9lbc7XqkDvGP*9NpvcjO z$xdh_v2HPg|dN>P( zl`M`zRF^+mbU5+sCpy68fPVRdMMJ95lwfqkLMii8TxM2+b{NnOqXSxKjzLm9p0SpI zSzt{Z1e1Y~F|wfmW|Jkstns!h;bhj8`I#A&3y!bCJR$`IE%v7__x-p{1V~9ExPH z!!lh~b}t%gB>gM21krSJl3!~ zL=2=aX2(bb3**d6OdiD(P>;D_ih)$bERO~%#WbK-vPm98L9KY}C{rHe@Q}v? zAjbqe3g0>umuxDqAPO5A^P$->36IxI&?U!YgaVTcXyFuu%yKzka4JBoL58|3>=al6 zmm|vnFh#gHvpfws3^KITOg#{IfCx+{T!u9`1J8JiJQI(=yGY1T)zo$-)XnHXdt+{p zp~VB_QxHrsCL85S5Gu?_HfC^X^i2n94p2A9Fr;QRJ;joqVjVCc*^+F%D#a!y+pN4( zkP0&9Gb=#Lk%$mdR2)V&{mdWh0DUDf*_v@`iZ$7qY`M@^@<6@-doRLz6kVm5!xWc^ zq5ojrSaQH@gf1olB#I935n~EwfP9SDO>K_>Awr4 zb15z(gHKgNuO)x(OXa@l^_>G#QMUGagn(J#jQUJxG-AR$#l@Bk2L8iEIaNY@ZN00cBkp}_+{bkh(#07Q2U!2>|_ z&=5QT1mv#J;DH>azw>vg)2K=Ik#t~<&{TOTg)zG1<(u39LWhr zxdGH<=<)#Bj}WEIR9RUR6M1#>}H7A%7%oZ6c9)nrw z_w-`2r3HvNpiSode;SMq=#M#Y69{E%vn7VD>4v`D5{x(W?Vf;8j|B4#eKQj*n=o>O z8~SD?SZ|P_umdpAGNErUXAIh%d?pOKF(y6MY!@6Mpw5JOF&5^&hGC+b(Y>gJn^BQl z&^F3&D8^D?HanV8;6q-5+eMIOitVv7*H9wQm@^2G$Fxx`m?I7BLf|kUlSRjJ;0>=q zaRqL!58YT!mnxfofI6!C3007af^n8DW4Xst)4Z#CIz=SF}cmRkZ4Z#CIxHJS0gvWK9I<7GbVGJAB zOyy6-PE6t9v^A6QG_RtVGOn%4xF&>RCqN#0pfJD#KtO{P1P=gFsv&p)2&k@-g9jk{ zOxVuz@kIZk4^XSQ(9B(i{NM_7K#YQuTM?F50>loOVv$!N5a(D8XqDGc%9#N1R{1PE z(j8Fu0dhNnDMp?L^Ax40n9PCSpgT59&}$LzXHll@d%5yh)JdD`HM&UAo4%~7RnZ%5 zprZ|gv^MYn5E!vaqj&%aj8_H016onE)xgFHSff!}S7GcJ;X9AOBi39HFlUT-2XYWs z4F`gcO!;hZ2~W|&=Lp9-#2n`U6k08-K*Cs1Z&7kP(jhi^J(4gy9p_S(F=Be(7;fxE z+nSNcEOHZXH;9fHi09ywyedkF7gy8c_cU0|OfgL@1v(o*r@(X&f@GFe7$Q(w&Ki0v zM&1aJVze6_o2a(YVun^*vT+RthgO|YByV)Up$c&oVN-yo=kICI2O(0K(QyID9O|B8 z5_5l7xaRC8n;aKXLP|%p<02r@M`c;y4L=YDvp}wC_=VkO&@ExG(qMyQvywLxKF7J3 z>=L=`F(66yWq8DzhwVT)bH@CP@vk5d+=2q};;OMoQ@Y_|AmmE`;0`W;@?1(mvrWDX zPq>4ZE03*&wb(6=D-e*c1SoXc z$887{mT{$}zJYhSW;{K)BVo6Rw1OFM@CA_u2qnNZT}{v5)6jZFZK)h6-A*K}VzPD3 zI3UokBYf1o-9~K2LtI5j`3~ffE=9c5k{)-knp5SR-H8NU9{H|F{B8v0djL{m1`JM) zk?*BotlA#YHf2PyF(0F;`5N8ui|gJZB*h*9j0TIs`-l@z5* zO>tdnic@NebNp9p3b&MV9PmS5ix{_s}R;x+h`HLAvoY*K9?{hq$G%|>G^wFZintka6C>Vp|vp|rX-P};u7L4BquqZ0{&2H zN3_+k8`ykS2DO3ivElfw$L|gJMSJ-V;l~0%$r%>S9q_lS_-}N0Dzw?a7_2tyZshBJ zqAMT^+Xy@fAqRMv0{%nzuhCy~5Gd2(DUs~yG~njr7sf`jr(@7wgJTb89dnt5ZAW?V zi@A)v1q>W=C@`0`T2}Q($ikf*%PLrEqlMOFX2r#|I3OW2_j4_d2^8E5nij`c1TBtn zfZXAg_W{f2n5Pj?jRRFAVvd4O*8cTJ*}sveN+y!)ia==vV4|Nxzi7db_U%PhZyU_Yxo3*mU1vMte5T*Y&}jHJND7@oGkO@NAx=lL;JT1cn3 zIJg*+ExM^Pg4U+W4s&H4+8DyGu5U?_;kj~L{-+8(SYn1PIfw1Bd+fc~Ej@y1z1Vf;AoABB)r@gW@T$a( ziT&92?AG{x?AP4Z_#Cz_cY1O^HY1h7y(Pk5lhhiY&sJyEfm&bN^kg%0TQ??}**M|hjL$nz9fe@x3^f5cI#Dvs}!N~wP&ZA{E(-OY8$CG45>_pm=} zLfDL6BCbwN>?b(ctH@(!M-u18<*-XrrziJfm!$>M2D8sCr^F9u<=F$l;RiX>lSi}l zv8|b-*=Z@Qnd8`=+`Ho@u~PfS#L?`UT*8k9G~;yxVe(=Kv&}|1x5r+e-h+LRxfb=_ zZ(p3-gKd}ACQro<2=P!DPqkNp&P*nB@1JC6!EPksp4~lmGy8?}_Eu_H4>KEW-k8{n zogtBIr}A)?J(yO($`bma7pCOcK!0fNTFf`{9_+@% zwaGo$m{g+kWA4Vp9?TzaOPvnr+T*#h7I*o2x$`-&o|(SSrV85m-B7 z??G1O7~wV^dloIGSPYL{ZKar*&kjlKzU+#$a`a9z$|tdVt&IugD3!`%>v~Wuk!65t z607I26b3_q*!q+MapedXvF(U^5MxYY#XRRDIg}=0-L;!HW~ZdNo)w1C})G%Da?R!AA{}_Y$!XG$G+n+Xc>>$(Do-#Y9VyqDvktf5yt|~ z6ej@o5vQZU54Q% z#S@+95+6W#cj}{nFQ+|;)E9XEqkzTi@`Rn1WY#@rpXHRcRL*BHhyMWor?kyPIGH_! zQXQ#vrX#THQKP_~HV|*CP0s-iGQJF0!MUpEaEo{V7{>YUW_%Cf?!cSbV%udFGdpZQ z2)IA@W5BkI&yXsxuK+i(W58&6e(jWJIVMudX#%{LB?4|@sesRPC`FXpGIFeDHaoW$ z&!1uNkgl=Q(S@w)+4C-oAV@dJb(aL<9R@mh%lrkP^!`0X~vE^0^n-Y#yTI1MxJhp`m zvYl?lK5TC)w}lOrYON`(8;^mCwb7c&KJBBVZL&67(^*bm9_#jVYMZqO8_8qq!DkX? zvRWSdn{ZG3I%_7|#AEF&Is5NSVh@CKUS{pd2KFN=>sf*MVM8Cbj>p>BXF1nf`?3Q{ z8fe~O?Z^JE#H?>ywzGWpyBhmf4#muQoQk!I#}d?7PVR%&e3q`pF3H*?;g45D!oZ4W|yh4 zx#_#D#q2sYR-O2wwS?WG#u^eWLJ7M^i9vz_D`gLdW3O0C+245VZ$eD`A?pwlAAX)S zQEUY3;h>n(n`2miC1!mMT#seNJl1ag2wab4!_~B{=#?@yPL17SNkVKok6nTdim$EX z*!?_qIbudzIs1vnwy@onEL#Oz3=bSy$91WaHSieKK1`^@mM!On*IvaE)EL!X#WK_w z)jo&isxhj44s)onYf@gc&Sfq&_CSh7n9GK#vBN22tn*lz8WU1YY#y7c#_r1PZ9A1! zsIez<`y;lH$DU;u2rk=vwnI(p*KMS20o$p@O1h0hY?m7Q4!yaM?NwvHqBj?^m(*Bl z;&yn7Z>X_8iAjiksKySM%5A5!Pu19AQw3t*D>2pwT3*er7{KMi`?i{GQ(_naW31Ke zHZ`^g+FH$as!fLqLi)w6td=g@BC^23`4f~MCj==X7 z;N49rq}q=NW2_FuPE})+R?DuyhN_lU%WhL+l;&X}Y|IwFhbsW0m2E3Nyl!u{Cx6q#V9y831lKYQTB2<%%kwdg@hQj&qa zoI>&$jhrXKQ>wo9&mjSk5q$%D9`ZM`d(6~Ql7JaBY2BjGJYG%#rLazblq@{ImFKsy zufeUrX$outq}{PzJr7El=uQ~IXs2K`5d}A^l^9whpim8bGQLefS34PY9`yk!#g?t z6ydv6_+)(4wDZwo6DemIAZp>^Q#g#{K3*L6@#46T7sq|PEu2~^%g?HX$2z)OBm7Yc zXYp_!9`3`#1w359!>RBJE!bS+al&CKLuO*qVN&B zQWWAoL+aJiF~Hf~{?4{@K3m0eq<;Z3DdF#c&t(cif3(XYyvN>8D;17_!(o7zcN;6T zikC=}5T2P)*6>m)2 zER+ii%~uF7h|dVyQR?=@9l{r&e-FYmGaeB8SOsAOX4y_YGWGfFSI7+h^^w( zxIDm_aRq?0czZ{8D-pXJsMm&})g#1Vf<1Sf=oWHprvQ%2nFn}Bf=ArMa%`&s3A2ga zk+4zhZzuuJKM0q{?GTO#ZMm0;-Gz(OZxM?Pzh&Mj4l~4NZD-wuS92Z_1(Ez3LHt+F zlc@L2%%_3*$ojHaZWxyOAz}iYYjIs zXX<9do$RQvNpK6V2-^{^hdj#!^3LW9&eYw8D+NluQmD@om|OTV=@o-p2=Fk?1Un!f z_{U;i=1}7UoU6w#M~LyezuK0oDr z9x;5M+ugJiQW{`tH>^!8H9g9?{hAfVO)y<)kcFwHpLmVG@fv^QbsaF+q>$+apRejF9JMLmZc99OSu7NEHSH9xxoseBG2P^oZL8Oj6u3p;+`~ zziaxz(42k9R4fVzC%_WiVNSsQ=w7oG?_BP-E z_7PwyON${mlf#DqN3fRx$Ft7>r?H;^E14tKiFf=>fVJ!#z-4SRV36GjxQe|VTgK}e z&(20&ZXT}X_13bh*}>R$jyaoS&gPhH>=NX>kz;P;nB5$+kB1NQ@FzUX1j=a;h>j#s zTO=Ot&EZ&%8PCIudAOE`&*tz(4tI0>ZXVtzJjR^y`*`>;#~%@h=TA6B5GmY~!`>X0 zaX6ksH;1(xwsW{a+{fm`Zxe51_PFgFvjZ48em5}naeFxC1zy7NCxWhcmY&<`QV>w*R zVH=0rINZ&l6hk@3a=4hoHV(IOxSK;Mmh^Bjhub)u4lR9!#R{fNhP7)kIc+U%M4BoRF(4A2SI5cq?;QN*) zKx;0+`*R5P$_)X2owXA1%WT42nR6!KXB_iskF^M2VkUgQ1cIlf6Q(I~Bj6_-e>MeNk&Av_pRWFt{d zV50yB(94=Az;@GJ#35m3ZFUMa#;07bt4C$OoYEy6a^ zp5b&rI#)Cd;hBIU_6KSAumVtojWcs5fP)Gqoy=U1WwT5V(E2A zC*0*&XDHO@Nk8A3KBZSXyasyG&$p&lo(~JJ@Xs$M8*Sfq%GZNln}oTe@VBNQxa*v6 z7q6ou&vl$$N1hY;D@SUr_VcajJ*@dU)7u<{=ej63V-#Ml=k&DqJVg7b=>d9;*-2Jq z;kHp4{d{YhuJWvx{ro6A%W56^{+P?fN%fjIH2|}VH?*S+{-KuD*Rec`?8ox<5-B3` zI@a#*VpopB=OdhiT9PrY?f6aM`|#Aht;v*bWClCwj*)$kjMu$*-j`g>p2Pa-6X6aP zE55+0#aG#S@dI|BxShR@I5xzE>4s$CPW(P=s1#l{`h+}FrLY9Q=bDm*r<5j*9Nk=9 zUCd@SH#E3w8oY~(S@}eNbE7w)#;V-GWk8k%Tm7{Zp5YDE%bsz~z6OssfP{%>G`kyo zq1N$oW0O0;QIxH$#qA66m_{xnQ}%LysI-KQ40wZ0vOnmZ;SC1eOT428RaXN`tdy{6 z-qyM9hGy?HYn!K&6K zuWRu@HnQBmTwdlK?WwLFf=?~HfjT+RI6EM(Xsz&`(d-R|C}k*80&*?5;SD8J$uKr@ zhU{r>@Q!Act-+AD(OEuA3svE366ZvJt?Z$fqRx5V8ZBkK+|c0V3;*p79c5Nd*X^FIS^8kXZUIZa!{@dIm?1gGrghla=`1H zvAmX3Wn~@@<5HjF54!8Tv;5Q}4c?H~!+TsD8Asx_Xk&+kmusIiyIU!rRo~uJty0{h^6|Pm}EPhvoztbUB;-(28Kl?e_#{ zG&h8NU|@E0O@ptNCWk9YL4>gsXe2_jY*QMjAr zL!Wd>Q#hRIZj6$qNHKa^Wojc_})Xi>V7EQ$mdmU5iwBJ-z_Ski5DS zndo0W+l_Cyx~7b84u<5$3GR@aXFzubx@M~KHG1Xd&cfR9N^fAfH*mcCup?cXrj9YSd%C92^?6&M()4LsmqZ$~imheANN`Fh)TCl3 zdqc#Luhz>DoZ=4F)0p97Ju-xNSzVOM>!RF(c^P3VI$C5E#|@-vq*aT=BGUueX4vr{ zsSvAZ_J^Q{WOk=u`~w5FC^jh|H>wzFRAdZu=5)~s-a0poh7O|~Iw=cQc^jK()Uz5{ zQ!w688qqvJiQ!1Z5-6hMMx3WMMuM|3SHUcM12neELO9)0(;QN0gp(9P$4OKzbM%sG zmv=0x41@}dRBshbyPvaEUCW0@CoBmnVzhWObWty#6nJsScqY2NvNqsr3Xv52nn)D8 z#)90uvGOT$FjPi1x7JM-ce=06OWnoXQE=*Xr}ikr#8Kn(ds#W3hDd$9Gu*ZHgsOxR z>f=FugwNun0c;LtdY=b6(E=BNVwf;#wwd5v-Vx8|l!fHL2QcDWH=q@Aa{%tkbhm#=GaRZ&4uvlop`CF$UL#2w zlU2TuzC=ehpkn$G@C@}z5J{R<6O_pViD0VS0Z4rkraEtn99R}f(8Mr zy#62*HiFVvByFDyZzF1Axu4uTuIlcF=srGEZ;+3x4mBv9#Yk8|s=s9$&z>q+XXq;#EX5v4MM6ky5%jB7)RJK)ks9t&s$E$Z~whSK}kk zJd!%Y-Bj7+p5$(5sKMal`pbY*0s*p1e8BK=%R`t|l*n>&$T1EY<>jR6+)mSQ8`oS{ z=M7Z)R(jcVcQ8~AgSui?9a9ZRRXxTJdC1&=ktHCT#peP-b~H0iwU;P`MyAeKRfgoI zCc+=j19nz$Q-0hmXtg?52AyH+PPxezD3c5tN3%hdtVYRRszKuBlxAtv^VI%l4Gf{3V+nc#CT@e|$Jppy>}^j4_0K5W&LK-jH9`C`Kp19Ol+7BmT|^tX{kwvlw9_M4NTMChLaQbG&FD;G}w5nctD*L%E(k< z0Kh%xnRMIvFf`IBba#EUe&*_9CM5G*xN{;0LrPJYM)%pBbJCh3m z+4$L1?ksRpQO1OlsPA8Gv?wX#-TqoH*7h`KDwwK3E7pqCUC=fRZ=Z)JVlHV3VJSxI z%c()x@5G4lA$6sa8tFToUQh5g(Wvp)wwC*8L4-QA-l_1`sq0`?u8zIP(in~Ao~sU1 zu1?uH6t_zg_^OEra|0ELlKCMOzyyO-WqHA7HDTj|;!3lqH9f*<04Qap!anSm@5*Sp6NW?dxws`|I-9*S847_5de#!VJ3IJX+DI8+%vEZ3c6;b`sAC0!c^ z>dFSDkLKAR!?1=@hkOW9714H+cy~ulh$?F8SEp+J6{6ut)cn};bdp;f&ZSrc?x_YD zcUARL*3DP51HMMA9+!i6RSaa3by(78NP^FMB$E)iV?nkwI-1%a@wbA!+4?x8pV$av zeK@eXI)rPSqN{~YZ_rcR>2gw^J5|4}(BoZR*ce_~JD2`f=`?BEAl?8KR;3bl+?_P~ zl|E7T{CFd^FyH(SGB^-!?pp-0l=X+)K7W{!x*%~zIsp@Lr@3E6=(3RSIFDRiTI1>P z9rh7)c!-J57dlkf;GzS&)Tqlx%6Fo4ZGEJlk95V4tDtZwxmANNa-2R<7X{Aaa zhu+L-I2v5hwrM+TH*;-0d9G?%c@3fIzviepr*M}?X_6Ku8DL`L@2~VYeOMiW>lq(%eD_OTjjJ{v zTTi|v{N<72Nh_MEcLY_D212}AdS8NTn((@{O6K9?F-t~RdA)L6c6C`IuDr5Iuk4Pi zn!vY!^=~j(l-IsIFZGyO9Rk$PJf=FtdU6^{-7nCh;r^P{9BOI~G1y;v%)ma`OfPO6 z)FxC4SNjQ;@ntgaUc|UGXdF=gBVMlyhiPkxlv%eQ$XV6LYgHoHR^Xe`N{2FC=Q6x% z4g}n-tUUaJaJGy=-pUynCwr6tUcoENZ3^(2j}Q0An|P+!k}6q;DpyRK4x`G7wus97 z9=?U9=#}cDPQsv+1FhWF__4>%4-&BQARR`S6`0uA6l!HtRe!S;haTDut8nO1Vl51B zg7Dd59|EnxF(nBHCYzDJ37RUW7;aqU66A4j%A2y4=kQHtVcpbnBoE0;%rbBH}% zCK&LwTiaLv^OXkCRm4^Us+UkbiAv(+sgcdR6C|83lOU>kG$p{BLo8F*IDxMM-is%t z5;Y0UqI^V0h8QHoB%A=NzzH&?kxFy5x|X1{(qu)TBpewzNr{MVkk_@GLnnk>gb!?2 z;S^l-PC)mxU0=ls5IHy34Fbe%YOBGF+ zRius>5+i9|5suH1c6t%&II;>kb~z5kHKJ2I_(yu*0xkl0I@wb2B4iiggQ@CHC95I6 zM&x3>J5r=$%#qQmP+*0%oF0u_FFq&JkL?MFEyrO#>TsnKn5`c9Fs0z`fCkX2E{iAm(_2)9=^FvN<1Z{1^uwf^XeG`|0zC5*BmC?i&J}hXIw%~wbFV(j7 z!Uu4Qt(%IPW`RSeIsiy<9Xua#*9!+QM?igtGnUtt_u(q{t8mnkS~8GY(wq1u`2{hI zh?7FzGU`8%Y5|1gkw~T9^KluDMxTs?L^|PyT=?n_6Kd}t`{aPM`fJABfX}!kCKx3_ zu$lmp(yA zXe9$6gpk$G5@SEZ-V6#>V}iYpm|!29W^WbJlGh-M0<#mWkPEZ7Cv$VWhu>Sr$=)8IS@-$g25tK5wN0rM61DSWd^XH+`d7{x`k(L zYqwa$<>-mw&Gdxn}j(r6LU&rB4u zl0AB;<{8i6TidDM!E!eQNm$Rtf5Hm%Z%*-sb(57^0ax zfpYtKT1--0fy3Y^^b9@jWL@!#HdkdvaPmV-A_(eo}rd)rYp|51f`-tax~ zJflVz#vxJ}&+v>@OM{+gL#P;W3T>XepF;@30Eu%AZ-0w)n8r60(BA%@@;I0xDGCjC z(WvD1BNzhIEzsz;gQx?7LLg3+4}!^4KsveoD6ilP4!=pJE>#&+m`LmtkLBDdY4J%I z*f^*W!VuS<>jhgqe6Vx&I9vHwt1`0L+hDy;G;^?Tx8UhMyMwbFs$T0qx#w^*(Aq4tsJ3~Jd(bbEWYV1>@8!+4}cO^MZ-JTiGY6oztf<1O+g zld{{}|B+z5cTDwJ$#2CBx8C(=>(KrO?_O+m-8JiP_uX>$H`bR|rTnqK@Zc$J+wjc+ zGqy2&W`&d0biNt!ipsKLoNvalXn`FY-rqQD$2((RxWDJ{OOCEy_dwwJnX%_5^!W6` zB|Coo`=M*A&l**6XYWtXf2N!8!-to}Jh?gh#u@q7jkx`T)E*hnoq6mT@4?fLnx<`e zwf3=*OCK2%xMTP|UyMrJw|C&i<+JX&cjxZlsH3U#@4jQwsfKk=T^oA(<95%(`#+xi z>y}-X4O!QooB#S_>Cs(+UMKfzj5yBC9ORTXVdm^Qx06p5SreQvqnE7!0mT{bb0Uf! z%-6JD$v;shTK13=qbvs?XSfAsyH7M*jb?k>wFI^UA&F+uqD~T`Ig4!gH0TV3d*BEA|5Cvg+6B29;ZUN27S(wWN%r$*tm=Vte zD1JN6&kISC3AXA2d)pSwbeAQ!U5T&2FpRb**d=`J#)mnj+c49?OrVg741GHoAbTk& z)M@t2N<9{QGBcfR_?O5!=vfW6AG1tLYmmQ;5kP;WOQJ{Cm;|I2^b6xhMV7seS}2(TJcFG z7f%8rSx7=%92Qc7MhAT`WqvH(Zk1mvRu%-A4- zb#u;~SVhOvu_0M7S2?3KYI&)%7z7eh!^gkqm|cUrl^-R_84#uJa5VTsy3^)-}Xc=c#iK9ZD(QVYr54iNF#o`RO;MI8Ja>&@M`F zcu~<39CB!`an{O>Mebme-y155>}40>god~1&)0+7M`P6&1$3IuSQWsDDAq$@Y2mG0 z2~BR2l>-R4I!#~}oDlQ6arBUt3e358hZHrdQz~m{kob|XpcL>1X(P;omD*&1jZQ`Ux7uK)_-@Pdo!gF^ZE;M9~>Jfup+#s zIcXvN8zDAFV6(#<9H$og$b!y{(tEJuye=5f;ad+@Bd|sPOQ=TKJybp#Ve_HTC#^#N zDk^gPEWEonAlj!VH0+e0etg&^#DtIW1yiBRg-zOvyTV3(sJXkqqT;bw?UJILAI4Ua z!0a7q(VIL)sXOA;7u}4#iSLyhbpnb(h9a=aP$dX!D!Ab41{W<(@cBqV9%Xpa&{j3lj1`Yakws;*WUt5&mDS349w z%01vbQYI3TY*fSedT;GA$ycXwjX&1|33cJ!=BsnyrD+G=7ibkM>QDpd+5%o2Zl*u+ zbG#BxRpPp)quiP<+~JH`2qr}Gds{RP9XPu$VGCRG;lDp5OCiXdGu*#JaT2%M6{AkT z3H3mSayH*^wOqNUpkqqIa0%xcg5FMOwJpQZl^yaQuVYE>6IXa^ahi`auX3q%W(OKd zS}-DOCk~!BsC}zRu|Q>5dq(h4^rF8`<{hd6SCbmtOY|(cgHnTxGgY1r85N$K4G>)j zbIb|oRVaEuJ){arlIwI8bRerLjY>V5g6PB>DH#dzAw%V0-Kk1dc9P6rGfIw#Fw~Ul z>JBOsNe>SqXCoS^<~~k4A+|1cb{#;`XxD;v=OJ?ZO7Nx?A2djK#e$PeVQawW-FkPR z5g!$5GS*8ZTD>0Bt0`N=^wD=21uFT@0~({hXEaK3$Kw4vm$NBvVVnx@+KZBog$iI; zz2Of!hjW$Ud<@sxx<;?Eoz2AY1{u0Vl~{GPH#kGF$#6eZy*inU0#Rhtxpk0A2uH@D z(Uq-@HFAU0bJQp)kIvIjPkHjBe*M%GXGpH($2BphcBXPN87Z{&6i8zH5YcccPia`5 zbV3=Otctvdi1KvAX>fNYd;)RTYR0k7dZL`W6CS_lZuBcEs-$q zxYdCs`8);iGL>1+7m8l61V-A6PcDO+@N;)mmwhe1c*=5hV)YEC%Unyz&oD-nT} zbdf_(hyjis)-!qi!(QYvZ!7dm5k>!K{o?e1_W}v|3L=&kG4ykX9$5e!IiOB_zJ?-@ z3oq2aQ?pe)^#?oj;0cBzCW#4(JSOrl@xn~-=>n@woTgAezL8q61eNejdZ9LpK=a_g zb{I9$y2r2AWu;7KHKzVo=PPX%B>^j$bvh)C(GMJ(O`Dvku-XoXPIOB71>r6y2};9{ zPhtjdkRpj-S3)S=L9VuFt@SvRhCtKY&@m+vy_=M@4kYyz==p>pR8<-#EF{wibk@6r zvs(PxT*=)%eUWI)$@;EP25o_66!kjyXX}zrk|p9+ zHG$(^y>v2)6o`blKQ|rzC;Wp@pjDe5$p2SIM3l)~O^H&e&i{)rLe|OEp&!>od_rY0 z_@BTcU27Z*C?dI}d==Yum06&4Z3H2&$_)^T_&;c_pMD!om(TL6n8kGHmgLO7Bt zQ7L<_o7_UDBlZ@6czh@d-LkpV5ON2{em z%EG&qmY2MWJnZLS|1+{}L{qLbbM_2v*gIP4eYN#cBa|Urt#^eFssZu%QE#;}Ffi{@ zFHk=EQ^U)Pohu{<{oUc^B?J2RR}!1tLG%~4g`1bua}SalNlMsA_gC<)^o5+*oZ%5ofq z0E6?rawF6rq5{0@2S^TZ7A}PxI2?zrZf?R3o!3JnL$4CyI>V}=iX%_8Zh4X$>Y{w| zK|v5xcAc?tP7PJQ;=?x`k{kL{gGClL(a<;Q@S52?*&9L+)-J=AbAc3;Nl@WR6=nP{ zimi$S3~gwnRW}v~P>}%C77UZZk)rca2q{3o1zd-@l~9x*NDPpGjyK2^MdX$&sFCLk zyQNxuy@FHIQXTEaKqK6t5bY&moG6=J5kp1$YxsH+{T#-1HE|BwF(MU1m65%8?IYU) zZhK~M7YP~EuS_ej{KCyccvYb+#SqpXk}Qy-e9BcI;Y?{DfG_UUv#0v6j`-X~7K$eF zRq-(tq#v3hpyRb()tX^PB&Y<-_!UC>t!W3%7fLauV8^yj!lo~5d`~?&c$-*@;{!qc zr_+?taS~Be^-SU^+3R%pl78Ti?Mnv4c*~+fWB}!syVK>)Jz3-U4;` z1=jh8w|wcTmBYrP7W88OSFgZ?hip{! zobZ}mb>x-T@rjvq8%^%)#z><_NhR=>T*~y#JriY~R3-`jJ~dDngymEmL1+=ZLBar| zDpVh>qYZINc^y@N7^0s6Qr<+Y=rLF6tKja4N|t6R*y;dm73{U*Sw~@7^Yq|9<>{>< zRiYD+8dM+ff8e8GgSUe^V0_G=J;5Muyx}ht$VOnQkl||4bRO{Hr8K+-?y_pL9QV87 zlZCWb1{kH0CP!qi*Lb|1!S{HeqZ%66IbIDmN+U%TDS1~oF?rT5>x|D^=+|tmVmERA zA4Vh!1vo$S>94c4#pB>RHmYPG3h0w&_4xcluM074pi@se?`XD#hBWn>QjAU@Ov3gM zO~M$)w5Yin(3`R>376OFI3+; z7UIJWl;!$OS@{k)u86?A06#{Vu2kQXghW5uo)#LVjy_d|I*&Frqv|K>_}0rrYZ++Z ze+Sujw1JcU%-pZ_0rYl~54Qz!rv;-iyjW30s;G|Q!N4JnbTWE~yp9OsWPPNuPaRW7 z7br!FO0*NpcT6>|I!lkHpBd_Er;Dgnp(4vnxkYP7lMm|+d6M81Qa80b(NNyhXf4Oi?y3k6;Ij%oj`HzXVKCGRORR1#tG-nv@1Nqgms+}4 zG#)!vJQI5#Slj(4)pZ<9Xv|#Y0u^Oh3Y&pVa-{(}@kD6{f0q?qLVvEmNlnSUY~e5O zCz7>y^s0h`stg|TWqM(@()DJ1_UD$N|tb2-1FJ9;@a)z)_ zbf{?R13gQBssfF-D9c23b&q>J0?q-byf(^g;Bk0y)sanRYJI_N1IA9)007R zbgAMvMd=m>{ZzaZ>}Z8S7B2}@O1QEB8(}A)5@~~0UZbrqq{>?*N;#aWki+kV!+oPF z%5gn0{?Rn;qeSufd_mf^!<5}&Pf6L1;Tt|3@ahVS#sC%LOBUTC4Yo&F(D1!6Y{k*) zv=)aAse;HR6`Z~xh645!>6${CY}JoLgZ*_YH&p^O5k@Q=n%Z@XyX4PoadV3wWh-6t zGJ27R#jObTWIF7im;NsyA4T|`YE$avRWIrf_wqH|ydF7}1_%DHb8TcRw9|Ky5MFIV z^Tz*mu1zl<2<5MHZ93oMuXAmfcoct2f2cq|iZF=CF@d=zyRABHT@HpudH3l2>s%W- z6Mvm+;|Hjmd@sN|TREcD8aey-*SR)r?&9YhFu>?Q++XL~0$!Y5=jXM^1CGdu4y>s{ z`s-Yqc1-rKb8X6p9{fFdlyeS$oomw#plEaTU+3DC<6ZiLTC{$M$m;*yb8Q1V7|{P6 z=h`BN%#;wV#gz~(o0ZVOKeK@TkI%miqPBP492oSUR{mc){{}sptv_i*jx_D6V{b-x zG)&vGQs1TIY5P+Jv^nRiYgOLU^Ec!CR2X(rw2yMa+kMJ0u6f}zR8|k*lg=s8i$cmDnHwvC{eo3YyNm8D_sZnDjPq!z9 z8Y8bYgUxvH`9JecQ%5lJQd8|6u(w=_+@2cc^(Ibc@k(i{4U#0qAbnZbNvRg*IVHXY zj~6`A-evwby$z-Pb!F#H)iYIB)ZM%eYUYft!|LG-I!S^(Fa6;R&{B5J@d}oIdeT|_ zp}5f#qMC-mf5tSNbl*_j*lSTn;z{=O==<6C505*#@&4x@dTFfX?gy@&JHYXPH~q^g zrsP{c+xWrIOZ1@zaaehgR?W+qG|P z6>pipM7Z7I-deT$#vkza>lwRy>Z|87Va9CwJpLT~PS}m#8xT-`=u2Pv!;g9RePK6# zb!kA+MG_r;Dk>*b&iVHj%l9t(p#0X^3%bQ$;d2m;qUs{N&-c~gR=r>m&Y2gT?91dL z_4D*19I2?q=iWF1fKS3tTFlwxsbQ5<%1QH41ZuEFrlGg29D{m#vrlgb<&@2pr1ebf<|YN=t=!Q6c%_x@W&|I zIxiMSKc(xKz~yfcRb*4qbff{lJr#nGXW9$`>Ay8+a%l`LYKgm<6^Kn z+#y0gedx9p+{70^4!SOkt~S&zSL7Mky~eLmjR2k^m!Wl~^gPewLc5iJ195#GWPrcJ zIv!=|n#V?da|vBq7X*F^_-Me*D0Dd)U13Q4(3NgAxZ;ht^Z@#CDJ0$Er-X=ex{SpQ zEL{-iMp(HNlCFx=cqUqONu7kN6zOh5C*(H~?UQhg<6Q6|abA=w@Th&$S$dd1qV30J za^b7ukUj&o(Fz{zxWG9ycW`iCdiqto?C*;266Qt+rfM2&&rx^ zk1XT#>2ges3iUnpY~QCnxJIZ2zSty(`(j9(1+ANPyC%`^GmX`YQbm5YMt z`pA>%RcDPQIZ=D)$Hj2F4D?w~uXC>}eNO$2zl#mKK!2kd7u$nEBfreD74kWL87J!a z>*s_L*o})}kYPgc33L6G`2VQ{R`f>0M3K4H_V$@=`Rk{w|0Q0qh}+ioJ`Je3q97C} zy5h~Y#p|aCUV~8-Ow6^=95cWy7=^V%M8UXirfa$@Lx)Lp*$e{PX1qacW3J*(WsTCY zy)g;$)(N{Go^N~P)W1)iGa>J~y<1jKz2XDEXGM4SowsdU8{h6)Yx={r*6`UjgDBw2 z%Ti3$=LRwYY4gWEhx-yKMr2iHg;=n3W^t^`W;V<*;u_95mBlHpWQtf*V&>uUCajR~ zH)G~Kn&RWef0A|MqETZqUfmkM^weDoTdtq>{8RH+O?>^QJICys@YIg>oWp}}o%j6* z?5vE*lkdIu*)`WKe0|>w7nV0{IRB!3*PoGhU7yl}Q-)hFeD`SSrq}vz`t|BfeXq}b zuylOYtJ$w)@A>@Z`}eHt_0XP)Pd>lEdSSy8%P;W!T9fnhAZt!usDzk=f_JzTxR}LTeTz56XVO(KOR}`}kevuMQOKFS>o?bEW4NU9$B&_q}J| zdeercL4SDPseSyiwEh2nXx_C6Z`V#OU9c)U_^NTM2t^fcTq~RjiL7+xqOY_28oRmD z!`eLEDwwU%b(6_rFu1ZQLxM5gn7V%BuSSxqVNC8aJ`amj#z zgNBw49i(v7n>cDqo#OW#oo#w!?d=&uhV*){@wOM6#mih(RAsJlhHILueB0!06W5QY zo5pa_SW8QbvoZYVxv^7T)U?beHwBAo0}ZsE!l!P~VW=-@Z#98J*N{TjP%Nz*TyCw+ zf?%BEs&t*A#a-h1i6^Z9%?h5RijXUg7*7#|Ka3)L>yCrjuvQe<#_sn`+dllstKLq0 z{hWbqYcj9-vE<|49>d+UubnX9XYbkD7aZL3&V_?qLdkh&EPv*a*}G1AGG_3DL*p;{ z+H~42z9+}V{(9)(uBux`oN?3i+biyv6ZSK6^M#Sd4@LKwpmsC$ZBW2Nrhpx+C_u2Fx_TG462IrXk6L<4*rB?SuC>T=J7`ZmXr&@;2+d;@6+}=U2u1 z=Z|`4<@wFu%oLAa`_z}8E#JX<$+;C(OYYg&V~S%$)A~1eOV_`1`n|KSd-{>hhhP8U z(2L#ou4vsO_xxqzl@@#9ZD%eyd`*SD@8*Lp%Vi$#%yS!Uw_clJ8GhTvmmF)o?*3r) z;pf-xf3ff4luu_}JnYSJ&o6rG-?K_=zdW>RaO~(0`t_|^x;^30SxYCJTJq`D8-3qi zy64FC!Y8*Kd^dJUx0?nGE;y9*a{aXOJN71iH!tHG)1fctzkFr$nCy3sy?_0vZ?>Mf zW!61)Kc08+<=8Wi&ThMF%aVrQ`|p48;G45vUHZ-odmmjmU`ySyXMIn-?SH5y_HkR; z?TgLldLP(3tlM)F@9Z|J=aE&v-~X%q=GlurzH8-AN4+b)c;sF8g`b}JZfW7a-@5zE zL0@dZ`Q8iO&)wc*)8W|Dmlm&GFz(ih$JRfvYwfb4iwv*-{}$5|Ms;> zGY0PZ@u5?DUOz4~f7utO&A$B+^Uxl~@?B@`i_1AUWZAR!cVoXFy7x-+z0VJOOGqsq z_r`|!R?oR-Ub?tX!#&rPU-L!%>92oub>)3A1^e!KZ^wYUSK97*=kob4F79FaqHg); zB^CYbMW5Yao&D`he!Wj^2Ys!Q9JLu=i;GfzJ6_6 z!Ot`2Zs|Fw@4jJv&smkbu1UPBd+&8G{j|%l{(@hszkjXbsZE!j`}ppjp}y7K91p#m z=NQ`eieXa+zq)$o#dl}*zI8|4*Y4b0|i*z{&+h zZ}tA9X;I=SlUnZol^uEfPH}DZ2fNeme2hg6r@3?clw2AMe@PzUrH|znS(~dH-8e z9Jk!MW=Y%M&aYWfeP7YKcjjHQ@TnGujW;{d>>LICS02pDw@m@k!enu6X_M+vjbH)uzL5Fdcs3 zN;2D2FE33n!VzP-`7i2Z)ID4vRW!!s#9*(2{vgG8R_2N&bDwA=GV5K5VcTzV888KO znC1e7!^Psw;~z~m%{=nutoh8nYs5_Cnze1lwrT6j)maF$Ro7{b&vEL3 zQ$7=6++x&Xu!bkQYFBA>NeQ3qPS++kOm-En*{+#d9FyI+6HRtS^xf{s=!abG*Aw%S zv3;wn{Zd!^maveV23Pypt}$A5qL5yCqUvb!_Qh{Rh6#wS zfjK2owr*3R8e0-FwgqSlq7@r&K`hv5b0_jwKAci^Cxgmo-z7h;zxj&8RjoaoZ@e2? z((CHj%af1PUVP=a%h$Z#8n=0mx7t}S`qzDd1C3|@{^Xd?V_qEb)Z`sE9`k)r`&6$% zH*a0!UAKA7#!0j1yc>7%>eqWr%Q`l4+{TL6?)~?&Pexmu{jdJpsLY$+d@#G^(qSKe z;dx=gs1+-FA4^$t%jVG87yR^6KXFq2-t&_lyJ?3h?&@#q|5@+6Y+L@A{AH(>*XG)M z{?o3w{L{04+I`WnNdpf3HsZA>27Tx6d-u_M^1gZP;IV{zu5@g@Vn)KK*dMJM-p<`u z((U8#pDBE0!F3Om4~uy=X796i-F@`F_dZBF@05wB4lOw&ug6(Cf6DvyP{DA?cg214 zH`M#(TOSVX8*4J(BIG+puN{*zqb_#${WE?(a?x2?a@v}Sw=O?AHs5>WzC{%^>-S~X z4&J){qxX;f`eXX`tMZQQzj^Cx-!7^x`(%OTnsY~+Tg(T{JDYP;pLDw){QkpdGmTGv zRQ6ngwO`DQ*Wn1oRtp77RufBQA#Fm^v&%S=c z4cD(++3TNEF3Y{+Uz2;c{e0c8Pc3_R+SZT1YF^Rf>o12~+1hQ|A8+5^yT18v_x$s> zjbFvKed!x<&u^}8jMFdt=%ePw+AX6FTswE>tf$)M_1eB7xuoaH@5*9!j``PZFW&}Jx(3p?>xq+*>HS+d3!C&2%V#M4|wk%GqJUPkGO zn=gHA|OWT zw)bf3cDymIA9h%n8P^JI#~n#Gjem2~gO7gq%NIB0N%>RqZErtcK4$6AeLs&%%*(FZ z+y9BV-nnZIKDPdst2W(WNWyhNclSW`~JQ4502j!`2M5PSN(mMYh=@)8NYpV+tRnD zJ^n)NPfgA@2QPW|;*z(Yzxl1!r^o&N!|iEt53M!MU3}5S|14N;PQRkhSvOB^&Kddr z)nDD&JpL`q{+TzV{(946n^qi4c>Mfh7sMYFKfEq6{qRK#wts)xn|FQnufnab?aS?1 zwKr+r+i@*}-gs@=GPippMUVs_O`wxJ?hGnk$YU!DKw@JGvT~ypGKmK>y-5D7zWA5DR?6>^PPepU}@Y{aa zc73;$5*Iwgp(Vv7B_#t(204p|4LQwaY!ii_wza=@Q~Q2b`-}fAZfRdvZ%ijxRAxoo z(lXqP2Y*zzxGe7H>Z4@KuBvzAaxbZ>vQnB@Idgb%$++=_6HCh`77iIWaa^%V&Y&kp zw>cD6hTM%!xT%N#Wz21B6Cgk157?4H%7=XM)X{U=hTfd}=1YqXO#1TFFFt(p=6UDly*YEjh-vHOwreI|e&^PVi)tQx z;9$2kuTQyct!Yn|bM$FfOxXBxch7Cho*y;rSlsqY-do=|{PO-AAGv<(5!;-cxDBt} zw)~2*XU@E?^@1V)7`kGv`@p*ErLEoeF1+ZHKCy2JuYYxSX!Vopzn#4I=Lff+agFI| zG!YRS zH7XDYAPI;diqr)bDNd9uuuEGyqS6s$r3i}DM5QeqD~R+W2n!;J0f9FW;h|68^PIQm zxM%;#nLB6Z&dkld-~GPdP0l>2&}r^J`|^SQT$+HUS&q-KO><*e#q+kWntSzU_~gS8 zzrQQSMcrUewX0b%wn9)#ZCPVuDUK;s4UU~w!^P`G__AJjw4In1{=|(wwo$bR#)QAw zf8OVyP?dr`F~HFnFj;n^h5&?Jk|6A|%0#}+jY7Q@8eLFFWnvfL19riDaH7N&CkHuE zCREi~DMLU# z3!Us6BBOd73kM$gD{dCfrl1Tl-v06Iy%7~rX;R9v1ml=`+T(Gby=7K+GSm_zHEe?_ z1gLI>bsK+CnZ5*%#(H=MkZKWh;*yE;12+j#3mR!sO*+`g#B<~d<*>hq%-xB7k|C&k zwvZszmOmfWW_9Zg1R2`BE*Rq`Ah9O7JlQ1W`r)1WbBi|xX%+l#*AR-u92Pd6Nh8gZ ztqx&I=HTT43T+2}PI+;K!d*WDg`Q%=ioydlXDw5j+Ga+cwIM)ZcY%b@Yz0DafwCVU z1j}cQ_4k1g%fbgh)B#dD1tlDgDSWu)q9U{Son`rdDOHvTvdoh=SXFH7Jzwn1od4;l zGwwzkAE$G}C;{{1KK8mlSXJF0B;WJ6qj5^ke3Jk8c2>-`eL{lKB28R;p+025EFaM3 zc})tuWVC<%Q~hFP&Rbe9B6FU&0R$OJ>H%cS=*%Iou~LeJH6Yfb3TjyIYcy8M>N%%3R zJXlL#^JptiBD;p2|I8^GB1YS9qD6P%++e~V`PZksWw|kv9R}I@Tk1R*;{rKbPkAK$xhU|_1BzrS|YVu9ln`0>OD6+4*CvGq3 zg4lBcrTZCW<7bQroN`Ag z+Nk-v$A4{@CZU2o8Z}_=Wuogop|!C#x6;4be`>ccaj)=H{7*U& z$6&e2JX>baKY_OGSw&|CYMS2u;SF=r1+=9k)SJf<=`mquJIih_u=YA%!|H5bFwR9U z-X089D7Cgqcuvq9dEFF$D*V?a2W$TqRXXb;WcpObw(7XpTsbf9ct0^UMSafSH^w2{ zE5os^H<2OoUin$nbags+3^lF%s^Cplt&7D)7cNUEixo)^o*bKkHxz@O>V0)?myi{ptp7bw1tKt{dr`irQygG z(XGnpvSw2@`3Yna9@jC!wO#n}EkB$nXGw?B^M_VpUG9NLP{|aQCJ4zwYpYQ9ewX~u zixVl5+|Z+Ou(Qc+K(GiR_+h!#scQD4h*$TvwpH-95b)VHrKgi1HU?fu^ZU;8)tZ$l zHs~#hY_PsjM*~1YfM+%TDd2VkSmNpqEOvPZ;0cM#GGl;$j zmJuKbWA)^V-8tr}e6@XIDuNU5wtMbmYNv(vtZ#BjhS%Z}T7AF6Bil?t#ljFe%~WqN zmX2RD0MIMydnbr0k2n|1D)BWlCCRQa$W3}MH=htG|2H-_J}j@Fxf7(Njjg?d=^i03#F9(h(60O!_J zz=FnrqX0MzfCB(n&MLOZdp43VQVIj$(US*oY84KOyIyyl%nThr?PWh#I7|Y-xWBi9c)=A zLf{q9K<}Dr3`w&~l=3tjx~En?*hQ<3s5|Uu!7+(za0%_p*`j*dcEM4(QiAWCB`ziK zgoIp!Pxwecjq4@>-Z#!KuB|&Tzn|^WwnUNv>ru@=NqJYu3(3CC_v8BA5+*I1wS}B@ zE}XtjvtS}rshjvCXQ&w;6@RCGv4*&bU4~y!k1%BTyQ;>ySxM{I zJMSIYh7ES~wZN$_2Bg-{rjr3S9+3RQ&XO+j&*W0Lh%Fx9oW{gM&H^sAlDGEe~1Ljkp$dyq;26nUADN^^L-Lzg{0 zY&-^%UdAdnV5@e7Mu!Z87MP?vQ1ZS}CHegY=;5;NdW=1Ks+pjuF|Mtpt&H9#$SgRVR?G97_d_T2d_J3H2G! zrUfF)VEmYBV90Z0m*O$RpL)i}Kd4Y=nXDhuRZOozt4Hj(RjFVidzaZjHk_vZOX(Il_E?Dv$88qCcGo>4otk=9^HE1hJt zq#dA%<{hIz)6KzvwDxlyIgtd&f{+7QiktVaRfhoG5Faf%5&G211N)0epaHe$^y~Pi zZws;%tDhbSUt_YlR>wR~PIKB9@YrN2b_Qiwv5>|dp$zMl?cqSWw}rv-KoO~3BM9t; z-~pRNMSem`=u7#EK&jZ0@LF)`VHQGAdO3^MkQ0^s4;~dIH|tycIlpqiXjbC z0=abV9vcPkv4F1!0bC;F%1prV1C~Lg+bl6Q0#iqC318Hl_JIgy3*A1J0aSy)*WkV) z&;;%BaT>Zo`&$r!F2ipuIW7afbQ%<>>x~0T+bcG@OkU-%(IN(h0w#uH@;Jv5*?~gX zXcZ`tjW|pWn~g*a4C`o^OvA?{&M~IbduUh)IXu*fH0H9Amr)jrjk+NWJD|tFZ3+#a z5jbZe-L5MQf24B=P94ALyQ zdUG^{6$~5}(j0PWxS5m1vPEl&OpvoZ8*^CA#4rKU4k(Y7&?Tu-vFWmjbQy_^(PF4^khK`sW0_HaZ88K>e7W zknRbPKt)Iha08-g5T?1#3m}sPz!J?y(L^wmmgulq%q}DY&Cy|Nh$NDQsv5EWPqeG5YlbtDYcZme5vEk@$|mx>0V~&) znQ|O}@{|r6%jpbdc+MOHPe!7A0;lWf*>I>at2@8A$xrh2G`3KeL=3t`Z7nQ0 zo=;q41^&|t<}?p}GWdaKLt^;#gZw=l0%94g(Ux@D2_O%N05(HGGz_O4RRm|B8hM&LQnx}OQ*d6{t7wJijf~t zK}*<+Fd~A9G&-Gz&NF4uq9v<4AUhENABkp$AMkQ|^3 zngGxf%>?L+eg@b9-3Azmo&$_St(iiUil(xJs1I5WP=bC1n1|i~R3k5T7|k=1h689= zj!ID=yPQsspkWmam!ivP0^5~129gXQusjlC1i%qAtfJvT;vAaA9>6>R`QV4r{;!?{FacVt_P3FrPc3GKfnqgGBB$PZSa=$;gP3sSD)d zl1RB&t)?<46w+C$iIQd(=Jb$B2Z!clWTZ$Xg(|f)GFK+gQb`pbOBGU;OoDQxnvBRo6?9IMAXbQTq*-aXDycXt zHVafF&&ZG|WEz=R-k2G$6lb9nI5dD)cvcpQC zP@$0ls+A;OrjVjYWqu}pYc*X`&`4{*L#SmZg)S9IVWgqcqKpiXUqja~kjbSgT2+vd z6|R9mKeG^u5~YP2l~|r4)k>|77b|iKL3vFSv>D}KF`M$j)oN*ero1FgrZLQh@dZsN zRbWaQX@Xdi3qm(lN)xMKjAGzqOgdPp%4;gnwjfn?k!58`6;1ik#TuzX4T^2b(l;Cf z-RS|{{AyvWB3r4-r-wu=|0dNZL-%D1QBt);B`d(=+Ef@N%@!BRH3`spsj4ZPHvVY2 zG#_j)5xS>tDuST{)zh+ot%-~2ltH<^L&++zaEYd=qP`$fSx};q<>VR^C5u6a;VPB5 zAOfJ(Hl;TN4TNP3_ri$=<2J`XF$jBGxNt4BzTs4+mBP)`k zc(Ga&tH_cTCuM(TutJ@tVFQW4`+#~C+9|5tRH8JcE|FT8siyatdInK4agIW%*2pAk zA#DpNxlo-;PiWjYm_POex=BXo0Dn*dXq(0g43j{QJEiq5C_yGsDb>nsjj+*})Zje~ z_zAey4!DxnivuY-G~^%rR{u@xvbG8ZO`REyvq>wGH$yQiHj>Z+6} z{s|F)lc7Xf)k{9f`jjG7t5__MKB;qzDbj46V+85xKA}XVCbh7jK&gUxA6+bw(k6|< zRXO1M!CVXF@}^wv2+_8plBtynl&mb!j}myILAXWQT*4JuV6jEAEUD@<=^L}PylAfq zMA{M8W1n_MpPPw2Fwi#kMdy=*dhew5>ngm+L`mhcd>QzgMh6RiM_=k+ z`SvOzG+e**blRS@)78>qp`ozwXmpF#H<~tR@-t$*#ui~uiG&g@q+hxg4CaHrN4i-I zrisVnz!t$x3h2bfXsx&e{zdARPRamVs)0^07 z*CT@o^y!3bnpmIarzn*ggR-x-_KDqpG86TkF&Ij%L(o~B8Wn(RNR{SbBUYp6Vu()E zwBNy#4@Oaqq+*p^CRNdCXh3wtvu9#?=cfhB@M3o)){&u4N72gGUy#|Us1 z4@tJQMKsQVLQ6zCAYLa(qHgUIu)?jeJ&$vBw~0%NH(8jb2++hFxVDWBpXhkbsc0| z2uzz1q(uvh7TV#(qiA8p=OcOuw0*a*f*mo|zaE7%PpIPx5C)tJ5Et@ctZ8lH-8dG`OVBJYzttYBn?65eA)zIh+Vp8ge2ma_0kLD^{W({=hlhI>Jg#YE^K_NCAW^AkjB8-eryQ&%fDYRMLjDA5Axw-; zi&Uzlu+3_xi(ESv`3gnAfN#~fNzv`AaZrzJ31r>4iV2`D#8h-R4;LH+;y`F96~n#@ z`4ULDzeey?QlTJRE*H@8yjq}w#YI&l&4Mexid;Cw$}|i`1N`<^cP>4%4usc)-oAMf4H(0kn3w%Ef!v01TUEKCJYU+c;zfl#h z34f!SK2AnfaO4ETOi{u>A4=%wLs4+`iH8g_g@K-;_U-*7B7d>O$4?UA?=SMr76)ZZ zMA?4XnVA7WnbIJ!kJwM@<4+q~%SJ5=usI0~!X4yCAn(TFZx4duki*>|fml+77hJia z6appu6ZJodpqkqE{K|<6f>T*0y`Mog+L^$jV|lKAH0Zf;mZ&9(vB*AuXl>f&9r;AV zI(v^%3maZNbd1j$oFW;Q*6V5vvAcJQZLXVe(Bt=A(B7IsPXr(jL3WuKyF3~=C(p$o>4gAJLzzmR*3uX179@Tm!yhj)gz7-HdU*!`)!m6-$os{`h(oAcfZsYU|6 zL|jk+R`g%xA}q+tM5$fEef$HEPRh-CDX}J!d7}ca9Q&z;5Dd1w0KL^ePjOnH$3A`E zFrY&y1DsWqT%I6??P$IlODYxOov!xz=muOqSJ|iR{-41JS`l#TR{m+1@xp=-e6aCF zKBnsezn%l&dntTjt$T_&;8#!&h#oTlM#E`zD%=St!3lK+yc1E3_Nyzji}~bF9FSze z39r>MKL-A43xDJUpLfs?6CkNe>t9ijAb_hF;?)?4Smh9##zJ(O4RI`fTycy8C*LZd zP(Z{grz2TyluHw!^~^f@?#M9a{gTrrnudaYYybS<6diPc8b}G;$l(||-!Lvl;ZUxo zqiC@~T&)K4Qi5y(xYLlL5;&DF0(s=95HJDU!HA&;DoABQ3U+Ov2?5l`@p(3sA04@^Xp@bYPhXy_ii$=xp#u2?5N--BT zXUvD+`FG{gQ|Nd4YppSU0vp{aue^bwrX}uLeyZ@c7rof0OVSN63^osX)O}jum zKjPueUT@#nJ{4e5iSWjIK>U0;)&kl(RA6_?PplQbm4O*UG|ti};Gm|hQ3kYnoBle_ zzhkA}nt=#~foE%yqX%t6dfUhC`-1(8=y@(gfyf6^Lbyf6ZwlVHAAV3Ddl@`$RPe@g zxJfHt>f~Q3zYy$C4u9AI3qg)}kRgYb0MFS17$3ZI&w<^#254%)AABj#x5h{a)ZsLD zfdLonwN&(I;ocTODhpbM?_g;?B3<+j0oO zQvb#iru{yR>H9b8{{Jff$7_K8#+@V)Rp}yQ8+nZGGWxYC!6BH$6Js!2ov?&4h%`)OOc}8m-I;7lvU{q?k}}5#*OHemR>L)Hjz*~vHKX`A zlVb^I6~Idx^6Lj1B6q4aE@xOeHf}}X;3G>aNR{O%fU6)mGF;$8iA0ox zjVWxUeJMXtpl^_0``&q^!Pqe>2{RaLf=5ZpD^3=ennd2T zTiUN1+09^7^^yHd10pS?OF=woJ{fO#i;|lygN-s)w&ayu7VN3b~{sl=_ z-#(@G>Ql@)Bp52Ow2~MG8W}=4!dTn8FOR%|M>ns+B!JzCh0iW5NX*GJn zn;e&2_ts>&opY(~u;oPelWxbTWL#{{jHNm+i>4w)ZK*ccc#JI#j>3}Q@=1FIE=Vqf zdnlzKMJ7>-np0Molx1n^<4aK@A5TC3K;J-rtwb(ZqH?P)imcnotaFvCY}&VX-kiVk z=R$H8m4=&iWF}B?RBTn}s_4;?xf)GDu($W%!GneQjhDX?WxjVoo=jPw_LivRc!LgB z3^okri>)^U123w*7ZoUka!Rc4GeI!BQ>j!pJx-CMqyJ$8&@J^pXhK7oV8Ja3;vC5NjEt^>Ec;DvSm-hGZv3--4&6J4Rs6c_ zc<({AiDX3HN>-M5j{0$1(|#e{-(>ZGV2!F2}-a<*=M<^HVI`rq)xOSy|G=G5JQ-3v4*SE2qzRQL=EO zI^)_;l_!378(?`WX?oBv5kK`i{~^i8==GM;0OQcht=-ZFF6K839~jls=hnOlvd1&` zU0+1pTv=adoYP{NXF$7#X2)~mVps1sdy;PRh}Cev*YUZ9o$N2ZxU{I_qdCK-C9TVT zKDPe2@vz&;l0p4{)o4?|wwmKNXJRwtf(YgnDH*N5|Khxy+d2RB`lE;%l? zop{Z-|3Fb?pNQ&|9iumGugvqF(qQLh^T!!xVCq4tk~0LBflTcZz!USQo~74X#%IPt zRgC?&xK{AycuF!X+cvp=eD*4c#Mj5!GPq8a3c?FDxk?p$QPQ{wz*5kjf|FJMASwti z0s%BCqA>a&U!*F@FP8%nF9#$n2QcSWKYgoeW+(iiPO+-8S%Tm8=UaL@EsAL6k$10m z@~Um@KwD<)_TdLi9O~QW9k!@5ej2!cE_?k?LFWl8QN+1%rX^WphRqz{DqpuScK*HG z{%5bwOWnY0cVOMGHJ)pS7_GZFyVuVHY+3iRi+=M-X>H+scQrTp)W)c-{pt=18HKBJ zUmVMS5!`oi^OrH(uLWkUQDpfSuc(rkd7TTJ@#ba&$Mk&PlI5{&@0#wevK+j7X2&P* zZhH1^=9tjKeaR5jHH+Y_vHj~FJ&K$*;@8p*rK4N@8d^KC-*4lRM%q4K?A`0u)DB*2 zeS03-8v3Wtxs8mDwHww=4;*%OL3z7Zi9Mz{`MVtmQe+KJ-9F#!hn6lQkGG zA6|ewWa%t>av{jJL5BpGd6gSyqG?}@1DW#?#~|OA8?=2Zc14Dq-*3o-;tNrkF{x7nD}z``kgUV^6$=GyD)a5v3@yx z1k2$)su|lz7v)(KObEn~!TR^r#i(Ut1uK$i;=qFwze3ozM51uY7`uBjCT265GHdkx zEQ$e3z$eR`$}5-@O^y7~ij{c%e)SR28JBT>RBv3vkqIjil~k2b6*oFow+g{(_2n{0 zuW<$156bA32<9!!T9~Yji(Llgo8jX_FLwR)iyJI&Re2i>HdPh zhN@VEg%>a@=1>(gsfuZhN)j@tiV;*NeRCwy-1o1V!;5#8Qlj=QfKOE5ds0b(T9~WJ zr@|T;kd&W;kHFsGa3F&|kdedDfCM&=8L*Yqz%~;fVCb*&g#!D}94fu~<~$$0{JU#u zCAPwIb($RKdB(HNuS=%SjhJ0_w!~!WK52%qUFe$wsx$c`{@mT^H{Q=3_H?dU`a*VD zvd7tf`J8^zkyFbi#3XmGGnqd0tZkg#i;##3DW}(e$h#TJ5w@Lor(>(-zihT2JTvIV zy{w~A9gBy!ys#`=F;z2S(#vD5$rz9QLxx_bB&mu5ebBM<b)WNH0>7j2bMCkcjt6{N+<1D( z>tvsWn_`1_hk5%C|FHJpRkL?!SGtg&H8{6TvFWbCnXcsJyeYc_4xLk#@daLF@ z7>m7v@Nf^U>|~jcZM=75!mI03hTAEv%c84`ZijhDmmcVsk~#W-y(D1H=&P4rym{Vy z@%L@6pIAQU^y7Y#@SA-&^T&j;2eZ$xYYQE%c8kTEpI$lKin;r0_z}MQ;|8hs!#Te% z?mN2^0vm!x$&T|*!JQ5_H#>G#C^Q5(IvO=&bqhnCp<7Nzc1^s?mhL089({z)xvzq zw2o&M^hiwFQ=aa;xY*psX~>gsUTvp$D~~Vhw{P*-dFg|CBzB438*y}AQ6FA;m%I-p zi}vlx&mVX+MQv$1B>9A>(z*{-X`K$+KdNHZe|q8i<_^$cQ(9HAmI4Q)+Y=fwL?(?v zJZw^7pVzcyH5Tz9{%pdnDetC=Op!BF@a*ae*3tOP9-HQ{N7&>(J9Tc#vAL}s&K%58 zdd)e+eJ-UU462)m{3xF)t8$Ak&)gQ|u@8|9wA50n#_Y91C z7}xW-^^i>)8k&z2Ygfvo)~@sGrDLopgd?^xkuoUA>|v+%a&%@=XW!mW=06lGO=k zp4Dw%y(9Ae)PuJM9q*s#Ho3m+a#+p@o5=Rw9d``LUG?t8ruYzlhK=9D*N@k}T3l&y zo2s<9-l$v#gAi3(oPoR(jU$B5CM#d*}98XjdVW8U(SkeN) znsuy4_Tn*!uN+P|3%hMy6(Sxgjaa&4Xu*xxkv0>~C-)>$t*Q&=kNtRxB-t4qy_OQ~ zTUh!~5FtXK=i}?&-p5zy;}_7IVwRJ{%c_dg%PLM#6+eF(mgDukXF!6ZZT9f$lTQs!BfSkNFIaWPUX`k}+9TthjPKB7Prz zBx7P|(D+DZ=%)(!7ahsydd9G{|Ek2g0~rb*$cTbOFg!l+Pku!K+5;Jpk4T69Uo}2p z+g}FuhUYx17x-VieLrpPRFAs#SL>>ZBfYs>Tb_UGsgTS0U30kgDL({ub-DL@=&lzv zAxC>~Vy!%Q^Ln+rVBD=u?IrKkk<&M>f2PVFI=l8La@*z_S~|(p#j*}A~HdWzy&#DZ-` zRY9+B#`@*)mrTiz+5M``G<{&(3N&S75XKrs1h0!U8NG?o)uViM{GB(Cr8jne5{;gh z1os^;n))KLbZAVgL%zAaN9A{?dfL_@!|jNo&frbzS~ygxs0vBW)aW13JreG?4sXVVuB3JDbT z`e2JrPK(r{R~v zO*XT~q?~>d^Y-SuxGm0CYCp!FsPZu#{i?R*#0hh5MlbxMK6tIHll8;1rP0rX;&;E! zzH>FKqe=J8fm=J+OD_lyCcI0}EL(Q9 zTfcO9HEf(pzT|tVl066| zei;1^yXAl6scP&^cMdimA1rwI-g3^Xx5H&K^E7GA&M)Vo%2Dqg4b6>fmvQL8ZSnr1 zt)bbTeV$sUwqc4K!&}+TvOj5LIeDm<>QzfcnLQgYc4S(l$;E_if!vJ|^)uF7P*drx zE0;!_p1%L8bH#~0t^<5}4v2Z)v-4=5kq#Ph&a{k*wAxcM;-~LBxT4<~v8BTOu*ejf%qc6^#%xMtV*h=j0iXUyiaLvx0|%HGSE z9X0I9>9`My+u#3OyYl%E51#1hr9}3$En~U=PKx zC_eFi=iZ}H{rWebPq31l6ZD?y4tS~?f4K$!s%!d}Y{Ad}-s9Mm-9KQBlr;0(0 zjtiD9c2aJ9u;TbD(e6{M8#RBvP0w#hZQOq-`{=-{ukJoA-gRWju>@ah`H;O~tWlqcuT09v(hcSGh@b z!v5v9QG`SJyH?{o(tWw~a`aTo@Puol|M2*Jsd+YaZimJv?y98p)!gykt&TXY>$Q39m8g(8$%8H~ zK6|M9O<6`RwesidScYZ?)=7K{tn#j zmjW)I%b3!j85?V{xRN{xN3w9Y3VZK2i~sN2PAqZZLDx8JmM5P<+A^%sF~Q5Ujw=|) z`c9fKc>cSCew)JBWmRxCR#Coe*nfDvGPs#y!9UAjp&P$_m`ypiFl*fZiTnbofZmN6 zuWEBYqpd31FUZo|tpVS-^1Q=8&@l|x= zp#|Q(l2ts4i>om>iv^4IX<~GhVQ2y(Gb$=jr=#3AueVNryrAVqS8GwLN_+MDE|%%l zZ;BEc9xQ)%VS-lTTALY_N-(*hN zwHUXUJyc$a6>-k$z_|`{yDlB=jVe^eL%V z604Y(nq#6$hAHeF;eV6?7CqxXJEGdNq_1pU4bPG)iLR7w#B&&bsdGiHn%Z1>Xg*HXp7@3)+yD&86}AiYHu_o<4zRK+c-Vi!{| zVruiY!;W9Px8>uNJ0{Eay+AHAdVb&iTV%pE`JpO#z z<=ppu>)r1^4{+Y!r=TeQx9KKbZLjs8{c`dAvkmqqle2$~@9%y2;oKn=XH55n{<=i< zYIaD`$nkzdB?;1=KlH=BX_{Yl4P5Pa=SigV=~+o8Pl&xEPtRG9K5^a;aeG(JaG2Sx z&ZqWhY=?_c`xuF-f?Z~h+V`2Q0V9xL5>Px4Q1QO+8*fq9 z`&#dNy+wCdT@So<-PP4ybwzhq|J9QO;`M#|-uvF~d%yR8gVWPhU0q#WU0vN>Gclph zG(;hUIB>szkI-&-;wy|z|8Y_d#a6BNSfTA^=bU#F@#mb=1}L?nB8@svBP|rkq$-tK zC(2QXG{q{BQYDH?N);8V%H~PE+!%r7XRm5V0pDg4f_`O>!KCLf5-4N)3UZrXB9Ka~(Q0IX zWM#{S3=MZM+$L8T43}7=C{P0-mKDp4b$~j})?d|}y0#6`P35xUw2 zAu|?>(6mH^)>6S%#2v^zJ!}{XVU+-2O?sPa;8~>#Jgq~ z&GVpF;itzEk}88j4%-gsit~;JL!u4s;1aejw8KH}& zuuedSV9y{cB}Doz)9xUpYUO1Dm65OqzS-mT@ldg zR?wU|&&!J9(P{_CyF(Xg4=&KR0=cmX!L+cZygE>hV7J7)S;my~x@#NTf63xwNZw}8J zs;S!pA?VV~60Xfj zwHFXIU$9*54Nn2>E{2CIO>x}8RAIz%|7a8o9RV}2CRv?jmQjR}dVyLMxx; z+TlOIRnL>xz!OaSvph{YCC z;Fsv81m#6i9;7??D*!%Lp$*3xW*9qq7L+vyDq&4~#*%7qV*)R0N(YmQ05mu*sP4(s zex!^~8DJao8mk45El`865m@qS zp+|;6WwpvNgPBWf!0i;Ny8wj^M?YBVFbr@#HP&2pIL^|1TWeZBpKW;7Jg*E>R;+!9 ztZ8)wCgodmNNb+mWSD9&o2~iF)scYqbTjj6%QMipM`1#<4++imgwUc0O1;O_Sy*$u zcmO&Bh~1pQ&!wZ0-|3g)R^SKn0T1i4q5rOi*(%V0?`(^vRH9! zdvI-gkhNG~*5B%M95Jbt`&!! z?|?`Ggn(`|FLg4e6>(`w-2-wx>TJxdI2_U)Rveng8g!33WarV`1Fu~Ol_2v9WP@$m z24n_jfM9mQddv|bA;GrMj^{=4hSD%!Np{SkTBFUgayO+|xk-b&qF@H5K+|g2gbB<& z+ws(CkO8mV*i#|jv<8Q7S=XGWAMi_c0-hJm(+{|uI0GE!@dlB zCdb2xEN7oF?qGK`J5;o~50K$Gf%OFjfxw$uleX@#n$iNwE3~<}rys5Hfk{B|7HIt7 z>E0J=uo%#2Kb&vCsxtu;@a%e<^C&Q-Z)gu+4UB$~o}EX3+z;9WL%R3Jt@~=mHWKCN zi5f8^<({Rd+SEv8VAY6eV0H5oqDD*uQG4QJp&Bs;BC$3bS}m92rj6TU+C!`bRnX-vgObYIgh6{2c){8IjsOg220ExWKod5`Qrx_GA1c;MnnwtpL)K z;B;Ne5b_6twlLXUQgs@oDo=|kdbfo04ODkYPerw0)Y!ybx~9j1*F(1fu7{0}OGJS> z2NS~ugH7~uTyAF81c0}MAHvHlWMQ3Pk0h{CAXqrqGZJ)+ErW@K#~jyXk8uKcVp(xL z=qCHbW#D|+8=)E+m*LXB9B%=Q%(yr$VN*L!otX_<1WafY!Lgue^pvH^pOj_Gku~!>7?hmVXwF zYrSAoH7m(@;4efMSUE4VnBn{@SpCSHRW`OF0>;0}oWqM|^A+ImcJeVq!damlpftfG zK873+<=hnILfvR6@noSEz$F^SL=1Ivi8xqo-t!Y7O(0UKK*S^3f~gQt6X$zV%>iq-`y14dLpk!V^2q@yTQ+W=Kk zTvXoxO`v$l%NfBn2TdjBQ3BMl0jj1fk-Py~Lp4Dw4bT$qb~tApZh-bvw&+#^bds_| zPa2?$ls$52gIk!6RQ&6d6B=TGEG_R-&ZvcpzHA}y8Rd$48z6JR8_FGR##039CBQP` ziB`h=#!w&f4y@eS?ex$t3o8zTvSG7;%O>%xIR5CR0TNlXx~g z9y-L8aKccU0Xjm2a3awS1N2r9!HGs9?3~d|{?GgbP7De&K!d1MfVvu>5mW|1Nf;t# zqIPsPrz?`PWzzx5<;0>r2FmM1Atw%fqlXZW90brUL)kTMAtxR^F_itrEdhw@sc(Hb zRme$1LOq1`Q-c8VFqD;=6>^eLkfCga*&u+D3}qe`g`8y6&rp_bF$f?X3r%mKF&ob5 zfy!B^inX2|XdDZTf~C<5^*|F$C{xfJ6Ur2{#6Z~^C{s|i0rCeZ6)iVFaj2XFi#1s6 zIdESD3IuI#uqy#5ur1?1iDZPm<_i$9N-6 zBZh-aDRCt)c7&Jv5JO-X|W zmatNpvwfGbBZyOIw;@lUMm&L<15aa`4LTvvX)`l~J(4w~T!?AlyfdT%h!_-@HANw8 z8qTJ%Y}$iOGuTwhrb;#)#HOWeTEV8%AtlgwHno7Z9AL%7KGcG>TU)?~AZG%%QiJxA z39t{XB>SNGNX^TJS^-op+Ja_rOCZgqOOS*x=Z`{dQJUFwuwHYEWhjKOvsjJ7iCN%X z52Mw@CiDZkXt5n)6%NE|NEey!1N;*1QAoG5r8lAUFzO4OGl+9!3FOysPeSWQ&A)~8 z0r>-x64+zapa60;q&F>|LwXU?`KX?zi21}u3k#wKO@MZ5&`;*8(K3VlBk8t)4+YM5 zz~{LWr_efchVWYbolNWNt$OctI+6vV` z>Vi%}>WMBw>W6q-G3>b}&|(ycRzVtvwnCbU9zxm|_2h}ccJm?4M@u2qq63f)Lr-~O zEPpAR%Gg%Q*|eHXSFrd)Z2l;lzs=?mf#nggX&9SkvuQb-RD z+-acF*VJPWT1fhWclo%kHTW!y!&2)n*tdO#E{ElZDXK~ZNJFwT~s#NvViX-{3iUue}A(bbo3Q9l38mj8l8eGFj6R*_j04@TQO6TW`Vv1F=Y+n=` zrDWMjHKiCbQh$I2Euc;bYI$*iqBERVvarM`Poc|-)g~9`6ewjVwN$H96p9<=(2Bb% zR0<6gDTWk*zzR8NptwL+tWk8%&&rCB%JSi06{A!XKmpcRqFSZrm8?-0DKt8zLi-6J zrb93gQ3_dsRHKk5D0BnVa#j++nn0-yPz+Q_DpIHn(m>Z0np~+&!B&daXw;glNcOE8 zR&faoPPEiyU;1;p;#^FaFS_4uV%mQiE#TuXu zm&;S6syqdZRf#%Z(O?;<(Jb)DX^YfaY$7P7Sfx`ID$+`e6y2mMIbc8`7>d!T3k?`7 zSE95~VH_+&9h4x=R~XcTYZwOhV@!lp%d*Fe(^YbXrl1rCkgXtVut^p)w2TR(3lxP4 z6)OmmH`rN2D~6#iWf3}K+Xgd1T9DV6*N-ih0qJ|KK*>@KK)6%-fr*hS3l#D+wQ(Sk z>8O2D7^yBS0(uSGO&E50xDJl`ImJ5AwW1g-pddw|9}8_f3`DUsPtiybrN}AH%fpIq z#D#0Mio%?N(ln*c6rCp3fQT{hc2_Z2t;uhsj~=2^sI)Mv8&O6UF(6n^h34~xv8r6w z8lk4N;EPm|YE`Z>uUI3+e&f>?q7+)0Mp^V>A#1U~RNGUjRYKoDl?^)4tBd89q9~9K zVRPEXa---lqVi&y?$d%uby2BCnK$6GMTJFDRcT`#gJI$}p`9FMfl_BuibuSsw4j(Z zaeW4+yFMdVRHKxtj77Ld$x___1l=9LN*1qBRg?;!LGF6jZKU|jQgR`h~))F9ta$tiByJp zj~xtdIC6lpK(0}!{swEjDw(u|WFJ5Vy>*4in6yASl(n3XYNYB{G~BE)Yt*(P*Rb5N z?z3@yVZk)D38K*pVLm4AD@u{8R4K8oqi{_gtg0#|zXBEwpas_i^Bq3+EA)r;7Zv-LqFq{ zszGd*U>Qu6Nnv$Ev3manGpa-h1NS$^!7#+=gVE3ryU}cncB&N{a|u$FG!NM4ff0U; z(`IQ5PS8kY5cfmt6Jx~~ED1P)rWyeSUSb<|GoS)o+_*tO25${`F;);p@qck2mC ztrjL(gGvh&S}m|QYV?B%`_E{xoJQ9NZ5cWfrIhBW)LNZVrq$1Z!Xo{$rGVwyuwBq1 za8HWDA{|zzso9xO7)@5c6vOP(uP~_!O^H&b&>EXFDp~vYN3>zEwD8f2VO2u=b zJ%CxD-tyr94Ypg0~RD~FbaM5jomOY4}F1&GcbApEuJMZsm@?O z2IprK4JG9agsx#NAka80DJ(%`u?9S%4kf5d6p8q2B&<}{L$k$tgH2ayi;IfX8rV}L zKt-h-_GRosFD=lMn(j;fDKRXlw!%)-6GEC!yT?Fg{ofx-@A0 zwCsNGIWk1|hv8N2kT&$XG+UB@Cy1Yb>v2!hXr z#JU;ITG7pfwgjB;;n{-_!n$QHuq-XW(5MxkM>G>=5<)2rwG_g1;9Ck1UxYB)1_6vqp{flQlH@=u zBxY0ykq1&(C@iE!$Wd5c10p*(u;Mu2hSRwioz4?M7M@&0I0)1EJPNk~Xj~Vb0v;FS za1bh?47UhPX9$`S1c|dw2>K<=;NeO@00v zDbt084V7?}LMvd4X)JiOqcDRH1cUev79hK$6Wb9d2(3^ANIM9|00xOq^GIQ_P|1O> z6RfbZq5Jqzj8#Q|Hn0M%@E{76Ry>YS!8Qj(jjAyW4t~IxfHq<1M&O~-Ka3ibn!%Xk z{upcp27$D)5|&Sfv9p3#XOtCOAQPk@A{0Eeaxg<2eZ~QpVJqWr?vgdq`g=hK{#Rd@ z2DiVtF}u7PLaT^Vj?gTyU=7H!9fnIcI&q=De5_W2vbBCD^hL7H^ zIhkla!OH&rl)Rey-|H42YY2qeuKFmLzT3yycKK^nq>0#`Q71snG`)>yF*6kncKo zw`=|MJ-qP_i^qCg+6!VpXqzTEw6J_UP9{^du!R76WH1pttwkrNUoSc1Lar(t&C zp-vE{TOx{m8nG~h30Bw;;OSt2M>N4fU&c4ow*rHO*I+=#4mn%f3iPSZIIvcb;2`7+ z5C_HzWBF#d5k*5T9p|7JY>h3(l#thBDQrSGYk|06C015V9hwT2Jj?+AK1>MKMg)i* za-meH;KF<8^6_js87vH@z+{LR!e~P;tgIZZAhc!$RtTmKu!94D1dT1QdDih>#N==QOf;FO9Sab}J3L?X&?J^UIK0%<85+^DD^P{pvne;!IxXmwgIkv{eWD`_ah`1&*W z@(*SoA$o{m0vTTxVJHvq4e;}q_(?D&i^n;*bN&3Jz9Edif37q{9^}u+LUR0kC4SNn zKSe;0EZ9HCKgbsz3MMC5$|xjKg@3RjFi0Ab8=M;`SA@s|a)WaH}?nXey|No4_& zU`CQFk;_5?7-^0ogptUle*SV_X^6rvM=F))Nc<&INsufkNRjI&3kVF5%L5dO04Bgc zCqyF44fM;&@skBgbAtVHgM6hqeo|?!BE(P5WcSYu}@C}v(`sW16^4TEQ;Tw78zz#fL~3@|hB0!fPKrOEmzf?#@pty@SxPH{-E3pKUp_M< z93yT5_Qo*cU|&Y;4;J9B7aWk{U{6U9s6`S0W92Uk3*z0|6B3%+e<_Jmi}^n_dzb2)LXEJ z2up*{ZqPfp;WHw5JEOlmp>Cq-w&`E6Q3THIOj&+;uLvK2A+Ilyer~&n7q#xD75-~G z#sk1E-jv;cb<+qoh=|lk{jW@98vH&2CW-!qgh-t$!f_3e+c0K?8~g@ECN0)Nu}%a( zP*Es#0~8vO)DRmN!R&$QrZk?8#YCt+z>23HOgS8L`)KO1!8egqXJ8L>hQ=f#+{A>t zN%emumYC@OpOC&#A3_jGMMdn}3Q>_UK7)e^SWsg$K}_`e5AiSj=zu4Z;scr%9tsiu zB~Qai5IooL389@9++1GI6OS1lxM<8*vqvpmT-sxo!|~)gcmg2DY^rvmOx%$#_c6 zh1&uqnguu~#q|xvlRVu_el29VRv5>+yWl)aLe$F#kCJBfTP{?+rKZW1xx|ZL&=5M1HRhg;}^Wy#jyn(aVUUiLkx$d*vvTwBm~HWBQg32 z$fumDSsDiVt^f0f*bV3a{Q}=L5Nuqekd2q%=#3WeF%a)i8R9)SUW8*DN+>IZNu&eW zL{MKJy%DjJi2#>_27>fB5@e*2v(icd# zTE>=ZfhHGP5W_eOfv0I4MhjSdgy(Y+FL3m5#l!cS#{L$ul9$2=>SIN?{L_|1EKiLg z8f2>d;Rt>M&@gIIAPa;@*)b>r$qaF}&+`1wNN(T}arm z7Q=V*zK|2cZxQj6VSkf29ALsETBjf3MooOGhySX~Vi?x~_`?$qw;c~M=Yi%6Sp61( zWnt^hLjyo}@O{i@NBv7;prA00jWfkB#AmK#D1Hp)42Xcn*|@K&pUL3N@sFSHM%h zAqfV5N5EL%Xe*8`=YVFh&-k(&Vz9`6(UlCl1z;t@?)v|(|L-)w{>B}?!(%F4l(d;g zRky0wmIRNiu5{@GsGcN2NSZK~v{`mlH$p*iNP>%)ezd@oCOAZ85J_;V6Pb9%&IHqh zF{23hesMWjjv#{cVO@@B#Gc(PGCFz5?mGGooL_UrcKED6zp7e$bi8iW*~QIDCXJ}B zw5(t%x$l`u>QOaCLIm5!50>h&8aqw1jIeLmkLZZ8n5{ur!W={@lbAE`d((6dZ9}G~ zN^BTw4Df9Py`H!&eP+%bC*3@1 z&C2mb0q+%8Wcy|}JNMVlUW=_R%ewpZ9pq^H*7rSHjSYS<=R;K`a#sy*V8{B*e^IhFOdtD zsNA-jO8y|3`)%bqyP%*pI||pHE+%I)X}HPOoCGG0iLLHh9bFYUK&LC};NvrR@L+La z!&fvib)ipDzEWMJ^^s``@bMF@7;G5K7h7)@PP~~QZzfm_<&4zWXM*6QGpS4uBg~Lh z(f_mo=$7`MG@)ZGu;4ZX@t#A%?&`zIOjVKun%Ht{+_DY_7F=#}X^emQh*pb!^S$dL zr#2=pj`Dn^7`3eL&FNRB1Tci}xIrbycPH=Zb3hQdBiM546KsJ*q^<5a zXl4Aml=Vs45sa|O&mFHn^cXmydfT_R_WEdL>9ln6+-D(ce`($8&yMC!r)r!3G&8IF zAe+o7bxS-(KZ^hLuv2>1u!y2vhv(%*KC{nNi#yei#VD2{a;DGX0LY+3pDS1 zy`5{?z-3l-BL_zH_PxJwqVktnhwm&U?ybFf)jY4oO3y&Ax~69b#Ko>Z(&Sk$yQkc` zpEAzQFYe-a<;At7p-<9LCKM?zYB6TP8DsPmm+@3z$oS0!iO{c7mT2Z|w&cVCrG zxnFkG&-<_MH>);J? zCu}7V-;TE|m5(i(mEE>r(~{Ulj|cR>bZcSiR)N>iO+VClZX9a1>B^jp)7kdi$GIgx z`lhrK`aD|CPrk4%YFFmfV`8d!{eTx|3SV^Sx2*Zgm_4_H6_G#KWp{M)up_<#m4!dIeUw!&Ca{8zrhHV{I z)#``NTP9`xI6i5#{cp>BGVV|7=)KXe_wikw-}!#KjSAheb<>RCvP+B0y4b1Q~Dz5F!pQEdA)Htws}jL0j0I3Z_9)>fa#(6kGfCwni>|AbokDgsPV_l;*Wo~D$++c`?acmh^V)hO=kA&1)Y=pMqk@J z&aQ4r;>$Uk_r+8f%)4~^^0-On#^vxSEQgPornH%1m)DHoz(x$2tbdEp|RK<4X4r`0JR8rC4|or(!NsF^j2~-k>Bg#Z-)9x)_@y ziROO)s5!iN%hfWiPmxAh2tRL-6=}r-bcIY<0|S!rck&fEngj{5*Z>R;LdoDjnFYs7 z9UMJz07(Ba4uph6jvqNxcJ1u~o@qzMcpRC~ zbnnUOt&izp@4^4d$<5~A-$J+e?&s44(A8c}a zT6^<_)u#FGbLS;kg_{4yAAh;^QQsDKpC9)=-*?IO*bu=9!I2YRZG5oxhwIJ8^@#2r z>^sQKe&m*yZuNCu9Yo4`TQkNFP^s7K(j5)s(yIv%_s*4FY!Y(K4{b|$b!X~G2X(U% z(Q8T`gn1}d9L-G0sXFQ?3!GbZ>)MO@-2h5^U!DEf-PPC zSbKJ5=HX@I7WNv{GqGFrp@>rpOZp1RyXF5?y7ch=!oq>4QnWUfLzB-*Dx39XDx39! z;~!Ho``^8Aeencnawx5?*vNnbGMov`D2YYGCLRu{aL#KyvYJb*VE@?&H)DJnD{>@l zIHD)_vc}VCyISUVl$6uXsXvuO&&$}&yWVXI66UwB*jmO!m{hlr_%puMw(x(LeG>m$ zW?$aoOLN+E+QGq$Q%RsHJ?mRt{@P_h#<5e+9_;;^^Vp4iI!_wc{r&cc@7g^We1X46 zB)(eOC+>MtY5cLpZ#O$!{6@Mz`1kX}?>*rCk-b-TeeQMU-2J8#XWf{QHFGvkdW=}{ zUD>=*9aRxYGfH;6IUPN@^pfk-TN6)Kx4i!H{m$FdE^HQN?`@y?cFv!^E4xh}*Jd=6 zIcfQ(^iG94b#KaZBc5n1ydKqX=|MkDm{Q*9PE~SjO&3eI9w%*v?>}6i=I&_Id&Psu zbM4}Km(8#~50CMt;@w7Jm=nnHM@k_ZFcc7i1>7_8aAdUS?>B0dwGh`QM+@Up6|v-uyl zW<1!ma{ru7N#}~)x70thbK3ixz3&o|&I}%5sC0-JYgAu!(`jWNJOj#e!BvnikKWK@_`hm=z_vf#*qg?A)-MjY^5Cbm`O`eE zZoYN3dPt-Xe^<-z-+HPF3aq;4@o%Pl72MtB@$a4Yzo_YSswXej)`nP=-Otqr%yj6W z+)hV;<=E=`+%HZ$hT<|be7&yq#H+ILYLoU-2EnX^Af z5VL2)Fj4rkLHpc8w;o-4>q2z*W8Y0DuEzGNckbwMbl02%KGnMx_IbSNjK_qruP2OC z-=MmcU)%inN!h(S2Y6fK3o5SL&%9Z>Yq8IosjAx%i+7tz{A6d}?9Lfmd$R zjT_rmpeZ|(ZLC>DhfR?dRokiV9_8!fAJ+e(xO?D(-RSqS4*e!broD(9Haw=)alZk5 z#uTPAJ@JOFH7ALIuuC7Urse&ZX?9DlbWINqpOb1eVY}U&u_?9BV&2~SBW`D# z8(ZGTo~!n?ta`Pj<)n#o??o?pbF;%nWtV18E)9$RRV@AEhdB>#g@szA?+D)2(NS?( zd@SLQUO6LH-U^+%Wv%V?u*L05UBTFofzT9o@vrBD%T|I4rfbVBaazyV>a(rmzjbWA)?ra;{P|ONmw$bt*_^LC z)z5x*{KveD{rAjR`|FI!_QEq>PBDqsmO4HuT{8LZvb1&e*QE!Vy>xk1HeOS(d;wEQ z4+6)RVGKf;Rj~hq2_ipI*8iL!gx>Kn5On}w=Lg^LVaFGs2jTO_fIk0bxBSmMRgI(N zzQNWLI*6Y9X*2iL+mXsy`MR{G->(v&$}xXD9X=q=E9>~t2ht-YyE^B3_I=(g)r})* z9p1`*w&Qs-n<>MkOvV-_s>!d}<3^`NT3kuk9n9YradYN|%UY&ayUG>OmbE{<>RNH` zVB2ip-q|s~_3m2bJK9Mn&6}Q8k+$W+%=j6HkFCzUD78_!pRj*ZRlfI@^v{^XZjNp9 zgc^J237g{Nvh z%i7$)=JLz#*n$22(NhgVT2f6KeE-aQc>f(Zwdm z#p;jVk;$n(h9Bkrjk9+$yrynEd*e?{{?^%>_i$Vf%eyCT&+Ae#hzec2Vwtmg+s~`d zzLFfcz`a}Z?rpEamdv&z$8%2&y!GnQ^CA1cS-Zsb-kW_-^V53qJ$qC}3IF&yb<)|F z*}@4WXT!q67vAV+_rBko{&oTL+V+goJ&S01a?`<)Cr17jG@?%zhu`LxcAuVtHU&4a zd*xGFq4=R@NB;e9&i{UTC{o8UQEl6Fy6}`*HD_u@`+YnA;@l}(>f7Dzuk=km?{+?z z;s|VLqoLOVGA!P596KAegZr7Z1e7SoJ;Z*)d ztMMLbAzS-iJ879df9P0kNB+Zk-ak#g?I#wte|5+w&CU7s$qk9u+;?xOxjtv>nuz76 zF0>3!xLx(eW5EjRT;|)oI^VckvSF|0Pw;8=jq|3A9UE^%b()(z=*qH7$J6gA>v|o& zSjQat>+HjXKP(SsCOuy4)H2v---X^>@iWWn%-kHl-&Pjj#NTr*@cOq|Q|ol& zVui~p$@37Bg?FoP_O4&{zwbD)+(iIgd*UD zj$v21$KJkhnBrHn@AlhGL1DXVVk_cTtKJM8EsW;&IXYvEOaDTPxg&1JxW*i0@=I-r zZ*7l$+i`yP6;(c{LSsHW{r#JW_rLQj{cNXpxiMku#Z47|r1wB)5|ztsV_xdcNGd5y zI6IoL7CrOdJEHnn(r1pYrm>_-qB~>X5OIKDlH~_6g-_x|BjwZPp6o{4aesKEvwO+F zH``pQcsEA=SQFK>`GQTI&1Fo*TN4JPkEG%!rs5G(ai6K!&k>E9*1Ub$*(;BCzJEXa zmzwDZZgzif5#syvzAVXjdP8+ud!}OE|A49RdBs7nY^(R^8JC;Y?tIa=kM_GAa}I4O z?~%AWRam>Y?JBE~iMu{HnL=Cu2f9{xX7P@%8@C~JyuHPbbf4U%`ws-%`g*?R$-z4# z{W~rgFDvd}bYJLNaF64%Y)}8kp|{m1Hsz`BRQ0)0Rq0;*TGwWySL<2N?|QGfvh-&*zahvfsG?sL;UDs9(wYr)*sM~_d2|AMX9 z!qN5#|L!XPx&0#DvQPKSIyrkyLd`ta_iv{57M6|p?&s@Xoj10X_Xw_?zimhStgNyb z52|B-*qKm${O-yb0pmN2;XHi2VYudx_FI2Uk;RRUl6h5nEuV>MhPS=)aFy3YjaAx~ pgxQR;Nq%9cUpbXS)UEptKGZY&m^E)ekM$eoZ1Pm%xt literal 0 HcmV?d00001 diff --git a/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Configuration.dll b/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Configuration.dll new file mode 100755 index 0000000000000000000000000000000000000000..c4ec0f15a12b9cdc007a459e5f0fe2be2e701340 GIT binary patch literal 27512 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 Cdd$KA literal 0 HcmV?d00001 diff --git a/bin/Debug/netcoreapp3.1/Microsoft.Extensions.DependencyInjection.Abstractions.dll b/bin/Debug/netcoreapp3.1/Microsoft.Extensions.DependencyInjection.Abstractions.dll new file mode 100755 index 0000000000000000000000000000000000000000..fa59db34b26ccb89bb2ba0431d511655bce118f2 GIT binary patch literal 37752 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 literal 0 HcmV?d00001 diff --git a/bin/Debug/netcoreapp3.1/Microsoft.Extensions.DependencyInjection.dll b/bin/Debug/netcoreapp3.1/Microsoft.Extensions.DependencyInjection.dll new file mode 100755 index 0000000000000000000000000000000000000000..9b8c43e830be718f118fea50df7db31b64387251 GIT binary patch literal 72568 zcmb@v3w%_?**`vW&e^lKTy~R9LLh+vNmzC_2}ux85xE6KxhEo^NJ0`I5^~~hP#`2t z1W{B}ykMbP5wCcu_f~w>7pk=?+M>1fMk#1(wbiy(Yt<_Lzt1ygFOb;w{rvvA?0ZPjyYgqSIHF=c$o ztMS&3h+#!uIZBAXfZ|fr>(ZnUMJN~HDuj>AnzEY+WIzAagAcm*N{N2eUrM6%FL||5 zB`qdG?;I*a?;Q@CNS7~!SUVioiBhEDGRiAO9nt^WzoLZcT*C$YjFh_N9nEVyfPeoZ z0Pwi4usijyNQnCKXe`d*7)fq9x$D1^szxO~mI zpq7*wrMcn!Qq39+>cR6s3JyUjSOk!JOh4u?&GY1X4+}H0)){f>nl%)RdHUS4fvSo% z40t3R3{nup2oX1Omd!<2c_I^Rqy$Je3^7=HWQ1L(6y!8lAUJ|#vs_k?t{&Z`&kc@5 zah@3>`w=q|{&1fpoEg9eYeA4bp~(m9<2Lt@>d;~>;@7M&czSN$kZ=$&WQGEv>`_jE zj?pmqV-avmG~IAy7_rGxn4T;V#5kH(8L1T6qa5Nv$m)>QE$%`r0QqcD>M$|n}6X7xB7EE zx-}j(A{n}M8m{c3t6Mx7sz;HtY<3a)OMJrwhdig@N}W>8goo?a1h9jr1C-@Lm@w6O zZAf|C7V_ATdTSysUT5y8jN_eXW4TUi5(G-oz*KVe0&U26rNB%JkJk*>PHV_7|Aruck_V>96Jo<}aHhW4AV%Dok z6a~HAn!?1U1ksx$HYbQVN#gPZ5%C(Yz9K=yl!y~oCWsiwII$%`oSr0JkRaA3iK`Ms zWP*5ge}V|(;>6YjF_t8*P7uGBBqCeceZMkEY)cS#B#BmnczcrAo*-iWsn&aFPLaQ- z!jCGxF(WDMs(I|ml4fqK2F&1ejG(4Ft!Y3??a7>t{MP_^%uj!&7JV9Ob?Z;4ADjzm z-P(iV)sd-Sy$4osHi(&8a2_rQZen_K)4~IsuAS+~5p$>kx2YQ7pm1K@QuQt>%m*i+ z=7%n>L3;>uw5JEp1S7Hx5;I9CKYC zw~37$sMttDK@6{_6pCj-ad@cRLRyv+W_G0Y#c2kFfSRcYM_S0k7UN+_xp1ij1~y%05HGf-!}rgtGx86l4z8l!8S zR1PA!nxWZRkq8RWg|INR!ND^j9J))(8@QF?za&@RU6N<)E*aq99_}v5&oERecos>P zY6JA(Oe%%6d?f!_syHxST&4}mxgaKAVt)=~4-yqNgN z8(}gmp%SSswQ+2CQrcTW*qK`Fd|bQ8czcr(4>UV;Vpw9#5?#RY*(vC&YC_zr3o8nA- z!po!A(=1yGLnBBtX6!+#i=Z;X3kdyP0-b(5cii#Zk%VGyS8{m+f#-a)~v9ndb64tR@r=3%Avb zYuQVOJ?@C8j|8q|h=Yl%!w{yHH7OOG??Ql9Yt17yAe$ zDG4EmexgxHNhnL6HJ7WJNeXTIV@m8KBhew-)+8lqYi}Q^Bqb?zppR6Nl9U?hNVI78J4vzoeWuDW zTC4*`cI8q0MYT@4>ed>NkaYAQrlA?T2-tc`$%=U~(9+O)8&wx;Er>>J5mJS<4#f~+ zmF}skaZN|e@;#Nuq*c+>^AdMn7WNXf7we>pX6ixAb2EOQH3)0rE2y7AG0$yxUkmF> z%JNFPuR-CMc^;aJZ9v_U9^wR%Ji}Hua8J0yw6O2=(B7yA*EC#vam_ZejNn34OLqr? zMIe;9U2ZN!0=g^3uuAYs!^8AwGd!8XaHq&zLNa>vVo0dl5mV)`O@}>Z1l`~qrW+|W zSS$I4?pHN2O7uLW^46cU*hXmU!WwL7u}xGQL`A-f)nYzM!AN@sh6D*e+=X=%Oe8s8 zHw-ZXUB~(cKM}{mLg4X?`w|UdTe=yD*GXy56GVpdSX%%h%bnI0xY8YdAnag9Hj;GQ zD@fNQR)#w!t~d`(MSIcH*p(o!2m2~wyHVJRLR_6KT?^^h)g5NG^H_sC@^VTk;(Wzgp_wJzu~Orz@t@_Q$Z zl5QR|u?IC{AbG4C0aVPJq8xSoJQidmuQ#xUEsf-9x*`}^LJ!uXKBZ4OfuQ+f2y87d zWHgR6+EzLQaFoJ`cFe>?G-KP*lx|o$!XO0gSVnPIV^H45racE6GK2Cy%5E-OC}X#% zOtx-9WwpY) zzuD-Qp$BM=;LeJ4oQzGoPznx?jNjV@i-xen)UAOwR@*cs>e#$D+JN*-p)Gnug!W-N|-oPQT0g2v%gfv)p{^L@S-? zb%A^{8u2^w7G@(jZ5>tjgg4}7!-qVz=0gA~z2PN_;P>*5H9Jl7r=blGw^34-UK+>A z3)$)Z^hl}S1HB%!p5A}!>8f=vsrP$xD}Ly*ZXpM}K^hEaUb*fp%gi#IdT#9ZAO+t9 z@EfMf`XQuZza*)Q!|4G47XqUR_#uBrGS)GCVkO*4AM9TFZy2KGR@7Fp>kydS0=pQD zlbZHL;6*yKaK^I>B?IRmZ$YijlNuS5g%lRM0}M}imd+DBlH-gsY2L?PWacQHbB=wM zm!~CUu7He#R!eB`Mt4w};YEihMttvsof5JQ$KFJPqb}9RGEArwj3ljwMKNUE2H?f% zmQ%ID^KH;5Q($)~a-lcFFdQ71Did0}A>WOerdAuwZmc%T5l^w(!6@k=4jmna>98p5 z33$z`%hDXdv(W+D@T*($swbPdJ1M7HccBsm)YWA^9eC_s$Yqi{U_8AU!wRIqn4vp6Pe)RPDKxYF93+&UX9V zC&LQ@C#ic-J(5n6X@0kN9F4iVY?Ot3|NXCl?yv6vSWAfL9mtU{MeypJN-@^Ae>(Q?YG~? z4TgW`pq3KS4OiSxhus)FJK8C=C2~88;%WGhK5jzr7eDXG<1xRwWh;`PhU5}HGsA%6 z2Ez)RtU7`hprv$oSuRnrW1x|UxLp`JigGZrGaQk0mqGXYwnc%E>2&Yr-F1e6?e&8u z?U*?28k}}hbj(88Xkj^&z8+=P>qbEm<2m6337)$eud9x#fa zObeI+>rra84b9mNTX>paTAxE?KyU+~YMa&p^b6-#Y+WDOay>6B2jDC`uEtcAX&pc^ z5Lgv)Htet@lzUP8QfSUFmX^7kSa=?T2?BY6(sMcz@F85YH0yDY%g%tO4BJzNgFTf+ zZ72oxw9!F6WLKp*TZ93sz~2!7C7rA9@9!fJ$A(}9)r%5;JP(KjE{5-&LRO7sarLdeo1Bu8O93&P|Ay<$75?ML;zd(ZL zLWMmI%@p#Y1X=l~8hSCI{DG9C(!q38s<{m|F57^0tX}sUp2UIaA&xVh?;Yax$&qxd z^}LSz zi3f8WPm5@7#1DNvW{rXRw3qebgSDIDK!l6Qy5~_XM1`Nn3y3pCd65dSmjKsO3}Bxj zia3`44CPSj27#1f0Qh*xhwCZ$EJ*pBfpWM`(>pK=G{ZWeba$YAU@zMkG8{0>5Nfvr zc^4Q)ld)pPuyJ9GM#QiV5*Gag{?_?1UGP;9V)X#)DS=wA5&yp^{fgu;Sw_=j*^HXO zzoTcG7W{|0P*#f#$H;fF1iC_g7>X-CIDgv(KA!GDz@r5}W#mIZlTNX)g@)#nNb|ee zfUYq-$Zvof`~bj+41%4%hFDpap&m5`mw>Krh%}>%D^_X2+d*VL&YV&Zs3win1ST?H z$I*2HI^hUnl*7UMP!nfDny7)j^rz)@VRY#BkS%bi2X4P%8x&&DX<*WZlS$gqMGfF_ zTNgKg28m48+(V|FX1kCytJUi^YIkR>6<#UPx^4!&MDIfE7$vz~*q&pPv>L1!T;ZW3 zvmmxnWT!5sD>HHQ^(J_90D7{SIE9bB1zOjcsE<=NNE+}FVvFpXK^M#dOaL?XHi?}D zidu(a&^e4_mL>$<@Ik;V8yU0MyiU@DQ+-llT?|eaHoCB|Jz=4mN%4w#)kC#TG9pPn zgj!lBwW!nCdl(T+3zVIoiqQUWiWNQhIEbEZ>;)4E7EHtn6wuk7DO&rrHLv>gyseY? zkwW(rRNg&cD>{S+4Bb-+E5Y4ja6c674*nL35~7od8BA9O1+3qF2XC3y#|6P7WKfk_ z+!Qjfo7B;%C%IhFy48ZjNM76|)#_1FKy$?*ujN_M zasXOxJP}Q!0Q(b(T!O-*Q1Neu0Cu~?NGU{VVh&`dWu@_s=_**L9VDP$*Z4DZdJf`H z!hZU?2$L^}S>y3?+@-m?G1m>#8HBeyIQO$%8A!Sk_n&?v_!qEoe&0PIDV=R5^~NLA znFwTe@UN)iclgcV-%tpC0)V)7?xt+)$#x!WO4zh2Zd10a`*i5X-8ki4PxnMZf}fGR z8~5;}C)?w9`Q5B7+uOH&ziW4Voc$iZmr}k*wTLG|w4e2KAlRk#Pn1H-Rd36^(Mu^M z)q}Radm7qAn8U}WI9nHD1blpODE6-G&*;C%)-NFGIarYBz_)Rt*F5+ncuM|DlseD_ z8Mg?1{|dAL_Qa>#Adq|%$rzw;qoAjVV;U9zc^ent~bd7KC7rXcvQ6I(&fNNvT5 zRzSkk3kS2QmGRU{xW5i1q9)l&YSX&Y?s}Se@N4QND@pV+p24U=m$D)MxSo~_069Q* z}RV$6AtTSDRy(O9a6+c6L4gdSRoI4`hBbP;iJC+Okn z-$P4N(tf46hH8-dZi=h8;oU@5F%UQ2Ch5@D!*gsH@-i=}-?c@11X-|aCKT~L0#i`! z&pL^u(;e$~?$2gXrNv03NV6vP5`<%CF`LNP>hKl2brk2=q`CHW9$hce^1J4v5LaMy z5gU4#+nqeHjIU@~@D(()o6nkP4@H<|pr_OXX~JW^TDo8(7kr0oGH6}LZbI!n;aL9D zYmjh`+tG&yX}Me@oUi4nf=?Tu3QjHGR_0Krf~*oP)=^XR+>#3*oE;}{VOl;dfMyK) zF|&uwqD?h#l0)6GHApJh;oX5M*x}uY3r?SD*?j|ngnld_UC?=seO*Xb^s9>qa5CdN zwcxwZo+yUrziVApwc z;Zs-+CF(ax(v>9WN+R)byhIHn5;!Ox+Pz}-nK2XH>pGuQ8C^^0qQx-z%&tZ%$56@a zT1G{ko^zXB4OFI8&rBK^!}@E|!#O+~W)4C|&HR`fsuU;Yq=xEIoeYa#Ngd(T1YN0B zT!WuO8O)@250=92AnzqEgWc-IM!dSm$oI*KGK4-+yLt?2OluVYo^)ktoz$O_GQBj6 zJ@2nUJ)G~2;sq5vm9|{4CJ5_1&X@;~p5J4wqmz@7H6ni$I)GPIlpVouP!;dq)=_WhdHN#3@+Xf?$`CpL%(3De%K4@MC$)<7mS z|9B-lI`J{ZIIHI}sr|nIb zq=z_|1~EMD@pP>Kl8AJK0uL7vY1kNV(>j*}PxO{f>F|avd(Wfcd5b2%7b7v2T4xg^ z)zIix2Dw5n_vveBl9YM$H8d;AG(DtI`ZsZGW#U2UV-&WX&8S%B)nb`s6d{VFTR6Y) z9QHWzgi{@#>2Q)dKdTfY7pwC#x;I6F6=30B8ZkhQnqpcQ9y~qqhDV!DD+^^dB+V6Z zx%kOkcz{jMqo+P*5K(KNG&xbrnOpG!6jH42hHk86{#YlgR!wy6ft6+_!N_`bO*FVb z;i}a%7k50}9U0}eFpBE2a5n5IOE92CM{R|mO{jkQg> z>u^Re7ra;=NjeUDvz*6rDk0=|hH$c|d_yOut(!###XF79WY`~J-;m#NFX7D6Y`^o+ z8iDk~!!Z#EQGWMm0Um|J9#;e#b=oT6pv-OS*Kooe9<6+jl$OW~T`i>GU`ZmSp|^OW ztqW84#FR#o6k;SnR}$e^8V*~_U~3Q$Nj-UM=Pd=%24+M*!+2h?N&oQ$AFjh#k9^%lEMgeVS3IXUHC{rMr&@)uOrW(mx z*hOsxhp=?82$#XZp@4K+AI9r&IK<)S{5Y%el;Hs(UU2kSr2wUfWjq-7q#e$T>srLR z4!PhqJ7zP)gqif{97kPh)`iNWA0u_eaOm$@AE!;wj^&_^h83=j{6b3|6_CpdE71zH|UO-MCinj6odv3j8Rje!Fl%8 z#;JZ^dw%hMv1iy2pVEoFM1bw4H6~2`EstT$%pUfF+V4y!r{hlxMj&v)nULPq34g)8 z8|dQb>Y_`m41!(VRK%(}4*FtvNapGK9w_QeXd3hlL;sU!IB&y#oC)z__zphNb4)z zt3#zgUhqdVU7~$RZeDT|J-|K_IXE#sPjQQq+`aGSw-h~ju~F!(hmsBA1oOc3nobTl zs}c;nO6m$$ftsFj5aqH!@mND)89h3g1pQftNvhSItlO#vzk~2D>T;Ih?s|x?X4k{G z`i;=N>I@~4X9OW@QaFu9ol?9i3p7k$Z%_pF4uj6e#8o^76wCA|#E*v{c&uhvCs9Ry z{y~qQJ~S-6VQhBeSw9Y2un3ygSQG8GV>OC5MXR{OVz!J_tx)(QS^sb zJuwnxUL!V*T0*z6gJKW&=cVq8sRp^l79w+$3TrymPwCScz}2Ye%Y1!8_Vuf z<3p*`sY6R^25Kd2Uaw5Xs{t5t*sSw*#)6^f;qf-xIE`%g+PKX&Q4IpA;0*=aY_r&A zKUNby8Dg7NV+L=Oc<$@`W-ggxS2`1o;7QZF6!O$dn@kbfy)NFXl(r%J9?6ogY%)!n zZgkJ!IYa9iLG&?RXEyLs#q3T5gN@Gtulu67+iVr?q>AGyh|`6Z?}91y7l7+`s&1(Y_CTb_uzx3> z(1tU$4SYu=-jCz@%E8gS5M1smjzi!&XikJif)(q*K$Vz0?c?t_E`ng!185g?N?~#O zVxs?u=vpUjH@fZzpp#+>#bmVMEJ;z=N8=&G$(qlluvz9mBk?pg1NcCEu(XQsD82jK zxX~fK`@EF$l9clKiLz1jE$UTd=-o>}GhVamaY4-n!Z=pdGxq=7?y`hVy}L1`+>}yo zPLz}FE(a~y?h3+E+PxIk(O+_t!pDR|ii0ajR|`N7&B&BBa(aA??4cDQg>i0zL2373 zRy?spEn*zQO3*_&F`1p{fxRbK1i$uB0>mMg5#)Uq?pk^jLGR)M2)%Iv7eKfqPT)d( zga2K}kHZlHT^p$i@@vZT;ZCCco9Dypaf7f4BG|gZSG1AcOcy+Ay$n~nzalPOiA`7H z)0O!bq572|pxza9adcrzVBm&ui!DV|k|rVgY6G!#3lC=Ld80wkvcwpy1K9otu^{3| z1nZPJ5O*dd$X|ua5=xsHTBc<9TLbp@Duc-0CcUyimH8_KiV^ya)=4ImW!tRlF-D3N zc51n7p3S)l99_NO9lFA-E({Rsvz07G>S5@@5QuLqBYOt49dsQV>4dqHOl4Dn}&L!K;oN@!c2}NHe)tKR) z^*k@mLVYa#h__=o@F#A!$<{LTRqvuwxB`*LG)4)bzVjD>&WDyR!c3;=)?yIo4GZPO z*;?oIVB)Ur23*t&bmcLmEVJiE5E62DWviVAiu;pq_eZ^Zi7y?~+o5+s@6|2A3wbzo ze%UXCT7yBRVckjEC_1o0b>2)>{(&uy)_DtxI^TI>axp{Ef)9h8?26WTD+Ckx)mrB+s;G6|h6_Jv z*3^@A+W+&jX53$QkV|e)t#^DMrlJogQy)6vh=kP_lht(VTjK2^y3?a|-hnH>^P+X$ zi6XxYWxx1>7a_=f%WNUlD-yDMRUTVMX50-*!hCGU?90F7??c6;MFX#fe1lZPe%)Dap^(BG>-A9$8k9XZQ(Y- zuXkYd24M@c9zyuO3BwJ5R#$4Rcx^<(BT%otlZU;Sz-kY_ktJ{s8SOPAr<-}FJ^}sO z2C|wD3i18gU^f(&ov!5~3P@gabwS9`*xoEnqu)RX|MqLD*GY^tZ3A77<;=#qr{&nS zpeF}<#vv4ilTS3YPVx~Snx?z?_>x{Njx5C<>;jBlwj;}Nyb0sAynkoH;SK*q`(dv; zdETik$TsmZecmD-F-6H8zZkFS9?r*W_Ct=TK67XBtR9;%&*ALj$-!RoIQm83!Jt3d zDP_UOMflLXr8Cko%3pdACo?2Gx%N!l@InB8Y4}_;x_nf5^{DDf1T_8HKr3KmGTz7O z#&2}sI({_DwH?uxwiPjwcpa%Kf`w!F*|kFSsNWPBKK<+&G$(w(zZeYOEGs#DDsFGbG;!`{Gz29(ql4it~&E*Usb{4tH-)&T^cDj;|T z%7ev+gCB_u7N?ASBw`95+wdgonK|;<5EHvvQD%w_L4vD6H^sjIGsM?ievc(Rev+J% zL6)4$aKLaX*A|pQXSA@c&?9atr5=qbeixFPxfd7db%n#kg zV3nvEMD!Q4sV_e)qH-?xv5Q;05alsqYKANsBRVx%Vv4p1jY~QA=x^C0imJqEqo~#! zVWOW~I-=+lF?i%!MEhgVHdvg)etv}E9SncP@MnOg_#OA9i>&vRi|CbEywyR=7q0C84> zOoq&WhbXV79UHO^@te=QQ!w*t@SUCEq8Gf)5yIS}N=RUTTIl(822gAzCkZ^tCMx9!y7S}O0 z!uLe+4cKw+V#z@66UA5I-0F75UdthDthk3U4}|F)oB4W3>7op}TNgf+2OeBunYtVOsH7C!M6 zyjz16D;-H69z>67M4RwS^5?x3)Lxs&W=Rts42gD;%h)(bmWzu7Zb?z^E_l8ME#r&= z*haQ`BYsNC3oWH(0+wtNlVv)vXDbQ2TuhfbBuhsMu~l3pYFTn}G4ZyFbEH1hCmuHh z-YC9CEM{JQA@R0}B~pi$k!YtzTrZZTNZu%#xP`w5NOGsRfF&Ua$sdST#wKvRTZP5g zVdm`;7p7>r9p4V57F4}E#F`Y|-C`~CqFir}=w#j?w)0-m#XY(N{i_l8BgU!k&w0s~ z2QgDfC-#2eJz`^d4&ps3Hp)s-lyPJFyq*;!cBEH|9if}kv&Dh5JJW}Xrm{WhW5gc@ zK7ipFHt=CkoaK)JKJI%4uqF7@bkn@UcsPAQ&(@0P0iQPr?$0FnOoZSJ(5uDPiapTK z<9-Qnxk>OR=JV-(ad+t}fR8y}gSG>OZ@`AU%492B)87UCuf=}>bfg_|#M?Sp{UtP; zBME*}L9il&;OY{B-}4hRM-jX?jo_IqKYjR@32P&j->@XXg#m(}_`ZQv5vRa55hKj|m9F$*i4g|c+{1O%xxe8JKse2gUBIk{u5WQOb zd3Z3RT68nq$*`T_Lkxe-P%jQDk3iL?gC~>G?lJFX+Z!h|L2&3(~I|j$&-vfUkmk-1ycQW7|b6^QBB(EKFbr zGaX`+k`ybm-_G=iiNi?CHn9U(y4Yo7zw*DI=@WPJje}|-M?A!sY9UADl~BE2Zaqg7 zF}7K3EB`z*N6cmHIUz@W1JCTUvHJ>5-vI2osNQqpiwd7_pjc;PD@*cy1!9AZ)l?7n z4Hi8%7Ro5|6$x{Ms&}AzjBl7IVocdmEFz34JB!813G8%Vu~@*^`||OU8efT6WMlJ7 zX8KCS3dU3)Mu<*@iOz~z-w1IhW1Gc1(}#C}9<;G%9q0NY;z=7@S#hqfT>LB{*)B$j zBR1Aq(cr5TtwFMSvv}5Vfv;NJVPh*RV!o5aGmNP|j1@02_P%@DsL!!0dBetXs<#7s z+s2%Q>wROz2R7y_?DdTk|5TVvFOfL!FtF|l@xDAOvc-3b$g;7e!>{$7Du&wF>-k%J zr-=$1yF0kUH$hBd?5M1E+yQKkja`l(7CK#=V@sYr@IK$^qS?mAR`&WPiVhoVD|g^+ zqe~c5<1j_s$k=vqTFE26DPng5+v}Suew@Je`=*IQjBP|Lz2rMX6opkEu1GswJ5!X~ z*usFscL+~q?5JEBc++>5m|kc6pgmzF{4JCE!r8|?D`_K9q)*(wJ~q_1K(`X zYh&ZR+wnV}TWoBu_XFP?aUEkDU1s{nzPVzjjb*0)9oX$kl4E|JxQ{V4e)Ggn7`xte zed!mzdAP%%K3wm5Gy52@!#4JN9Hz_@?-M4k7q<`m)HNS-oFuma^ZM(=>;~ddr^Xk*`{O5=rHt)!=V#gwJm(3Hyv;2$1GdAyF zQL$sOIAHVsUX=IJI)uU+PwThS^o1ytYtUUipevOOl6yRMT(#zRuQ4QV&$h)c!dZ5_R zDynT>Ng&JLD$Zg|MeAyDzQROHRl8U%=-aO}Z(q-E$3FQA8@tsJ@mu14#(KrL^wItc z#YZ+acF-yQsCcu2>mfoW`#VGchfK(k;zPvl8qtIuq`*DQS2?r&Ys9Vuw$Ohu?r@Z3 zCwS|`8C43qyL`64Q>?YI4~^OWF7cR+otiP*|2;7mCs5Qv{*Xq0uQ<=f?k;cjZxo-| z*oQ`||1vQXw{9f)a?X1Hm15#pg>4IO@n0hzU~IFv)zRR)K|E#i>f~(ycJYGEdpUon z|NG)&#-038^d3S%5;p*;V9|7Ou>V}A$lhoZ;ERsq{3o?@(5yp#U8f45l4=V`PC zJnO$pwAvDl#yk=oxl!MyUjzQgj?vvIc1GJEGih=?D}iT;;bWLtisTvdSK@%TSRAC zTh_Z`3u7ByY55O|_r$h@WLMUE;w8qOcl`}9_XqKYjYYBv`@M~=@@~rdgZPNCjjrz% zZvpn1jjae@1MF+Y$h+HtrA;8i3EQ3Zfmp(rYT+Z%Y-7~IM6=Jd9#&%|Sl^@_B?&t&~W zL?)6XMb>LspNkqB`=a7d))!*Fjjb&CL)KSfk&V?<|26AtvE0TERDYRuOk8ebp$sis z$oxqHe>87j%hF^8W4+?p3~#m}>ujDJIWXHPf5zB0F`;sJwp)H+^H!mrSEfxSExqFN z!t(5NIcW-E+r-a@kIl}IwTx{RKgy`d&Xnzn$GcIVe07?tH&D*b_Q|&yBhS}oWy!A@ zQyvV+k<&?Xv#YrJCOt=1DvTtvbL1I}sWBQL=h_&J(EwR%V>CtsJK2qLjV`k;&z;00(w8VTP_)p|sJ%^2mZ zpJqoAJ|pjzB{1@C5+m=HN$(8R_lEQrv&&?*jkRWMhvYnkL8k49gOvg!r(uEy~7wqh#oje{zKJsJu%V~7$d(?Jl6-AIlvqwXx>lHHsC4q6WcsB8Fa%40x zMP|;W)+y7j4AjU18(Rfzx}0ibUsQAkX2_W~wz6bX;4E2ZV>Q)R2WH9hY%G-V{lFY~ ztBoC~zAZ3M-ow~tF}L{MK&^a4VeHR3`6Od%=G4g-61+#U>SVz@_6x5T=g4-(dd2(x zM*|Dx6E?Od{n5Z88Jn;A(3$>JV6og~V{+v4f%D}1HuiV$&X)!rN>XoE0jrm@Z0w7Q zUj~-RB{sIQURUn4H5nWV8?1Pi*Y;LMgV$w{0wI^!A)BGII&H zE*4f@n{%b4pA&&C;#9ocf2BNCVXhzGeBw$ug|S}O9{fVXm2xIy&x<7$_sgqfR7tW2 zx61W)y=A4Ji>>k!8>6hTRbG*hyg6s9+{u_4>1*U&37!DUVh5hMsd5` zmvg;zE+w7HmK$U?V=52cAO|tFQT&g1A?F5JY-8WZU*_B>XV};j{jHpv^WKnO=IoL=4FZ2k%WgT8F=fkc8DVUrSS${@ zcgu59c(==?$6+gMN$UIUvYoM`a&;yC&ldT?GHT(dJm|ZK-=2_SBz~b-6N~fdVcDEQ zpHCAPWK#LwY*qI8bn$Y?=QG5PGM~>OE*U}GTAV>@kf9USW}G_wI|}_@9aGEk`iwXS zTSA8|e=Wb$@qP~JsU1Zch!QWCq?8{^k!ebypOZqTUv7@qRrY8h(s>wXtWrFcMO@Oa z3s)6c@-eqa^f>n?35q822FB@euCi9?`D}2U8<#ADPVB(|HJn*fc}^k0My3p7uA-zu zC9fz-gR+^RCI*K|gDR^YeFi^kw)d3fsa9R;CwbL+U-&>3jiwsq2iU3)**~vKszp!} z5j|d3lvLQ4t0=m72ek|_4bKEq^(cBO<=>Z;pOcWRosvyD?`2q9N|e`lTwI8y__(~x zem;LB*{{lKjQ;y_6qajZ1KZ!udPoCe9-0j?ypr1bF8afmDH=x?{!b>@X&h$*QQ~^` zVeA~D*BkE<-uXoIs@`ehZSIANe>IL{IG#V{*3}$QIQDtS1Dl2x)U|M2aE0d5-th zqqKdFOsk2d)ikEc+lrnFQ{&;k8SB*XB|RFRinCgu;(Z{%dhC{P17O-b%-W~5-rCH6pUvpknWwJ-NXKQNQ_HCCW zHCu8oRx#DC6seM`-M%@tnqywke~eic&sWMz{~SV^3y}{o>p7Pyii+eZoVy5WqS235 zg=$^RbQR&LQL08((bWu6<^PxHRb%wu#MO6MrDEp)U#m!4eBD%Kik$d<;7E|lszn8f zqVZ}gMQS-U-cn;gl~c!8`GNL1ST(Q?>e$;*&P?6gxGIQFPuZlMt2gt$h+y1WrFj~U zY%A}G)SC4z&v&(^t5{M{%^G_8C^?5{;!(~dN?t*wQ^mQ0Y6hvYlDU^_osZ0e-5Sr| zR$dd8%n|I;@GGu(TI0mqy-xgch7-Rq=@hwmYwbdO_TsYvpQrKjk{9B$7oVr`z3oz* zO|Ql0LVWh(^E5twSt=d}XD>b%;`21#U#pRBK_?%6KnLEDqw-Kd558ah8GcIZWQLO% z&R{r?;Ub0&3|kmp$Z#FQUWN|?O0l2ehYY_2#Q!WOxfMVkzGZ)_qa1Hu-HoTPA2R(D zhU>J?@Jr%bG}`HI(P)ReLsaK)2V8)=s%;`a^H#tk)pvtJr|H|o3t8Loj_ti^kD|OE z&vdqll|?(nm)gIw_M-d|B)5syLeS;D@_k|p+p|S{P@6EATz4`Ex?&o+wsoX zKL`8~+$QheK>46_yKw7unIy9WaF3Wd=ySXdPjHVIn)Vgw8(3SD*Cn@!(+Y^*iQKTS@Zt{JVp#dRQN44w8G>l48hbYMaD) zqlRf$G50F2I|+9w+wpc9oxoisrdEy8_CtP*b`&Rqr)%pZoyG0IShtHE@|l5WX@33U z@`c(wokqd04^3MN%C_=mhHVVjGQ32)fm^vj9IiSbUu7F^V9RgdKHh-dmBFi5mfx)H z5wB+6uH6jzL)u$ma1XeW8&ihV|0=~Rey>#KgaMbeM#j)eFIBY zN;=*BP!APv(GeR(+eM|MyZcYj`ZiF$UrzDnPeTNA6}l=!didNze2OBt6S3;HP~BlAZt#HAr)Tq~~!3lAh5ONP5CoAnD0ofutvT z1(KfRQ4~!=nc6DgCyNobWSe+1tI6CZ&Mmae(cIQlWi8t?l_}%pPRIS`OgSxcnC6#b z3yzw8dB5?gIhA|lm)}(QoqqImfKzIZc*D*wb!WzCXC2q|%efVEom07w*dkP22uXSh z@uEDpup8wGm6rm3Q}HBVM#i&%KQDM0a981BK&|pmfMW|j1^iy&w_L{mssNcG49fxk zQgw+^ka`cyg_ZzxFy+-5EF83D5Z+34n?i;kny$zXP3Y<~m z&9V)W-ZI-D>6~N}WDaTDjD3OMxqFS`>cO7djE{ZAo;}8vijZfA@vq8Jo~xjFvF8RE zM84f?gfm+``;8ZIR(XT`dBrg8MZ}Cx)bWVa@d(!Oh@Z#sX14hbZslek_r0)WuV=6J zc<^PJMs8Oq_^4BQ;yg-$8?@{Ar`A1O3 zc>n0xCd$0&UXl-hKG#q(!%*%SsmdXgA1fw#QTRvC{cP3!?8BqRm(Y1Xd-bUCeQ@_{ zOA5||wrdNTyq_4^RiBIfS{}+rjcJvnVGHyhHCE><%@=_F5H#=CZZ7CRtuP+r9X0-y zO%zNzln<5v(bFL*SKrU@sPPnAJ_Y?cYAn|YdRganfYggl==3^>{v1o5#gc6-naz?r z8Tui!O%#pZ=>5|8h*mN2`?9UxxAdk;ztM{Pc7QYXPH#Twu^cC*~9Pg zN{4UMGv3E|bb5_>!++)N)%FGSv|g>U(hYcKL5=nl*L{j(<~cb`AErHr^HMzPV0FJ5({*3eu7i$4; z7F~dMaNT>j?)_Z%A+EcRDbInDC1y#o;URem;6B*~%6_IiCoco#1xc2?EYAl06{a7Q zSK*~0FEo_ne~Gw};EUT;6Dsg|~6}c82>IKFjbZL+PYiI>Vt1hcleSa0^i{b4I_c45y;Sq-KF%&M+KZRir!(9w-a}#|(!=ntPhbTiCPGZ==u$SR&4EHlU z%20Y)p5Y{h4Geo3$~5LOoW!t!;ZcS%ow*DrF>GLXTL#hhF_b=*VK|9ly^ltrp36N9 zdl~Lx`YtZt#&93Q{S1#Xoa85M4Geo3-o|i0!%5l1J;G1~s9ewR2t$!Wlp=;b4EHHY zF4J=lfV*n|l|??mi41!f?qax4(FYRu2*Zhks4o)-5v87C4^w)$yo+H`0c$H@NiNrO zxt_~Cg{+OC7)<3NhV=}4817=Yk6}>}Yg2G2mFpSyFx)qcC}ITbVK|XtJ;NS`yBO|c zXy8A-fQBH+_b}YWa34c4lDJ|dYvXbem+M0;&+tfyWR7rIgjqgJ+=*pWo>)fZdWJm} zzY^txdqy1qzwHt>OR?B>#lcib>HdsdZM0d%q*_MsFD3Ybg`cz@35IJ_~ogb09Sr8Gb$_&&D&B zukqi(;+v?|PQV$3Uck&SmFw_BiugtA^en)eO7j3e$Swr@bm(xvdSp~WH0C!SKk2mhY>pfBbC%s)#6hle~9vre0u;_mplmASHpp{ z$3Xv0@JYbZ@_m4pgkA(}$fOo~$_PFfBG@+KEkId8c1|n(E#Lz@rprr-qI|fp@?DhG zSgTQ(080>O5|QIX`Ba>{(A|w2<tuhRh^5R(9Z1ba1n>yN%!`4ax82~8ZpoWQx7I1BI<%neQa0<%LC z2l34h4KuzL@HNa44c`Ym2k;Girw`9SuuqWU9Y76ttV>Y-Eue<){w)Q3S2O^=hh2mw zJ`~M>e-bMI|14SnKN70|KgNldCjKfcz`x}Ng0a~aOo!_ItFu&nt~Xq!-%gy z|2E^Bl&8tZ<$E$;8=-C04rpF|kRH~j=(F{E^k3@3jZR~)@eclHwqD0wj%OTiI6ijN znrqDOncK|Q%u}5=yL|2%_e}Q#?%%lQdzw5~dA{$d_CDv$OFJd4F3sqnGg8U_pB)|{ ziu>@rSvp6hC(7z?N7|D(FD05xp+#|4dLj+o!yjpj|LsnDDMDo&cJhbHJJRkdpzHB% zEWruviL^%&b=d&$cciVvNi)f%+VY`Ymrmr>-;T7*inv^oHWNKNv5h*rjnw|)AcEym z+fd(4KEB;2ak8xbsEq=gLRX;oqhMVnzIj}QOi+!_Xq@1lgwGg!#^V1M8i#p*GJZGb z6nsv_XFTTnX&ChhyfOumK_Zxy5v))VM8yPdAS7n+OL!r1BloLY{7q7u-2(sZI$t-F zi^ZjKH(v`i#V^zpzfe>BA=+iezr;71S6-kOXovKZcw;CU64(G@Cza78Twxq%2@e>-CE}hyEYj15>H>I^97OPx3 zN{laW?69H}mMvXcSw-lAmRL*2l!n&U+Ln%HA~Us5&1#aJaPrcnT$sP6ZBARw>h_Lx zwH*zOtEie1II+Q#;?=6SG$q>H(9vAm9KEQev3XKsV{GyqVii{;64hj!Q8t z#a|~AdGeZ;)+SPq^8Dt8)|U10UfM)<^NgCdHLIJW4a-{D(~zCse4Ot=nb1Z`W;V52 zjkwl!sO!w8hUg05?U0}mwPMYaV(Z!(C#+bybkfBQEgc(1iMmQPLU0dC|H*@K;r{F; z-Wm*rZAPVS2H|8zrI@y+t+BpR%wE&lN}WM5rE7%Ei8eJyo12pTWswWlG<4YVbq%pq zpw+Bxk0J;#K0qcl(m;{q6sxthIgU-SR<}1qTVl+jdfegWD63QsMSuW1qan7kwz-4o zGh1SOwL@)g)Vinz7ENoQSXu`O^rKR&Xzo}#qoa9srD(4dXU}NssIC%qRS7Sm^q;&~ zWxJ@#c2SjbO;x-vRpPAXbqg9=*EG*J%_yEgP!B=1jAqs~bA{=kdHbyDiqRym?L=&8pVs zxUw0sBt9cnyQaO}iY9rpo8fzSN9AqKsTToXV6`-10YSEFLfdoNR1#dZbm?TQ3HWuR zX)VpI5IC!)t!Y9Z>I|gzhPKA$z8pkTKh!A=jVt>hPeTft-LSeJPEFg2mbQNAv#tK9 zwT)JLKf>h5z82b!=$}amZC!qPGe~N>+uL zP0NwAXlD=~K0C1qc%TnW?J`-M(p+MBXQX3g)Vg@a^0>XTt&VB%l~O*dxnm{%V`zJI zv$0tXtKzX`QxYjZfpc!37PVHN(a_e^+HBLwUUb36cvC)oO+yrG39@YCDpe+-88KdS zmNzsui}}sCGr*PT9K!8{#k*}sCv(+0V^6L)LoGG^vX0*Z(|Q-L6jN&mYmF}fLap8j zlYof3n4bdiW3c^y%Y3BBe$ZB0`eP9#ol#=6{>Je}@@PL!pcT_5693p+zZ zuUaNl$g9Z^r;#sh3e+lz$A2WHS@H z8f8cG#fh@o?1&jB#I{YgvrPX?yMyrsF+MHqs(`uk6+W3b-X_IT zIZBn0V^m>fyg<#<#8c#@(L^yulb4O6kmCaFwe53_<|g}gg_$YoKSelI0*29nH?-nP#-5O>?cr8gx>=|Z|MxPSvEvmwtaxdDGeQWB{9o^e zXIj>(HSOi`NqPKaqs`JX>{!ZihsuYAV(BtETO-Heo}qaK=DfW^C(yZ8J639<+iR@7 zg|VWXFL0(%xs>)nkl^WvMM)iZ#xrmNx5F-hr>uzyT65wIFF}fLnGytLdIF8b@4*rj zdlce*Pta`x`p|8K@w|~d4;795&=CF!jl7pgV9Cj6dw{DWB_t#|q769Ez?LdOv2Eql zHccI%C3v>I{qmNdAln%Cy1n8=6Pw#f9r!imWos}#DVw<@adz_>Sk+2fAll`{W;V2~ zSc9EfQetZJvNbDK(AFeLn-q&RuU^)=uCArycruPnIWFvVC0U~mr);~&G zL#c0$p3%~T1D+&3ar%=a#ao?*J;MS_4>}D?^e)b%yKOqA0kfg?JEbsI%Uf2giK-*D zK1$+;O2@Upn|mmY(XhiEbyl)<`vhSYywV&^lBcyctcWF1H8|Yn{N~n%wOmT!$NPW~ z{r}qg4zQ?>uK&9QSU}oh&w^`<9q!VxgQ%dOM8K}N>@I@RWETOAx{JoBF_ze4Ppr{c zVl;V;y(Gp&V~MfXM2#lK9!;Y0|2uQ<-CYp#`Q&}y?|q;D^Pzk1%$auP%$YN1&Xj9} zW!{lc3h0nuP+FKhILj#r12bz_N8|)ErU=IFc{!yHm?Hz&d-I$EL>+`M12!4iIoTGc z(3IFxFb+vNHbju_3jP<|P#FXV1v^_%IJ*ch2c>8j+{?j){K|ohPPQ1qgb9g@g^GWl zEELs$OxbetheH)2t-_d)n1Xc%G8s#&B+d|YYSAlpTG5xwW}Yl%lD?!vR#Dzi=BXf( z7|cxhGkYLOdQ10A%qEPc61+uoY+SZ}a9+OIl5H>tr55T95Oh*dY8K?T(Fq_nW01)3 z6oQ75dbMyNItP7(-Hc8_qAR5+1NEcmqGdd%R3Ha|67%f^I^)86EMp2xqa5@}(pwB! z;+R)S0D`kbEt{2KUpQhpB|J(5DVmI`biIc-cVM1T6iJbK#_^L1bxedGW0ndJlVN;SE>m}A_=iF zp~ffbGfar7FB~ek>~{U!0;unK7MhOd2;)E^6pS1;s8^n|V`}cOxEphFVC{#ZkPCA^ zdr_Yzg^%e<%pr2RBtU5}#YC9}rDtXrnk_;si@s2xfe?~Sc?j5|OF&p<4`%jynnp4T zkpaIbmy6BM&oSxqxP;8qEK?rPhoXvQG7|Qwn26^AJqvpaS)gip!UUZ7f)-(u^ngg7 z4q4=LSPz)jz@A<55h5&{I3{8on-2)`p(51TPpshNM;|d}3*(U!RM0316(=Cs6NF_R zC!jE>I05YP)d|KrBE*st2z{u$k1?GSh*;mgM#!b*VU^6u9}AW(2QWF}Qo9p-Qmt6q z+dbfIj3v4GutK2S?O=)I=s%K0#U3VdX%ADTxGot)6WgGKL{W#KGN{1rjuj}8%X*lY zdDiR{Qht6ViX*4+mrf~S)fwN0AfvWWRcKv=O{IOYk{%<8Ye&`WV#~4CCi1t_ypwfi z#xW$RD-Xa3kYC(AgBHWYIfFwMaj=HkmznI+h>Iy4j1}@cOZOrSHjq7oO^z_4FBm}3 zYQzOEnie=>2$Pw=juSI@a3PyTIFeyH`2xx7h$A6JOWqDB^?ipAJ%iT5(2|1A<_ICw z#W6e2z98cW7V!Ry2$Vi1Hv`&Wev!j^kY89ai^~7WncyIMfts4T*~z?th8dk`l}ci&e+l=!<>z`jM42aB$$w( zX0Qb`8ef??P+thW8m@v;yx6J%DfAo`bOnLQe9ze}ox+?{R3~UseqJ_~h}lT*1nw+Z zFj=-zq>^mWuF0T+jaSt3oYD%?l=kU30ZFLkNakRc97Rw^67UulAO$y#Gc@`MK4DXa zL*g;0Ao-coF7ug>HIGB}VlYDmKPD0AEEcSogMOICb8$rlFD<#G)pfz1fK_w*D!T{~ z#UqTQ!?+F@lM6YFriFI#CQY)1HZO0D6o=6YK+y(R0V){(D*zLOo>8t0HZ+?Gxft5H zV^^hwmXX4QA|#)n0ZTsCaFPe4w4ilN(i$wQh1dn{Fvn0?F(lnFQdSHSjJ6e_t=n4C z1yc-afN>YrHC7~B>E-fizmH=m5hvHZ9j^WtQBD#su5+s|bod=;oRZzhMD<3vFUJw#l>hL~qP83`TTMuI#yWdJU0slYLb;2iRYqs~S1Lw%vW`cAV` zVRi$0!pdYcV~Li{=EWk+&K=p#2_mrk)&+^OA`f716kDn)wC5z^Xtqa`ENCw;W2N3| z4w8DQSzK8)gY(Ji2D;IlO~6|ig0OdjwUxssZfPRr4HeFSMc0y$C-rF|=?gY0u!U(Z z`!6- zEOCJCLd5|R`kbU_IpD$wU^j$0HJ5$1kz7dPBYQZgN3s_*XJ$KRdnvRz3*cs$yTj7c zEm_$@1^nNeyzB#)b6jEFlLl;LE$s|7zdX0bkflhN0NHVMk~>Uxfkr@qHVt5! z1SWQ@)plpA`(`%su(m=32_{xU8qXzgdcK%O?1RFP^p^~6ei1X9N%+}0$;{a~NXSmK zxEO&vD#B57~4dfn&_bp0|ScKR8D&hO3-p-uo9+>Fa?SZSi1@>k{dQ1 z#Oh(PFp-#$C~Qq)9?=OwQpmR1iT-@HdC4II?VXBE;S`@4;vch@}dZWLn6FIe;;ljzBm`PfqGgpAcuP2o*6 zLZ7Ah0+|G-o&h>!nG8dppJ%huV)KoqAU)I6#La39L>WQ@Vr@_FLQyp#H!(9==EyA# zACli7IjG7sBvGWH_+d^h8n9WpP8*t2ir7ID+N4t|hDnQ0%qvct?ejvW5lBGi$z8dC zbWzln15&N*Z3bzEvj%K5k#b{XEVrjX3X!<7{4`PuWmrg_Oflp9f^;@YV>OI}J0TC2 zMkqD#Q88>2Bn;JLu~8 zQruT$g3ExfG3s%~j`K0XZ$Qjk_z}m;h`2@A$e%;;JTvjmM~DTV3eLtiQSf#r2&|=u zn~!)ySbD%c&G3o&!<~g#g%sb*jAtQAU}@Zon2X{UvAl(xig1?Eo}wXPQ@}9DMebB8 zVUW$rO+^_6gquI%KNz@5am*Z7!;FwZZaCr^;IhYcAIeGvH9QT-i)xP?+zRo`1Z+5~ zdlA8K@mDs=G9gz-Y7F_@2nzL-!cdkMm1|*GBVV6%&fiN>t z=79cK;>6F<5?o{llu(HD)arzH9LtGXmne{j5QwekOK6pbFgjR5{FsW|V^|HcQ3mmZ zqm3&`JGeXJlsufflI8!4QaVz2q zsyFP0I#f>IBvvEhO)fkIcoIiZOC`nE;Slhq)uHlr1Z z=cva}4}ug3r`8nY4N2#Uy;{q9L&bEQmvd`y{?Bs**O@4ggMXBxAf-qO2(nTO3<*;$ ztD!?)n8Ei2tj1D1aCJyVP&<(f#&$MV3#m_IyujD4oO?Mqx)zNG2Aomv1q?9x!gDC% zEi2_BS0JhRH9LiH!i}Vuq)CN?CikN9pN*?N0iqK3(O)W6gBey&jU+OQM zLJzr?fu8|VS;DP5B*+kq8Is=#OV5tThwv-qxVjZ4uqC$gfr6As>FA)x(OAqNM_~JC`eq0 zRtqSPb$Oh*S`O~&1d3AcC+tBFe`kL-@I*F`^+rk7#3MJ7?@X6a;5fNg zJrVzUz@PKd;sz3-KK0Od^3dkQ!JMKWegoKOD~t{$9M_9#KysRJ5M;*7(u_13N|gud z(I{zxKYU@0TFCYE-iWADX_e|Ug+irL zx*;b9SGa2BfT>*E09Gk+;hQ(;p;EYM6-cB~xoPF7zQ4@P4bea!GDnR2xFK<_^0#6k(0nKfGwxcK>g}HEY zAb}|428z~wD&TINC{WY-A>7m+{+x>CM$IBa9SO$(03n^L`B^VhIC~4RRsNjD%~k!n zUt=^HWw9IYjg%GpznfAKfKrJ8Xa~W^q7zx+MIqj(PNu0@+gC0J_uZ8RQq`6Vuha5CE>Py>;T+wE1v}D{f1}Ld z_i#9gCNhC5G#U@YJ5SsRMvy9S#LrhI1N=irsV*Kw=9+G<$mX&{ao~MKZM};B#OZK= zmLRRS2WyAZa`iA`ZMF4VDg<6C#D}=epDJ@2?G2VD-ao>kO|F8PR#PBa7-8cfxthB9 zfJE&XLI^-~FeNy29&sr-$qgs|R{`R7N-2Rebz;UUlT~1Q7M%< z4ct7y5;utX@nT&A=)#`_hzc(X5h_M<;|7RDRkGfY*YcI2iKMo1Y9cu!+6^z@6ktb+ zSWulrSlyy*ypdQ8y#>tONm5vEIPy^^gO<1PD6x~+i+MU#~{hk-ya$ulXKJTt_6@fL>P^y8_|tgbFPN^At7Z4K!(aStR*Ltj8Z2^ zEk9S|$Krx2_Q+Kk2Ll4+>_Eoi)~dWrA#gr;+#gru_@ljjsbpI%NAcd}y?&sits!y( z&)KN)CZcPSK&XYp@C5+s>ETFDtp8AzF!Qky9WWw;GTKf^X%UV$P zVoa?bM!4B1b`=UD2?jo*;h;>%x=b~eB3x+)P(PAaWzc9vIjFmsxkj#Hd4b3c?q*7t;Bl&*edMG#*y zywLYZp4gN`btf>>&eXO(-cmeU9}u1?eTYTbveXG)K=VUUU<}jLrUw3)211+3{@>4* zjsG+-0?5=OTeg@h;H+E2GJ3xAVexzZAX(?6RNXd8%_80pCe7ik(xtt314U|EGQrECm zVST~6TeYEG`WU|x9xYWL{-ZRi$@z7ItV?hUAE&f(xHK0RE6VYJzeh@p4mWLKawFsJ zw``*9zWQYQFE`a~IpgZ<<327t(9Ls_ckLgh3|{^C*9!~N$F%9Ow*C*3_Scl%JvYl^ z$FzX=lbSAS^}*SywQGDa`u={?`GHqmx=#Pb@LB62pSCMp({lZdHa>gzguOMq`}z$V zcbVH$7Zt^_ZcCy5hQ7iUweu^7mh><6O{>qZIHWa=zYV* zmHH~2Hc}>RxUCaI3O&3~avVAQ)Iw79Ry%i91IXTi?NFr15(O7DTXagRl^zoSf8CEV z!Fb@%8yKXVCV_ZSP@tK#r8fyj%1_jwfbL8nWL-;G^Rk|#ct%1NM5486CIg;4G= zC~@L^4#lKVK3|JCITU{tf#)GSj2x#J%}DFHA;@E1fdB-tY%xT!{S@ypd86G(;Z5>|ERcI^n?YaT-h4yqw5eKX{zj7$oC zjR|EuF|t_?vFA~!e29w|srcSXeBDVPrp67^RSo`V=*No$HmX9l0??TGKwnSfCzVU0 z9BLq@Umk)BsDuFrXy5pUYpW>~Fho#cn!reo85H?_wQOb~c%U-M#Wq3jLs)`z&sq6LIBSE6aA-gfXm#rT8VNMb?ph!P7Dx^Y z=50_rDIsZz(AS03gJ7Uw*&rxEvcOEH87TxJD?AY95bzJQZWlkTW1tmu7hkC+QfICr z0jMsl(wo7Bs36Ld(JXC(JH@cIKxssn_NT7A=rB$U+HzEX$;AlXR583ss&7us2!236fel8Rar zFV>6@tC(b9-U3Rh6VO^@!V}G2tZg7BK@3=q=8=vGWT_F6{01rl8F>T$0YLXjV$msc zP-CvAWL3gI!y0723PXvaG47mg%*kCFBdd8TWn&VOD$w8%dmdG&IB%E6@Xw{7MCROp z1R8iT!~xct!EU%VCiQi)M`M8*$aY1^HX|Dv=n=6!0K~rpn84gtHH%%IW05Kf(baJ* zE0HHDtC<8HhUDNV${Vf1k`w7gheT;0sG!(s42OB_IawuKaLa*fp)RJ%tM@9@7tn!U z>9!oURog5>Jks826gM0N>>};Mw8~^anLryLxb>Xs#Nc)_5;{XTk|-Z6`zzC z@v?`Sf>N>b+T2_#+#!f9B5im+B#fuOuqgJ57JNJ(!G|z_7#oRplLv%QgBazX(&ZrL!GluA+O`#cjy)i=< zrqk;p4Uv(i%uqvkM7YryZZd`Q;b9rkIzwheXhue;Awr)K6`C0tqR$A`<5s`uP$Qpd z2t^TLQ5lgDz%?_2&(In8$k0%uDO?v89<4X&Gr}UmqxewZoJmzNgqcF3bP-`0kp`nF zBrGyBDq5GJ=OghlL>r@!xiKUogX3)D(E`?&Zh>S|A={UW(~tkx4*$w_s4e5F*;_%2 zUWBU}g_D1{kDGJDp?wow0m6mKxS&0&wUtH<(#GWEXxS-!vld&gubC?h|c(rq*b`;ZmC|U2&;JBRk4)+7KL6$yq~`fG=+OpriAAP*eyX6o$SRCZGyn zP*gKrBp6Z`j$RUGhzJkYg`&G<8g!XqnHd=o(dZ`n5Iy)coQa!Sj=GUR(K_uU=32n%EvLnjPwJ(m=Tr0`9 zu%Hn9|yUREw9TDWXRj|JtK6rZvS!$-^mm~HH+N8?vZLuE*qwSZb!sgmsvmw7QCp*Kr zlkh?K_Y$2XGEyIoVNn+yia|Fjy8iQpISxWm>DW9?UB?SQ`b&<9qyGy|Ken!z8@lWt z@0YFny4KAjI(d^Tz3V1iyUR~~{Be%=lLvKut4v<9px(|M*8Fto;40g>%4qVUFE7FTWS?9ul^7PFS8}US>OB19Xq3(vBWy=Bs>XqXp4h{{79G zTajEAFC6{XTJp7Y2#9XP)>?2%McZg3KdMoX78i0rU&+bIFUBDtEjG*B57KCHrdx|U z$b}R3EoHq}3L$YmZYgqTLuRdTHKA~$0Uc-y(x#bBTJeU17&_Za2pEMsytO#XN+k(r zb%SJy4ist2J2vlY#f{`llX76IEzZIfQd&Jufa3f%;p<$hMk95okSr!fYY^`#b=J;` z^=5c2I4EN>3fTe)sTe47j#7eT9kG$#jN9}qTAYY0GLfF=2-X_(d5tXE3|0j?4uSlD zhLn{U5va(*I)?W2sSakwAhDXbE?iRLGv?7boV2 zqZq_R+0^GMK~?C2jBL+yPmnCXTfQ^Ro@+Z01Fhy%hEZEYx9UmMG;0}qQD>8~w|6?$ zjz-~>w!q|OOhh>DlM|ETkB-YcSK89lcEX053kIt5ZD*+_P{m{Z+6YRPM_mh1?qJ2qDNeJnpX zuDSNA&MVBSnKk#5o!U$Bvj;vtrT^|!^6!1PgH1B_=|70S_uHLCf5fkNRCNR4P_pjW z6i$|u3~|fN!f%`>zCCq|LWDmI6`VhQjqt05>0PZ~1i191BUsKA)P zrNqaCghy~9UP0|dyij-VlF3&VPCZti2Jwm8M(I9xqi7?+d7 zE=^+kq{$RSmq5|qvxdl{B8kdp_J6*A69r_9@HH`MEnk2zyXGr_Q@nWmdTV7|JWY4S zzj%E0n&WzMDfre|Pn{L@So8%{#q@Ft zrx_siGv~iJcx1?xPLy;KcUsd9d)gsRe+^iwRD{w_WHWXbJDuBLF*YbyA!8YEa-33n zKBsXk4v$^*!oM)=CkG9_YJ*fis0i;8cXn-ZF%RnPDuPi4aPy zJkNiwCX{D;aImB7o+z76U^vPQ1zmKkJ%jM&u@Ja|@I^9u^LTSO@kL(}Bq|X-3-P8i z3Jyvir%R`>2=OyWVRyVNhpCvd~_<^StwkcuzB$?z3O;%_5* z5}iwMP``3M3_^^KID?|Cv>#Bt=!=l$^Q_1j0$&hMGy{J`;$Ilb)^XvewE_G=z6kij z0SiU1)8m_UnJh*o!ZINlG7uh(rwLCzQs@CU;SIAV{-Pk$WM~VV-v^Y=-U+8#UW`W& zIP!nvPlm6?Vk=SW|BbT#uZ;gT3Y63bMshjFm(|a9b#FR8e*7aZnVWn`S^d5M^_0tG zIv?K4)qT+Tc$rC|l*?Q=zQ3zSGgp~XRu(CjDVKEP6ZslW5Fg%MA>)=P-;-N8EW(vf ztJJP*KYV%m;D3CZqAHoBaharEL@vAM0j4LI<9v&W|5YfH+!Y%hOVH{=6S~RQ?{l@MRH9 zIq)eZoiFcAKsSFZw-|Aeq)`{hYY5`uU-{aMt}*{Ag)98)*fnpg-55>U6kH=p6Pe@= zG1?Gbr{e=_cwto}ln>KIg+_-(_JvmmZ>Z?yE&mq$MEn&mz@IOZ)pI5k+D=g>^Fdq7 zJmh8AUw8PEFFnnh9(CX3QLlE;pyCaDpOtHNg?zTL+Z)rSWp6HUT{x@j8y~qD122ck zx_@pvT;Nru!}pr^2efHd}QM zrbg$^8y0>(YEl1Vd%v8LkTY@8)V+&`HCogl^n83v)s$0LLnj|;IQjAX$qg6R*&Ny- z^_zgh0lR-(zG?TkdRumP+;O0vYD&)b;cpusX9PYBR|PjZI{2rnb$!ka-q`%bW5*=-rpIzg!UU5VE#rqM-E1ny!7Uz8Y*k@)$QDzsFJy= z!0RqJilpEJD1x`Ly0Yr{w;m6!zx~EqW5eV1SGL-6DD7~=ulQsN_ERSCotJgwJLsD5 zjfi}JKp`y=hz!z)={r4xEFGz zzEQC*d0||$ho-Sh`<!uhSK zD_RX(miR%BHQmjlc(u<@t!R6|NfKiP@gs@M@%ZZ)lGhN;m(`ahp*=9 z<=5$vI(YqCwc{JNDj5ImF74uz12-fu+V|N$KwVx{o@}b5pliHG1%+ z1wGUar=92BW*JT0-pqAhxv+*?%T@2pxL>+xlR5p;fwDsf8xHdSq5C`0-^LyoaN=qA z5cfx0Mn-tHJ^O0I)FDf~FN_%y*E{5g`EOI{xaP8E5zR07ex21d zVa*<&+r4Vsa=CD`&)4&c+6A1ve`ax;TXRNF@4i0s-h}gCdyc-EZ2fTh;G93396EUZ z+wR{CIr-(DfAnuQJ#*;i**m|>+mhkA%{}IWL9TC_KHd{u^NWsaYqqI-dE}p)9;=rp z54iH-hzD0qB{x1jrJwS{=u@FBo}O4YI{d~&Tqg7OnL0~rPrl?iaEPv~U+l^rpN;=` zYuV7?sTVXYYW#Lo8I`h+FLN7#VIV^o0zCBI(~hyBQ&E9gc-w@3i)e*3r!J}RZ{iUB zbl;4&1Nb`|H-3}JET#zG1H)B0rS?GpLqQ~uMe^`yKAHxB2ZRuTiaqKHihu-L${K2QLQMHu`TgU9J5_mpx z=;!KFo_C`5%yZpvAo_%?sxJ2UM6Xigo1CE3-D}4Z|Kc4p+uZ)+`(}N8>m>DT{N9Md zOX`-NBn&)t>sE*9V^5F#Xyo`;PPg4SdBBeoyN|1VZ)tF!AEvcxu`aat{!iNe8FGA+ zqRqyS*1r=q`q)Bi^M~DfPOlr@aBp;;aZJkA1wJ3vsz2_l2U`{6-+q*S=SYv8lV`rU zZC71O!}OYsw|w2Gaa6;((On|Gd41zM>ooOOuFm{fUuVeW#t944CtPVb;CS7xZF}t7 z+^by!#hs%g`URh;|9!y#pVvASZ+gsK-nLd=mVS0uwN2Y!`8KWV_2{KOH|i&BtNCf% z>m7gCy|-}0rNZkCF7E6!Z~yH*nqFtezWsAj0>5(2l#4(2TfF|s`3;#@cF(bmy!G9! zuGbTqtn_cZV&$m8)@ze8O42_H9(S_Wg8n;;8#lgtD|c_>sm-UhkL->B4sV;u+os!z6r|v7WBGPcadKJp(7!5<25)1&!5mzGTLp1{x}m@vlx4}~ z+uJjc^I?G@+5jg5LOL_fI#DGYCP{GALnjtfnKv;h?aDjR(V-y6St?xoby+Cj%p zSq9ge?>XD=vf-V1v9m`VE3GnZw<$fSdE3W(3yr8_#>HiQm=P8&dPi zo&7Bi_gnOFLbS){9(z9jaNX69PM@td;kAyvqe6x?sy$}ogGP@pG;gWRp8HXsiCKC1 zD?hR9ZSUf`Le{i#+p>24NtvFzHYGj0JavpFzuKsdD~Dfg-_-Q}-T^%_#_tU_x6$Q8%jX>VWq={(`+jZ<-fZhy?0VF7V^N)|JM{X^cg}tOigL%rm@m8= z|8l_;{PUb&m-e51iu-P9r|o_2&spx?HQslgwayW)$^MP=m$&O!92oxjvG?9vJYqz> z-{WW1S@TEd`qqbw9`79bN!K}7ekv-d{qxPpd8IYGKKpJ{{j8#E>wkap)=!?+o7t__ zKjCjF6Q^9fSd?p+-sb4Sp540dwDzjEw8Sr@?ugql9vj>JvFht(19mT+Fu&KZp55X* z?uz|#{_uVt*7%`MOBe6no|`-5%N}NbuMx?IbY<20@nzL|Vfx40X8orJt{2V#ohGGA zZ0mRkAaPFUuFzGnEAg15VxH%ivU=*gp?^C3)%ajXLZz;rQoDMg?anVv-uv_3*;~)*xGHAHB*)-ClH~;0(E8E{}#K$@%uc8a%LzYyvs-L&ZEv;>>`Jz7U-0d(iQ!@Ml`%FBb;p@84Ti_xhf*Ctp>3(eK3W2EO$! zz2R4P>$t`I&5sVqdrWuV6g{cfWB%nG@A>!s?p@E)U+N6``p((qmpvW$L4V9kRC&*(TIG0NN^- zDW11Yl*wLm^^~~47v_mFS$oj7HHNe(aI={8xIP{VStZ7atk;XL{c4#xodix7VY+h)btOb9mr7hLPEnMLqdZ>L!J< zV2SO>GTR~EcCfr!Dw-!${_*Eq7JPhPgb)pEH7 z+7#hpyCr4bpr7(COfsjPOfsH7{I+9ieqz88W|HxAW@s|Wyk4FF|00u&STluxK&2Rq z1{t0VGP-CTnkOU_?{L8&qYKfA-v6)K2fY2fV()C{nIk{3u#+z4({IL}DM@X-Ij`@t z{-%SQpMA07V4Q44@|CxC-Q3H)y`W9#tC~L+U#Px0YyZZ>U4kEVyeFTXxUcgM`%{L_ z8K#=QwdZ$Px!%f|1!efsi~&UMoF4O@I=cl?S& zD^E`LUtZViXxD1o)Qe%Wn^_MWSu=IdfUU!(UnuI)=}E%oA*q?a#rN1!^U{WE4d%OS zn5x})pg8E0x^o}d-kF@UGwA5DRsEwqQ}inp-+y)g)|2C>4=kAQt~I@S?yW!c_YO2| z+OTR|!@MrNsx~R;HUH^=Vb)2jZdUy!)Ah5gk3T8fnLhB#K8p;N^ZB2zJr=XR`=z^g zCB^m?P^yNL8v9|L(>DVq1unQW*DE>B^z2dYzzes_X`?3$E&ET>O}pP=|(cxyqq?Q{)OHJMkTWg&&)15riu2IG&yLZWK``U`Jsun zebF#Nb{&T%`hvVG+FSgo1`U-}cn_%vg{ngLg`rT!z53((3s>Kc_;~C2+pSa|YIjYX za3{!pxTb6K-*(;1zwuhb??$9|asTkvqZzM--TFPkZG}(GoEdF@N-dc=$@Sr~Ihnul zrCn-9c&A)B5kJ5^;_Yjx-wnR`1=nkD{Rvxa$ENH)w{GnAYu6&S3}3mo+kmle&EB|s z*C6k^YmJ}mo_}rp*7NI=2gQs{tzW?Ln-x}ZUczte0pX1ZBV<*IZpAp+Ap!1!rgElW~Hc$7bD)C&arjb)>KAGgj zm$?pu;Oiq9A>3_EnGr%>fmr`NMhHRh@vu5T)`em-J_){X!HW|l;eG$ZV)=iPRI3BL zwiWwLYN`GCiT|93zmLhDInw3P=Mn2Bx?w|?dQae;Rne=ItYE$g_8Ed~Y^Sxdzd%vUCk(&=Y z+Yaq)Fes$=picLCcOD-yF3_SMJU!i(y78MCiSO**w_?Ciy?K$2`p3rI;Nz`u35o zPxG$6dvN2bdn1~9=IVD)!llBsG?_?}tJLcZB)#Rn--fq_>yykV~^GkEv*@h|FEPQ`y-TX~I zt@!$(ZpSw+S62V|d#~JD{H8toGrt^i@!|D5CELGPwW#6uziqoUG_{wi*=uES>OcOG zGWqKVgVd9Tf8D-)%=~lxYdq`!+rS#(a~t&RYPlWjdtm*}F`tjQ7dfhLJI%d$rCp}? z;MPa^)OZ+NYBQZ)y?N*lUmX7R;0P|iD<9XOUh8jeDVEQk+Na63El-t~3l@iTY4kL0 zeej=Ku1*R4EF=Bhv%T8ixO;eB=CsMrhGdL6zrTy;^jEJ$|6HrfFvG%;b#wPFc>lfD zzmFL;d&sns6}iVQFZeCsNz|#C4?bV+F?;;7?Tc!!Q^t<{bhCASy(sPGhF6V0KYFlp zw4qN!pAkXPy@tOx>;ufKY`o!_@ z;h}&BpS~drwEpqR#HOjyAN4zPz$(e_hr5DP8`XVuU~RWE zjX&ME`t0nFR>r>f9PH3-)CRwwfpD=e%I5luO55pvjwN=c$A20p?Z#wZ_eGgR4&DEuuw?bZ9QH{I% z^tS-rkd$+GCaK%Jb9!xCj{?5O64=IU)@7sr!{e3H%9IN(mT=*&{P;A4uUFH@KL68& zMTA83wF5BhG5}u;;Ud@=Fxgbfbiq*dJj4vhnCgLtTwZ6H90pJ~=JuN>M7Y`QBZ?5= zlw3|r(RQN+&0gh8Ja`o)Q@AbFE|uJ}@k^Xl6QHcH**O33L(6up{&CQshnocNd9rWK zw9xRr?^PXKFQf0YZA))mh|1V-#_GxxP^A>^jH74#XIoUTB~>zYb+#py$-3~h?G^_Zlf25= z6rQsex!*apqk;dmUmlKd>FIW~{;0NrxraZw+Ti>r_d~~2TVMJvZ~NUT19`B{c9XYV z=WRdmw(Ux7*wiD3wJB{|Hkfm_ph16^E8DADn%~`ZV}I%sJI5Q;d0%Yh)SAFzOsk=*+ zqtCo2xOesQ8KWBM<2pUO{)onZ^ypGr(E>LC|W&irWmEpdha>E^F|>a(MDtEN{iCl<)B?C=lja=6{#{h3K2 z$|=46Ft(C=RPFHiwShYlrx_-gB5p(ngf}Q|dG&*sMPoiLtUKe8cigB=&uVU8JKPW@l$-XLjerpb_&C9U;Vk z=j&I5_Q4w`PYV8HkOkG+=H=RGmqxY4K4MU{MMR=V&PkR@6J-1(j({(bNEMt|AxD-f z;fN$0-;i)lk~B`p)zV^Ht4N3XAvB1fqq}cT?Qb5f9$9iU2@;_WP{LN0>N&xi1CJ*> z2(_p3G$r4-0P|0!EPzn{@*skFjh>2|;(x7g6^e@>9dbk{1ZO-E+Qq^dRkB1V-3s!f z5o!mo0tbX5R8@cJ#X(5DO+$6S2eiSt3Sqhea3cc%P)E%b_->mxFgjNzmkFSd;>{B> zn5YpvZIUN&&y@+qQfP>I#XMsfP;}wdoIDZoZq7HqU%~uw!o1NC6ZNn_=ncqAgDPzW z9GHJrEBe!%@k9a^!;am-j%y3K?owS?LOU~>tu{g|{MN%bR}Mq4vZ$uLlw~yf1Ynu! z37w56>f?6WhGU@5cx8owokRvbl4-Ubp|i{ovbG>Swj6ToOyh}k+`V}Opn=KQf}XKp zxXySus)4aBhzK~L%YhRXv@oVn6=TK|L6KUi;I1~fD^=}s>)*=KPA!6;$^LkCqtGZvagl+jp7PMbz&p}Pcz!>Bxsf(2B`K??SxN|GVZ zM!kp~K#f4|K;bOv#blu~Oab(bqT3^FG=^RSwMVHER|c*%C-CS-RQqcPx6}cshpN#% z$XC;F$#Uq6Qx^(i`4>VinHdDqZN?7Ll^Bhxd!fQKpuRnt3@rykt{sJ)fV#mTSv?9H zM`3hiOkrOrjDa{nzdgE#a7zZVMm$u6nveyWi#}2LuK*QDB|>yuYbR5UP|6d1hrOn0 zwyC>8(`kdfL2WSs(r;6Dqb*Hl7~QC~j(Lr4+6K#KS`nZrR65SQMC%6DG?atUrRpVg zdxC)?DeQp;=97U&C@~_I;RIMbh20^17$z`R35DevCBv#PP#T3TFiK;1K+Bw#y7o}F zfWnkCnP{;J!(1~_o(jV=VxrY53`>HE)~YZ(cP850+z;f!MB9`YfoID^rzi~1!3(e& z3d^QAW1?%Seh~~6bfdeSXlp3$g@x_dcw4T(P9}S>?T|?18t_cqwDA( z(*xb1+FPLU=m4FIG*KGC1v@hdU}v-%pcN_x*d5&h=!lvC_C`z^7x^G}fPu&WdWEBI z07s%|fCBUjz_F;5?nTk$Q!tx?Sp*)Xo`#_(9m6aJhBS~N9VCS1gJrHp$pl-xJ|{0i`sq$UYv{8+JYG!J~h1N1Jxm=hOE6#`zDcTlC@MXZ2 zKOC)vzk(&Dgy-(D88@oktS!zLv;DUo4IVbwtoZnF$gJWKy{_UcvQCR|q9o`f@H_3Yc%2C=S+x>lG^p zHBjwd}ft$4ywD6%)YHqW7 z2k|AK+cFd{5`(;2wi=j+<_*-=5;R*6P<^lp3YCe$jky9Pq+Y7gd`0{OiBzr-3FOVh zRI0#j-hbgjS(*qoSxbHMu0zUA2CEO|1?qpeVxclol1L#+gL=I8v5`v?e!J#B>Dg8| z->!8tCvB$vgDREJrILK5bAUeBAAfT)y1eb%TUjQ&}+xwAiW_P z?FocYGsIv+8QhT#^`Z%VL}%&xu@GGwlKPH*F_UyJvwNv;`!&O@+pX=RvkJfwB1RTM zi(yO_c6We>g?sV9)q$@g(Cc2^7$KXkdY&q?=(XtnFH?5OP6lhv)Hc31H(^uLA9eXL zlRUz{j>QeAB?V^eX@%V5zQOSATl|O7ryR~#9Bs&s+gshxziC0a+6oq|Eyz`dSG2Kq zgoKF+#;xhLK+YD(*#bFROims8VPJxRwYu_9fRGuMMFg!wq>P^&ES0nvh=@d)bex=k zc35@@ITOf;8|)Y1Bb5ogl9PL=jHO4KBbNsRv<+HZ4)%Lueg@?ijbZ6pHWCN=CQFrG z1MbEIQUgyQP zSrN)Pd`TQ9PPIQoLOEB94f{VyDiLRJQsu%pjv^yjDDS1kZW-|BX8HSl_Sd@M-HI*h zUvJ%FJCOl_bU>~o$#ruexlRrw>71UzTHz`;r2;_S?GjOV+@3wZHP z@v*Tk?y*95z60M$=-^DPZl{(xa`5_bTKx|~P6V=Vss6bL+R7NBC|CX>+jdRVglDxS`tv<{bV}VBa%R&kW*zqt=cyQoRm4>mfIu3=qehffA6b88f zh_nX-9stl^8Ffbo8PC69uN?<>QiCEV2&&=r4s5JQ_Zc`N8Q-LGdS7 z%^p*3o@Xf4It^;#ppA?gH2`G$Ek79)7kGxv^TeF}U86Pg(!6^A3fh03Cwy;$XiM|@ zB~vSr0UF7t))MQ-_p{?rQjmef@fx+&rs<#&M2k#)sTINN0MRv&S*y-{PxF7WK0nhi zggjyAw(>DlwW6)#JHpEIC_U!FHwXvFagh`CCgF|HbbtixOyx?;;LQh}Yn95smVYkj zpcwwJf#CulgMj}8iUYjMl0nz8L=)gvqJTD=U?+Uf&(GF~3$48<>YO%I@E*kb4(}%! zN&^@NBO^4Ql0%59CAJJ$4$XRsF}&k{q$7XldbY|Vg8DY0)ZsYT|JY8nuF8-2;J`eB zVed!441Z(+5XwRJAmeXo{#j#``hs<(JLruo{5iqcJmd@#5P;rb%mpxKD02jR!-tr2 zJk=r|>f*r?#zMV2Kp{Xr^x#9e5Z-Whh2#b{o`7|cQ!9`J?UWYo=X`J}+e>x+Kk)ZS z02~^8mP7{F2>f6A|4stbZyabeMCMqDSQ>V@19IPK5o)x89IFvfG?YdVJRMStr7=2p z03oC^Xz)pmjAF67vj_%}<4PkK1;OMXvSXVP9a4i%paRBPS{5RCf9lKNsIQ_e6)nG9 zp)>gQiGv!pyWKOA>@(QBLw~668jz7y?_7|hl}+X_zmhrhhXr&RL8IxzC5MnJlE z?s)=#=LQUuRWVCw0!tHlnxqDcK7_&2rws|`>65w`QP*cj^5uyT_=E2Py!NCvE>zQp z;6xlm4B~iZqzNuz>;E{C!Lud1;Ci~gdCOHAA{}u;PPiyR0#rGnK3*ILlE)*>I%>gH z-jQ_TxjDK!xsCvo2dJY8B^Cb?{#5+af5JbRLs+&I6s#RRhtPqwCfKwbfiqel-N~%{C4p0Ss>PYzaUw#FXP-;fYUgv;WL>mJ zzmDhgw8ji8j~cfo@Z{m)laj@5nzsVRh7ns#9|V z#4~2jt6G!Nb+xtQtpUB%=U%(-IJ?GXcGJq)HfzjxJNiVNH$7)s`DlGvJq7v(Jh>0MPOwt_I+SG<&M0RM==0WNNOC5Bb$yB4$NmJZFo6&(`kUOg>!Rp}S zt#LLNt%`f^sUC99<_sB%t92OxWd9;R(udcL?245~Q@>5@D(V<|xZxfF$mIDDz^@=8mqemb;TSo=&AL zAtUgR=8PaRkPIm3U*MPPlc-Q6_p-MiH*Op^spZ3jK$>KqJXR!4mfH(tVjPeFEe0J1 z^~Ks7gF#QywI}Jug?f_TJZFMn3?akG!Ob{H%k}%G1HiQ8|6~XS*$y)fzjye`puyeh z+s#bRfe)9nI_(TB>~(0x6`c!How6o$UiHeM!77fvJv869`&;4U!jZQYT%GGo5)RW- z(vIy5Egx}+?XufVYu+>Fhz+7co|;W{x5^_n^iC-nv^i``hdG6_<8c*yJdmw!M>cFI8~XTphI|boJ4F^Xo6X ztUKN5NP0%4)Z(4ray7l48z&~zuL{$%nSYB^TM{P>o|dFhoZnHc*T#j5UT3T>lgHGb z%&9(YGg|*%$U^r^-Y26ke-3fbc(-S~i)P=OU2G!86l&K^8sj_6;oizwqTd%+-dRK3 z-FWMoW`a>scb6V@?aw9#25dQ^^E|R+BeU+w@UzQP`L!Q%8P{>b@X;>~YcIE0R62ng=wzHjida6Ye_VZgj$L ztC5Gro$+7Fn)KF(MmKEBd~;uz{&?Rt{@i;LuQ~Soe0lps=f^YPYt@_^=7q+y>orG> z;pL3D+q&s#3E)>cm zG5T+JQaQBm-2n}|0~)vk*mGN6e2}#_;cmMo*__ip$f^9*o?#YiygS>CeLNy`^FEfF zF(aUSQdK*%Tdre|>s`});dW#>YsX3V%Y*^X`{E3(jJRnN7mv0Um#hw0^*C|Vh1)B` zcd~m_m0aJ{eS4-x$S_0aQWzI&su9p%zfw z4YggHDXZ7(wKrhYwZ=xD1(UCj-#I?F^Yy-^v!fr)2$^F1s?dJ;z4^U+Zg(7ZY;WH$ z4j0Sl9;G`=7P?Kmke}7#ZSc?q7S1+R?vl7k;pMAzwso?aa^_7rJ$KH#m=`r+hi5OI zcA&ySVH0CyyXS0ITQ{3!?gL%U|5CbeyNOltrub)k^D%d91M*|0H`qj9v5c>b1>$8F>aR?nt=a4j8^IkuCfl<#RHr;c zf&m9H)W-k)&>3}V>0m%(v@>HvbS)L`bw0?8)Wqgqhk?oDk~%H6pGnfe1$^V?WIcP) zc=LUJHDCtcc~X3WS8FxHi5!7@m@~i=ks$>^1%bH%DlY`y>U%dw`M6}|j}0hK1p5|t zEo{~nXBR^{#yB`o&Tdq*a|34=Muw8X%{Vwa?|;=u9?jO)sklAZ6^BhKY9+|zE z%wEtUBrcuIo=o;@9*#zIaQsKZVdotu70B(A;X^fFmLW)%a}yOwq-P5O8tG)_z%gwT zJc*$KR$>U92q1(K16OSYT*GlFuQ_bV<(U4-pi!BbjCS)Yg)!V7eVeLewMmn|9P0OoeY*GI{+rgl7Tpvawsc;f7cHDJf5I&P z&>`2_E&SzzaiGcTKHjs!YIb}cd$+F|x7*4G9-Y@;+HE>+v3tYgxKq9!>6uoq^(SnY zub4dN&6zGVf4d_y+wU*h#B8^+G4VqpcS(U=KfAHR0tDt7BFTtlOYcp7Q!($gfA_ji zy=x9SKbP2SzhBa|vF6rm?ULoTdCP*dJv3jb&$wb<^IEKA*HMFq|!HCo9cS>;)s^*96lpaA}!vlsPbg8HV}5UeRKNh2gPev zlm)%LGjEcK)Nq1daoT-PJK?&j=&;z_DpP?=UheH1ubWr@ICI4>6_0t<*n@edy_I45skm^pTLFct=ImE*y74CVhS5{4)Hk?0OaYNF+ zwIhRP$>2!(?rrBNZf`dsotCt;(*~c%%)np2PO1vne`axkG|0K0^lsC=9nXn$C@{#< z`#vUFXq;vAvpwB*+rh<*kwc)J?&sHUb)A~#W}R|io5#p&E1vXqxiog=+9@e}zif%# zd+viJqb4ly;)bT*tY_XlJSk%EWVWu!m%sxf_m!Pk?SQ!dqid28}+E5qgbge%hG&7D2Gw=UN=zI6A|!w(0pRWu9{ zH)hNkIyBqe@vcqZT@T~R`1Ca;w#FZPMn&&fV;}Hqt!Hk@y!OlODvo&fcj+GV*n6SW zX+nw9kcVL-Y5u-D+Qmp~CuX<1y463vvWsNIiB$t!%Wm`^Iq~bls+yf?GmOPM->w;X zeD?**N3Ryjs#{hF z$0qa+K~Xu4pno5m$RP%^G@G@cJ%lH62v3l0A8=`Ipv@}MQ--tY#1DcKeJz}O-rVB& z;mXk3hFM{{Q8MiwRsQsydhaveuPeGrbEdIkJbLy!+QCTQfrJwx9P}I#__t4*2?Cl5s7^KtBHv4aE@Pia4$!1U#Ff<-fm=17k3{=o(*Y*+tKw+TFK&{ z2lWhB@RO1`s$WzUjS#|{lUI%oF|WVIp3e>weS4o z8|e|YyCoyOMhQ>v{(54=X zs2s4Ny7=mB{q+`FwSk6c-fgF)-Lp>CY?*f?x;$k;U22&Br-0pKBI4f<2-{;+zvF@R zO6HDvoYIryxO**@y~|!WTYQ*XTeLCCT{E0tOuu{Pb>pXt*H5mRz9K88LsH{M{;QLA zb~XmSHj;sn2Hlb)SALF8$(p(GiNX1J*8ap@dvgxQj5;-ZwLo!8dVK2zuac1ZmoJ+S zww*yz9ormZx0zpmVmi}oRsAxpP+#HKcS)n_o_}*1y)5VzHIq00wa@rp{5v0WOdK&a zX$UzKALz^(AtZ!d3Lxy#5)=7rr%~8nu)9D}aoB~V!Y(}OBs!w`BnKx^98?|HjKfK^ z@6X%_j_b6ZM1Mm2&+!(0JOdj>JCfZz1YP}4+ZO_b1nTl=UH+!$F1yNaJ@2i)jZ-mW z`U|c`nn_@f_Z3g1j|baa$&4AOv90mlqQOp$A6(Qn=opC?^?e$VzIZ0)q9~|BLd`yNkLn=Y3Hh^jmK`*SSWYW@?c+tQ0VO!<&N; z8rgPK5Q6q6Vg2t3LMRO%2~h{Ib&l{0GHm#qm8cU&|IKFkpINF+rdkKa>CWuMdG<*^ z@9l?4qQzqs5$!LpXQP~{9~*y34D1netm;1hNZQ`M@!dzhFbwa?;F)`MHeOpTZ`#iMwEiZoaTin4SqLQPrD82gAfr?YU(W5%7BA6kTLCu!x0a&Vr ze|QD|p=tVCuHcvd7iuc%KTO?JjTDP{(he;Ebj+vjnA?d=MRqstdxm{cQ=Ju6aIT@{2pYQ#5WzE0$TR^Ka}3HIp8Ec?aEo$Wtp?)a#wFfBK`QjRUs4 ztCLOSkCl$wlzpaHW2^iAXUET6%h@HXHhr^iDq)uOvGWYO2=|>MZ=BQ`vOIH|ytn#; zWj&wFsdwb+b$eT3AJNs~-N~)NH*EKnZo0X2XR-I%Q|CK*1=Z)iw_CAJH=ew>U*QmV zTQL6Z@|pIXPgs-;-@W}e-#&SvDOU?G92;_1R2NxUTSr!WKKmf(qt@Z*kjMFEo!smX zoFB&IKG!M;b-wXjqpQi~vWd=S>g6|FZeEO;SEraBpjVhfI|m_I__hjn@20~4yz9hT zD>h6`jm7M)O{W>t4bjWb?@f7Q!hd@)Q_o}J^{su`$z)go#Ky9-iYES>{Z*SUQ%v|T zeoWNx=(7W9X{6I~|KmBiIJk^xDFC-i6_De=xF}-`aM@%KJbO6mu~h_cFqI8}Ml&y> zK>$>Z%IhvyHh2=e6E|>a)18JtMYjYk@a>gWz$VpkH@aFOr?5Fs};g( zTwPSL>Cxyf=epS+`E+#4d`IUIYYh@CV@J$CP}o@K7Q5r|$B={j{cel?sJl1_1zb+g z4=BIhd2~TVyR4+)r9orU6r09p7IB&~*xsdv!|HY{y>T`q-g#Gs!vYu7Se?#XJo!yb z=&jmrAB6IlS<_zY=XrJCy+MBOOnORSZ$=kyUJf0OQgjVUqZj>qS5z5G`oYz;Z7eB= z7)TnoL>wTPr1ecq;rn>ejW>=a;!9@&c8uRYw7Szi6Hzya{@pQ_)H|;FSZ)vd_(K~4 zG<#n56EgcDnSGDUKFHuW&8s=b3Gds>I`3t&briGVpn;;t%ZkUxB0e!H^rPg{$?RqS z3%0_K1qZ>h=azfIlW$IaTyJ-=;9>Wij#aq>X0Rp<&n9)|y576;;6z)6gt!0>bh-4* zKV4-oiN$!~*BDmnS((4W@g>K)M~1tey{Jpt?Al*Siq75{@oDEI&xMz^9ND0=J7MR& z?Q=x7S=&edwk$EebZ3U(OWoU4s|WYaUejhY3<+zh-BmxsVMD*l(n}BYk3ILwnxAf* zRLj!1d%yVD%i>I*kC%ecvZgc1@)ap|-h zU0v1P=bT~qxCfYwF($|NufG`Eiz|Klarngk!d>hW#Bmoa~y7A3ifK=Sj?AwbZ5PBHXr;=NRq{Dn7~+o80+Q0waOX7n07|6))0zotlAKU zOV<#sD3dFk;YfQmYm_kxLt7+2Q$?XJ#!JMYwT+g<=qk!03>aV~@&ZjVW(R+CFFtG=A7%xXIaqi4Z&xC!-4PA(hQZzvON>L(3f)tf3 z%A8$^0hNlHCC-FeZ!OJ9H z3EorQ%}A#KEsF-^D#beLlQR{`NYMaRN_#H=mp;iTkRRaq4*fE8M=h<=5hJjwa05zc zV||ql6R@@%ixxt>L{)3A+-WXzCo#nCON<9fx{8byyG9wnpPFKAO(F}xl|EuHFW9US z4IpVhqkL)HVS5?|5gBVQ)@iA0R4)NIIv*f2IKVANY!k(#4$BPDs4oq0v!ZJouVx>N zvkrw~QAimDgCf3+d9gMfm;#m|^pr_e+uCDLH3~K*vNDu_rocazx~!HNU}ee}mCR|R zGO}4PIJrFzX@5a7vz9zjMqN;9m9g&9N~Z}0y;PFg4X}V#PAbY%@;*_U7{UNqjJr9t z!AupKbMMriI}=9bYA{CavS4>sTlYv~9w@zGU;&1D+Xu$X?W%fRRQI632b5JERcos%QyEZapRw7*+NJUZYMS~X= z3ZI1wM`>naAdF7Tdu0Qs@)=DsMm;FaTu~Mo>)qAS6J{oPi+Uf_#$1Fo$)n=MIzkP4 z;xt4wKzMW%lTB_<`Wq7Yp(gYXh7=%5)t&H5T0;*2%x&~p=}aL4q>i4|54<8{L%PoD zi^L7(RLbp%+{gyXF<^E?*He4Vi8bA*>#_2#!O@{wWew>u)=OCfenOiYGR%(P8?qY# zT}5(Ot~w0HO*TjhAMRwn!*T5|6YHpN+&F@72&6ZzsBlAXvHM7zPkU8xm!7jHI!H(ApWTtl>d9Yr0CT z!HFa3RL_mL+u%9wHaOzZMlkfCWT4WLAOPXR0P9nRg@h^fpbd6r5Jw{gl?VelI-1uq z_A~P6BN_%G-#G}N9x(?2qZLQsk-K6EY|@>?h`PdxD64Nzh`b&nBp2%lhS&##m6V1# zftk{YG1A(H+?hPolMGRn&S6vXHmG`tg=oCo@1QrQ5@i7v$d7+*gJTfFe{&NI0Hnvy#P!Mm^DhIC%V(FB%0Eu zu0dG|ckF~oh8WNtt-TOH8=a`6)veY`Vxy9Z*^5C68EZ#ZwR{=iEvls!RQ#f}mmnwh zXtNekO=&L$@>z4LhX*(KXt?K&ZL6t4J3?%r#^up9HE8Z8kKRmfoKXxFSzp#~Hkl=G zW?)5!nQSrA$(|iUVbWJJ=sqp>Ye&d;_sG}PBT;35PPMKwNi`_<#rpvFq&{QF4GBi8+sa}RvF;RlyKJEpzV`D^p5VYwogXF zM<+9s;~FT}$qjWVCNoq3wO0bbk?*6EU?VWT zTvbV9dyK1CC5^3X?V7-R`Y~A`hF8Q4=sR4}^^>#GA>R!pT2MNhz@~xZ?F@Z}q87Eep+qEAI_H8UImcP|A~}n4XIRx98W3od^#-aPJ}Z_k?ZpOu zeOj!eBKCR2OG+XlSBDFci@b7uPfGGNFLYogL{WbiU8KNRA5ZBzf^sQ7iU#-;Wmi&W zDyUqUJOKhR;{=`np$8F2yOe-->EfZ?6v~En5kQp0kQ(NDvJH?I_5~l201~N>u2G_) z6eaB#ZzZNB=8K%X*Zt^mthY{nBM7G7Hb5S&Q-it$R6Y#OrAWcd;IEZlScg17#bv?K zSgIJ7A+0hz2pD4&>qsquir_#5Z=F(dNm6g?sr6>>0PG(F6q2`bNd!5i*f5QSERl|V zDBcFZh}&@aCH;|N?GK?D`*MI;1A+2=P6iS;l$di$=L%#*Hc*aXC6WduR%%+q!<1YN z;H9)bf{RbIMPq*y2`rW1uMw-YSmj$a&bc65DAnTY38qL)@ovaK;<|PvOk6klnxt{s|}M;ESA@f7S;7c!xU{9 z8|ONdttW9jokws~fEotwirphw#X-q$kafNw3R*JJd&D}fs`X&tI#PfsX!+i&1M=0R z(^%R$X`_8b30*jqg>$zrMop>X-A9NN3s(YEY{I!G-&* zc4z^1DKJDK+7AcFYG9!P*0?Hu@T82A)sWO)su-1u4gs;QKZNc}oAW5_klXN0M$|aC z$22g-#uibE{OpW;wCVIq{1Aoc~c>i+Raqtg{3S$Z$_tKDu_+3aKL&T(I#4HG3^o3zO*(iMd@ZF6s zoF~JC;pH$k+%b2>6&{}FQ9a^8Z7cAFk>K-*H_@oXP<3^nk{#zTO*Jaek8KJhdb#Sj zM#=P?zFYl@uacct5uD4@G7j(Ml*c)o%qgRg*0K(&<$=Czqi;yCFMC}T60Bqj)xvNk zn;e>fP&8dPRik4gyrzQx1fL9_U^dO?Xq#|0Pcc=~o~`yD7ox=OB*RC^o?!&{aCk{s z9oU|&^BWh^iM{PNS7^_k4WW{kedh{Fc8MhZ44+QyThvmr z6oJwm{VCl`P5g&J1|`epEiQzFN@nt*+%M5?SC%FCghjE}1Lg|B%;I~rjgkH6pQVXn z-a&JPC>Ft?8Bodk^0wA-jWvLqk!@Ed1jnz;8eeuvOFZ+qC-xD9cL;r-gGp!DVtf{T;{w+7D@eAx~iaZ{of zQLMd=dZ*Opm`%x1ZQcC z?6uG=^k{e>jrBIKSwTt`A5L(Pj^GQyvx1E55nTet>vz=Z&w49wgn*DkN&m~)+Z3-{^>3uaw;3oDREBiD^{3G@3%M_34EAGQ8n0AZn+pM?G7Ls&PQU=j8d$Kr4sj{2}6=pyoZ;ZBpRBQVG_9DDw1 z=7l^BrtU?S#-@4XrL&nHSO%Nzfeper^oWLU!roAt*{YD^%8qPF$VtFH;qNI0wld%| zz&P1iz*?^_0cQtX0Nkg!fHI5aRBNp4GANmCu7Xk({)UT#Qn^I? z55Wu$>y#&z$?Q4#pVXGWpdzSLnb`@sRu#ye^qw#4$nNpifu70X%7AuAlMEf14bn<- z3T&3Hqe@_dxP*(igd@WvQL=-aWL^q-M^++_1?59OB}#rNES3rE9S-M+ROT^73h1@I zy;K40b=iF6_C;MY`%{;OT4lV&IR6Z!1>F#oT*_;860?y$;-3bXrX|?QN8%uGZXMY! z*;w>T3Ei66Kn_XI$!wZ1UKPw1vx(sBkfi`#l=T8s%7>^Zx17T&l<{ZPJUv^Lqldw< zmF$di4qB8xulkfImZ}tNqn_}2q5T5=;k$RXV9QlX7TuBOsfPyC!KdHj!mI)N1vM*o zVGn5Pa8`Ps3)`gGFKE~!9GjyK3wTteWiPt0?g8t8y&+*N6?ri6PSipp8;Ke3#j-ed zL3m$D*cgr-1-4)CV&xLXdSjM*vo#!>r%nm06uj9+jy1A3wNI+N*^e%4Y}i@3k88_( zL3qn=tIAip`^_#0zlH2l`7w1DYW;%HM!Q$#&k{MdEOcOC4tD(`IM#@H^e9F+pJOZ4 zJLN9}n<(W$XG)YT-eNoR%Z1WGQHFfL0FTgI^qny1313qkB*j!Civv5g#C z$#TW_R1~r4^QsS(3}L_VJd*QySqM{8aAy~|WT7m`h5e$PFNCr%7q&)Q39PFN>!u_u z!G%36o>7Ie3>P*rybk_pu!IS1eZE9q9>=J?i@=IpB}o%utjdK^dtr?30+1}!UKm^C z!l=D4w#tQ3dtq#g3#0bJ*ft5{?S-*-I7aPVLCMcruwPZ}SaUaOVUGG(U>(!53oeZ8 zTF?IB!pN@m>=zgIZjemfk^RN7dF*qay_kQ!uqGu-UJk4iTf?zAEXjATsxupgBM7v> zjv%iKQ(zrSR!3GI$$U8`S$QOjkuYxMUD?JCph*x$Cj}r+9KqA=)ykNj%9HS z3krOev3b7T)FzhBv4@y%s3 z0*sv#e9+s0ERJJRZwIpsjy=TMg^a~>F=Jhr30NkZ?85Gb6%1i(Tv%GzSezv!CJ|4G z%P_X_CTu6iNP}46vb`Le!S63^OWthtaCW@~TcFNnf!LS8LevN3OI0ITTNgIh zXSsSL>+Hh5_kRRfG{>aYN3tGL9&c|X>&vk@Yyex2lEXYo=CZLKC3D$CSIKa;NuA4V z9wqZwjYr8mMu#snQ*+ribspb85jGRpD9{B~fRH7!^GbTQWGtYZZIBav5_V=16xmX~ zHteh+iYNSyQ-07A{R0lKc)*u+M4y7)odn%{`uY>)cRy-Z;w(`lNbQR3lK_(EBdqn^ zGPF|UH_0QlvI^V;b}w&TN=vf6gtkPM&gJ~Ov?RII3yGVQKF4{IW(4*TPkZ)VO1Emy zEvMAFiMLB>8G8~MzFBWlU8$A+kXdBeT=FV`(nOcBLr8m$j=<@6f|B0WDX8uYU#iub zmNAi!g4By)Tn}j?l}Qt2Yyw8ximwgpBpY_Gjrh{v{a70ruwJRfx}+BO#cViG@y2%o zR{GxfPQd!8U!Z`M0?m^!KrQPI=+Dd?rgE6ZVJ3$oILznJ!l8}BDIC^vxDXKW9#DyU zSF|d+$kSn1L9}K00@2^#@I^-6FF>Rg!^DH)T?E7WvJEJof%NXM9B`oW-NkRjvCNE; z6Oeur-XK-X3mwZe;Ny>#N54QjG(qWhOpEx~j{TyZ4cISmF3S`nWQ*7`UUG!^rJ{)C zi;o0t1|Pd}57MI7e!$h?W0{R}$QSKlZ?NA`*Pl%h7y5m`Y5_k(`6mA_0A~Ywv-rTT z*a(TI@K*3otP7W6p}1VB6=GazM`)6;P~09qR0F+CaiHdVa0}7M#KW9^m{s_Ai>uKKotVf5h+$$cHcad! zUIm9JaRcZB0S_sLi-L^S1REH^Ey6ymcysZMiICdm*g-z;H`ugC9UpaWr2;dEv|IB|9n}RVAm>{O%ODT zWj0~A?`qjDHo|8k(skk6WUG1Xw#aB@I+t7BT(&24HoFfT<^qx(-p486?7dO8LAa#W z$;~oHo3`@hyp_Y^8Lthnkdt91`4pK|$d_Lg!nFnRHC&$?xy%=Znb5OM7~!)`c2%ei zogtsg`Pa(GavEj6;%xas*>j2q0HecJ%9qKGhdqk)BW*T-+e%@p+$K~9%@>HWTb?hr z4S!MIC|=N13i)Dj=pObPM)`#NH_XlV% zmixlb98#ze{r>_?XL6+)QCkBzjQIlQus~%uL?*e?2+#AE+KBr*YMh0%W!(TfGZSDm zE8*~4tr1Tej`23KyO;xT0Gkasll&KwR9w<2A{({ng{g2S^MG8vWZCnwm*;RX&5OKAns4|CX2#Y=LS#^FQ`EgUv* zxSqp~YATt=p@l=emM9ZBY~b(^hi5rt-ju87upfsLIXo-T{dl_^PUKJxUmmJV!V}St zvz_b+dxu?Ni-ilqPePKIC(aii6(1LW7JJGbkR6a+l+BYLl*<(|#0EJciGoK06(WHe zw_!9G6D_=#KcYb}B0(6UKzrQfq;1?h#V#C=+5(;j+@c}4C}1C8ao9n?=j2BK^FoQf zE$sCcC{g~sCs=`i-Elf5;t7=yz-VYu#NMVYU@VIOG_nqWX4Vlf9yU+U z(?$X&qPEDAP@A4qi3aS68X~Me4(;{=6j^W76Jh-cpyUCHY&2>JYz&}?`~E$U&Ic6P zIF<@{H)@M)BI*gu0!YuR^hLS|P=qf{L)r=`;_>tWfTb)0unec^BGv?%fHN@TL{^70 zH#vIR8G7jlIepjyr17!=sDA7?ho3-NoFK6pEIguw&BFV_=R%b@O*|e6WhWmEUzPAN9=r z2~uQXMRu#qPFFw3;-rtaV(T6HG4&30pSVLm&U0D-#z%+I3B=SlsnlE@>1ak>QXObQMKLCr?8;FY$`CZUVTyv3KDo~fTg^srrc6( z9Z+VeEVVkRjFi(_C4s6Ki`*;{Z^3&|c1ESM#$nB@v{lteWz2OJTVc$;^z(nhLAKjb%HEtqyDPO~kaKYMZ^1$_}uXms>rs ziYkl4>fl_a)IhfC+5vVCn#38}p%Nplmg4Nn^4eiGXEksxNjw{BtsQMCud(J>Y>tWX zY=FJ8sK(*2R#vCmcsmwHEy$(T>Vn+CY4J(P%volk3)IYd4YwE9lw13-+*)U~wZfR0 z&88Bsf&!LSRb{O#PPbHBP_oEfpjCXQagepr>aZ2Da*MNC8lU1()kUm8!mUMqQeTSm0C}?mRl*E>CCZImyNXB2_XS8odYbDMOGLRS;t80 zlo~5Wp_rxHt8*OI65Dj7Z?i*IP+}{$jt=CeC_gRywPxfj*N9 z3i?}$CgbMkK%2E3IeGTU*2-LajpI(4qnuW<*QwSV*edGWUVQ-GFPeNi*;PKXvfAo^ z8Qoq$Qa5k>_RQf@mu}A>wgc@Bsj~C-d`Va-8xEtq5M8}PF_&~6GTfmMjm~W?RKd*g z4Bbd;Rk@|eDh-`WwH)!#CM$rIVn{tn!)-+lyVG7$ZOoWnZLM@-tewVz7{nZheX0%4 z!fDLBT{xqsZTuV9k-_~POXokyE2wU@6-H8HI!HPgRcR}tG$veTC7*4W6;wiUCK;90 zj#^3EG(R&cr`jC$$_hB9(H4h|yrrk-WSQwUXO-Q_=@}JO)wLctG3A=h!rbGDfpEVZ z!6YtAD=)Rfuas4A3S1WVFs!&ny1IPZ$eK!;A#jitg|hjoBdj(UUExFcYgh}FF5 zDs;ucJtz5xv}!z(P*{VkQI%6+WhGoM1EAH`oGfciwZl?A((2^%)j152u*OpAQ6k-1 zSW{X`nrp3<23J&3SYDfFtM(-4SsajeAl}KePP02E-(H?nJsKtnBfUM7`s}FS-pW#b zTd7c3`g*FQ4t+^S~p&|@+|5^aD8*X}RxUEu35D5k?AqZuIte7hZ$5K#cx#T>^ zF;kcuX|1p$HIVEMD;kzrS!|u2T>@r*<87pAFbL1I!2CJS_eH!67;U_8FL zCJ#+9Z$pCIIQGIEae<8aIY>n=34#mv=lw_92N{jWoa%}CS`ErB?#1I3=Ng> zzEV_XC6WYXEQ>6hG|I`Oi=47rr>)3R-a;Vf(}HA|7q{RTuaN1t1C3RV;`eclA{HKF-?WpXc5zN=sRLRly+cjU9Pd;bl8AXu&O6fV9xzC8vT$#(v9UhNW9eEH&lTx00oh z>b85bQiPOBS~FV9?=1Vx(zz97EG{o+Y0lcpB3eztO;$VX<*o@p{s)uCYN?PSl$2~) zvh%fsgkcibR4{aO7?z^cOKuCf@KJ2At+?1)$-B!}6WEIIb*_YvoqOW2WWJ#Gq`A62 z##UZDz~U(O%yJi}yrNt3qzFj8_N?Jzb}N}H5Kiu0o3xQ54a1EgEb|?fd-UO1TzfmXYKx<&ESpC%mYI#+h*e6r z_<}5Z^+0<~WpQg(nxho^$jWLGzm=L<35&E9XJZk{qgiXts7gysbs1JZSnQ`26=B3% z^W3~zDefM4P`DT7p~_)%+9lh_g`dQB1sI$Z`D2zzDyGN}*C>hHLU0>z3xOP zl9MCH>q&IYonf}hDJ-oVJ7w3RF4v0fxCP5Qh~kiX?p~xbw=~p;7NQe-WUGS}6e6Pc zuPG@(+QqwNy#_BWt=xuNDzR*H@F~cnTx;RXY>!E7bZzcJLFIhzZ01T$6Xuijf_fKU{do^2R*W|QonN^vADUkrxKlR76sfupbgiS zI%6tk!C*^eF_y}b$Kz}8o5&dshuv`#g+fyQdNkC-NKyab0?W?*CBK4o&3<(7w8>fnbF zTypG`q-%@CwQPo9eQq1_JZ3yCJN?}lchNvmRi0- zax(IsqpEG?Ersvgjh1b=q*m7ecsTWz`fjspJrAMPI2~wtP;OOO>$cK)XLYywCif=C zm_}O-DMB{q0_`rN<1*f$|#Kt4qAVr-U;_q6#gx zxF^@#;L8j;t8oQPTBu^yIa}5Sx97NB{_QzX#qGqA7Ms(x`r{Ta=}wA1lm{2&qEkq_ z6P;{3V>&iQQdOLf!(ZW4+)~Z53n$_92CFk#r_oT*E-|gL7$MqP&C*>bN7*GMgkq7G zSy5GPE3#EXO#sB$wGE)Ud~2TVa8ocqP`tE%g^*y0?Sd;> zomqi{O6OrS$v2#c6;rKQ^xIP|OV6XUbVdP#;6qE9v^mYPPUB+YussX!1EX^YGFIBE zU_URNd~;;DWjfF8W$IqPzuZKZkw|iuw-a5@aJ)`?jBdxNQa~X)KjH5R`_1tOC z@RNsLXqVSzb_j(mZ>eGNx=(Ckg$6!g4 zP+#?Et(H?rhb6$>8qNis2GWYQGf|UTXS;hY*!BIl*ZXg*y^!lZUHlz;=?b<0+qNp2zmtaIZTNlt6pw-I--Kcf} z`2qPL3Nn@8i#x_5_=tipC4GIBLAnY-mq?U$p^Bh@DT0VbMY$gLU8%W1rt=r%?U_IR ziT>@VbbI{90jkJVqOYiCGSSyJpwUd2FCH`S_4QThMUhC5##dJlCcb!Rp3)7C5KGsX z%3*I&Dbwf~Bwvk26e>a2uvW`)^r~Tl1{s?~B*ZX(LF9dHPlZ>Yd7jlCorD+-8?^3{ zy4rAm(N$EqxoCSqr6p#%TKvqGn+^4%mK4>n2VI6zpt4MY4SUo~2xxdw%Fse>>Hxh` zK%YhgG>!^r%vT3APT-xesL{?b^mecox(d=YTG1C8Dp3ibYqUw13h6S1I(1CcdF#9- zwU3aa+Y?BR5vZh=`KS~DgLM;h7G1*$U5Xld3}pU+umDI_Lp*Q+H4u#i3Z!Pbx>~LW zCx4Z)wSL1XT`#GQ85do{DPJFz90IJysADYF`Y;(+60m^Adm#{XOXffYpbs@9@>Oe8 zq)@8D$EtA|nwG|LZ9A1h3>eIFg8~}PkrLe3fWiK*k>wPU(&wgvYIjLF>g7gYq;|4G$+XpqEal5W@OIMWw zBuUM!jgr!Nqm-aO-<$I^Et#YOFjT+<@_l5=fPA@mC`I%tJNC4LhY+oM<~=Py-dJGjhP;yz%&xn5!{j+ z{=__i$to}z;BO*i+>Rw{R)7QPoXs6{aQTop%ejtkIYRok& z?C#j}p|57nea`WEme(TR@bgPbxBU8Z^V)*hy+>~Ae16ffP~qxlE3_{^5b?zDsK@Sl z`qMVyA+OE4cFcO_p05-`m%UT8zt^O_eH~kS?zq_7@5n2Oi>GGq*tzSFv-ekR@}Jo{ zaI9?Z!L`*#zi2Fe;lvk%eqFXtwXogV`BA6$_xV4Ib8;2BBo_!!=j7-W^$dZ1hf!!) zaqBwAV>@GX@26U6Et}97y{qEwd!`t@>-I|TL}NVuOfmWaSaRY)m)@1qJ;NA%PE8>e zuvlmDGl<@Wri7BDk{%^yb8(W%l3)oE@fiK0>zmF<*#5{MwQQA-|3S1T&j!1Zz^MjnZJszno0Ls#x=DeDbnjc_p>p_Q^| zT7zt%{1a$YL5a%*PJug3NO*ds&VX;a7ggZ_Mpp}b7`{22%_crefaZBIxo(6jd}31Q zEZmF(+EE$-6aGCBR*a~JiCOE*eQYB~CXiw4+PI^et`>O|ebn$1xCFqfA;`Q4sB1XD z8P%&Xhv1ao5GiEyL_j+)?n5O<24^p{(>1*Bx_<1so`IJV0tS;rBhY3*KF9MpPm2aT z(SKi^0r|+H_>oUV4UmUsH~Fs!MTA1j3;yN{nu_{DqM|(>hP)_`$D@W*T;LNNo5{XFo%GFSU!ocIJfoXZ_MK1$|U#U|l0D(||fX;vd7&i`2 zsimjs@GKoo<~%W&4$N@g)^gyCBL@34r+{)aKd@jHSg0{8BX0n95_sAu#%;}06O3js z@NLs_o0=X4D7Vz|+xv}k1lCypU+-*miSatVq%FUwYW#3sVKEDA>N!|NlmaO^(ab7EKKYX zkBik*m|`(m%@%87iZ!{1CAB1_B)Qm{T1+!Ap*ShtQWT$nJWElMImKiyF&7u5VpbMf zQ%&Y#OG09Cyd~9|P-w9f7n&2z7ITlH9zCoj2}McCNyWuUR%?rP*|8y zlx!(XNhs+NZz)W$SW2v^3B{(8q69RNm{Qmy8M2lXnhMQDrXC3i#nvQqVp6KbYAH-i zPD(K)K;{zaN>QRUKE<4zSlFYe*czYMqa-EOTxc=%z@;d)I0ej$;|mKJYn+5ZC{C}f zv{cxNaF{S1x2h}M_t4}2zpnqCx(>(cx5eD`m@GIQ<$fB!C?PP_NStNR11Bs&V8&Or z=@D#Y*k2O&AYm;n>d8mwJq`vLe(xl@CHwCMaytP0Mhdol*2-A?)(3r#`#f}@ z`v<>8Oh{Vr$>91^@mY~4Rhjqv{zu_wJ%=YfSN`zNJBB3tU5FT;^J&u0lMXzZu&kiR z#=+L1rtjXrdgAL>Z z?*z(`KD3O$i)nb)nXxh0w~o0-qPrn~eAkWOIx;ss_n@EYmA`(xIN*t`eP@32u4M%A zh%1Q0>5Z)f2Pe)rd*P(G|AyY;T&5LQX{|1TkH+l}4CH@@gR!c(khz{ZbxZf9OFC$v zBwF0NEj9d;^WR)w_}r7|rTcS;(t0;`^VR(;9;}DcvnFBV71ipw7QFgcYLVE zXdDCKP9YAK=s2w9fChP8_!2x1xpcJVL_QrU*>HSQ>0+@{ejgYMkcp0{Za!FRB!1`bXA1|J33af z;V6ub+$cxt0UgY_OAY7w#Dh)_OTga<9ZtuUTBF+37bmFhHgj%ik@Dy>3~$xAWu-I9 zO0=GZE6Git+gsA}o;lD5I&AaQTm#-I5n5VI2L~s5LHetLWUczWo#+3K^f|X^im`sM z&erxvbIrPSL48R;pUr%%jCe~u9w{T4313k3g$7{%7Pi!UpL0 zmfAO>{b7*1l($S4RE6;%4VI#})hM$CR&cuWyZluqN^^&VWvlIUoZ4v!tMLf4Tl zTfqCD?J7xDPZsF5Ai^Z8xV`;<$N07CA&-Sa50b?eI(YBc-q31=g6T*^#C4rWJS!cofOeMTT3GzxX`wNku z%8$=eksFV1BD5Qi8uUrQn?-p48G0wpSD;)uMpq9{MdQ$FsjYGtF(UurPnGl=W$*R+ z56kiYoBxk!U^@N4mMAh)Q)in}6E$z}ykC3-mAJmC^Ei-3i-KVGGx;br6Xy*UtTMSM zD41zHeyCk3$c3gJq99+NWg2D*@u2vbG%|s$mp?AT-$OU$2*m0uIj;5US@pLL5Q){a)j* zrU~Y5AngyC&83x zPDw~j>@g0g8EAqFHC6wQ$mfz@_BZmInuJcCio)2*nglAjxAi@eesD`;`?JZL$9(@On;kM}(9X55);~7>^pQ7~ zWR@>nwDicjDcv6Hl5l2lPxX?IzDl_7WaNFnK6+o|x(<612IRdH@pi=FZ#L~dJh#*H zhcjM&{ciP=@&i-vFaEW#{ZC2ixNfIPzx}GC-)B?z4L@V-n{v>rCiz^>qSFhH-dkON zcR*6aCl!h;Q}3O8U$CVbMz~f=>MT{Ft@A z9~2EqxVtXG`Hp;*2tyT~XcA^YBQs1LFxC-~@=#N7i!~2Z3raO?U7=9PWTprz;42T7 zx0$#2*V4`hE^aH1e7E!FyPiKW>g~w4OgWStAkQ=n+L&P)VD4_}M#ke6=&?I*d7#sY zLt3k&+O8jo*J;ebrZ!Ym5$F@2fWxNv=)|Oygp?#nqRu2yLz}^s#b4zp-fen1q(_fV zdn%rKvqoHD%A+Pb$cLMTnljf9TAwj*Kv{KlRnNG%Y15_|D_UL(D6&_?RZX_ptDJE~ zj&j<}!HQwSFkiCX0s^t79oDFxM zS@z+QB$E)oV9L~Edvo@Uds&;jC&g#!cZzXO+FtJG^=tE)eR)sbHD%+lr$=thcGjD8 ze&62p>4m6Ci`MUc_w)U6&Z1FD%l)gaq(1eJ4r8w0<<(U6KJfdu<`en7Kb*0s=5m(!)!KuXzMi^;b+UIDnOC}Farj`v zT~+hmJEULt;XONZ9y_}CfwQNtHoqD6%Jka9_Kv?~tXAn_pPE&AcFjm#cD&}7=j)Qa`h40o zGH=ob-{#qq(#OW1e{`|!AIlG)TPJ+^)R~XGN<%kBC&x7VA1@o4x%CylD`P?~E1ECm zA75S5H{!!98UEzO!EUOfom!-GB4Q{qvsN*EBh9X>+^Skl#+p zQ*w`*np86o1`4GRptbluaGJ+Q*)7ImYFzL?;#%R&X-dihySKW2dca0M0QN22HL>c` zq(`xW{7ntvCK6W%kDY-`J=hdYGaP<_;^e7Gczd1mn!}G_x8B!u2 zP92i`&dgm8KGUxA<}D@PSvpKQXUJSzu;7cx3Ga3s+Gpg^J!ATIk$rz^#@%u6cmA?! zg5QXN({}&L&b_ovY%2KlP|)rJZQmO;^y}0Oeiu7uz7)DQeP+h_!$%x5&N{yC^7+Am ztB+lIrQMiM=iL9@@J!R@txG=t?(TIvuAkXi^2Om*jdhnlxIFah%aFKxK6 zsBn70vvG4j9J6Np!D$A=)yow}3`=8{_Un;-_}sne3y*4s9eZ!nfVk=vzf}G@T|YJ^ zaKgkDkMzk-nET1j1tHCkW&OBv=Su_Emp^>^><0_(^Kys7%Ls=TP5w%aYn2xy$gvP( z9`Wyv!6>YyLK{);-Cm2+l^X1U2Cy`f7rA>sIkA~%@@w(^3X=>W;HEI=i0vtw9~kgr z8%5T+OPgOapX$6Y(KL=~bdVzwnX=apUq5tSrYi~|THPMzc#Ol@Hofe}BN65;W-TUb zORy_2B^1QR^I&(6JGdd(jWp$$vfMa=UH^X;?Ba^tk?x=HuQoNVBjNS(##N@q<)+4E zElM)VOpS9)ecjE8LU6)AYmS0vO0%J^{UynFWRm{2Za^G*XZ{Brq(3U5z**+~g*ePk#stMM)57aLn zm^11l?+0g|4j({H)`_O%%Tn&TjjWiSDv5q%5xb~}4eea7agU-gT!K5=Bi$ijI?B8rk%&HMb5Yrp;wyy1~< z=T2-|b@Cq*iqgKkTeW6>ALTUVDdn!34sBkxSoVDX*{f~kFMpo)ny=v>&DOZ@R{gwT z{K}8m2O9<+$iKE~lV<2(|J4m0PO|RDc0IbOZ^pFtNw1!M{PA@&W_0>}@QMyw{}|M{ z;it!bJvjM=p{u_5wq|af*9W^hm(^U@@%#0~-+DD%vfZ`gy6Lif*pkmb zuc;_n*89}j(OKCC8^(0nFg+l?z38a?2GkhD;{KuYpp0ZcarOW@6hYXjDz1ye)!>+%!`^fMSh<$ z)qA*O^V;C&R_tvvZcm7*zeja%bD}AJeVYc|?dNtI!W%;WZccknJ8aD4O#)kk3yt9L&0#;If9IsNlb-8Zgq-RLuC$22|r(VWo{9bT@lOP)6_w?o@$!t7TrzJ2eb zEbiy5!B33}`XK7hN$-3<>-*jFeE!hf>wMvzgtZfGzR8QX4u9pbAHJ^W^Zv_MIv!i} zXU=2(+s5}h@j;6Jt~og=uYI09dh@_GLvyf7`*`9DS51v0+xCfn?c~Djrf-&XJFl;t zdNOXyD+jd0*UM91{djVIs$>8CSz)rElAm>Vot^Q_)wQ;i?!)4DoQgOYAp-K0ZsY!RPMY%GWU~bZ#0_{Z02+`Su?q!hn;WyxJKbvS0 zMku}9R)8lW*Eb3Mpxa&uX(_N~7wftCTA6T%!-;{XJhEyz`|E{RgyWR|1 z-{cGZ$*ynKvuo-*hD7>X|Gs;*Ju#4rEMp zAY)E7V|e26-$R&_qyrgqyxE2RKQ%tE?b{djp65KP#P`<@G^g!-XU-?n^9*|`$Ne?l z`sSX$UVHM*bm7UIFBTuVbcEf%rguWuc7LpE4&GCCY}eaE;(p2aL0mcP=%Dk*awo5v zqJDJW=nu*&-r4r{yM0bRbo{IQHTD}ve$`|I1T-uY<{iEA@ww}RIusn8vhIt+gP%OH z`NR7HH+A$mH8hAV{XB7Hbi?Z>w=R8U!oDfXnrlW5yq>vdQeMe#gGW9edUof9E{`g9 zF4gaPeVXxwjt~FR_~3oz2aTsTJ~ckoE7!7F_T^jGE?f*69W1!#jr_-os?XS8-F7-{NA}sP zSKSNSw$N0F$1-+%hmS8sENZ{z?881e>DIq~sko>4%1x`$_ltUtUu1sZ+JL&51KS=; zC>wWg#VFHgTF`ZnXPa>BvL44SEoUPC+G-T@3$qJ`O2;lHe(YlAE75W8l^j;0bf`MS zjbkO+=kLM@o$Iu&ME{2Ot>-O))PqR5w@K@6LZ-fD`r@EaU|qj?V(peI$Pf%Q@`w6-n>T&=BIQpT zSC#x`svQ!V?3??=`-3NFlJCEe_d)5U*VvdNofkacczVg<&z_lc;KGIE=cjHyk~Lw@ z;+4A&ADZZUbzAWZhabH#Z{L|6ITO?7D-%tg1TOxd3nijCAr~bR^fvbM{eYS1+C_cv)-)4hLOo>?|Drr_9-uPm=jeW6cD z^xfYF<#v;sJEXM@UlH-PCUD72iz$DXDc$et#07Kn26%rsd~b?+cmFdFZTrA!8q>Au z3H-+xmwp=5c;aA}iSc764*X&4pn36g+gDpkmlZVT?Rw{-VGkZY`s9RDmcUBGtKq-R zYuNv}<@&(G-6Fb_>Kx%67ws5YyfCM5*MvW(b?E*5n3`<|7WE(AZ^S9THOfAvvwtc% zBwLw2>&nTYe^!3=$eX*K`e8puc`Z_Ls-{v1bD?YGM zIIPz^H2uW&mkzy=KH;9=HG(3$({Q(^x&Tl0#XsGG-_bSwTejfu|2+DwrQbY0zOd|6 z@8u8N{o&h>gdY7rb$TsZWS7%Rj*U+I|?7q!^>tb_;W=dP{0XeyG#nMlL{0n<;>AfxY-kTmZ`Iq+IstXH7_)Y;!)wM&GjbuAg{6c<;t8KJ?yk*bi^RK=A^P4l6eW)qDOQ&A%T$XKGxir7~ zOV9r)KUcLben_`JN9~Ba@%&dy680AsJo4$7eiyI4y}IOq`~I3#IQz`8AzsV6ev$fJ z*pMkjYwJ2z99i?kZmtl5^j|GQV;`l#tS$BBp^_uebCZ}_9_!l=B|XYc;xb)QkIXUuorrM~cR?4|q9 zCKz?ye>xPG*RA6(uW!rx#ISeQmQPncySe}4Z@d$hHvH_o-=ZFQBA~?d?*8idp`RDk z{j_>fT-(<=?#SQs%xCGnR^?3jaKq_iqrS8?k2!p**>vd7;}?ei;d5|8_QkdB!&2g2 zdS|S{c*SRZPSPh=G~L?0zk60vd-c9gl0SX7U}QEB_TIm4__6BiG|>tg&I^tp9Ml^0+gF zS8GHC`{J8F<4v7H{aW^a=EUUqqoafkdQR)@iwKM3dcS0(uT{;DTO;P{*irPf5zvwpPS#s zyPfY(Uz@q_`rbu%{Vf34N_-xV~rdFRScj%Sx7Jy#pQESX(C zFvQ|`?6T@=RhRLKFAlV+j=6g1 z;<3Ez@$dW4XpG-cwfP4BMo zU-xj2({rBP^nT}nE!su%uPvLuJt^z+^X z?X<9Puxaa40h<@8&pw`E_kMB0mh-Rm&b9Qtw&JOGOUE}Z9@g{Jio-h(Rt49;xiB(f qc&^iXAH2K&uFHk*7ws+nCgLel(Xaj literal 0 HcmV?d00001 diff --git a/bin/Debug/netcoreapp3.1/Microsoft.Extensions.FileSystemGlobbing.dll b/bin/Debug/netcoreapp3.1/Microsoft.Extensions.FileSystemGlobbing.dll new file mode 100755 index 0000000000000000000000000000000000000000..37373e96eb89556a863e686fb19f363030602d4f GIT binary patch literal 39288 zcmeFa33yaRvp?MD%syFXvau5afsl13dsxFx*dbvFf?<+O!a$MQJI2~YZD^7QYMS`_=Y-tEtJ>W;N}Nf>mjP0mD{GrZhkFLqc; z!wW2BWp-D1zBSxYQ5J413-3KNJG|6hXpQ&t)3=jZ59`C&AVI;_boly=yR~yHBHTwX zF;)VMR>DTyk7qc(4frw^$n&BkHz7!V{yB#f_`wYf{hDwekJ|`A3Hk2|A zj7?BcM*d7?YVXrM*)yrwgzO>_?F@8^~r>};vLo!I|xZul9_bCr~$7}CSyIlK%P~QUhyH>M5bcT z^kD3fevIijwlT>>|7#n;zs$7~qnb0Ok9I#3#hC)E6V-x{5u&1+plHULn?yDcTmTvr zaau7nN`t;dhw2sfCLr~RF>36g$oPudD9EB#hmFx|>_Nc9T{>&fRD_|bpDtFdvm1f? zR8&j#nE+dhESR-QWCjv4B7jA~ztz!2qF6<3H_w-zV-%AtvM@oAB?Pok8Dvp}#;6tc zmf))QaAoYD(xCGap9f&5=EO{+RM=a2b4v_Yp|wd)xU3p_szS3$dO}QPbT_Do5Tdf0 z!_Nf>QLw36ZZ zMTLV+6x0zz7-G_hQAa^?b#%0-P=-c9;p*t-CMDYnJ`mU-Mm-FaBB~9^;o|^{a%Tkc zGn8=}XIo?fMNtve4w-5gRH=#$Ku;i)68!>SWwbI1-HUOy2Zdf~?|_F-OoYZBg^aIS zThkHG8py7<#~_J{rCb~m+4dit)oWta8n@A9&UdRNwI=&R4vVj6dUSz7&s+>VNxtZO z(f$N=KOSv}RU~MblXtpX>l@AuD2WuSlZbGQQqjzw0IJxgN-m(njtHfphDa!$;wO8^O{+^q|@P=Hr+*mD$~kkWA13NlYwtIcGs zYSmHbfj(BR6`kmS+V5c}uI=;~Vd zf)eAoc@zeUI{J0dnT#f?wZO_*9c80XR}ag>`QQM~VW6#s8I%}}Rh+hpAccJd3hb#w zOC`MOoh38eb*Nk+RuNNYCe`dgGDtC{JM;qs8x;CbpO{3oW+hjKZ%lxeyO^J-vttOU z+iRs*a`~)Y8>`kz{-g;TMD9Tk?5U|puiqZ3A(CQ-%xME!j@zkK)fm{o_aPFc}#x|(Ho=C0R5mQrWoi>?HmX)1d^s; z66YsYQJ14Y6%*@^X>kcC?1MlN(_aE;a*nYN0me6`jn+OC8B`*vboO;bJPepv4d&_L z$jGDaL+?>1R$;&%;o~xbk0<|4c zRv*(1jf7Jp8iOX*EE+U5U2bh;7txRAjZg_qu`#h)P}|1<30ZUT=+yt_&6{WajmjIL zaHQsPq_K}hQIIYs!l;Y7hq8L5LEk7$kdJ848+^D8K`{;#aqokP?nWr=A~O-A-~kl( zgeV$C{aBn!id7=p!1fjj=n3Ix2nm~{Jk1}4z`+Dxw`uiVlh>^jaT{_LU6I&tNBm(+ZSct*kD>Q&b?F79-=Fh=f*1F+N6t z`wG;{=UwtX;0-nCpAstbXvQa|6-Y@lzDljaZbQb;sF3_jsnefric+qhkD(vITR%`7 zd1IWK^F+64baQR{#I%=r1}T*W%#Xx1NM%$>Y<0Xskm_u6H}7|E=dF%5sGYE4NcrX_fuYB;FL+wk$N0*2ws-cj?KijE)=L5ZvPA{(Kh+xOCn>K8?o>3am@D2 zy^0zvB$W0^FngdN1Cs&pb*8l1ObGMBJ03>Ws1i=@EX6|~<`e82>=zsa=P>~eQiTSo z)6HnipbpYVH4SQmDk>ZD2Wf+YbOv2qszGbet7e#2&FCbZb3V1Ci%Ia1#3!}&B8g85(Le{QNC$SbJ;OPN zR{;0soO@VOkXKcWv&voES!&#zfpsWI;kljx7hJXKC&nVO_0{0>$Dw~s3|8M zNz0}n9|`hBxnE4B!7s>PQG*DhH24{`lD+~A{sv7_oFTxVCEosq0GgICfnwTHJFB^1 zF&T{oLHd{&PVDc6^Nk6kn(+pMPa~Eu&I|!zV}kssxx_kjKZvFRgRjhef!u8#1mna| zAA_y}ZYRbKM+ROa#wKawLe}!ajR>|%fsXiM(gO+wWQ`~b@Tu%Vk%L? zJ_AWL46Uba0b#@{g6uOXtB^{%$+S>AmNx<_J26@4t2sGep3;b%CDmw44bU1i3s$F( z7*&fB>|}ieI35;2`WfQPIy|b7SH`s!qcAC{W1EW#X?89k$WNM5)KP;;1ycA1FIvYh z#S;@R=2v2(m)OVM!n4$yR~+`_Vb#=D%t(JO7 zNzjaH5eCum4Im`x?6W~?Wa=ua7dEDv9yr6811v3Y+X9TP_hRkUAa{(gTzP;{F=B6RAj`hhkM$7%>w>ex_d4})5AMU3fNT#9TV;@9#wY@8nY77Qt`qOA%oat$*(_;ijArz})+q*k}prV#MmZXW9 zZe%mDXjVoJ2pf|VGfAS3Ya#WPAACe1T;b$_yp`AJE7K%O{fLWp_oEFYk{TyrxGAcM zwULEZW0j<&b;(T1@V3-dn0J-2mGJ&U5XsB?W2~T~9&$RWOi|m zjW&>riPC#K!z;+YFm&ly-Ecb-xpP%ys<1KY1dLvVPpEH9f)}A$n~P3SSkv(F%mW3c zvS^L{NhsO}(~hrJopdaWf(MBk^`^(jjlp9Qa5Q!l4F1nQvXlEbyaNgEF8Q7mNciaS zaeJK@h6u*T0a=)P9bEFS^%<6%n&6YL5i9vbW8@|T=SqSgpR-IJ|E73w+v_KJuF%uO8+6cq>!s2yGY8?vNS_% zJQAvIj|Q>+jl_dIlECO8ViaavHIC#6&5t@U$0}GNw4sNOc=mejB?>jCOKKwR>ZHov zbwgoyiB%lfO67F&zy(XK>3~KQ(ut}^;&>iyYN;q%&%5L9%R}xXs_JMILi8AVsH$V> zfg_uaausxj2&hv;K~Ew94nC%0yYV!TzsrZcYKjwTzP47|F{q{N81C;SV1+RC%TT26oD!FajE+W)KAo+r=2r$1Jo~K!An+pvq+(m zB9G(2CYXCx0a*<}l{kA7`9+*a{!~S!dUfkRa{FkYM<0AKb@ThE5cx?k;iK7E+`l{x zxjtoQHDc5z%E1QG9yXqdCOSgKtj*Gy*h$Jahwp9#gCI{^K4Mi8n)KE5QGk{zG~k;J zno#|j8a%|1YA&%88qil`5vLTj{APq7rB|bKO0o5yoF@HwR28cTB^|G8wfs6o7u5u^ zWk97&C+$C#QUM3Bt5E4`l&C~5YfwpB2HI(aBt?okEx)CxHd8xcyqPflnTynr+-gjB zT_}$3rbE0SjaWqz8Z<_&9k$oUHFqPV<8B?_QQ6m^C`N10N}wz;bfWLnjpk>rR54iU zo5aAr7NymxBt+{!xD+v+#F+#~HJ~I&C*ojk9ddX)froT$BuU*wmila>yRKXl)0;l- zWyx|9>P83**gRBE_I!%$i8-xD3$%j%(q|0}LSJrJz-4ahaHYq>m|Xc7e&lho<+zwP zLWwg!Z=_&G>WpsY#4y*-aD(7SYfqfw(H>6r#nv~Hnut~8sN7{S;f3<*nup1+(GbL3;E)b-*xeOyy$o*+(liRPLjBZTPf_QgvtuK|4~Or zD3taLcLtP=Z0p6U4PcLQ=n2yt4`SXsF!#BOq8cka9>C?NvsmIoXMXDF#tESZ$Pn3j z(gQOAmH;#{WXhEZB*nR5q9&Ng@pMj=nY!r7*C9=z#}KZ^zMzSW3urG&PN=UYggUxR ztfEY;!SNQ4Yy?DYB%KArR=4pOd^-<9a2}NL@F2j=qcP+R0agwU_w6mwh7@zC z7%}J1c-*V!hNb9vIC&c#p>QJKeFY&9xMPTtT?Rgs_l@ep?I`|x#SmzLAqG+m*@p)_ zk?6G241kcO&%h952qbYpJC36Jp?1VCy?ry1>JdQF=%zX`_li{n+qa;^Pgj8oLJ&?t zVdevA|~miK>a4D$Y$MbEm-{_ox^}y~fC=7Nt>m znAAYW>Rb;r4$qyF^gv^eB$PPN*yC~W#AgfCu@ZtY--w!}AYFh0$S8_~`rr z{w5@m10WQ!F8IPK483RX;JXN4^pC+{tU%5;!xICWrQ%D~VHRGO>g(`T;p>Ypq8mJr+QvPiR)^)Xd6D|J0`Ws#!;#?&fKKo?g-rUcvM0 zcv{LaX_|T9)`Iho*2RG4s)|ypYIC5PE%B%HqLDCDIR0NONmR2B7-8Px`St=~{CFC! zCj1=E?IDg?hjcdU!sUDgGOJl6$M5nb%J;RDmiSY;K%lfaO6@ZJn;cWm)6aQZnSRaD zR!5$O^7JwCxT z@s#@#E@||d8v$9c4(tHvGBiw($h3f3_z&Sc1N`+&<})|?ICW#9Yl z3Cv}!@YYuy+KUtV8*?G$C=R{s*B_hyw%FZL|9(~WH|DT*%*vrhWvG}_&J+6^Ls2$~ zmwke=2`myXTv5GAGBlM#p9Z~W$VFKthn|z6nH)O8p$@E`L!&tq#pZHor3@|L?bWI) z0+&EzOL$q1e??#|phtMw1YVZF9_MAfQ8pj?Tg}T#QI^Y0(2)X~9}N=|w1God1_DaM zyFH3Ffh++&k&Bh%c3!rPmvv&9N@&}9yFXM30)JR?zWFzdzM@PhiW zL!8SM-rf+5A%T4?)T-LB5Ji7Q8@39mnJqHR2Ijkfc}U+73I7~V^@c^j#Pjq|zvalk z>AOlLuuF;tv;NIz^lmb)V+bUmGLOj7Y#>IcYhFZ zSc(+#s8^{{+2i8-$XA22TekfHvsGsHl^;oXR;1R|K6MHuJEM9Ca&A|A4E%P*8KlIa z4Z8u!&CDF!Uy;fl^*Qgs_u>8hQ*jZP7@i;E_bu`TdTOh+-&JtFss07&gCYMyY7>7^ zsoAxFEyzz3ZXkV5@KFowxL{NxI_ZhOzt~zG3XQfyTEo-jECKmutSe|<4%sWVVPVPv z>Nf08MK;nH1?44-1$i~=sd^f%1cg#t?R-fa(Sa5ZUf}qZendG!MKrfl-d$!JOhgeA97PT+?REDyZ<8gP_G=lR)y=`hg){aBequuHN z_5+6wX}73uD2(j73@zgj!VEr#w6j7F;##w*1hMXhw*htJP#xPC`aYl>xy%vzi8`1) zBSQ;R7t|pvyd7~_+GKFRWq3eW4oR91Wqm!+cPN|2p+iER@|rq~EtR2n05xG-WGGqp zo4P4G%AsYfxk1!4V^NXR!ZP-2pr~oV=EzV_y}zavJ0U|?bWJtk>?;q{MiasQ^gz*? zNaoXC;&Mfos_DR@I7D*x(nPav9%!&8hUG|*_Tzvtnm9I2hCT;n9J9*M#()US7v&sU z#%%r;4b2|(Ipnw5FiDfZK9DHUf(y`f4oP+}GuDAqYRL{}rj;SG1Iqa4ke|Xgg1Y1*yED4(j{7%65h<)lihB&mq;$kjFI15&&p)XoH4UNc1_R zvW5zLt;8YT2UcTtIV`A8Wd>QyhAjwbg%xSpThD_OkJuCX=;`ktkm_Ue)wu*JX&L z?#<@MN@die-mC>J4Kc=!_(ZTitep(e80*7gIYgsFsqMqMaA+BO!l2joV|_Rzd2)Z2 zE!6|1fOnJgJq}X9XbbHCHbI7-^NrLFVI>m8 z$I5W_FozBaWU=8?2_MNuw63KOK}$8+5&($$m%|>F>rvlFvZpyThrO?Q576r}bSyLi zD~gj6#QQLcUE~niC{{a)UE|OpMm{l`4dTvqh*1k;*kumQ(SGWisLf?pC5YV!iohHk z%pGqID-WvDN!L$EY*x-uX>e@XK%@6)c1Q?C+?yWWgc^J zh`4mqPGEC9Wshkr>^%-$;&SG*QtrNo7-^z_ZRQY3-CJA0o|hoD&@TdIuglOR4t*g* z)Q19=%w2m9o9>sTEo5tChqS0TWox$QcbcoM*Gg+n# z5zm?IB^e@~)$Dx<;_W-%9s&I?~4($=zbGITH` z0?;;GyHecE5~%E`486>uOB_0{yA(V}Tg$$eAmJw?QT{BK<%c8zLXgJiyzsdHLQwXS zp=JU7Q8ti6l4sSjY!1yvBz**wB^;7$TgRq*QP#0qnbL=?)Yh^2GBh7hJzF9}>)1N& zY_>v%+OaL#``8m4lG>ZcHp^uN>}_!#d)rgCQ@enj=FlY_&C?6n1ql+iV@_SjzLp`H zQx~!yJ@sDGE@WXikfTvd^WP%YT83!;Tf{oZ5b<2Z5@d+x%|$Ftf_MvySa%ts78bGo z9Ga_b5qLqnh?U9^%~gxo1GkiIzoqP$1aV6*VqbAcvh-rsE|cUuFOa1dv)CR4NtRyB z`g2IK?P4}eg1BuLv(a)H*>*9TAeWJC7qcg2h-|wU`~+4nQaT<-DOg4Gl&%N_cGO5| zp&zBWz>AFDYZllnJ>}zkDIdx)BB!5&yvV-C$%Vig^9uGP=PzNJp{~TiorbCjgXOL# z9m@0moLiZJ@KSz^SAGiTBjJ~-8fmB%ygB2Ak>rsmrBVsgn2Kx{mznyA9&veygUB+2 z2_xYnIsU~^!btq3ybq)jSprf8BgvKQEv^|V1)j@!C5ZCAoLdu~Z;2E-2fc`0*6n$T z^C!@%ThFq#Z_|~?iXpRt{Q?e3_8sR#niM%kA!8CeJrbD2SxP_WT9P#H-6N^L^m`b$ zT_k#m(pwLIRrjBBkSHk?Wz9<%$)g%e;f>tu#s*S;dlK(cGGnmT;_tx|E9S68J0F<6NGekc~L2aKh+= z(+`|#;Vz^LPK%Opl9kL_;@b+}*7(wEtC4ItzIuE|;yWJi6UXA4j=Q-`eA96zL+4t< z@zvuy65sJS@1)g*0jY{L<@q*9_1ItZ3kYNxJng~LES?VMX)aGKJhkz33QsF}TF27` zNCkEkX$zdq{EC@o6Qj5j%<4kokv9errVbIM1d4cjoI{;JYnAPc z(k@7+HKOMTBEd_lbR{K^2 z2F<%j7YGBD$B`ec-wMha@jc{ULfr+z&-&9y=jg{H&C^`~{<7*Tx6HODM;f(bA*?LheIvM_X)KMW?>MdH4EE$>gPlGG@gG5=>p-bu|n9- z`M5aenLM2%^L#C2mGA)aFA6i+4nKj-WGh3)b$xGkh`Db{3C%4fv;L}q)$|;X>jElGX9>;&m@n7&- zpUR~*VzT%EI3$bIm-XVeyv1+%iO;uKWxp+6j-;g+OOv?Svw~ zc-BIo6R~!Jul_yOj@NC+`LyG0wPUmsYR6B_Vui1Ko>C-pp6&R4=?loYLlMgx9k zr(7WH5B(i7kR)ArtyoSU%Xb>d9N$|wZdAd(*~&AJY72a+HzWS!OW!JbbK6Z3Xw7C5 zj^H%6Ek!VxV#mmwAvdSl1c(t3EpvgM^HL-pU-IE@Yf? zoRAtC&&CP8bPix>e0|L63k5oBD-k4ZC;F~XP7%5qBbZI-ZrHALfkSsT6CC1kR^h`2 z=;Cn;KNM+mHU?>1HVtVEt3{f`UPRiNrTfI=BsCl9KsEtsHhTo=J?u2n0(J%IWY*R< z9&bGLL|Vn{zCGA%aPB3idgLuUUm&N1+0XOmd8!adl3KyYQ>t4hP};yT4LrY&r{{Sp z;9djtJZ<3VIq`lr!?#dzis~w;bRAFEbBv%QOt_L-$>iw-o?1A*mgnnuzJceT61KVYAyp$_iHGBo~Hsew_CQ6=WhERS2PiuMF zz|(y^%?#t*czTYftO;SldCHnn-Ef}P^0a}c`*?ber>q&#Sa9<&52te9vp^vnQLS2B zD{c`l;>Wkk6t5`WS6op1q6k(_Q!Y_HsXU=nVvbW`=2K$^*5NYK2dOV+C_nteoeOSo zjPT81++K&UCb;Hnj{Ce8$hE|oaw|Zs0kvV_tS$bvW9>2Xb;Q3I%y_X#O-K_l)6v=1 zP2D$I#%AcRAZ_nU=~fk`Z}4<>=ugOh8SpQpTLMJPYD z!t=*{s8r&wR<}m}hHoTKqmfE=r8HYdt$Smn{C+Os@W2GnZ{c}KLP=Ul&VPdG7n}wT zdxN_omHOf>r-YH@4-f1C8cAmFd?N>uDe#YO*T`0WuoL}~U57LT7QaTqFMz0wh> z1zbf|21|;#tx7;T6Z}NnF(e_a$Gw|~yQws!3$bbu+5L!ESZjf|$Q}e&k*#1okgh}w z6WJ=9{)uc2ewQY)wRqoNWDRId#2SQd5TC&Po5-F-%Ocy1I481auv!xFp517qui>Oi zWP1_$M79qrD3R@Fc}U-Yj3PUTSST`_J0X1&zhV;EQT%pDWXBO5Bk|WHB9RUeIv~vv zIwBn<#2_6b#33CkBp@9pn9<9JK#4mvP{y&xKpDqYf-;Uh4$3&Zb(4U!0hA%|_%uj8 z61tg!_0(QSAP8Eay-+3078VNIgx`gBVyxIn93+kuCyFj{p14R{CcY@XCw5T`RE$>S zDP|}ZD%L2TQS4V7S0pHhDT|fW%KMaim2WDQwX_-)_-|kZjG(hh2mA!vFVE+FWp^b3 zkr==2LDvCRkHWVj?2b22V6_l zZuxGI7bH@_V2i6@A}`=zw}QO9-Zp1>iKVhviN)#U$bMGW2&=QA#O2H?>swJ$GR)%Q zRovA9yR43~UiLEjD;ZAWh9bFf^R0~olp9CRyKySGt#NZ|o@s)aW%VhmD788)`6X5k zO{uWBWFXsRDVR*iUiOj_Yk|vVFLRTW*j$yp?4{)vht=W51Zn`(-{PE@ZFLcTkj+WY zTl)Y+mu_i!dD9%0a>|zG<@L3dSxQPO0mGVY$>x8TMKh0I;@t$tU}Z*$;-2q*<3bDi3i!Eu#h>e z*23E~JHk?os;sXCx+`R5c1NkD#5M!jE<+$lx5;^VJz-M30@K%KEdiGN?d~O#acxd} zSx#m7U21Yo-^q|W?;XwbDJyi2w!y9MDCub}ww3)w8Qjm|`irtGXLdzFfz|0OswlaW zYc`zbPOR*NcNW0Ve5_cVcb1VC-UUsg(E`cutdMOjE`=5EEa_QcgUWLpwo<5rm04X* zm!+)G;wWSztcVB&R)$DGKGzF>6^OyWS!D$!70BK?cq9|M%X(W2N-zf9;H{*C;Kde) zyQ~-d$%Vn;9ZmY$J;i9S&-A};@a|<&3+}SNXu(~K7Diagimez?Q|*)Sa1OD%dX$%! z*a|4%Fmg?o14)mm@L!Jd3QjDGBB$NS@ud`3t%YP9(i(pj5kTXJ9NLZLc|y89oeFx} z9EfIiM!N^mtiDOIAGl4X)v&%Mf^c*ZyhE)b|5CYhYhor z$p&JDlA*YO=s##IWv*U``V|gIYI*d#Q90Bn3Vb~+cvF*r##qQvo=$j(NS@nSXB8s| zSbGr6dt37>ii^q2jkq38r?oV{q%z0m z@UmKb5l;UJ0>?4NG(_${cRAttP$U5y31PT#GKKH zayLu{7-eA*7*SE?vXxpn-et?T(K?}#RiEkB0`iX>K9;ygO1T_IWk0J+%1@;^ z95JHMI(=vnvy@dLby`b`*kD_M!|t>fx#B&Ba>h4~jDC1m69cu_JULmlim(x*%kRt{+=iwc5=Yv69nUNM;b|9iv%7vI2ObcSrL4N zXP^a&96V1er7|q^N?@j`5(+)OW8uf+mb?gLc{V2uf@+*Yp*w2H{Lm5&=|R@AVma%c zW}z-=4gw|lj|Xp+=V4y4aq4CHo>`ceG)}y?bMh*&F?;?bMj@bJGOs0vkAG^Wc(-rg zy~5v@-f8vtkuF;a<5ucXg3LejmH0x?k`}$!6U^qdxR6S*o`5PqMj4`~6$a1rvXn^! z%*s){EF}dMu(1S@OMy-bqilfPR_1X|YmvO7X4#md3nmWbBcEYL%&sUew>uCtF>hKW zY!62<*63xfA@GbwEXDc~Tj9`h3WA6!jU{gSM$9m91PPN|oDWYvOL@;&EKBwm-Z6JR zOImPvKxxW%gXNNkVYm*qmSRRF!%#S6c{B=muF+N;bW`3ke_>?0y_*wJWgD>>W-rG& z0S=7e+s|RIC}%lVCzi;V{yiAjj#i2uSRT(3xjcnI>M5*O2~>UCa!TqB>rv9UD#*5C zu+p^BYa+c5Rh%3E9CxU_zqJHbJ)7uR>cghqq<1UcCf6XJb@CA}<+wLHvFJ(8%X8t+ zdV0kdTCMlM6kX{Ax({~GB~qg_@+n+6$%EWklE%GtxIMOd@CEYT!tGp*vz=G7jmW!9 zf$`oJbF0Y98~!mLcNC77$Gg*OU*bVwbISJ(9z^3-!h_1QN_z_r!tF1&Z}Zu0%=jpF zvfHZ5SguYCQfK4H@eE$LhO|SJ;@-nj&TrQKV$|B_m8(jiT@3@feVU=);`Wx}L>db@ZAxpM{2RQ=Kdn(q>Sh|-LSX>MnLxeOo zG=CCyN|>T(vbu{SdBO=sZ#)(=Ru?O=7P%N-Rx*2eUREh>?`$r2)a8w1a7qgwHKtQ1P_=uJ^ssBzyZ_+N^67%xlI9#<-ki|xX<W#jWubPGlTh^>?>a7{;hd{@Q&0q2zN?M;ue zN{({RKb6u6gnKPS%b&)gevR{#R7-N)TL@&kHR7;)lNJfmi3cqehTuM=H;TR{NGElhav>nu)kgvkMO*ME+&ji3`4pSW$=jlKl zhIiPb@sHW*z4v$)ftm%NAa42K6wW!9fNwakh4?4QLOiHFl31cF=8~1k@=?7aFN#}R zMW1tf@m4y>e5|-HAdW?-U*h3e1TGE^Ss@YW!QFq7CLGd`79|}KWhHtb6x^NjowSnN z|D`tU-ffUh3LrJvg0vy^bs}<@YhkNWq$K@+qdlLg;9kNiz=_q?4fd#o3?Lbc9Do{k zf+!!)+q-K+sS|j&kksu8)FH=`o}^s2+k~@eP%Uu}2aSbyfy&5*U_3q`MC|0TCGN@HI8gy9Iwy_TCo)aZ;Q~1fwwjY_g4zh z-``NXRH+dRfw-VD)~-7e+5zj5^2Ikkyrz#RcLXG>hJIGt5M24jkWWE0uJ(&3dVGZT>CMe0UBjX&Jzt# z+bRvZ`51uOXGKG>KbQ$Enl!;5w&v{%k`%nO6>BA^^hD$f`C7JuVn{*-e$Pk(OBL`_ zYf>x;LprQoCm74Q1cqQ8=VDAZc2Vm^dIX>r3Fqd7swm@?{B`IeDKdyzn(hW6QSBy$u?v)J=+Ak~_wk@=MK@ioP9sQFs9TVwi$(@X->XGq zvIxI`f|vs8YT=`S4r?1An4v!!=Q$tJ2Q`ITZ*90}=ubI!TSSP?wPHaUwY%$Gj9rMx z&>z%6=tYo_qzUAWClmJv1!FRQc;}7DT6~Pja2@!hKl0Fke@lfVbTWpF0>3};N3*3c z3g9h$<bP>{cB5FJ~=pg zP3O&@1UCzNv*xFR)-(5BR1I8uqTrP-lV0lX*wSh1<*oq-UQfP%>d>v*w(oOxy%?PP z+?Kv$6m#~jcD-?-uJFZU7y4aax?8iL#p-#{CtnfOdW9OU1k0hT+!k!n*!QNZ0n9gA-!zB7qCJeMlJK*=6at)=G@ zU#jW0Cs85f0oQ0kqIw*Ez>&fq#Uww|_9Ooh7O5Tt$otlGT5Zf_{f>%3=4pe~}K>!VeN-^uoR%?Ym0Ac9w zg+YV{DJEEk7AXqI8cIjk5iclU@c_)Do?winR$?KRKTV+|T_#~NCApVS^EB)FK|(2H z5TqgT;ek?bUXWybL6pEf+&toxgIbU zq@aE4Lv}}Q35tq}D5k~NUlm2(qK)F-Vh9FG)DggK<1goA5VWLN)QF`dQ$xk*2Nx@e_$ckus~px}}thSD+S5U;~&yux6g=EMs_@>@Nr0&5ySq)!euApABw zR=%(4IyEsKf0jANKiG4FC%-zwZ*A*l39PR2pPpdS0fRF(d{{+3P9w1Y>S{72CY$J! zoX#H^5@a%^ni4reE>B5JNlG>+nTe9)DTi-SQj#Sx!<3v{WXUK@OEwi`MXlPnoY z)|9k@^yK{Hv_w3tru=k^$!fM(lhduKX_kzl^rF;4Yer#8QCd+_VM?N zy2)H*E-c7MF9W$TGfNU!{Og;-?@AgUj=P$0epuuTci{NQ zG1Xd#wR#_cWzxZGxRbyC6J9J|?S;GS;YGHxLL@k!4d;jMI7|w+ggeWv1-2rawJ=;h zr~#K?fdwSR!&vd@iKh5u*cI<&k~l!dr^lGn&{=Z|ERbA~nv!Bpf+>p%%tgsX`T40C zFo7k}0$t$enQ-N%jq;PThBuzoF%~PZ4xZwFb2o`U3&B*@vbd4ijOF9!Gykw2F3Y6* z70rxvOyNn?J31Ke%M+_LiNjU3ZSnZh5ru_b*z0f3?}^-bY*S3}11r zd(GLU?Nnt`Hg`Pnc%|~^oAb9hk4%OL%-FQw7A6cHMoS%9^8_!%w}eWh4+Sawbcz4$ z{b`gv?Nvq;_zBD{pAp%;v)P7k1g|%M5b6GD_4x9_e3sq6M`8+o|0{_V-a{4(U5~L}irJX`L9;#;KD&iq(LMLa za6fY4Zs^vh`+s{SVR1p>=v`7W*n->2QfC2PAF=XlQeJv95=?Ga(XHJ6uYu^V*D$0FjCslXiiLO7sV;ZpLRuLq9lqwn>qgXcH+Z}~Bfkz;hg?E030M0_%7kT>Z zQC_)0tMWo@nuFITD+Jm+;_S~mNPT<`f z=y<0RUpfgZh4U0c0z2yFLk2n(q!T$iQaVMGj&>+V=V^5G(|F40rlvDAr+mt2g= zo6ARaZJ=$Wx*N}USbREY=tRva^K;@z%B`VnFa7kpO*@Qb!V4SQ9R)594;Sh~5;&Q; zP2%y3yF}#T@!JD>n)q)JrsHjB0bb@li=?Bm5-%;>se}KHyz%he68xjVfpbk*fKC&s zMbc|IdP*8A#vz>xG@GFBJKO&&8^nXU2j?E{#f7|t&M@iR(t*D^Ox}RWAMI1Whsu=X zJtT!&=k5c-|Fpdt`=5hfiwJnzoV=?L$CY#@{_lJ*9u$4>e^v~?tH&_>>LB3`p0|61 zi@c+lDh+hxY zx3#Ht(R2IH{nby>F>bi(`Xv6X(6Yt3$c(l9-*3ZQP+ge)`2{e)(a}!3$rv zjO@j%A2-zd)tTy5H%;}5FB=p%q!5FWFjdcUggHWTGvDMtY!T)WTUl7a2O`y&eM~yF zVx&?XB#z8B2bl~6XoK{l@xlxCOD=nvInadvgV{)>CI~yV!cu!#p}Cc*1!43-ci+~T zqfG6oToKgTv(m-3uh1HvZ7VLLUD&W*J;D=BX0xePm>)JQfJriF za{Z6UC(Ez+3;9j;LWH-XU^_*<5CB^Xda+)>AC-IYu#a=cuS0j}Bbvoen6}N7yK&3D z#8~>3*R1-c5C_&ZTY~{lh10R#?A&+g2Z{UNi3Gfy0ZkN){|!d|>UA4r|&a zo$236yXd2fNe{de`M~v64@9nQ{X$Z&oD(gNx7`2Lh8_FoMC{t%=e4))(Jm_4Gxfp3 z>-nvIPSGZGc(?eQi){ivow|GQnfUJMdwnWW&ktL8a={z-xvK9mq_jL;su~i%xz}#> zH}A$COW54y&7^q=4=UhV%u!GNTDs#-cvD3^IV>$L;)T+uk5q_{nsTVg*2=-A zfu^j6ehq!*_L}H&m3K-=m^N)%e5vP!P`o{tP(ImaFLx#sI7(>W1uupV!+ptn^C*ck zrNx=j<56z1xce*!%8{mQ({MLz66f~$w+*0M&VSQ{%j8Rf2MNMWrHEDAt%F%nFAD7b zrq2&t*XgyD9|WAdFS)k5`Qtw(UT9mWcy8G0-Z4L0XRo{G%+e1RrI>`o`BSDId}-M3 zv9IY93CSq!>cC`8A zp5MMPAIt6f;f#e9-whEjuHO6gms2;f2z%=hImKJ=Z`MDmbNSr&_Jyzg@ZN31*1Yl3 zl5;1oo;}j^_34%S?QMSTvqEExd%C9h+~XsRkxR~)G>;Zqhs-P0ZCo9u>GbqN5C2rT zW`{HH+*|d>jzmrf`eNuq8SnLcYyA6v4o%ekx~nSHr`sp(BXcIL^FKRlQtvT|U#z;{ z_WdLK滻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 literal 0 HcmV?d00001 diff --git a/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Logging.Abstractions.dll b/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Logging.Abstractions.dll new file mode 100755 index 0000000000000000000000000000000000000000..7e3bdc2c486e074c78692f9b11e769c513f4f120 GIT binary patch literal 48504 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 ZlEYUNe!WM;)_orLSMR^v%~BzV_&-p5fLj0n literal 0 HcmV?d00001 diff --git a/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Logging.Console.dll b/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Logging.Console.dll new file mode 100755 index 0000000000000000000000000000000000000000..6d511729a769ec6f206c63390ae030d63c084111 GIT binary patch literal 28024 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 RynRzYJYGD#&s1z8{ujI2Lb?C| literal 0 HcmV?d00001 diff --git a/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Logging.dll b/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Logging.dll new file mode 100755 index 0000000000000000000000000000000000000000..8aaa4eab0f4b26ab67176aca121a912fea83e157 GIT binary patch literal 34168 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 literal 0 HcmV?d00001 diff --git a/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Options.dll b/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Options.dll new file mode 100755 index 0000000000000000000000000000000000000000..2d288bed85ee586ea0e2470af02ca4b675177043 GIT binary patch literal 50552 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 xQsGlU?b3L~6dRr*j literal 0 HcmV?d00001 diff --git a/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Primitives.dll b/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Primitives.dll new file mode 100755 index 0000000000000000000000000000000000000000..a8e17b258756c78f3f09aed1e8f8916ab2973f5b GIT binary patch literal 38776 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 PzA--g?B*Zo8RGv1(}%q+ literal 0 HcmV?d00001 diff --git a/bin/Debug/netcoreapp3.1/Newtonsoft.Json.dll b/bin/Debug/netcoreapp3.1/Newtonsoft.Json.dll new file mode 100755 index 0000000000000000000000000000000000000000..b8ea6e0e27527675d0fe0359bed022b995013f1e GIT binary patch literal 669608 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�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 literal 0 HcmV?d00001 diff --git a/bin/Debug/netcoreapp3.1/contacts.deps.json b/bin/Debug/netcoreapp3.1/contacts.deps.json new file mode 100644 index 0000000..81f7a2d --- /dev/null +++ b/bin/Debug/netcoreapp3.1/contacts.deps.json @@ -0,0 +1,3646 @@ +{ + "runtimeTarget": { + "name": ".NETCoreApp,Version=v3.1", + "signature": "" + }, + "compilationOptions": { + "defines": [ + "TRACE", + "DEBUG", + "NETCOREAPP", + "NETCOREAPP3_1" + ], + "languageVersion": "8.0", + "platform": "", + "allowUnsafe": false, + "warningsAsErrors": false, + "optimize": false, + "keyFile": "", + "emitEntryPoint": true, + "xmlDoc": false, + "debugType": "portable" + }, + "targets": { + ".NETCoreApp,Version=v3.1": { + "contacts/1.0.0": { + "dependencies": { + "Microsoft.AspNetCore.SpaServices.Extensions": "3.1.8", + "Microsoft.AspNetCore.Antiforgery": "3.1.0.0", + "Microsoft.AspNetCore.Authentication.Abstractions": "3.1.0.0", + "Microsoft.AspNetCore.Authentication.Cookies": "3.1.0.0", + "Microsoft.AspNetCore.Authentication.Core": "3.1.0.0", + "Microsoft.AspNetCore.Authentication": "3.1.0.0", + "Microsoft.AspNetCore.Authentication.OAuth": "3.1.0.0", + "Microsoft.AspNetCore.Authorization": "3.1.0.0", + "Microsoft.AspNetCore.Authorization.Policy": "3.1.0.0", + "Microsoft.AspNetCore.Components.Authorization": "3.1.0.0", + "Microsoft.AspNetCore.Components": "3.1.0.0", + "Microsoft.AspNetCore.Components.Forms": "3.1.0.0", + "Microsoft.AspNetCore.Components.Server": "3.1.0.0", + "Microsoft.AspNetCore.Components.Web": "3.1.0.0", + "Microsoft.AspNetCore.Connections.Abstractions": "3.1.0.0", + "Microsoft.AspNetCore.CookiePolicy": "3.1.0.0", + "Microsoft.AspNetCore.Cors": "3.1.0.0", + "Microsoft.AspNetCore.Cryptography.Internal": "3.1.0.0", + "Microsoft.AspNetCore.Cryptography.KeyDerivation": "3.1.0.0", + "Microsoft.AspNetCore.DataProtection.Abstractions": "3.1.0.0", + "Microsoft.AspNetCore.DataProtection": "3.1.0.0", + "Microsoft.AspNetCore.DataProtection.Extensions": "3.1.0.0", + "Microsoft.AspNetCore.Diagnostics.Abstractions": "3.1.0.0", + "Microsoft.AspNetCore.Diagnostics": "3.1.0.0", + "Microsoft.AspNetCore.Diagnostics.HealthChecks": "3.1.0.0", + "Microsoft.AspNetCore": "3.1.0.0", + "Microsoft.AspNetCore.HostFiltering": "3.1.0.0", + "Microsoft.AspNetCore.Hosting.Abstractions": "3.1.0.0", + "Microsoft.AspNetCore.Hosting": "3.1.0.0", + "Microsoft.AspNetCore.Hosting.Server.Abstractions": "3.1.0.0", + "Microsoft.AspNetCore.Html.Abstractions": "3.1.0.0", + "Microsoft.AspNetCore.Http.Abstractions": "3.1.0.0", + "Microsoft.AspNetCore.Http.Connections.Common": "3.1.0.0", + "Microsoft.AspNetCore.Http.Connections": "3.1.0.0", + "Microsoft.AspNetCore.Http": "3.1.0.0", + "Microsoft.AspNetCore.Http.Extensions": "3.1.0.0", + "Microsoft.AspNetCore.Http.Features": "3.1.0.0", + "Microsoft.AspNetCore.HttpOverrides": "3.1.0.0", + "Microsoft.AspNetCore.HttpsPolicy": "3.1.0.0", + "Microsoft.AspNetCore.Identity": "3.1.0.0", + "Microsoft.AspNetCore.Localization": "3.1.0.0", + "Microsoft.AspNetCore.Localization.Routing": "3.1.0.0", + "Microsoft.AspNetCore.Metadata": "3.1.0.0", + "Microsoft.AspNetCore.Mvc.Abstractions": "3.1.0.0", + "Microsoft.AspNetCore.Mvc.ApiExplorer": "3.1.0.0", + "Microsoft.AspNetCore.Mvc.Core": "3.1.0.0", + "Microsoft.AspNetCore.Mvc.Cors": "3.1.0.0", + "Microsoft.AspNetCore.Mvc.DataAnnotations": "3.1.0.0", + "Microsoft.AspNetCore.Mvc": "3.1.0.0", + "Microsoft.AspNetCore.Mvc.Formatters.Json": "3.1.0.0", + "Microsoft.AspNetCore.Mvc.Formatters.Xml": "3.1.0.0", + "Microsoft.AspNetCore.Mvc.Localization": "3.1.0.0", + "Microsoft.AspNetCore.Mvc.Razor": "3.1.0.0", + "Microsoft.AspNetCore.Mvc.RazorPages": "3.1.0.0", + "Microsoft.AspNetCore.Mvc.TagHelpers": "3.1.0.0", + "Microsoft.AspNetCore.Mvc.ViewFeatures": "3.1.0.0", + "Microsoft.AspNetCore.Razor": "3.1.0.0", + "Microsoft.AspNetCore.Razor.Runtime": "3.1.0.0", + "Microsoft.AspNetCore.ResponseCaching.Abstractions": "3.1.0.0", + "Microsoft.AspNetCore.ResponseCaching": "3.1.0.0", + "Microsoft.AspNetCore.ResponseCompression": "3.1.0.0", + "Microsoft.AspNetCore.Rewrite": "3.1.0.0", + "Microsoft.AspNetCore.Routing.Abstractions": "3.1.0.0", + "Microsoft.AspNetCore.Routing": "3.1.0.0", + "Microsoft.AspNetCore.Server.HttpSys": "3.1.0.0", + "Microsoft.AspNetCore.Server.IIS": "3.1.0.0", + "Microsoft.AspNetCore.Server.IISIntegration": "3.1.0.0", + "Microsoft.AspNetCore.Server.Kestrel.Core": "3.1.0.0", + "Microsoft.AspNetCore.Server.Kestrel": "3.1.0.0", + "Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets": "3.1.0.0", + "Microsoft.AspNetCore.Session": "3.1.0.0", + "Microsoft.AspNetCore.SignalR.Common": "3.1.0.0", + "Microsoft.AspNetCore.SignalR.Core": "3.1.0.0", + "Microsoft.AspNetCore.SignalR": "3.1.0.0", + "Microsoft.AspNetCore.SignalR.Protocols.Json": "3.1.0.0", + "Microsoft.AspNetCore.StaticFiles": "3.1.0.0", + "Microsoft.AspNetCore.WebSockets": "3.1.0.0", + "Microsoft.AspNetCore.WebUtilities": "3.1.0.0", + "Microsoft.CSharp": "4.0.0.0", + "Microsoft.Extensions.Caching.Abstractions": "3.1.0.0", + "Microsoft.Extensions.Caching.Memory": "3.1.0.0", + "Microsoft.Extensions.Configuration.CommandLine": "3.1.0.0", + "Microsoft.Extensions.Configuration.EnvironmentVariables": "3.1.0.0", + "Microsoft.Extensions.Configuration.FileExtensions": "3.1.0.0", + "Microsoft.Extensions.Configuration.Ini": "3.1.0.0", + "Microsoft.Extensions.Configuration.Json": "3.1.0.0", + "Microsoft.Extensions.Configuration.KeyPerFile": "3.1.0.0", + "Microsoft.Extensions.Configuration.UserSecrets": "3.1.0.0", + "Microsoft.Extensions.Configuration.Xml": "3.1.0.0", + "Microsoft.Extensions.Diagnostics.HealthChecks.Abstractions": "3.1.0.0", + "Microsoft.Extensions.Diagnostics.HealthChecks": "3.1.0.0", + "Microsoft.Extensions.FileProviders.Composite": "3.1.0.0", + "Microsoft.Extensions.FileProviders.Embedded": "3.1.0.0", + "Microsoft.Extensions.Hosting.Abstractions": "3.1.0.0", + "Microsoft.Extensions.Hosting": "3.1.0.0", + "Microsoft.Extensions.Http": "3.1.0.0", + "Microsoft.Extensions.Identity.Core": "3.1.0.0", + "Microsoft.Extensions.Identity.Stores": "3.1.0.0", + "Microsoft.Extensions.Localization.Abstractions": "3.1.0.0", + "Microsoft.Extensions.Localization": "3.1.0.0", + "Microsoft.Extensions.Logging.Debug": "3.1.0.0", + "Microsoft.Extensions.Logging.EventLog": "3.1.0.0", + "Microsoft.Extensions.Logging.EventSource": "3.1.0.0", + "Microsoft.Extensions.Logging.TraceSource": "3.1.0.0", + "Microsoft.Extensions.ObjectPool": "3.1.0.0", + "Microsoft.Extensions.Options.DataAnnotations": "3.1.0.0", + "Microsoft.Extensions.WebEncoders": "3.1.0.0", + "Microsoft.JSInterop": "3.1.0.0", + "Microsoft.Net.Http.Headers": "3.1.0.0", + "Microsoft.VisualBasic.Core": "10.0.5.0", + "Microsoft.VisualBasic": "10.0.0.0", + "Microsoft.Win32.Primitives": "4.1.2.0", + "Microsoft.Win32.Registry": "4.1.3.0", + "mscorlib": "4.0.0.0", + "netstandard": "2.1.0.0", + "System.AppContext": "4.2.2.0", + "System.Buffers": "4.0.2.0", + "System.Collections.Concurrent": "4.0.15.0", + "System.Collections": "4.1.2.0", + "System.Collections.Immutable": "1.2.5.0", + "System.Collections.NonGeneric": "4.1.2.0", + "System.Collections.Specialized": "4.1.2.0", + "System.ComponentModel.Annotations": "4.3.1.0", + "System.ComponentModel.DataAnnotations": "4.0.0.0", + "System.ComponentModel": "4.0.4.0", + "System.ComponentModel.EventBasedAsync": "4.1.2.0", + "System.ComponentModel.Primitives": "4.2.2.0", + "System.ComponentModel.TypeConverter": "4.2.2.0", + "System.Configuration": "4.0.0.0", + "System.Console": "4.1.2.0", + "System.Core": "4.0.0.0", + "System.Data.Common": "4.2.2.0", + "System.Data.DataSetExtensions": "4.0.1.0", + "System.Data": "4.0.0.0", + "System.Diagnostics.Contracts": "4.0.4.0", + "System.Diagnostics.Debug": "4.1.2.0", + "System.Diagnostics.DiagnosticSource": "4.0.5.0", + "System.Diagnostics.EventLog": "4.0.2.0", + "System.Diagnostics.FileVersionInfo": "4.0.4.0", + "System.Diagnostics.Process": "4.2.2.0", + "System.Diagnostics.StackTrace": "4.1.2.0", + "System.Diagnostics.TextWriterTraceListener": "4.1.2.0", + "System.Diagnostics.Tools": "4.1.2.0", + "System.Diagnostics.TraceSource": "4.1.2.0", + "System.Diagnostics.Tracing": "4.2.2.0", + "System": "4.0.0.0", + "System.Drawing": "4.0.0.0", + "System.Drawing.Primitives": "4.2.1.0", + "System.Dynamic.Runtime": "4.1.2.0", + "System.Globalization.Calendars": "4.1.2.0", + "System.Globalization": "4.1.2.0", + "System.Globalization.Extensions": "4.1.2.0", + "System.IO.Compression.Brotli": "4.2.2.0", + "System.IO.Compression": "4.2.2.0", + "System.IO.Compression.FileSystem": "4.0.0.0", + "System.IO.Compression.ZipFile": "4.0.5.0", + "System.IO": "4.2.2.0", + "System.IO.FileSystem": "4.1.2.0", + "System.IO.FileSystem.DriveInfo": "4.1.2.0", + "System.IO.FileSystem.Primitives": "4.1.2.0", + "System.IO.FileSystem.Watcher": "4.1.2.0", + "System.IO.IsolatedStorage": "4.1.2.0", + "System.IO.MemoryMappedFiles": "4.1.2.0", + "System.IO.Pipelines": "4.0.2.0", + "System.IO.Pipes": "4.1.2.0", + "System.IO.UnmanagedMemoryStream": "4.1.2.0", + "System.Linq": "4.2.2.0", + "System.Linq.Expressions": "4.2.2.0", + "System.Linq.Parallel": "4.0.4.0", + "System.Linq.Queryable": "4.0.4.0", + "System.Memory": "4.2.1.0", + "System.Net": "4.0.0.0", + "System.Net.Http": "4.2.2.0", + "System.Net.HttpListener": "4.0.2.0", + "System.Net.Mail": "4.0.2.0", + "System.Net.NameResolution": "4.1.2.0", + "System.Net.NetworkInformation": "4.2.2.0", + "System.Net.Ping": "4.1.2.0", + "System.Net.Primitives": "4.1.2.0", + "System.Net.Requests": "4.1.2.0", + "System.Net.Security": "4.1.2.0", + "System.Net.ServicePoint": "4.0.2.0", + "System.Net.Sockets": "4.2.2.0", + "System.Net.WebClient": "4.0.2.0", + "System.Net.WebHeaderCollection": "4.1.2.0", + "System.Net.WebProxy": "4.0.2.0", + "System.Net.WebSockets.Client": "4.1.2.0", + "System.Net.WebSockets": "4.1.2.0", + "System.Numerics": "4.0.0.0", + "System.Numerics.Vectors": "4.1.6.0", + "System.ObjectModel": "4.1.2.0", + "System.Reflection.DispatchProxy": "4.0.6.0", + "System.Reflection": "4.2.2.0", + "System.Reflection.Emit": "4.1.2.0", + "System.Reflection.Emit.ILGeneration": "4.1.1.0", + "System.Reflection.Emit.Lightweight": "4.1.1.0", + "System.Reflection.Extensions": "4.1.2.0", + "System.Reflection.Metadata": "1.4.5.0", + "System.Reflection.Primitives": "4.1.2.0", + "System.Reflection.TypeExtensions": "4.1.2.0", + "System.Resources.Reader": "4.1.2.0", + "System.Resources.ResourceManager": "4.1.2.0", + "System.Resources.Writer": "4.1.2.0", + "System.Runtime.CompilerServices.Unsafe": "4.0.6.0", + "System.Runtime.CompilerServices.VisualC": "4.1.2.0", + "System.Runtime": "4.2.2.0", + "System.Runtime.Extensions": "4.2.2.0", + "System.Runtime.Handles": "4.1.2.0", + "System.Runtime.InteropServices": "4.2.2.0", + "System.Runtime.InteropServices.RuntimeInformation": "4.0.4.0", + "System.Runtime.InteropServices.WindowsRuntime": "4.0.4.0", + "System.Runtime.Intrinsics": "4.0.1.0", + "System.Runtime.Loader": "4.1.1.0", + "System.Runtime.Numerics": "4.1.2.0", + "System.Runtime.Serialization": "4.0.0.0", + "System.Runtime.Serialization.Formatters": "4.0.4.0", + "System.Runtime.Serialization.Json": "4.0.5.0", + "System.Runtime.Serialization.Primitives": "4.2.2.0", + "System.Runtime.Serialization.Xml": "4.1.5.0", + "System.Security.AccessControl": "4.1.1.0", + "System.Security.Claims": "4.1.2.0", + "System.Security.Cryptography.Algorithms": "4.3.2.0", + "System.Security.Cryptography.Cng": "4.3.3.0", + "System.Security.Cryptography.Csp": "4.1.2.0", + "System.Security.Cryptography.Encoding": "4.1.2.0", + "System.Security.Cryptography.Primitives": "4.1.2.0", + "System.Security.Cryptography.X509Certificates": "4.2.2.0", + "System.Security.Cryptography.Xml": "4.0.3.0", + "System.Security": "4.0.0.0", + "System.Security.Permissions": "4.0.3.0", + "System.Security.Principal": "4.1.2.0", + "System.Security.Principal.Windows": "4.1.1.0", + "System.Security.SecureString": "4.1.2.0", + "System.ServiceModel.Web": "4.0.0.0", + "System.ServiceProcess": "4.0.0.0", + "System.Text.Encoding.CodePages": "4.1.3.0", + "System.Text.Encoding": "4.1.2.0", + "System.Text.Encoding.Extensions": "4.1.2.0", + "System.Text.Encodings.Web": "4.0.5.0", + "System.Text.Json": "4.0.1.0", + "System.Text.RegularExpressions": "4.2.2.0", + "System.Threading.Channels": "4.0.2.0", + "System.Threading": "4.1.2.0", + "System.Threading.Overlapped": "4.1.2.0", + "System.Threading.Tasks.Dataflow": "4.6.5.0", + "System.Threading.Tasks": "4.1.2.0", + "System.Threading.Tasks.Extensions": "4.3.1.0", + "System.Threading.Tasks.Parallel": "4.0.4.0", + "System.Threading.Thread": "4.1.2.0", + "System.Threading.ThreadPool": "4.1.2.0", + "System.Threading.Timer": "4.1.2.0", + "System.Transactions": "4.0.0.0", + "System.Transactions.Local": "4.0.2.0", + "System.ValueTuple": "4.0.3.0", + "System.Web": "4.0.0.0", + "System.Web.HttpUtility": "4.0.2.0", + "System.Windows": "4.0.0.0", + "System.Windows.Extensions": "4.0.1.0", + "System.Xml": "4.0.0.0", + "System.Xml.Linq": "4.0.0.0", + "System.Xml.ReaderWriter": "4.2.2.0", + "System.Xml.Serialization": "4.0.0.0", + "System.Xml.XDocument": "4.1.2.0", + "System.Xml.XmlDocument": "4.1.2.0", + "System.Xml.XmlSerializer": "4.1.2.0", + "System.Xml.XPath": "4.1.2.0", + "System.Xml.XPath.XDocument": "4.1.2.0", + "WindowsBase": "4.0.0.0" + }, + "runtime": { + "contacts.dll": {} + }, + "compile": { + "contacts.dll": {} + } + }, + "Microsoft.AspNetCore.NodeServices/3.1.8": { + "dependencies": { + "Microsoft.Extensions.Logging.Console": "3.1.8", + "Newtonsoft.Json": "12.0.2" + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.AspNetCore.NodeServices.dll": { + "assemblyVersion": "3.1.8.0", + "fileVersion": "3.100.820.42106" + } + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.AspNetCore.NodeServices.dll": {} + } + }, + "Microsoft.AspNetCore.SpaServices/3.1.8": { + "dependencies": { + "Microsoft.AspNetCore.NodeServices": "3.1.8" + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.AspNetCore.SpaServices.dll": { + "assemblyVersion": "3.1.8.0", + "fileVersion": "3.100.820.42106" + } + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.AspNetCore.SpaServices.dll": {} + } + }, + "Microsoft.AspNetCore.SpaServices.Extensions/3.1.8": { + "dependencies": { + "Microsoft.AspNetCore.SpaServices": "3.1.8", + "Microsoft.Extensions.FileProviders.Physical": "3.1.8" + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.AspNetCore.SpaServices.Extensions.dll": { + "assemblyVersion": "3.1.8.0", + "fileVersion": "3.100.820.42106" + } + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.AspNetCore.SpaServices.Extensions.dll": {} + } + }, + "Microsoft.Extensions.Configuration/3.1.8": { + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "3.1.8" + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.Extensions.Configuration.dll": { + "assemblyVersion": "3.1.8.0", + "fileVersion": "3.100.820.42004" + } + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.Extensions.Configuration.dll": {} + } + }, + "Microsoft.Extensions.Configuration.Abstractions/3.1.8": { + "dependencies": { + "Microsoft.Extensions.Primitives": "3.1.8" + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.Extensions.Configuration.Abstractions.dll": { + "assemblyVersion": "3.1.8.0", + "fileVersion": "3.100.820.42004" + } + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.Extensions.Configuration.Abstractions.dll": {} + } + }, + "Microsoft.Extensions.Configuration.Binder/3.1.8": { + "dependencies": { + "Microsoft.Extensions.Configuration": "3.1.8" + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.Extensions.Configuration.Binder.dll": { + "assemblyVersion": "3.1.8.0", + "fileVersion": "3.100.820.42004" + } + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.Extensions.Configuration.Binder.dll": {} + } + }, + "Microsoft.Extensions.DependencyInjection/3.1.8": { + "dependencies": { + "Microsoft.Extensions.DependencyInjection.Abstractions": "3.1.8" + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.Extensions.DependencyInjection.dll": { + "assemblyVersion": "3.1.8.0", + "fileVersion": "3.100.820.42004" + } + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.Extensions.DependencyInjection.dll": {} + } + }, + "Microsoft.Extensions.DependencyInjection.Abstractions/3.1.8": { + "runtime": { + "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.Abstractions.dll": { + "assemblyVersion": "3.1.8.0", + "fileVersion": "3.100.820.42004" + } + }, + "compile": { + "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.Abstractions.dll": {} + } + }, + "Microsoft.Extensions.FileProviders.Abstractions/3.1.8": { + "dependencies": { + "Microsoft.Extensions.Primitives": "3.1.8" + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.Extensions.FileProviders.Abstractions.dll": { + "assemblyVersion": "3.1.8.0", + "fileVersion": "3.100.820.42004" + } + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.Extensions.FileProviders.Abstractions.dll": {} + } + }, + "Microsoft.Extensions.FileProviders.Physical/3.1.8": { + "dependencies": { + "Microsoft.Extensions.FileProviders.Abstractions": "3.1.8", + "Microsoft.Extensions.FileSystemGlobbing": "3.1.8" + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.Extensions.FileProviders.Physical.dll": { + "assemblyVersion": "3.1.8.0", + "fileVersion": "3.100.820.42004" + } + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.Extensions.FileProviders.Physical.dll": {} + } + }, + "Microsoft.Extensions.FileSystemGlobbing/3.1.8": { + "runtime": { + "lib/netstandard2.0/Microsoft.Extensions.FileSystemGlobbing.dll": { + "assemblyVersion": "3.1.8.0", + "fileVersion": "3.100.820.42004" + } + }, + "compile": { + "lib/netstandard2.0/Microsoft.Extensions.FileSystemGlobbing.dll": {} + } + }, + "Microsoft.Extensions.Logging/3.1.8": { + "dependencies": { + "Microsoft.Extensions.Configuration.Binder": "3.1.8", + "Microsoft.Extensions.DependencyInjection": "3.1.8", + "Microsoft.Extensions.Logging.Abstractions": "3.1.8", + "Microsoft.Extensions.Options": "3.1.8" + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.Extensions.Logging.dll": { + "assemblyVersion": "3.1.8.0", + "fileVersion": "3.100.820.42004" + } + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.Extensions.Logging.dll": {} + } + }, + "Microsoft.Extensions.Logging.Abstractions/3.1.8": { + "runtime": { + "lib/netstandard2.0/Microsoft.Extensions.Logging.Abstractions.dll": { + "assemblyVersion": "3.1.8.0", + "fileVersion": "3.100.820.42004" + } + }, + "compile": { + "lib/netstandard2.0/Microsoft.Extensions.Logging.Abstractions.dll": {} + } + }, + "Microsoft.Extensions.Logging.Configuration/3.1.8": { + "dependencies": { + "Microsoft.Extensions.Logging": "3.1.8", + "Microsoft.Extensions.Options.ConfigurationExtensions": "3.1.8" + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.Extensions.Logging.Configuration.dll": { + "assemblyVersion": "3.1.8.0", + "fileVersion": "3.100.820.42004" + } + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.Extensions.Logging.Configuration.dll": {} + } + }, + "Microsoft.Extensions.Logging.Console/3.1.8": { + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "3.1.8", + "Microsoft.Extensions.Logging": "3.1.8", + "Microsoft.Extensions.Logging.Configuration": "3.1.8" + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.Extensions.Logging.Console.dll": { + "assemblyVersion": "3.1.8.0", + "fileVersion": "3.100.820.42004" + } + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.Extensions.Logging.Console.dll": {} + } + }, + "Microsoft.Extensions.Options/3.1.8": { + "dependencies": { + "Microsoft.Extensions.DependencyInjection.Abstractions": "3.1.8", + "Microsoft.Extensions.Primitives": "3.1.8" + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.Extensions.Options.dll": { + "assemblyVersion": "3.1.8.0", + "fileVersion": "3.100.820.42004" + } + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.Extensions.Options.dll": {} + } + }, + "Microsoft.Extensions.Options.ConfigurationExtensions/3.1.8": { + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "3.1.8", + "Microsoft.Extensions.Configuration.Binder": "3.1.8", + "Microsoft.Extensions.DependencyInjection.Abstractions": "3.1.8", + "Microsoft.Extensions.Options": "3.1.8" + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.Extensions.Options.ConfigurationExtensions.dll": { + "assemblyVersion": "3.1.8.0", + "fileVersion": "3.100.820.42004" + } + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.Extensions.Options.ConfigurationExtensions.dll": {} + } + }, + "Microsoft.Extensions.Primitives/3.1.8": { + "runtime": { + "lib/netcoreapp3.1/Microsoft.Extensions.Primitives.dll": { + "assemblyVersion": "3.1.8.0", + "fileVersion": "3.100.820.42004" + } + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.Extensions.Primitives.dll": {} + } + }, + "Newtonsoft.Json/12.0.2": { + "runtime": { + "lib/netstandard2.0/Newtonsoft.Json.dll": { + "assemblyVersion": "12.0.0.0", + "fileVersion": "12.0.2.23222" + } + }, + "compile": { + "lib/netstandard2.0/Newtonsoft.Json.dll": {} + } + }, + "Microsoft.AspNetCore.Antiforgery/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Antiforgery.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Authentication.Abstractions/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Authentication.Abstractions.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Authentication.Cookies/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Authentication.Cookies.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Authentication.Core/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Authentication.Core.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Authentication/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Authentication.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Authentication.OAuth/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Authentication.OAuth.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Authorization/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Authorization.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Authorization.Policy/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Authorization.Policy.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Components.Authorization/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Components.Authorization.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Components/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Components.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Components.Forms/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Components.Forms.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Components.Server/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Components.Server.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Components.Web/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Components.Web.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Connections.Abstractions/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Connections.Abstractions.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.CookiePolicy/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.CookiePolicy.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Cors/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Cors.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Cryptography.Internal/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Cryptography.Internal.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Cryptography.KeyDerivation/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Cryptography.KeyDerivation.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.DataProtection.Abstractions/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.DataProtection.Abstractions.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.DataProtection/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.DataProtection.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.DataProtection.Extensions/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.DataProtection.Extensions.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Diagnostics.Abstractions/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Diagnostics.Abstractions.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Diagnostics/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Diagnostics.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Diagnostics.HealthChecks/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Diagnostics.HealthChecks.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.HostFiltering/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.HostFiltering.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Hosting.Abstractions/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Hosting.Abstractions.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Hosting/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Hosting.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Hosting.Server.Abstractions/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Hosting.Server.Abstractions.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Html.Abstractions/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Html.Abstractions.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Http.Abstractions/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Http.Abstractions.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Http.Connections.Common/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Http.Connections.Common.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Http.Connections/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Http.Connections.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Http/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Http.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Http.Extensions/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Http.Extensions.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Http.Features/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Http.Features.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.HttpOverrides/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.HttpOverrides.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.HttpsPolicy/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.HttpsPolicy.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Identity/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Identity.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Localization/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Localization.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Localization.Routing/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Localization.Routing.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Metadata/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Metadata.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Mvc.Abstractions/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Mvc.Abstractions.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Mvc.ApiExplorer/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Mvc.ApiExplorer.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Mvc.Core/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Mvc.Core.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Mvc.Cors/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Mvc.Cors.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Mvc.DataAnnotations/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Mvc.DataAnnotations.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Mvc/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Mvc.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Mvc.Formatters.Json/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Mvc.Formatters.Json.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Mvc.Formatters.Xml/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Mvc.Formatters.Xml.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Mvc.Localization/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Mvc.Localization.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Mvc.Razor/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Mvc.Razor.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Mvc.RazorPages/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Mvc.RazorPages.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Mvc.TagHelpers/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Mvc.TagHelpers.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Mvc.ViewFeatures/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Mvc.ViewFeatures.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Razor/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Razor.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Razor.Runtime/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Razor.Runtime.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.ResponseCaching.Abstractions/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.ResponseCaching.Abstractions.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.ResponseCaching/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.ResponseCaching.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.ResponseCompression/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.ResponseCompression.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Rewrite/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Rewrite.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Routing.Abstractions/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Routing.Abstractions.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Routing/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Routing.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Server.HttpSys/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Server.HttpSys.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Server.IIS/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Server.IIS.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Server.IISIntegration/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Server.IISIntegration.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Server.Kestrel.Core/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Server.Kestrel.Core.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Server.Kestrel/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Server.Kestrel.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.Session/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.Session.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.SignalR.Common/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.SignalR.Common.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.SignalR.Core/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.SignalR.Core.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.SignalR/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.SignalR.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.SignalR.Protocols.Json/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.SignalR.Protocols.Json.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.StaticFiles/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.StaticFiles.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.WebSockets/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.WebSockets.dll": {} + }, + "compileOnly": true + }, + "Microsoft.AspNetCore.WebUtilities/3.1.0.0": { + "compile": { + "Microsoft.AspNetCore.WebUtilities.dll": {} + }, + "compileOnly": true + }, + "Microsoft.CSharp/4.0.0.0": { + "compile": { + "Microsoft.CSharp.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.Caching.Abstractions/3.1.0.0": { + "compile": { + "Microsoft.Extensions.Caching.Abstractions.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.Caching.Memory/3.1.0.0": { + "compile": { + "Microsoft.Extensions.Caching.Memory.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.Configuration.CommandLine/3.1.0.0": { + "compile": { + "Microsoft.Extensions.Configuration.CommandLine.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.Configuration.EnvironmentVariables/3.1.0.0": { + "compile": { + "Microsoft.Extensions.Configuration.EnvironmentVariables.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.Configuration.FileExtensions/3.1.0.0": { + "compile": { + "Microsoft.Extensions.Configuration.FileExtensions.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.Configuration.Ini/3.1.0.0": { + "compile": { + "Microsoft.Extensions.Configuration.Ini.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.Configuration.Json/3.1.0.0": { + "compile": { + "Microsoft.Extensions.Configuration.Json.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.Configuration.KeyPerFile/3.1.0.0": { + "compile": { + "Microsoft.Extensions.Configuration.KeyPerFile.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.Configuration.UserSecrets/3.1.0.0": { + "compile": { + "Microsoft.Extensions.Configuration.UserSecrets.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.Configuration.Xml/3.1.0.0": { + "compile": { + "Microsoft.Extensions.Configuration.Xml.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.Diagnostics.HealthChecks.Abstractions/3.1.0.0": { + "compile": { + "Microsoft.Extensions.Diagnostics.HealthChecks.Abstractions.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.Diagnostics.HealthChecks/3.1.0.0": { + "compile": { + "Microsoft.Extensions.Diagnostics.HealthChecks.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.FileProviders.Composite/3.1.0.0": { + "compile": { + "Microsoft.Extensions.FileProviders.Composite.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.FileProviders.Embedded/3.1.0.0": { + "compile": { + "Microsoft.Extensions.FileProviders.Embedded.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.Hosting.Abstractions/3.1.0.0": { + "compile": { + "Microsoft.Extensions.Hosting.Abstractions.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.Hosting/3.1.0.0": { + "compile": { + "Microsoft.Extensions.Hosting.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.Http/3.1.0.0": { + "compile": { + "Microsoft.Extensions.Http.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.Identity.Core/3.1.0.0": { + "compile": { + "Microsoft.Extensions.Identity.Core.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.Identity.Stores/3.1.0.0": { + "compile": { + "Microsoft.Extensions.Identity.Stores.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.Localization.Abstractions/3.1.0.0": { + "compile": { + "Microsoft.Extensions.Localization.Abstractions.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.Localization/3.1.0.0": { + "compile": { + "Microsoft.Extensions.Localization.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.Logging.Debug/3.1.0.0": { + "compile": { + "Microsoft.Extensions.Logging.Debug.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.Logging.EventLog/3.1.0.0": { + "compile": { + "Microsoft.Extensions.Logging.EventLog.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.Logging.EventSource/3.1.0.0": { + "compile": { + "Microsoft.Extensions.Logging.EventSource.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.Logging.TraceSource/3.1.0.0": { + "compile": { + "Microsoft.Extensions.Logging.TraceSource.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.ObjectPool/3.1.0.0": { + "compile": { + "Microsoft.Extensions.ObjectPool.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.Options.DataAnnotations/3.1.0.0": { + "compile": { + "Microsoft.Extensions.Options.DataAnnotations.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Extensions.WebEncoders/3.1.0.0": { + "compile": { + "Microsoft.Extensions.WebEncoders.dll": {} + }, + "compileOnly": true + }, + "Microsoft.JSInterop/3.1.0.0": { + "compile": { + "Microsoft.JSInterop.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Net.Http.Headers/3.1.0.0": { + "compile": { + "Microsoft.Net.Http.Headers.dll": {} + }, + "compileOnly": true + }, + "Microsoft.VisualBasic.Core/10.0.5.0": { + "compile": { + "Microsoft.VisualBasic.Core.dll": {} + }, + "compileOnly": true + }, + "Microsoft.VisualBasic/10.0.0.0": { + "compile": { + "Microsoft.VisualBasic.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Win32.Primitives/4.1.2.0": { + "compile": { + "Microsoft.Win32.Primitives.dll": {} + }, + "compileOnly": true + }, + "Microsoft.Win32.Registry/4.1.3.0": { + "compile": { + "Microsoft.Win32.Registry.dll": {} + }, + "compileOnly": true + }, + "mscorlib/4.0.0.0": { + "compile": { + "mscorlib.dll": {} + }, + "compileOnly": true + }, + "netstandard/2.1.0.0": { + "compile": { + "netstandard.dll": {} + }, + "compileOnly": true + }, + "System.AppContext/4.2.2.0": { + "compile": { + "System.AppContext.dll": {} + }, + "compileOnly": true + }, + "System.Buffers/4.0.2.0": { + "compile": { + "System.Buffers.dll": {} + }, + "compileOnly": true + }, + "System.Collections.Concurrent/4.0.15.0": { + "compile": { + "System.Collections.Concurrent.dll": {} + }, + "compileOnly": true + }, + "System.Collections/4.1.2.0": { + "compile": { + "System.Collections.dll": {} + }, + "compileOnly": true + }, + "System.Collections.Immutable/1.2.5.0": { + "compile": { + "System.Collections.Immutable.dll": {} + }, + "compileOnly": true + }, + "System.Collections.NonGeneric/4.1.2.0": { + "compile": { + "System.Collections.NonGeneric.dll": {} + }, + "compileOnly": true + }, + "System.Collections.Specialized/4.1.2.0": { + "compile": { + "System.Collections.Specialized.dll": {} + }, + "compileOnly": true + }, + "System.ComponentModel.Annotations/4.3.1.0": { + "compile": { + "System.ComponentModel.Annotations.dll": {} + }, + "compileOnly": true + }, + "System.ComponentModel.DataAnnotations/4.0.0.0": { + "compile": { + "System.ComponentModel.DataAnnotations.dll": {} + }, + "compileOnly": true + }, + "System.ComponentModel/4.0.4.0": { + "compile": { + "System.ComponentModel.dll": {} + }, + "compileOnly": true + }, + "System.ComponentModel.EventBasedAsync/4.1.2.0": { + "compile": { + "System.ComponentModel.EventBasedAsync.dll": {} + }, + "compileOnly": true + }, + "System.ComponentModel.Primitives/4.2.2.0": { + "compile": { + "System.ComponentModel.Primitives.dll": {} + }, + "compileOnly": true + }, + "System.ComponentModel.TypeConverter/4.2.2.0": { + "compile": { + "System.ComponentModel.TypeConverter.dll": {} + }, + "compileOnly": true + }, + "System.Configuration/4.0.0.0": { + "compile": { + "System.Configuration.dll": {} + }, + "compileOnly": true + }, + "System.Console/4.1.2.0": { + "compile": { + "System.Console.dll": {} + }, + "compileOnly": true + }, + "System.Core/4.0.0.0": { + "compile": { + "System.Core.dll": {} + }, + "compileOnly": true + }, + "System.Data.Common/4.2.2.0": { + "compile": { + "System.Data.Common.dll": {} + }, + "compileOnly": true + }, + "System.Data.DataSetExtensions/4.0.1.0": { + "compile": { + "System.Data.DataSetExtensions.dll": {} + }, + "compileOnly": true + }, + "System.Data/4.0.0.0": { + "compile": { + "System.Data.dll": {} + }, + "compileOnly": true + }, + "System.Diagnostics.Contracts/4.0.4.0": { + "compile": { + "System.Diagnostics.Contracts.dll": {} + }, + "compileOnly": true + }, + "System.Diagnostics.Debug/4.1.2.0": { + "compile": { + "System.Diagnostics.Debug.dll": {} + }, + "compileOnly": true + }, + "System.Diagnostics.DiagnosticSource/4.0.5.0": { + "compile": { + "System.Diagnostics.DiagnosticSource.dll": {} + }, + "compileOnly": true + }, + "System.Diagnostics.EventLog/4.0.2.0": { + "compile": { + "System.Diagnostics.EventLog.dll": {} + }, + "compileOnly": true + }, + "System.Diagnostics.FileVersionInfo/4.0.4.0": { + "compile": { + "System.Diagnostics.FileVersionInfo.dll": {} + }, + "compileOnly": true + }, + "System.Diagnostics.Process/4.2.2.0": { + "compile": { + "System.Diagnostics.Process.dll": {} + }, + "compileOnly": true + }, + "System.Diagnostics.StackTrace/4.1.2.0": { + "compile": { + "System.Diagnostics.StackTrace.dll": {} + }, + "compileOnly": true + }, + "System.Diagnostics.TextWriterTraceListener/4.1.2.0": { + "compile": { + "System.Diagnostics.TextWriterTraceListener.dll": {} + }, + "compileOnly": true + }, + "System.Diagnostics.Tools/4.1.2.0": { + "compile": { + "System.Diagnostics.Tools.dll": {} + }, + "compileOnly": true + }, + "System.Diagnostics.TraceSource/4.1.2.0": { + "compile": { + "System.Diagnostics.TraceSource.dll": {} + }, + "compileOnly": true + }, + "System.Diagnostics.Tracing/4.2.2.0": { + "compile": { + "System.Diagnostics.Tracing.dll": {} + }, + "compileOnly": true + }, + "System/4.0.0.0": { + "compile": { + "System.dll": {} + }, + "compileOnly": true + }, + "System.Drawing/4.0.0.0": { + "compile": { + "System.Drawing.dll": {} + }, + "compileOnly": true + }, + "System.Drawing.Primitives/4.2.1.0": { + "compile": { + "System.Drawing.Primitives.dll": {} + }, + "compileOnly": true + }, + "System.Dynamic.Runtime/4.1.2.0": { + "compile": { + "System.Dynamic.Runtime.dll": {} + }, + "compileOnly": true + }, + "System.Globalization.Calendars/4.1.2.0": { + "compile": { + "System.Globalization.Calendars.dll": {} + }, + "compileOnly": true + }, + "System.Globalization/4.1.2.0": { + "compile": { + "System.Globalization.dll": {} + }, + "compileOnly": true + }, + "System.Globalization.Extensions/4.1.2.0": { + "compile": { + "System.Globalization.Extensions.dll": {} + }, + "compileOnly": true + }, + "System.IO.Compression.Brotli/4.2.2.0": { + "compile": { + "System.IO.Compression.Brotli.dll": {} + }, + "compileOnly": true + }, + "System.IO.Compression/4.2.2.0": { + "compile": { + "System.IO.Compression.dll": {} + }, + "compileOnly": true + }, + "System.IO.Compression.FileSystem/4.0.0.0": { + "compile": { + "System.IO.Compression.FileSystem.dll": {} + }, + "compileOnly": true + }, + "System.IO.Compression.ZipFile/4.0.5.0": { + "compile": { + "System.IO.Compression.ZipFile.dll": {} + }, + "compileOnly": true + }, + "System.IO/4.2.2.0": { + "compile": { + "System.IO.dll": {} + }, + "compileOnly": true + }, + "System.IO.FileSystem/4.1.2.0": { + "compile": { + "System.IO.FileSystem.dll": {} + }, + "compileOnly": true + }, + "System.IO.FileSystem.DriveInfo/4.1.2.0": { + "compile": { + "System.IO.FileSystem.DriveInfo.dll": {} + }, + "compileOnly": true + }, + "System.IO.FileSystem.Primitives/4.1.2.0": { + "compile": { + "System.IO.FileSystem.Primitives.dll": {} + }, + "compileOnly": true + }, + "System.IO.FileSystem.Watcher/4.1.2.0": { + "compile": { + "System.IO.FileSystem.Watcher.dll": {} + }, + "compileOnly": true + }, + "System.IO.IsolatedStorage/4.1.2.0": { + "compile": { + "System.IO.IsolatedStorage.dll": {} + }, + "compileOnly": true + }, + "System.IO.MemoryMappedFiles/4.1.2.0": { + "compile": { + "System.IO.MemoryMappedFiles.dll": {} + }, + "compileOnly": true + }, + "System.IO.Pipelines/4.0.2.0": { + "compile": { + "System.IO.Pipelines.dll": {} + }, + "compileOnly": true + }, + "System.IO.Pipes/4.1.2.0": { + "compile": { + "System.IO.Pipes.dll": {} + }, + "compileOnly": true + }, + "System.IO.UnmanagedMemoryStream/4.1.2.0": { + "compile": { + "System.IO.UnmanagedMemoryStream.dll": {} + }, + "compileOnly": true + }, + "System.Linq/4.2.2.0": { + "compile": { + "System.Linq.dll": {} + }, + "compileOnly": true + }, + "System.Linq.Expressions/4.2.2.0": { + "compile": { + "System.Linq.Expressions.dll": {} + }, + "compileOnly": true + }, + "System.Linq.Parallel/4.0.4.0": { + "compile": { + "System.Linq.Parallel.dll": {} + }, + "compileOnly": true + }, + "System.Linq.Queryable/4.0.4.0": { + "compile": { + "System.Linq.Queryable.dll": {} + }, + "compileOnly": true + }, + "System.Memory/4.2.1.0": { + "compile": { + "System.Memory.dll": {} + }, + "compileOnly": true + }, + "System.Net/4.0.0.0": { + "compile": { + "System.Net.dll": {} + }, + "compileOnly": true + }, + "System.Net.Http/4.2.2.0": { + "compile": { + "System.Net.Http.dll": {} + }, + "compileOnly": true + }, + "System.Net.HttpListener/4.0.2.0": { + "compile": { + "System.Net.HttpListener.dll": {} + }, + "compileOnly": true + }, + "System.Net.Mail/4.0.2.0": { + "compile": { + "System.Net.Mail.dll": {} + }, + "compileOnly": true + }, + "System.Net.NameResolution/4.1.2.0": { + "compile": { + "System.Net.NameResolution.dll": {} + }, + "compileOnly": true + }, + "System.Net.NetworkInformation/4.2.2.0": { + "compile": { + "System.Net.NetworkInformation.dll": {} + }, + "compileOnly": true + }, + "System.Net.Ping/4.1.2.0": { + "compile": { + "System.Net.Ping.dll": {} + }, + "compileOnly": true + }, + "System.Net.Primitives/4.1.2.0": { + "compile": { + "System.Net.Primitives.dll": {} + }, + "compileOnly": true + }, + "System.Net.Requests/4.1.2.0": { + "compile": { + "System.Net.Requests.dll": {} + }, + "compileOnly": true + }, + "System.Net.Security/4.1.2.0": { + "compile": { + "System.Net.Security.dll": {} + }, + "compileOnly": true + }, + "System.Net.ServicePoint/4.0.2.0": { + "compile": { + "System.Net.ServicePoint.dll": {} + }, + "compileOnly": true + }, + "System.Net.Sockets/4.2.2.0": { + "compile": { + "System.Net.Sockets.dll": {} + }, + "compileOnly": true + }, + "System.Net.WebClient/4.0.2.0": { + "compile": { + "System.Net.WebClient.dll": {} + }, + "compileOnly": true + }, + "System.Net.WebHeaderCollection/4.1.2.0": { + "compile": { + "System.Net.WebHeaderCollection.dll": {} + }, + "compileOnly": true + }, + "System.Net.WebProxy/4.0.2.0": { + "compile": { + "System.Net.WebProxy.dll": {} + }, + "compileOnly": true + }, + "System.Net.WebSockets.Client/4.1.2.0": { + "compile": { + "System.Net.WebSockets.Client.dll": {} + }, + "compileOnly": true + }, + "System.Net.WebSockets/4.1.2.0": { + "compile": { + "System.Net.WebSockets.dll": {} + }, + "compileOnly": true + }, + "System.Numerics/4.0.0.0": { + "compile": { + "System.Numerics.dll": {} + }, + "compileOnly": true + }, + "System.Numerics.Vectors/4.1.6.0": { + "compile": { + "System.Numerics.Vectors.dll": {} + }, + "compileOnly": true + }, + "System.ObjectModel/4.1.2.0": { + "compile": { + "System.ObjectModel.dll": {} + }, + "compileOnly": true + }, + "System.Reflection.DispatchProxy/4.0.6.0": { + "compile": { + "System.Reflection.DispatchProxy.dll": {} + }, + "compileOnly": true + }, + "System.Reflection/4.2.2.0": { + "compile": { + "System.Reflection.dll": {} + }, + "compileOnly": true + }, + "System.Reflection.Emit/4.1.2.0": { + "compile": { + "System.Reflection.Emit.dll": {} + }, + "compileOnly": true + }, + "System.Reflection.Emit.ILGeneration/4.1.1.0": { + "compile": { + "System.Reflection.Emit.ILGeneration.dll": {} + }, + "compileOnly": true + }, + "System.Reflection.Emit.Lightweight/4.1.1.0": { + "compile": { + "System.Reflection.Emit.Lightweight.dll": {} + }, + "compileOnly": true + }, + "System.Reflection.Extensions/4.1.2.0": { + "compile": { + "System.Reflection.Extensions.dll": {} + }, + "compileOnly": true + }, + "System.Reflection.Metadata/1.4.5.0": { + "compile": { + "System.Reflection.Metadata.dll": {} + }, + "compileOnly": true + }, + "System.Reflection.Primitives/4.1.2.0": { + "compile": { + "System.Reflection.Primitives.dll": {} + }, + "compileOnly": true + }, + "System.Reflection.TypeExtensions/4.1.2.0": { + "compile": { + "System.Reflection.TypeExtensions.dll": {} + }, + "compileOnly": true + }, + "System.Resources.Reader/4.1.2.0": { + "compile": { + "System.Resources.Reader.dll": {} + }, + "compileOnly": true + }, + "System.Resources.ResourceManager/4.1.2.0": { + "compile": { + "System.Resources.ResourceManager.dll": {} + }, + "compileOnly": true + }, + "System.Resources.Writer/4.1.2.0": { + "compile": { + "System.Resources.Writer.dll": {} + }, + "compileOnly": true + }, + "System.Runtime.CompilerServices.Unsafe/4.0.6.0": { + "compile": { + "System.Runtime.CompilerServices.Unsafe.dll": {} + }, + "compileOnly": true + }, + "System.Runtime.CompilerServices.VisualC/4.1.2.0": { + "compile": { + "System.Runtime.CompilerServices.VisualC.dll": {} + }, + "compileOnly": true + }, + "System.Runtime/4.2.2.0": { + "compile": { + "System.Runtime.dll": {} + }, + "compileOnly": true + }, + "System.Runtime.Extensions/4.2.2.0": { + "compile": { + "System.Runtime.Extensions.dll": {} + }, + "compileOnly": true + }, + "System.Runtime.Handles/4.1.2.0": { + "compile": { + "System.Runtime.Handles.dll": {} + }, + "compileOnly": true + }, + "System.Runtime.InteropServices/4.2.2.0": { + "compile": { + "System.Runtime.InteropServices.dll": {} + }, + "compileOnly": true + }, + "System.Runtime.InteropServices.RuntimeInformation/4.0.4.0": { + "compile": { + "System.Runtime.InteropServices.RuntimeInformation.dll": {} + }, + "compileOnly": true + }, + "System.Runtime.InteropServices.WindowsRuntime/4.0.4.0": { + "compile": { + "System.Runtime.InteropServices.WindowsRuntime.dll": {} + }, + "compileOnly": true + }, + "System.Runtime.Intrinsics/4.0.1.0": { + "compile": { + "System.Runtime.Intrinsics.dll": {} + }, + "compileOnly": true + }, + "System.Runtime.Loader/4.1.1.0": { + "compile": { + "System.Runtime.Loader.dll": {} + }, + "compileOnly": true + }, + "System.Runtime.Numerics/4.1.2.0": { + "compile": { + "System.Runtime.Numerics.dll": {} + }, + "compileOnly": true + }, + "System.Runtime.Serialization/4.0.0.0": { + "compile": { + "System.Runtime.Serialization.dll": {} + }, + "compileOnly": true + }, + "System.Runtime.Serialization.Formatters/4.0.4.0": { + "compile": { + "System.Runtime.Serialization.Formatters.dll": {} + }, + "compileOnly": true + }, + "System.Runtime.Serialization.Json/4.0.5.0": { + "compile": { + "System.Runtime.Serialization.Json.dll": {} + }, + "compileOnly": true + }, + "System.Runtime.Serialization.Primitives/4.2.2.0": { + "compile": { + "System.Runtime.Serialization.Primitives.dll": {} + }, + "compileOnly": true + }, + "System.Runtime.Serialization.Xml/4.1.5.0": { + "compile": { + "System.Runtime.Serialization.Xml.dll": {} + }, + "compileOnly": true + }, + "System.Security.AccessControl/4.1.1.0": { + "compile": { + "System.Security.AccessControl.dll": {} + }, + "compileOnly": true + }, + "System.Security.Claims/4.1.2.0": { + "compile": { + "System.Security.Claims.dll": {} + }, + "compileOnly": true + }, + "System.Security.Cryptography.Algorithms/4.3.2.0": { + "compile": { + "System.Security.Cryptography.Algorithms.dll": {} + }, + "compileOnly": true + }, + "System.Security.Cryptography.Cng/4.3.3.0": { + "compile": { + "System.Security.Cryptography.Cng.dll": {} + }, + "compileOnly": true + }, + "System.Security.Cryptography.Csp/4.1.2.0": { + "compile": { + "System.Security.Cryptography.Csp.dll": {} + }, + "compileOnly": true + }, + "System.Security.Cryptography.Encoding/4.1.2.0": { + "compile": { + "System.Security.Cryptography.Encoding.dll": {} + }, + "compileOnly": true + }, + "System.Security.Cryptography.Primitives/4.1.2.0": { + "compile": { + "System.Security.Cryptography.Primitives.dll": {} + }, + "compileOnly": true + }, + "System.Security.Cryptography.X509Certificates/4.2.2.0": { + "compile": { + "System.Security.Cryptography.X509Certificates.dll": {} + }, + "compileOnly": true + }, + "System.Security.Cryptography.Xml/4.0.3.0": { + "compile": { + "System.Security.Cryptography.Xml.dll": {} + }, + "compileOnly": true + }, + "System.Security/4.0.0.0": { + "compile": { + "System.Security.dll": {} + }, + "compileOnly": true + }, + "System.Security.Permissions/4.0.3.0": { + "compile": { + "System.Security.Permissions.dll": {} + }, + "compileOnly": true + }, + "System.Security.Principal/4.1.2.0": { + "compile": { + "System.Security.Principal.dll": {} + }, + "compileOnly": true + }, + "System.Security.Principal.Windows/4.1.1.0": { + "compile": { + "System.Security.Principal.Windows.dll": {} + }, + "compileOnly": true + }, + "System.Security.SecureString/4.1.2.0": { + "compile": { + "System.Security.SecureString.dll": {} + }, + "compileOnly": true + }, + "System.ServiceModel.Web/4.0.0.0": { + "compile": { + "System.ServiceModel.Web.dll": {} + }, + "compileOnly": true + }, + "System.ServiceProcess/4.0.0.0": { + "compile": { + "System.ServiceProcess.dll": {} + }, + "compileOnly": true + }, + "System.Text.Encoding.CodePages/4.1.3.0": { + "compile": { + "System.Text.Encoding.CodePages.dll": {} + }, + "compileOnly": true + }, + "System.Text.Encoding/4.1.2.0": { + "compile": { + "System.Text.Encoding.dll": {} + }, + "compileOnly": true + }, + "System.Text.Encoding.Extensions/4.1.2.0": { + "compile": { + "System.Text.Encoding.Extensions.dll": {} + }, + "compileOnly": true + }, + "System.Text.Encodings.Web/4.0.5.0": { + "compile": { + "System.Text.Encodings.Web.dll": {} + }, + "compileOnly": true + }, + "System.Text.Json/4.0.1.0": { + "compile": { + "System.Text.Json.dll": {} + }, + "compileOnly": true + }, + "System.Text.RegularExpressions/4.2.2.0": { + "compile": { + "System.Text.RegularExpressions.dll": {} + }, + "compileOnly": true + }, + "System.Threading.Channels/4.0.2.0": { + "compile": { + "System.Threading.Channels.dll": {} + }, + "compileOnly": true + }, + "System.Threading/4.1.2.0": { + "compile": { + "System.Threading.dll": {} + }, + "compileOnly": true + }, + "System.Threading.Overlapped/4.1.2.0": { + "compile": { + "System.Threading.Overlapped.dll": {} + }, + "compileOnly": true + }, + "System.Threading.Tasks.Dataflow/4.6.5.0": { + "compile": { + "System.Threading.Tasks.Dataflow.dll": {} + }, + "compileOnly": true + }, + "System.Threading.Tasks/4.1.2.0": { + "compile": { + "System.Threading.Tasks.dll": {} + }, + "compileOnly": true + }, + "System.Threading.Tasks.Extensions/4.3.1.0": { + "compile": { + "System.Threading.Tasks.Extensions.dll": {} + }, + "compileOnly": true + }, + "System.Threading.Tasks.Parallel/4.0.4.0": { + "compile": { + "System.Threading.Tasks.Parallel.dll": {} + }, + "compileOnly": true + }, + "System.Threading.Thread/4.1.2.0": { + "compile": { + "System.Threading.Thread.dll": {} + }, + "compileOnly": true + }, + "System.Threading.ThreadPool/4.1.2.0": { + "compile": { + "System.Threading.ThreadPool.dll": {} + }, + "compileOnly": true + }, + "System.Threading.Timer/4.1.2.0": { + "compile": { + "System.Threading.Timer.dll": {} + }, + "compileOnly": true + }, + "System.Transactions/4.0.0.0": { + "compile": { + "System.Transactions.dll": {} + }, + "compileOnly": true + }, + "System.Transactions.Local/4.0.2.0": { + "compile": { + "System.Transactions.Local.dll": {} + }, + "compileOnly": true + }, + "System.ValueTuple/4.0.3.0": { + "compile": { + "System.ValueTuple.dll": {} + }, + "compileOnly": true + }, + "System.Web/4.0.0.0": { + "compile": { + "System.Web.dll": {} + }, + "compileOnly": true + }, + "System.Web.HttpUtility/4.0.2.0": { + "compile": { + "System.Web.HttpUtility.dll": {} + }, + "compileOnly": true + }, + "System.Windows/4.0.0.0": { + "compile": { + "System.Windows.dll": {} + }, + "compileOnly": true + }, + "System.Windows.Extensions/4.0.1.0": { + "compile": { + "System.Windows.Extensions.dll": {} + }, + "compileOnly": true + }, + "System.Xml/4.0.0.0": { + "compile": { + "System.Xml.dll": {} + }, + "compileOnly": true + }, + "System.Xml.Linq/4.0.0.0": { + "compile": { + "System.Xml.Linq.dll": {} + }, + "compileOnly": true + }, + "System.Xml.ReaderWriter/4.2.2.0": { + "compile": { + "System.Xml.ReaderWriter.dll": {} + }, + "compileOnly": true + }, + "System.Xml.Serialization/4.0.0.0": { + "compile": { + "System.Xml.Serialization.dll": {} + }, + "compileOnly": true + }, + "System.Xml.XDocument/4.1.2.0": { + "compile": { + "System.Xml.XDocument.dll": {} + }, + "compileOnly": true + }, + "System.Xml.XmlDocument/4.1.2.0": { + "compile": { + "System.Xml.XmlDocument.dll": {} + }, + "compileOnly": true + }, + "System.Xml.XmlSerializer/4.1.2.0": { + "compile": { + "System.Xml.XmlSerializer.dll": {} + }, + "compileOnly": true + }, + "System.Xml.XPath/4.1.2.0": { + "compile": { + "System.Xml.XPath.dll": {} + }, + "compileOnly": true + }, + "System.Xml.XPath.XDocument/4.1.2.0": { + "compile": { + "System.Xml.XPath.XDocument.dll": {} + }, + "compileOnly": true + }, + "WindowsBase/4.0.0.0": { + "compile": { + "WindowsBase.dll": {} + }, + "compileOnly": true + } + } + }, + "libraries": { + "contacts/1.0.0": { + "type": "project", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.NodeServices/3.1.8": { + "type": "package", + "serviceable": true, + "sha512": "sha512-RIQRd+xuvFntX1ZP0vFOFjGwMxMLkSNOwWuEiCWG8pcc/L9pl/NraefrjFTH88pvyX8a0y1eyA4l/EkHMGjZ/g==", + "path": "microsoft.aspnetcore.nodeservices/3.1.8", + "hashPath": "microsoft.aspnetcore.nodeservices.3.1.8.nupkg.sha512" + }, + "Microsoft.AspNetCore.SpaServices/3.1.8": { + "type": "package", + "serviceable": true, + "sha512": "sha512-jnd1fpGjmVud8iyaaN0N/R3wxySvweMUo6Hml1OaWHWBbRI0wjX7TfOqvRJXC5Mwq9SP3B8bg5ik/BfHEKGgog==", + "path": "microsoft.aspnetcore.spaservices/3.1.8", + "hashPath": "microsoft.aspnetcore.spaservices.3.1.8.nupkg.sha512" + }, + "Microsoft.AspNetCore.SpaServices.Extensions/3.1.8": { + "type": "package", + "serviceable": true, + "sha512": "sha512-c1OftMALLUQOVbHKalS8JfdjadiRw/Teta0GDzpig7t7FkzLx56LMxmfeZBGg47oG21mnulX3o5eZuSj6EDR+Q==", + "path": "microsoft.aspnetcore.spaservices.extensions/3.1.8", + "hashPath": "microsoft.aspnetcore.spaservices.extensions.3.1.8.nupkg.sha512" + }, + "Microsoft.Extensions.Configuration/3.1.8": { + "type": "package", + "serviceable": true, + "sha512": "sha512-xWvtu/ra8xDOy62ZXzQj1ElmmH3GpZBSKvw4LbfNXKCy+PaziS5Uh0gQ47D4H4w3u+PJfhNWCCGCp9ORNEzkRw==", + "path": "microsoft.extensions.configuration/3.1.8", + "hashPath": "microsoft.extensions.configuration.3.1.8.nupkg.sha512" + }, + "Microsoft.Extensions.Configuration.Abstractions/3.1.8": { + "type": "package", + "serviceable": true, + "sha512": "sha512-0qbNyxGpuNP/fuQ3FLHesm1Vn/83qYcAgVsi1UQCQN1peY4YH1uiizOh4xbYkQyxiVMD/c/zhiYYv94G0DXSSA==", + "path": "microsoft.extensions.configuration.abstractions/3.1.8", + "hashPath": "microsoft.extensions.configuration.abstractions.3.1.8.nupkg.sha512" + }, + "Microsoft.Extensions.Configuration.Binder/3.1.8": { + "type": "package", + "serviceable": true, + "sha512": "sha512-l/oqIWRM4YF62mlCOrIKGUOCemsaID/lngK2SZEtpYI8LrktpjPd4QzvENWj5GebbLbqOtsFhF6Ko6dgzmUnBw==", + "path": "microsoft.extensions.configuration.binder/3.1.8", + "hashPath": "microsoft.extensions.configuration.binder.3.1.8.nupkg.sha512" + }, + "Microsoft.Extensions.DependencyInjection/3.1.8": { + "type": "package", + "serviceable": true, + "sha512": "sha512-tUpYcVxFqwh8wVD8O+6A8gJnVtl6L4N1Vd9bLJgQSJ0gjBTUQ/eKwJn0LglkkaDU7GAxODDv4eexgZn3QSE0NQ==", + "path": "microsoft.extensions.dependencyinjection/3.1.8", + "hashPath": "microsoft.extensions.dependencyinjection.3.1.8.nupkg.sha512" + }, + "Microsoft.Extensions.DependencyInjection.Abstractions/3.1.8": { + "type": "package", + "serviceable": true, + "sha512": "sha512-YP0kEBkSLTVl3znqZEux+xyJpz5iVNwFZf0OPS7nupdKbojSlO7Fa+JuQjLYpWfpAshaMcznu27tjWzfXRJnOA==", + "path": "microsoft.extensions.dependencyinjection.abstractions/3.1.8", + "hashPath": "microsoft.extensions.dependencyinjection.abstractions.3.1.8.nupkg.sha512" + }, + "Microsoft.Extensions.FileProviders.Abstractions/3.1.8": { + "type": "package", + "serviceable": true, + "sha512": "sha512-U7ffyzrPfRDH5K3h/mBpqJVoHbppw1kc1KyHZcZeDR7b1A0FRaqMSiizGpN9IGwWs9BuN7oXIKFyviuSGBjHtQ==", + "path": "microsoft.extensions.fileproviders.abstractions/3.1.8", + "hashPath": "microsoft.extensions.fileproviders.abstractions.3.1.8.nupkg.sha512" + }, + "Microsoft.Extensions.FileProviders.Physical/3.1.8": { + "type": "package", + "serviceable": true, + "sha512": "sha512-C75r2Xos93s0cAFFihJjyUui7wXaTQjvbqxDhJnpGkAS2Iqw5LBzIida5qz0qgI7IrAfWoOHxKHD3o83YdGA7w==", + "path": "microsoft.extensions.fileproviders.physical/3.1.8", + "hashPath": "microsoft.extensions.fileproviders.physical.3.1.8.nupkg.sha512" + }, + "Microsoft.Extensions.FileSystemGlobbing/3.1.8": { + "type": "package", + "serviceable": true, + "sha512": "sha512-WkVBJy0bgkvegB11KT6Jc1xZEnd4qwowZsjsASx2y0AaulSkBHydGUqpEGkYgtIIQdvIvf2QeoEHM/K0JDCIrA==", + "path": "microsoft.extensions.filesystemglobbing/3.1.8", + "hashPath": "microsoft.extensions.filesystemglobbing.3.1.8.nupkg.sha512" + }, + "Microsoft.Extensions.Logging/3.1.8": { + "type": "package", + "serviceable": true, + "sha512": "sha512-Bch88WGwrgJUabSOiTbPgne/jkCcWTyP97db8GWzQH9RcGi6TThiRm8ggsD+OXBW2UBwAYx1Zb1ns1elsMiomQ==", + "path": "microsoft.extensions.logging/3.1.8", + "hashPath": "microsoft.extensions.logging.3.1.8.nupkg.sha512" + }, + "Microsoft.Extensions.Logging.Abstractions/3.1.8": { + "type": "package", + "serviceable": true, + "sha512": "sha512-LxQPR/KE4P9nx304VcFipWPcW8ZOZOGHuiYlG0ncAQJItogDzR9nyYUNvziLObx2MfX2Z9iCTdAqEtoImaQOYg==", + "path": "microsoft.extensions.logging.abstractions/3.1.8", + "hashPath": "microsoft.extensions.logging.abstractions.3.1.8.nupkg.sha512" + }, + "Microsoft.Extensions.Logging.Configuration/3.1.8": { + "type": "package", + "serviceable": true, + "sha512": "sha512-tfvQYDDwc3ni8VTXQavINMHRUIsM8fQ8gBQTs98mt1QFE3YIVm8XzhqPZMBBlLnXTESymb8HctM2fMnU8qC8Rg==", + "path": "microsoft.extensions.logging.configuration/3.1.8", + "hashPath": "microsoft.extensions.logging.configuration.3.1.8.nupkg.sha512" + }, + "Microsoft.Extensions.Logging.Console/3.1.8": { + "type": "package", + "serviceable": true, + "sha512": "sha512-7JCZuqty78ZDwoXOGXGUXMC44rpocfeaa/48ONY7neKhCh2Oml/faW3PANPCdwy6M3TicmU03kIOhyrw3dQ2Eg==", + "path": "microsoft.extensions.logging.console/3.1.8", + "hashPath": "microsoft.extensions.logging.console.3.1.8.nupkg.sha512" + }, + "Microsoft.Extensions.Options/3.1.8": { + "type": "package", + "serviceable": true, + "sha512": "sha512-mpkwjNg5sr1XHEJwVS8G1w6dsh5/72vQOOe4aqhg012j93m8OOmfyIBwoQN4SE0KRRS+fatdW3qqUrHbRwlWOA==", + "path": "microsoft.extensions.options/3.1.8", + "hashPath": "microsoft.extensions.options.3.1.8.nupkg.sha512" + }, + "Microsoft.Extensions.Options.ConfigurationExtensions/3.1.8": { + "type": "package", + "serviceable": true, + "sha512": "sha512-/q7OhcsgDq6cPqg03nv55QqLt8o/OAvrVkd/w6h0YNasZ4C/Lxpx6I0DsnIH0MB5ORnqCyhmeyv1hFqOeehJng==", + "path": "microsoft.extensions.options.configurationextensions/3.1.8", + "hashPath": "microsoft.extensions.options.configurationextensions.3.1.8.nupkg.sha512" + }, + "Microsoft.Extensions.Primitives/3.1.8": { + "type": "package", + "serviceable": true, + "sha512": "sha512-XcIoXQhT0kwnEhOKv/LmpWR6yF6QWmBTy9Fcsz4aHuCOgTJ7Zd23ELtUA4BfwlYoFlSedavS+vURz9tNekd44g==", + "path": "microsoft.extensions.primitives/3.1.8", + "hashPath": "microsoft.extensions.primitives.3.1.8.nupkg.sha512" + }, + "Newtonsoft.Json/12.0.2": { + "type": "package", + "serviceable": true, + "sha512": "sha512-rTK0s2EKlfHsQsH6Yx2smvcTCeyoDNgCW7FEYyV01drPlh2T243PR2DiDXqtC5N4GDm4Ma/lkxfW5a/4793vbA==", + "path": "newtonsoft.json/12.0.2", + "hashPath": "newtonsoft.json.12.0.2.nupkg.sha512" + }, + "Microsoft.AspNetCore.Antiforgery/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Authentication.Abstractions/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Authentication.Cookies/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Authentication.Core/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Authentication/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Authentication.OAuth/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Authorization/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Authorization.Policy/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Components.Authorization/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Components/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Components.Forms/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Components.Server/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Components.Web/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Connections.Abstractions/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.CookiePolicy/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Cors/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Cryptography.Internal/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Cryptography.KeyDerivation/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.DataProtection.Abstractions/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.DataProtection/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.DataProtection.Extensions/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Diagnostics.Abstractions/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Diagnostics/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Diagnostics.HealthChecks/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.HostFiltering/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Hosting.Abstractions/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Hosting/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Hosting.Server.Abstractions/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Html.Abstractions/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Http.Abstractions/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Http.Connections.Common/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Http.Connections/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Http/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Http.Extensions/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Http.Features/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.HttpOverrides/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.HttpsPolicy/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Identity/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Localization/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Localization.Routing/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Metadata/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Mvc.Abstractions/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Mvc.ApiExplorer/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Mvc.Core/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Mvc.Cors/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Mvc.DataAnnotations/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Mvc/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Mvc.Formatters.Json/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Mvc.Formatters.Xml/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Mvc.Localization/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Mvc.Razor/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Mvc.RazorPages/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Mvc.TagHelpers/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Mvc.ViewFeatures/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Razor/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Razor.Runtime/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.ResponseCaching.Abstractions/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.ResponseCaching/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.ResponseCompression/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Rewrite/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Routing.Abstractions/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Routing/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Server.HttpSys/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Server.IIS/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Server.IISIntegration/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Server.Kestrel.Core/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Server.Kestrel/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.Session/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.SignalR.Common/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.SignalR.Core/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.SignalR/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.SignalR.Protocols.Json/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.StaticFiles/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.WebSockets/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.AspNetCore.WebUtilities/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.CSharp/4.0.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.Caching.Abstractions/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.Caching.Memory/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.Configuration.CommandLine/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.Configuration.EnvironmentVariables/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.Configuration.FileExtensions/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.Configuration.Ini/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.Configuration.Json/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.Configuration.KeyPerFile/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.Configuration.UserSecrets/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.Configuration.Xml/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.Diagnostics.HealthChecks.Abstractions/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.Diagnostics.HealthChecks/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.FileProviders.Composite/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.FileProviders.Embedded/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.Hosting.Abstractions/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.Hosting/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.Http/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.Identity.Core/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.Identity.Stores/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.Localization.Abstractions/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.Localization/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.Logging.Debug/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.Logging.EventLog/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.Logging.EventSource/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.Logging.TraceSource/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.ObjectPool/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.Options.DataAnnotations/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Extensions.WebEncoders/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.JSInterop/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Net.Http.Headers/3.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.VisualBasic.Core/10.0.5.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.VisualBasic/10.0.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Win32.Primitives/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "Microsoft.Win32.Registry/4.1.3.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "mscorlib/4.0.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "netstandard/2.1.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.AppContext/4.2.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Buffers/4.0.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Collections.Concurrent/4.0.15.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Collections/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Collections.Immutable/1.2.5.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Collections.NonGeneric/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Collections.Specialized/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.ComponentModel.Annotations/4.3.1.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.ComponentModel.DataAnnotations/4.0.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.ComponentModel/4.0.4.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.ComponentModel.EventBasedAsync/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.ComponentModel.Primitives/4.2.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.ComponentModel.TypeConverter/4.2.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Configuration/4.0.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Console/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Core/4.0.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Data.Common/4.2.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Data.DataSetExtensions/4.0.1.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Data/4.0.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Diagnostics.Contracts/4.0.4.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Diagnostics.Debug/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Diagnostics.DiagnosticSource/4.0.5.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Diagnostics.EventLog/4.0.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Diagnostics.FileVersionInfo/4.0.4.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Diagnostics.Process/4.2.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Diagnostics.StackTrace/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Diagnostics.TextWriterTraceListener/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Diagnostics.Tools/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Diagnostics.TraceSource/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Diagnostics.Tracing/4.2.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System/4.0.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Drawing/4.0.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Drawing.Primitives/4.2.1.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Dynamic.Runtime/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Globalization.Calendars/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Globalization/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Globalization.Extensions/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.IO.Compression.Brotli/4.2.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.IO.Compression/4.2.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.IO.Compression.FileSystem/4.0.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.IO.Compression.ZipFile/4.0.5.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.IO/4.2.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.IO.FileSystem/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.IO.FileSystem.DriveInfo/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.IO.FileSystem.Primitives/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.IO.FileSystem.Watcher/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.IO.IsolatedStorage/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.IO.MemoryMappedFiles/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.IO.Pipelines/4.0.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.IO.Pipes/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.IO.UnmanagedMemoryStream/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Linq/4.2.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Linq.Expressions/4.2.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Linq.Parallel/4.0.4.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Linq.Queryable/4.0.4.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Memory/4.2.1.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Net/4.0.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Net.Http/4.2.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Net.HttpListener/4.0.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Net.Mail/4.0.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Net.NameResolution/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Net.NetworkInformation/4.2.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Net.Ping/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Net.Primitives/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Net.Requests/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Net.Security/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Net.ServicePoint/4.0.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Net.Sockets/4.2.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Net.WebClient/4.0.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Net.WebHeaderCollection/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Net.WebProxy/4.0.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Net.WebSockets.Client/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Net.WebSockets/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Numerics/4.0.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Numerics.Vectors/4.1.6.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.ObjectModel/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Reflection.DispatchProxy/4.0.6.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Reflection/4.2.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Reflection.Emit/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Reflection.Emit.ILGeneration/4.1.1.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Reflection.Emit.Lightweight/4.1.1.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Reflection.Extensions/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Reflection.Metadata/1.4.5.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Reflection.Primitives/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Reflection.TypeExtensions/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Resources.Reader/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Resources.ResourceManager/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Resources.Writer/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Runtime.CompilerServices.Unsafe/4.0.6.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Runtime.CompilerServices.VisualC/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Runtime/4.2.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Runtime.Extensions/4.2.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Runtime.Handles/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Runtime.InteropServices/4.2.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Runtime.InteropServices.RuntimeInformation/4.0.4.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Runtime.InteropServices.WindowsRuntime/4.0.4.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Runtime.Intrinsics/4.0.1.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Runtime.Loader/4.1.1.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Runtime.Numerics/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Runtime.Serialization/4.0.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Runtime.Serialization.Formatters/4.0.4.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Runtime.Serialization.Json/4.0.5.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Runtime.Serialization.Primitives/4.2.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Runtime.Serialization.Xml/4.1.5.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Security.AccessControl/4.1.1.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Security.Claims/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Security.Cryptography.Algorithms/4.3.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Security.Cryptography.Cng/4.3.3.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Security.Cryptography.Csp/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Security.Cryptography.Encoding/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Security.Cryptography.Primitives/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Security.Cryptography.X509Certificates/4.2.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Security.Cryptography.Xml/4.0.3.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Security/4.0.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Security.Permissions/4.0.3.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Security.Principal/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Security.Principal.Windows/4.1.1.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Security.SecureString/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.ServiceModel.Web/4.0.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.ServiceProcess/4.0.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Text.Encoding.CodePages/4.1.3.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Text.Encoding/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Text.Encoding.Extensions/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Text.Encodings.Web/4.0.5.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Text.Json/4.0.1.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Text.RegularExpressions/4.2.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Threading.Channels/4.0.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Threading/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Threading.Overlapped/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Threading.Tasks.Dataflow/4.6.5.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Threading.Tasks/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Threading.Tasks.Extensions/4.3.1.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Threading.Tasks.Parallel/4.0.4.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Threading.Thread/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Threading.ThreadPool/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Threading.Timer/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Transactions/4.0.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Transactions.Local/4.0.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.ValueTuple/4.0.3.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Web/4.0.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Web.HttpUtility/4.0.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Windows/4.0.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Windows.Extensions/4.0.1.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Xml/4.0.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Xml.Linq/4.0.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Xml.ReaderWriter/4.2.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Xml.Serialization/4.0.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Xml.XDocument/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Xml.XmlDocument/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Xml.XmlSerializer/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Xml.XPath/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "System.Xml.XPath.XDocument/4.1.2.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + }, + "WindowsBase/4.0.0.0": { + "type": "referenceassembly", + "serviceable": false, + "sha512": "" + } + } +} \ No newline at end of file diff --git a/bin/Debug/netcoreapp3.1/contacts.dll b/bin/Debug/netcoreapp3.1/contacts.dll new file mode 100644 index 0000000000000000000000000000000000000000..815a0f59ab70417eb022db342a8a94c08cb79972 GIT binary patch literal 11776 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 UA8P-}$>QdzXDJ=AZZJpw2mZdWWdHyG literal 0 HcmV?d00001 diff --git a/bin/Debug/netcoreapp3.1/contacts.runtimeconfig.dev.json b/bin/Debug/netcoreapp3.1/contacts.runtimeconfig.dev.json new file mode 100644 index 0000000..a8e3ddb --- /dev/null +++ b/bin/Debug/netcoreapp3.1/contacts.runtimeconfig.dev.json @@ -0,0 +1,8 @@ +{ + "runtimeOptions": { + "additionalProbingPaths": [ + "/Users/matthuntington/.dotnet/store/|arch|/|tfm|", + "/Users/matthuntington/.nuget/packages" + ] + } +} \ No newline at end of file diff --git a/bin/Debug/netcoreapp3.1/contacts.runtimeconfig.json b/bin/Debug/netcoreapp3.1/contacts.runtimeconfig.json new file mode 100644 index 0000000..6be1e94 --- /dev/null +++ b/bin/Debug/netcoreapp3.1/contacts.runtimeconfig.json @@ -0,0 +1,12 @@ +{ + "runtimeOptions": { + "tfm": "netcoreapp3.1", + "framework": { + "name": "Microsoft.AspNetCore.App", + "version": "3.1.0" + }, + "configProperties": { + "System.GC.Server": true + } + } +} \ No newline at end of file diff --git a/contacts.csproj b/contacts.csproj new file mode 100644 index 0000000..13f684e --- /dev/null +++ b/contacts.csproj @@ -0,0 +1,49 @@ + + + + netcoreapp3.1 + true + Latest + false + ClientApp\ + $(DefaultItemExcludes);$(SpaRoot)node_modules\** + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + %(DistFiles.Identity) + PreserveNewest + true + + + + + diff --git a/obj/Debug/netcoreapp3.1/.NETCoreApp,Version=v3.1.AssemblyAttributes.cs b/obj/Debug/netcoreapp3.1/.NETCoreApp,Version=v3.1.AssemblyAttributes.cs new file mode 100644 index 0000000..03fd1de --- /dev/null +++ b/obj/Debug/netcoreapp3.1/.NETCoreApp,Version=v3.1.AssemblyAttributes.cs @@ -0,0 +1,4 @@ +// +using System; +using System.Reflection; +[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETCoreApp,Version=v3.1", FrameworkDisplayName = "")] diff --git a/obj/Debug/netcoreapp3.1/Razor/Pages/Error.cshtml.g.cs b/obj/Debug/netcoreapp3.1/Razor/Pages/Error.cshtml.g.cs new file mode 100644 index 0000000..f712e45 --- /dev/null +++ b/obj/Debug/netcoreapp3.1/Razor/Pages/Error.cshtml.g.cs @@ -0,0 +1,90 @@ +#pragma checksum "/Users/matthuntington/Documents/.NET-React/Pages/Error.cshtml" "{ff1816ec-aa5e-4d10-87f7-6f4963833460}" "1f02565c188bc0cf60de1bc120acef71a3608055" +// +#pragma warning disable 1591 +[assembly: global::Microsoft.AspNetCore.Razor.Hosting.RazorCompiledItemAttribute(typeof(contacts.Pages.Pages_Error), @"mvc.1.0.razor-page", @"/Pages/Error.cshtml")] +namespace contacts.Pages +{ + #line hidden + using System; + using System.Collections.Generic; + using System.Linq; + using System.Threading.Tasks; + using Microsoft.AspNetCore.Mvc; + using Microsoft.AspNetCore.Mvc.Rendering; + using Microsoft.AspNetCore.Mvc.ViewFeatures; +#nullable restore +#line 1 "/Users/matthuntington/Documents/.NET-React/Pages/_ViewImports.cshtml" +using contacts; + +#line default +#line hidden +#nullable disable + [global::Microsoft.AspNetCore.Razor.Hosting.RazorSourceChecksumAttribute(@"SHA1", @"1f02565c188bc0cf60de1bc120acef71a3608055", @"/Pages/Error.cshtml")] + [global::Microsoft.AspNetCore.Razor.Hosting.RazorSourceChecksumAttribute(@"SHA1", @"aaea7bd54ea4599689c62f37348e4c631b024f98", @"/Pages/_ViewImports.cshtml")] + public class Pages_Error : global::Microsoft.AspNetCore.Mvc.RazorPages.Page + { + #pragma warning disable 1998 + public async override global::System.Threading.Tasks.Task ExecuteAsync() + { +#nullable restore +#line 3 "/Users/matthuntington/Documents/.NET-React/Pages/Error.cshtml" + + ViewData["Title"] = "Error"; + +#line default +#line hidden +#nullable disable + WriteLiteral("\r\n

Error.

\r\n

An error occurred while processing your request.

\r\n\r\n"); +#nullable restore +#line 10 "/Users/matthuntington/Documents/.NET-React/Pages/Error.cshtml" + if (Model.ShowRequestId) +{ + +#line default +#line hidden +#nullable disable + WriteLiteral("

\r\n Request ID: "); +#nullable restore +#line 13 "/Users/matthuntington/Documents/.NET-React/Pages/Error.cshtml" + Write(Model.RequestId); + +#line default +#line hidden +#nullable disable + WriteLiteral("\r\n

\r\n"); +#nullable restore +#line 15 "/Users/matthuntington/Documents/.NET-React/Pages/Error.cshtml" +} + +#line default +#line hidden +#nullable disable + WriteLiteral(@" +

Development Mode

+

+ Swapping to the Development environment displays detailed information about the error that occurred. +

+

+ The Development environment shouldn't be enabled for deployed applications. + It can result in displaying sensitive information from exceptions to end users. + For local debugging, enable the Development environment by setting the ASPNETCORE_ENVIRONMENT environment variable to Development + and restarting the app. +

+"); + } + #pragma warning restore 1998 + [global::Microsoft.AspNetCore.Mvc.Razor.Internal.RazorInjectAttribute] + public global::Microsoft.AspNetCore.Mvc.ViewFeatures.IModelExpressionProvider ModelExpressionProvider { get; private set; } + [global::Microsoft.AspNetCore.Mvc.Razor.Internal.RazorInjectAttribute] + public global::Microsoft.AspNetCore.Mvc.IUrlHelper Url { get; private set; } + [global::Microsoft.AspNetCore.Mvc.Razor.Internal.RazorInjectAttribute] + public global::Microsoft.AspNetCore.Mvc.IViewComponentHelper Component { get; private set; } + [global::Microsoft.AspNetCore.Mvc.Razor.Internal.RazorInjectAttribute] + public global::Microsoft.AspNetCore.Mvc.Rendering.IJsonHelper Json { get; private set; } + [global::Microsoft.AspNetCore.Mvc.Razor.Internal.RazorInjectAttribute] + public global::Microsoft.AspNetCore.Mvc.Rendering.IHtmlHelper Html { get; private set; } + public global::Microsoft.AspNetCore.Mvc.ViewFeatures.ViewDataDictionary ViewData => (global::Microsoft.AspNetCore.Mvc.ViewFeatures.ViewDataDictionary)PageContext?.ViewData; + public ErrorModel Model => ViewData.Model; + } +} +#pragma warning restore 1591 diff --git a/obj/Debug/netcoreapp3.1/Razor/Pages/_ViewImports.cshtml.g.cs b/obj/Debug/netcoreapp3.1/Razor/Pages/_ViewImports.cshtml.g.cs new file mode 100644 index 0000000..32666cd --- /dev/null +++ b/obj/Debug/netcoreapp3.1/Razor/Pages/_ViewImports.cshtml.g.cs @@ -0,0 +1,42 @@ +#pragma checksum "/Users/matthuntington/Documents/.NET-React/Pages/_ViewImports.cshtml" "{ff1816ec-aa5e-4d10-87f7-6f4963833460}" "aaea7bd54ea4599689c62f37348e4c631b024f98" +// +#pragma warning disable 1591 +[assembly: global::Microsoft.AspNetCore.Razor.Hosting.RazorCompiledItemAttribute(typeof(contacts.Pages.Pages__ViewImports), @"mvc.1.0.view", @"/Pages/_ViewImports.cshtml")] +namespace contacts.Pages +{ + #line hidden + using System; + using System.Collections.Generic; + using System.Linq; + using System.Threading.Tasks; + using Microsoft.AspNetCore.Mvc; + using Microsoft.AspNetCore.Mvc.Rendering; + using Microsoft.AspNetCore.Mvc.ViewFeatures; +#nullable restore +#line 1 "/Users/matthuntington/Documents/.NET-React/Pages/_ViewImports.cshtml" +using contacts; + +#line default +#line hidden +#nullable disable + [global::Microsoft.AspNetCore.Razor.Hosting.RazorSourceChecksumAttribute(@"SHA1", @"aaea7bd54ea4599689c62f37348e4c631b024f98", @"/Pages/_ViewImports.cshtml")] + public class Pages__ViewImports : global::Microsoft.AspNetCore.Mvc.Razor.RazorPage + { + #pragma warning disable 1998 + public async override global::System.Threading.Tasks.Task ExecuteAsync() + { + } + #pragma warning restore 1998 + [global::Microsoft.AspNetCore.Mvc.Razor.Internal.RazorInjectAttribute] + public global::Microsoft.AspNetCore.Mvc.ViewFeatures.IModelExpressionProvider ModelExpressionProvider { get; private set; } + [global::Microsoft.AspNetCore.Mvc.Razor.Internal.RazorInjectAttribute] + public global::Microsoft.AspNetCore.Mvc.IUrlHelper Url { get; private set; } + [global::Microsoft.AspNetCore.Mvc.Razor.Internal.RazorInjectAttribute] + public global::Microsoft.AspNetCore.Mvc.IViewComponentHelper Component { get; private set; } + [global::Microsoft.AspNetCore.Mvc.Razor.Internal.RazorInjectAttribute] + public global::Microsoft.AspNetCore.Mvc.Rendering.IJsonHelper Json { get; private set; } + [global::Microsoft.AspNetCore.Mvc.Razor.Internal.RazorInjectAttribute] + public global::Microsoft.AspNetCore.Mvc.Rendering.IHtmlHelper Html { get; private set; } + } +} +#pragma warning restore 1591 diff --git a/obj/Debug/netcoreapp3.1/contacts.AssemblyInfo.cs b/obj/Debug/netcoreapp3.1/contacts.AssemblyInfo.cs new file mode 100644 index 0000000..e0465e7 --- /dev/null +++ b/obj/Debug/netcoreapp3.1/contacts.AssemblyInfo.cs @@ -0,0 +1,22 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +using System; +using System.Reflection; + +[assembly: System.Reflection.AssemblyCompanyAttribute("contacts")] +[assembly: System.Reflection.AssemblyConfigurationAttribute("Debug")] +[assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.0")] +[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0")] +[assembly: System.Reflection.AssemblyProductAttribute("contacts")] +[assembly: System.Reflection.AssemblyTitleAttribute("contacts")] +[assembly: System.Reflection.AssemblyVersionAttribute("1.0.0.0")] + +// Generated by the MSBuild WriteCodeFragment class. + diff --git a/obj/Debug/netcoreapp3.1/contacts.AssemblyInfoInputs.cache b/obj/Debug/netcoreapp3.1/contacts.AssemblyInfoInputs.cache new file mode 100644 index 0000000..d772d31 --- /dev/null +++ b/obj/Debug/netcoreapp3.1/contacts.AssemblyInfoInputs.cache @@ -0,0 +1 @@ +d6e9127b9d93abac827090c9eccb4fb921db795c diff --git a/obj/Debug/netcoreapp3.1/contacts.MvcApplicationPartsAssemblyInfo.cache b/obj/Debug/netcoreapp3.1/contacts.MvcApplicationPartsAssemblyInfo.cache new file mode 100644 index 0000000..e69de29 diff --git a/obj/Debug/netcoreapp3.1/contacts.MvcApplicationPartsAssemblyInfo.cs b/obj/Debug/netcoreapp3.1/contacts.MvcApplicationPartsAssemblyInfo.cs new file mode 100644 index 0000000..2df51c3 --- /dev/null +++ b/obj/Debug/netcoreapp3.1/contacts.MvcApplicationPartsAssemblyInfo.cs @@ -0,0 +1,17 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +using System; +using System.Reflection; + +[assembly: Microsoft.AspNetCore.Mvc.ApplicationParts.ApplicationPartAttribute("Microsoft.AspNetCore.SpaServices")] +[assembly: Microsoft.AspNetCore.Mvc.ApplicationParts.ApplicationPartAttribute("Microsoft.AspNetCore.SpaServices.Extensions")] + +// Generated by the MSBuild WriteCodeFragment class. + diff --git a/obj/Debug/netcoreapp3.1/contacts.RazorAssemblyInfo.cache b/obj/Debug/netcoreapp3.1/contacts.RazorAssemblyInfo.cache new file mode 100644 index 0000000..175a1b0 --- /dev/null +++ b/obj/Debug/netcoreapp3.1/contacts.RazorAssemblyInfo.cache @@ -0,0 +1 @@ +d7c370a012328a670d15a5d38725721fe689d39c diff --git a/obj/Debug/netcoreapp3.1/contacts.RazorAssemblyInfo.cs b/obj/Debug/netcoreapp3.1/contacts.RazorAssemblyInfo.cs new file mode 100644 index 0000000..44b7904 --- /dev/null +++ b/obj/Debug/netcoreapp3.1/contacts.RazorAssemblyInfo.cs @@ -0,0 +1,16 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +using System; +using System.Reflection; + +[assembly: Microsoft.AspNetCore.Mvc.ApplicationParts.RelatedAssemblyAttribute("contacts.Views")] + +// Generated by the MSBuild WriteCodeFragment class. + diff --git a/obj/Debug/netcoreapp3.1/contacts.RazorCoreGenerate.cache b/obj/Debug/netcoreapp3.1/contacts.RazorCoreGenerate.cache new file mode 100644 index 0000000..1cc2a37 --- /dev/null +++ b/obj/Debug/netcoreapp3.1/contacts.RazorCoreGenerate.cache @@ -0,0 +1 @@ +3f5b327bcf109135df6f539d63fad5e4e99116d9 diff --git a/obj/Debug/netcoreapp3.1/contacts.RazorTargetAssemblyInfo.cache b/obj/Debug/netcoreapp3.1/contacts.RazorTargetAssemblyInfo.cache new file mode 100644 index 0000000..8814db6 --- /dev/null +++ b/obj/Debug/netcoreapp3.1/contacts.RazorTargetAssemblyInfo.cache @@ -0,0 +1 @@ +5288859479d4aeddf207a483e91a24f6d3817787 diff --git a/obj/Debug/netcoreapp3.1/contacts.RazorTargetAssemblyInfo.cs b/obj/Debug/netcoreapp3.1/contacts.RazorTargetAssemblyInfo.cs new file mode 100644 index 0000000..7873487 --- /dev/null +++ b/obj/Debug/netcoreapp3.1/contacts.RazorTargetAssemblyInfo.cs @@ -0,0 +1,24 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +using System; +using System.Reflection; + +[assembly: Microsoft.AspNetCore.Mvc.ApplicationParts.ProvideApplicationPartFactoryAttribute("Microsoft.AspNetCore.Mvc.ApplicationParts.CompiledRazorAssemblyApplicationPartFac" + + "tory, Microsoft.AspNetCore.Mvc.Razor")] +[assembly: System.Reflection.AssemblyCompanyAttribute("contacts")] +[assembly: System.Reflection.AssemblyConfigurationAttribute("Debug")] +[assembly: System.Reflection.AssemblyProductAttribute("contacts")] +[assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.0")] +[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0")] +[assembly: System.Reflection.AssemblyTitleAttribute("contacts.Views")] +[assembly: System.Reflection.AssemblyVersionAttribute("1.0.0.0")] + +// Generated by the MSBuild WriteCodeFragment class. + diff --git a/obj/Debug/netcoreapp3.1/contacts.TagHelpers.input.cache b/obj/Debug/netcoreapp3.1/contacts.TagHelpers.input.cache new file mode 100644 index 0000000..e69de29 diff --git a/obj/Debug/netcoreapp3.1/contacts.TagHelpers.output.cache b/obj/Debug/netcoreapp3.1/contacts.TagHelpers.output.cache new file mode 100644 index 0000000..6040f36 --- /dev/null +++ b/obj/Debug/netcoreapp3.1/contacts.TagHelpers.output.cache @@ -0,0 +1 @@ +[{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.Razor.TagHelpers.BodyTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.Razor","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"body","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.Razor.TagHelpers.BodyTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.Razor.TagHelpers.HeadTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.Razor","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"head","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.Razor.TagHelpers.HeadTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.Razor.TagHelpers.UrlResolutionTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.Razor","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"itemid","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"a","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"href","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"applet","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"archive","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"area","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"href","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"audio","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"src","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"base","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"href","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"blockquote","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"cite","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"button","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"formaction","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"del","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"cite","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"embed","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"src","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"form","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"action","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"html","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"manifest","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"iframe","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"src","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"img","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"src","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"img","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"srcset","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"formaction","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"src","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"ins","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"cite","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"link","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"href","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"menuitem","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"icon","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"object","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"archive","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"object","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"data","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"q","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"cite","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"script","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"src","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"source","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"src","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"source","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"srcset","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"track","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"src","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"video","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"poster","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"video","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"src","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.Razor.TagHelpers.UrlResolutionTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.AnchorTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"a","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-action","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"a","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-all-route-data","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"a","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-area","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"a","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-controller","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"a","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-fragment","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"a","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-host","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"a","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-page","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"a","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-page-handler","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"a","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-protocol","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"a","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-route","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"a","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-route-","NameComparison":1,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"asp-action","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Action"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-area","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Area"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-controller","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Controller"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-fragment","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Fragment"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-host","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Host"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-page","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Page"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-page-handler","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"PageHandler"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-protocol","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Protocol"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-route","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Route"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-all-route-data","TypeName":"System.Collections.Generic.IDictionary","IsEnum":false,"IndexerNamePrefix":"asp-route-","IndexerTypeName":"System.String","Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"RouteValues"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.AnchorTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.CacheTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"cache","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"priority","TypeName":"Microsoft.Extensions.Caching.Memory.CacheItemPriority?","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Priority"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"enabled","TypeName":"System.Boolean","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Enabled"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"expires-after","TypeName":"System.TimeSpan?","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ExpiresAfter"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"expires-on","TypeName":"System.DateTimeOffset?","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ExpiresOn"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"expires-sliding","TypeName":"System.TimeSpan?","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ExpiresSliding"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryBy"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by-cookie","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryByCookie"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by-culture","TypeName":"System.Boolean","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryByCulture"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by-header","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryByHeader"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by-query","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryByQuery"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by-route","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryByRoute"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by-user","TypeName":"System.Boolean","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryByUser"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.CacheTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.ComponentTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"component","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"type","TypeName":"System.Type","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ComponentType"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"params","TypeName":"System.Collections.Generic.IDictionary","IsEnum":false,"IndexerNamePrefix":"param-","IndexerTypeName":"System.Object","Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Parameters"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"render-mode","TypeName":"Microsoft.AspNetCore.Mvc.Rendering.RenderMode","IsEnum":true,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"RenderMode"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.ComponentTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.DistributedCacheTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"distributed-cache","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"name","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"name","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Name"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"enabled","TypeName":"System.Boolean","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Enabled"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"expires-after","TypeName":"System.TimeSpan?","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ExpiresAfter"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"expires-on","TypeName":"System.DateTimeOffset?","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ExpiresOn"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"expires-sliding","TypeName":"System.TimeSpan?","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ExpiresSliding"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryBy"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by-cookie","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryByCookie"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by-culture","TypeName":"System.Boolean","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryByCulture"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by-header","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryByHeader"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by-query","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryByQuery"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by-route","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryByRoute"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by-user","TypeName":"System.Boolean","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryByUser"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.DistributedCacheTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.EnvironmentTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"environment","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"exclude","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Exclude"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"include","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Include"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"names","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Names"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.EnvironmentTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.FormActionTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"button","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-action","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"button","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-all-route-data","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"button","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-area","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"button","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-controller","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"button","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-fragment","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"button","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-page","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"button","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-page-handler","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"button","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-route","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"button","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-route-","NameComparison":1,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"image","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-action","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"image","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-all-route-data","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"image","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-area","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"image","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-controller","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"image","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-fragment","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"image","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-page","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"image","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-page-handler","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"image","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-route","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"image","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-route-","NameComparison":1,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"submit","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-action","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"submit","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-all-route-data","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"submit","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-area","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"submit","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-controller","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"submit","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-fragment","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"submit","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-page","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"submit","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-page-handler","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"submit","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-route","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"submit","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-route-","NameComparison":1,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"asp-action","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Action"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-area","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Area"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-controller","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Controller"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-fragment","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Fragment"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-page","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Page"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-page-handler","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"PageHandler"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-route","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Route"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-all-route-data","TypeName":"System.Collections.Generic.IDictionary","IsEnum":false,"IndexerNamePrefix":"asp-route-","IndexerTypeName":"System.String","Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"RouteValues"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.FormActionTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.FormTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"form","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"asp-action","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Action"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-antiforgery","TypeName":"System.Boolean?","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Antiforgery"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-area","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Area"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-controller","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Controller"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-fragment","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Fragment"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"method","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Method"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-page","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Page"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-page-handler","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"PageHandler"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-route","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Route"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-all-route-data","TypeName":"System.Collections.Generic.IDictionary","IsEnum":false,"IndexerNamePrefix":"asp-route-","IndexerTypeName":"System.String","Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"RouteValues"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.FormTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.ImageTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"img","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"asp-append-version","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}},{"Name":"src","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"asp-append-version","TypeName":"System.Boolean","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AppendVersion"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"src","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Src"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.ImageTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.InputTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"asp-for","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"asp-for","TypeName":"Microsoft.AspNetCore.Mvc.ViewFeatures.ModelExpression","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"For"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-format","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Format"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"type","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"InputTypeName"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"name","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Name"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"value","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.InputTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.LabelTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"label","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-for","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"asp-for","TypeName":"Microsoft.AspNetCore.Mvc.ViewFeatures.ModelExpression","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"For"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.LabelTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.LinkTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"link","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"asp-append-version","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"link","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"asp-fallback-href","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"link","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"asp-fallback-href-exclude","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"link","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"asp-fallback-href-include","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"link","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"asp-fallback-test-class","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"link","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"asp-fallback-test-property","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"link","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"asp-fallback-test-value","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"link","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"asp-href-exclude","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"link","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"asp-href-include","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"asp-append-version","TypeName":"System.Boolean?","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AppendVersion"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-fallback-href","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"FallbackHref"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-fallback-href-exclude","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"FallbackHrefExclude"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-fallback-href-include","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"FallbackHrefInclude"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-fallback-test-class","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"FallbackTestClass"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-fallback-test-property","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"FallbackTestProperty"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-fallback-test-value","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"FallbackTestValue"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"href","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Href"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-href-exclude","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"HrefExclude"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-href-include","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"HrefInclude"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-suppress-fallback-integrity","TypeName":"System.Boolean","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"SuppressFallbackIntegrity"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.LinkTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.OptionTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"option","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"value","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.OptionTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.PartialTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"partial","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"name","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"fallback-name","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"FallbackName"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"for","TypeName":"Microsoft.AspNetCore.Mvc.ViewFeatures.ModelExpression","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"For"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"model","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Model"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"name","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Name"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"optional","TypeName":"System.Boolean","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Optional"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"view-data","TypeName":"Microsoft.AspNetCore.Mvc.ViewFeatures.ViewDataDictionary","IsEnum":false,"IndexerNamePrefix":"view-data-","IndexerTypeName":"System.Object","Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ViewData"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.PartialTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.RenderAtEndOfFormTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"form","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.RenderAtEndOfFormTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.ScriptTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"script","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-append-version","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"script","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-fallback-src","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"script","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-fallback-src-exclude","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"script","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-fallback-src-include","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"script","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-fallback-test","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"script","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-src-exclude","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"script","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-src-include","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"asp-append-version","TypeName":"System.Boolean?","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AppendVersion"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-fallback-src","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"FallbackSrc"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-fallback-src-exclude","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"FallbackSrcExclude"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-fallback-src-include","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"FallbackSrcInclude"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-fallback-test","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"FallbackTestExpression"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"src","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Src"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-src-exclude","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"SrcExclude"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-src-include","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"SrcInclude"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-suppress-fallback-integrity","TypeName":"System.Boolean","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"SuppressFallbackIntegrity"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.ScriptTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.SelectTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"select","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-for","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"select","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-items","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"asp-for","TypeName":"Microsoft.AspNetCore.Mvc.ViewFeatures.ModelExpression","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"For"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-items","TypeName":"System.Collections.Generic.IEnumerable","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Items"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"name","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Name"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.SelectTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.TextAreaTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"textarea","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-for","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"asp-for","TypeName":"Microsoft.AspNetCore.Mvc.ViewFeatures.ModelExpression","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"For"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"name","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Name"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.TextAreaTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.ValidationMessageTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"span","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-validation-for","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"asp-validation-for","TypeName":"Microsoft.AspNetCore.Mvc.ViewFeatures.ModelExpression","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"For"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.ValidationMessageTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.ValidationSummaryTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"div","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-validation-summary","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"asp-validation-summary","TypeName":"Microsoft.AspNetCore.Mvc.Rendering.ValidationSummary","IsEnum":true,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ValidationSummary"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.ValidationSummaryTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.SpaServices.Prerendering.PrerenderTagHelper","AssemblyName":"Microsoft.AspNetCore.SpaServices","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-prerender-module","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"asp-prerender-module","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ModuleName"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-prerender-export","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ExportName"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-prerender-data","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"CustomDataParameter"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-prerender-timeout","TypeName":"System.Int32","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"TimeoutMillisecondsParameter"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.SpaServices.Prerendering.PrerenderTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.Razor.TagHelpers.BodyTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.Razor","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"body","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.Razor.TagHelpers.BodyTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.Razor.TagHelpers.HeadTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.Razor","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"head","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.Razor.TagHelpers.HeadTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.Razor.TagHelpers.UrlResolutionTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.Razor","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"itemid","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"a","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"href","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"applet","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"archive","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"area","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"href","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"audio","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"src","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"base","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"href","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"blockquote","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"cite","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"button","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"formaction","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"del","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"cite","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"embed","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"src","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"form","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"action","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"html","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"manifest","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"iframe","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"src","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"img","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"src","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"img","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"srcset","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"formaction","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"src","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"ins","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"cite","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"link","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"href","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"menuitem","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"icon","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"object","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"archive","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"object","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"data","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"q","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"cite","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"script","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"src","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"source","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"src","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"source","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"srcset","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"track","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"src","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"video","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"poster","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"video","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"src","NameComparison":0,"Value":"~/","ValueComparison":2,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.Razor.TagHelpers.UrlResolutionTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.AnchorTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"a","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-action","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"a","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-all-route-data","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"a","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-area","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"a","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-controller","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"a","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-fragment","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"a","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-host","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"a","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-page","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"a","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-page-handler","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"a","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-protocol","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"a","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-route","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"a","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-route-","NameComparison":1,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"asp-action","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Action"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-area","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Area"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-controller","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Controller"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-fragment","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Fragment"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-host","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Host"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-page","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Page"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-page-handler","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"PageHandler"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-protocol","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Protocol"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-route","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Route"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-all-route-data","TypeName":"System.Collections.Generic.IDictionary","IsEnum":false,"IndexerNamePrefix":"asp-route-","IndexerTypeName":"System.String","Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"RouteValues"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.AnchorTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.CacheTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"cache","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"priority","TypeName":"Microsoft.Extensions.Caching.Memory.CacheItemPriority?","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Priority"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"enabled","TypeName":"System.Boolean","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Enabled"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"expires-after","TypeName":"System.TimeSpan?","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ExpiresAfter"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"expires-on","TypeName":"System.DateTimeOffset?","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ExpiresOn"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"expires-sliding","TypeName":"System.TimeSpan?","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ExpiresSliding"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryBy"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by-cookie","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryByCookie"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by-culture","TypeName":"System.Boolean","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryByCulture"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by-header","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryByHeader"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by-query","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryByQuery"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by-route","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryByRoute"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by-user","TypeName":"System.Boolean","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryByUser"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.CacheTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.ComponentTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"component","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"type","TypeName":"System.Type","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ComponentType"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"params","TypeName":"System.Collections.Generic.IDictionary","IsEnum":false,"IndexerNamePrefix":"param-","IndexerTypeName":"System.Object","Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Parameters"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"render-mode","TypeName":"Microsoft.AspNetCore.Mvc.Rendering.RenderMode","IsEnum":true,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"RenderMode"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.ComponentTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.DistributedCacheTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"distributed-cache","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"name","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"name","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Name"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"enabled","TypeName":"System.Boolean","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Enabled"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"expires-after","TypeName":"System.TimeSpan?","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ExpiresAfter"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"expires-on","TypeName":"System.DateTimeOffset?","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ExpiresOn"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"expires-sliding","TypeName":"System.TimeSpan?","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ExpiresSliding"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryBy"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by-cookie","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryByCookie"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by-culture","TypeName":"System.Boolean","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryByCulture"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by-header","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryByHeader"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by-query","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryByQuery"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by-route","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryByRoute"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"vary-by-user","TypeName":"System.Boolean","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"VaryByUser"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.DistributedCacheTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.EnvironmentTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"environment","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"exclude","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Exclude"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"include","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Include"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"names","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Names"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.EnvironmentTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.FormActionTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"button","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-action","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"button","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-all-route-data","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"button","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-area","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"button","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-controller","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"button","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-fragment","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"button","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-page","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"button","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-page-handler","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"button","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-route","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"button","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-route-","NameComparison":1,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"image","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-action","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"image","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-all-route-data","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"image","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-area","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"image","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-controller","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"image","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-fragment","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"image","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-page","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"image","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-page-handler","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"image","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-route","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"image","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-route-","NameComparison":1,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"submit","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-action","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"submit","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-all-route-data","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"submit","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-area","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"submit","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-controller","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"submit","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-fragment","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"submit","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-page","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"submit","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-page-handler","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"submit","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-route","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"type","NameComparison":0,"Value":"submit","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"asp-route-","NameComparison":1,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"asp-action","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Action"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-area","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Area"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-controller","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Controller"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-fragment","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Fragment"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-page","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Page"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-page-handler","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"PageHandler"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-route","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Route"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-all-route-data","TypeName":"System.Collections.Generic.IDictionary","IsEnum":false,"IndexerNamePrefix":"asp-route-","IndexerTypeName":"System.String","Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"RouteValues"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.FormActionTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.FormTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"form","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"asp-action","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Action"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-antiforgery","TypeName":"System.Boolean?","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Antiforgery"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-area","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Area"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-controller","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Controller"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-fragment","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Fragment"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"method","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Method"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-page","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Page"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-page-handler","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"PageHandler"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-route","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Route"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-all-route-data","TypeName":"System.Collections.Generic.IDictionary","IsEnum":false,"IndexerNamePrefix":"asp-route-","IndexerTypeName":"System.String","Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"RouteValues"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.FormTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.ImageTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"img","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"asp-append-version","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}},{"Name":"src","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"asp-append-version","TypeName":"System.Boolean","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AppendVersion"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"src","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Src"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.ImageTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.InputTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"input","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"asp-for","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"asp-for","TypeName":"Microsoft.AspNetCore.Mvc.ViewFeatures.ModelExpression","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"For"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-format","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Format"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"type","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"InputTypeName"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"name","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Name"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"value","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.InputTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.LabelTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"label","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-for","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"asp-for","TypeName":"Microsoft.AspNetCore.Mvc.ViewFeatures.ModelExpression","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"For"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.LabelTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.LinkTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"link","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"asp-append-version","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"link","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"asp-fallback-href","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"link","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"asp-fallback-href-exclude","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"link","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"asp-fallback-href-include","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"link","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"asp-fallback-test-class","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"link","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"asp-fallback-test-property","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"link","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"asp-fallback-test-value","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"link","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"asp-href-exclude","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"link","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"asp-href-include","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"asp-append-version","TypeName":"System.Boolean?","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AppendVersion"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-fallback-href","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"FallbackHref"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-fallback-href-exclude","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"FallbackHrefExclude"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-fallback-href-include","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"FallbackHrefInclude"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-fallback-test-class","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"FallbackTestClass"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-fallback-test-property","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"FallbackTestProperty"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-fallback-test-value","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"FallbackTestValue"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"href","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Href"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-href-exclude","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"HrefExclude"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-href-include","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"HrefInclude"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-suppress-fallback-integrity","TypeName":"System.Boolean","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"SuppressFallbackIntegrity"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.LinkTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.OptionTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"option","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"value","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.OptionTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.PartialTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"partial","ParentTag":null,"TagStructure":2,"Attributes":[{"Name":"name","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"fallback-name","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"FallbackName"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"for","TypeName":"Microsoft.AspNetCore.Mvc.ViewFeatures.ModelExpression","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"For"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"model","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Model"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"name","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Name"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"optional","TypeName":"System.Boolean","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Optional"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"view-data","TypeName":"Microsoft.AspNetCore.Mvc.ViewFeatures.ViewDataDictionary","IsEnum":false,"IndexerNamePrefix":"view-data-","IndexerTypeName":"System.Object","Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ViewData"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.PartialTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.RenderAtEndOfFormTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"form","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.RenderAtEndOfFormTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.ScriptTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"script","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-append-version","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"script","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-fallback-src","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"script","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-fallback-src-exclude","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"script","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-fallback-src-include","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"script","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-fallback-test","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"script","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-src-exclude","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"script","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-src-include","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"asp-append-version","TypeName":"System.Boolean?","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AppendVersion"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-fallback-src","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"FallbackSrc"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-fallback-src-exclude","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"FallbackSrcExclude"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-fallback-src-include","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"FallbackSrcInclude"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-fallback-test","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"FallbackTestExpression"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"src","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Src"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-src-exclude","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"SrcExclude"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-src-include","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"SrcInclude"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-suppress-fallback-integrity","TypeName":"System.Boolean","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"SuppressFallbackIntegrity"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.ScriptTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.SelectTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"select","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-for","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]},{"TagName":"select","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-items","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"asp-for","TypeName":"Microsoft.AspNetCore.Mvc.ViewFeatures.ModelExpression","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"For"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-items","TypeName":"System.Collections.Generic.IEnumerable","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Items"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"name","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Name"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.SelectTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.TextAreaTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"textarea","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-for","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"asp-for","TypeName":"Microsoft.AspNetCore.Mvc.ViewFeatures.ModelExpression","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"For"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"name","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Name"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.TextAreaTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.ValidationMessageTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"span","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-validation-for","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"asp-validation-for","TypeName":"Microsoft.AspNetCore.Mvc.ViewFeatures.ModelExpression","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"For"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.ValidationMessageTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.Mvc.TagHelpers.ValidationSummaryTagHelper","AssemblyName":"Microsoft.AspNetCore.Mvc.TagHelpers","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"div","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-validation-summary","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"asp-validation-summary","TypeName":"Microsoft.AspNetCore.Mvc.Rendering.ValidationSummary","IsEnum":true,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ValidationSummary"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.Mvc.TagHelpers.ValidationSummaryTagHelper"}},{"Kind":"ITagHelper","Name":"Microsoft.AspNetCore.SpaServices.Prerendering.PrerenderTagHelper","AssemblyName":"Microsoft.AspNetCore.SpaServices","Documentation":null,"TagOutputHint":null,"CaseSensitive":false,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"asp-prerender-module","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"ITagHelper","Name":"asp-prerender-module","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ModuleName"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-prerender-export","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ExportName"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-prerender-data","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"CustomDataParameter"},"BoundAttributeParameters":[]},{"Kind":"ITagHelper","Name":"asp-prerender-timeout","TypeName":"System.Int32","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"TimeoutMillisecondsParameter"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"ITagHelper","Common.TypeName":"Microsoft.AspNetCore.SpaServices.Prerendering.PrerenderTagHelper"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Authorization.AuthorizeRouteView","AssemblyName":"Microsoft.AspNetCore.Components.Authorization","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"AuthorizeRouteView","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"Authorizing","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Authorizing","Components.ChildContent":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"NotAuthorized","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"NotAuthorized","Components.ChildContent":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"DefaultLayout","TypeName":"System.Type","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"DefaultLayout"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"RouteData","TypeName":"Microsoft.AspNetCore.Components.RouteData","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"RouteData"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Context","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the parameter name for all child content expressions.","Diagnostics":[],"Metadata":{"Components.ChildContentParameterName":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Authorization.AuthorizeRouteView"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Authorization.AuthorizeRouteView","AssemblyName":"Microsoft.AspNetCore.Components.Authorization","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Microsoft.AspNetCore.Components.Authorization.AuthorizeRouteView","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"Authorizing","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Authorizing","Components.ChildContent":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"NotAuthorized","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"NotAuthorized","Components.ChildContent":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"DefaultLayout","TypeName":"System.Type","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"DefaultLayout"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"RouteData","TypeName":"Microsoft.AspNetCore.Components.RouteData","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"RouteData"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Context","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the parameter name for all child content expressions.","Diagnostics":[],"Metadata":{"Components.ChildContentParameterName":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Authorization.AuthorizeRouteView","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.Authorization.AuthorizeRouteView.Authorizing","AssemblyName":"Microsoft.AspNetCore.Components.Authorization","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Authorizing","ParentTag":"AuthorizeRouteView","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.Authorization.AuthorizeRouteView.Authorizing","Components.IsSpecialKind":"Components.ChildContent"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.Authorization.AuthorizeRouteView.Authorizing","AssemblyName":"Microsoft.AspNetCore.Components.Authorization","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Authorizing","ParentTag":"Microsoft.AspNetCore.Components.Authorization.AuthorizeRouteView","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.Authorization.AuthorizeRouteView.Authorizing","Components.IsSpecialKind":"Components.ChildContent","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.Authorization.AuthorizeRouteView.NotAuthorized","AssemblyName":"Microsoft.AspNetCore.Components.Authorization","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"NotAuthorized","ParentTag":"AuthorizeRouteView","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.ChildContent","Name":"Context","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the parameter name for the 'NotAuthorized' child content expression.","Diagnostics":[],"Metadata":{"Components.ChildContentParameterName":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.Authorization.AuthorizeRouteView.NotAuthorized","Components.IsSpecialKind":"Components.ChildContent"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.Authorization.AuthorizeRouteView.NotAuthorized","AssemblyName":"Microsoft.AspNetCore.Components.Authorization","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"NotAuthorized","ParentTag":"Microsoft.AspNetCore.Components.Authorization.AuthorizeRouteView","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.ChildContent","Name":"Context","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the parameter name for the 'NotAuthorized' child content expression.","Diagnostics":[],"Metadata":{"Components.ChildContentParameterName":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.Authorization.AuthorizeRouteView.NotAuthorized","Components.IsSpecialKind":"Components.ChildContent","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Authorization.AuthorizeView","AssemblyName":"Microsoft.AspNetCore.Components.Authorization","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"AuthorizeView","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"Policy","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Policy"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Roles","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Roles"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Authorized","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Authorized","Components.ChildContent":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Authorizing","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Authorizing","Components.ChildContent":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ChildContent","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ChildContent","Components.ChildContent":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"NotAuthorized","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"NotAuthorized","Components.ChildContent":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Resource","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Resource"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Context","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the parameter name for all child content expressions.","Diagnostics":[],"Metadata":{"Components.ChildContentParameterName":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Authorization.AuthorizeView"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Authorization.AuthorizeView","AssemblyName":"Microsoft.AspNetCore.Components.Authorization","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Microsoft.AspNetCore.Components.Authorization.AuthorizeView","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"Policy","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Policy"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Roles","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Roles"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Authorized","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Authorized","Components.ChildContent":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Authorizing","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Authorizing","Components.ChildContent":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ChildContent","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ChildContent","Components.ChildContent":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"NotAuthorized","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"NotAuthorized","Components.ChildContent":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Resource","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Resource"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Context","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the parameter name for all child content expressions.","Diagnostics":[],"Metadata":{"Components.ChildContentParameterName":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Authorization.AuthorizeView","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.Authorization.AuthorizeView.Authorized","AssemblyName":"Microsoft.AspNetCore.Components.Authorization","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Authorized","ParentTag":"AuthorizeView","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.ChildContent","Name":"Context","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the parameter name for the 'Authorized' child content expression.","Diagnostics":[],"Metadata":{"Components.ChildContentParameterName":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.Authorization.AuthorizeView.Authorized","Components.IsSpecialKind":"Components.ChildContent"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.Authorization.AuthorizeView.Authorized","AssemblyName":"Microsoft.AspNetCore.Components.Authorization","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Authorized","ParentTag":"Microsoft.AspNetCore.Components.Authorization.AuthorizeView","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.ChildContent","Name":"Context","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the parameter name for the 'Authorized' child content expression.","Diagnostics":[],"Metadata":{"Components.ChildContentParameterName":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.Authorization.AuthorizeView.Authorized","Components.IsSpecialKind":"Components.ChildContent","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.Authorization.AuthorizeView.Authorizing","AssemblyName":"Microsoft.AspNetCore.Components.Authorization","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Authorizing","ParentTag":"AuthorizeView","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.Authorization.AuthorizeView.Authorizing","Components.IsSpecialKind":"Components.ChildContent"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.Authorization.AuthorizeView.Authorizing","AssemblyName":"Microsoft.AspNetCore.Components.Authorization","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Authorizing","ParentTag":"Microsoft.AspNetCore.Components.Authorization.AuthorizeView","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.Authorization.AuthorizeView.Authorizing","Components.IsSpecialKind":"Components.ChildContent","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.Authorization.AuthorizeView.ChildContent","AssemblyName":"Microsoft.AspNetCore.Components.Authorization","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"ChildContent","ParentTag":"AuthorizeView","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.ChildContent","Name":"Context","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the parameter name for the 'ChildContent' child content expression.","Diagnostics":[],"Metadata":{"Components.ChildContentParameterName":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.Authorization.AuthorizeView.ChildContent","Components.IsSpecialKind":"Components.ChildContent"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.Authorization.AuthorizeView.ChildContent","AssemblyName":"Microsoft.AspNetCore.Components.Authorization","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"ChildContent","ParentTag":"Microsoft.AspNetCore.Components.Authorization.AuthorizeView","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.ChildContent","Name":"Context","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the parameter name for the 'ChildContent' child content expression.","Diagnostics":[],"Metadata":{"Components.ChildContentParameterName":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.Authorization.AuthorizeView.ChildContent","Components.IsSpecialKind":"Components.ChildContent","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.Authorization.AuthorizeView.NotAuthorized","AssemblyName":"Microsoft.AspNetCore.Components.Authorization","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"NotAuthorized","ParentTag":"AuthorizeView","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.ChildContent","Name":"Context","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the parameter name for the 'NotAuthorized' child content expression.","Diagnostics":[],"Metadata":{"Components.ChildContentParameterName":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.Authorization.AuthorizeView.NotAuthorized","Components.IsSpecialKind":"Components.ChildContent"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.Authorization.AuthorizeView.NotAuthorized","AssemblyName":"Microsoft.AspNetCore.Components.Authorization","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"NotAuthorized","ParentTag":"Microsoft.AspNetCore.Components.Authorization.AuthorizeView","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.ChildContent","Name":"Context","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the parameter name for the 'NotAuthorized' child content expression.","Diagnostics":[],"Metadata":{"Components.ChildContentParameterName":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.Authorization.AuthorizeView.NotAuthorized","Components.IsSpecialKind":"Components.ChildContent","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Authorization.CascadingAuthenticationState","AssemblyName":"Microsoft.AspNetCore.Components.Authorization","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"CascadingAuthenticationState","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"ChildContent","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ChildContent","Components.ChildContent":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Authorization.CascadingAuthenticationState"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Authorization.CascadingAuthenticationState","AssemblyName":"Microsoft.AspNetCore.Components.Authorization","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Microsoft.AspNetCore.Components.Authorization.CascadingAuthenticationState","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"ChildContent","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ChildContent","Components.ChildContent":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Authorization.CascadingAuthenticationState","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.Authorization.CascadingAuthenticationState.ChildContent","AssemblyName":"Microsoft.AspNetCore.Components.Authorization","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"ChildContent","ParentTag":"CascadingAuthenticationState","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.Authorization.CascadingAuthenticationState.ChildContent","Components.IsSpecialKind":"Components.ChildContent"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.Authorization.CascadingAuthenticationState.ChildContent","AssemblyName":"Microsoft.AspNetCore.Components.Authorization","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"ChildContent","ParentTag":"Microsoft.AspNetCore.Components.Authorization.CascadingAuthenticationState","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.Authorization.CascadingAuthenticationState.ChildContent","Components.IsSpecialKind":"Components.ChildContent","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.CascadingValue","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"CascadingValue","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"TValue","TypeName":"System.Type","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the type of the type parameter TValue for the Microsoft.AspNetCore.Components.CascadingValue component.","Diagnostics":[],"Metadata":{"Common.PropertyName":"TValue","Components.TypeParameter":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ChildContent","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ChildContent","Components.ChildContent":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"IsFixed","TypeName":"System.Boolean","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"IsFixed"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Name","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Name"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Value","TypeName":"TValue","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Value","Components.GenericTyped":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.CascadingValue","Components.GenericTyped":"True"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.CascadingValue","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Microsoft.AspNetCore.Components.CascadingValue","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"TValue","TypeName":"System.Type","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the type of the type parameter TValue for the Microsoft.AspNetCore.Components.CascadingValue component.","Diagnostics":[],"Metadata":{"Common.PropertyName":"TValue","Components.TypeParameter":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ChildContent","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ChildContent","Components.ChildContent":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"IsFixed","TypeName":"System.Boolean","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"IsFixed"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Name","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Name"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Value","TypeName":"TValue","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Value","Components.GenericTyped":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.CascadingValue","Components.GenericTyped":"True","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.CascadingValue.ChildContent","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"ChildContent","ParentTag":"CascadingValue","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.CascadingValue.ChildContent","Components.IsSpecialKind":"Components.ChildContent"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.CascadingValue.ChildContent","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"ChildContent","ParentTag":"Microsoft.AspNetCore.Components.CascadingValue","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.CascadingValue.ChildContent","Components.IsSpecialKind":"Components.ChildContent","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.LayoutView","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"LayoutView","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"ChildContent","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ChildContent","Components.ChildContent":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Layout","TypeName":"System.Type","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Layout"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.LayoutView"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.LayoutView","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Microsoft.AspNetCore.Components.LayoutView","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"ChildContent","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ChildContent","Components.ChildContent":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Layout","TypeName":"System.Type","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Layout"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.LayoutView","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.LayoutView.ChildContent","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"ChildContent","ParentTag":"LayoutView","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.LayoutView.ChildContent","Components.IsSpecialKind":"Components.ChildContent"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.LayoutView.ChildContent","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"ChildContent","ParentTag":"Microsoft.AspNetCore.Components.LayoutView","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.LayoutView.ChildContent","Components.IsSpecialKind":"Components.ChildContent","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.RouteView","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"RouteView","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"DefaultLayout","TypeName":"System.Type","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"DefaultLayout"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"RouteData","TypeName":"Microsoft.AspNetCore.Components.RouteData","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"RouteData"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.RouteView"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.RouteView","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Microsoft.AspNetCore.Components.RouteView","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"DefaultLayout","TypeName":"System.Type","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"DefaultLayout"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"RouteData","TypeName":"Microsoft.AspNetCore.Components.RouteData","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"RouteData"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.RouteView","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Routing.Router","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Router","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"AdditionalAssemblies","TypeName":"System.Collections.Generic.IEnumerable","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AdditionalAssemblies"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"AppAssembly","TypeName":"System.Reflection.Assembly","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AppAssembly"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Found","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Found","Components.ChildContent":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"NotFound","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"NotFound","Components.ChildContent":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Context","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the parameter name for all child content expressions.","Diagnostics":[],"Metadata":{"Components.ChildContentParameterName":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Routing.Router"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Routing.Router","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Microsoft.AspNetCore.Components.Routing.Router","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"AdditionalAssemblies","TypeName":"System.Collections.Generic.IEnumerable","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AdditionalAssemblies"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"AppAssembly","TypeName":"System.Reflection.Assembly","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AppAssembly"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Found","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Found","Components.ChildContent":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"NotFound","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"NotFound","Components.ChildContent":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Context","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the parameter name for all child content expressions.","Diagnostics":[],"Metadata":{"Components.ChildContentParameterName":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Routing.Router","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.Routing.Router.Found","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Found","ParentTag":"Router","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.ChildContent","Name":"Context","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the parameter name for the 'Found' child content expression.","Diagnostics":[],"Metadata":{"Components.ChildContentParameterName":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.Routing.Router.Found","Components.IsSpecialKind":"Components.ChildContent"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.Routing.Router.Found","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Found","ParentTag":"Microsoft.AspNetCore.Components.Routing.Router","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.ChildContent","Name":"Context","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the parameter name for the 'Found' child content expression.","Diagnostics":[],"Metadata":{"Components.ChildContentParameterName":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.Routing.Router.Found","Components.IsSpecialKind":"Components.ChildContent","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.Routing.Router.NotFound","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"NotFound","ParentTag":"Router","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.Routing.Router.NotFound","Components.IsSpecialKind":"Components.ChildContent"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.Routing.Router.NotFound","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"NotFound","ParentTag":"Microsoft.AspNetCore.Components.Routing.Router","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.Routing.Router.NotFound","Components.IsSpecialKind":"Components.ChildContent","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Forms.DataAnnotationsValidator","AssemblyName":"Microsoft.AspNetCore.Components.Forms","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"DataAnnotationsValidator","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.DataAnnotationsValidator"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Forms.DataAnnotationsValidator","AssemblyName":"Microsoft.AspNetCore.Components.Forms","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Microsoft.AspNetCore.Components.Forms.DataAnnotationsValidator","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.DataAnnotationsValidator","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Forms.EditForm","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"EditForm","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"AdditionalAttributes","TypeName":"System.Collections.Generic.IReadOnlyDictionary","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AdditionalAttributes"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ChildContent","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ChildContent","Components.ChildContent":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"EditContext","TypeName":"Microsoft.AspNetCore.Components.Forms.EditContext","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"EditContext"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Model","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Model"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"OnInvalidSubmit","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"OnInvalidSubmit","Components.EventCallback":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"OnSubmit","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"OnSubmit","Components.EventCallback":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"OnValidSubmit","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"OnValidSubmit","Components.EventCallback":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Context","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the parameter name for all child content expressions.","Diagnostics":[],"Metadata":{"Components.ChildContentParameterName":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.EditForm"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Forms.EditForm","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Microsoft.AspNetCore.Components.Forms.EditForm","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"AdditionalAttributes","TypeName":"System.Collections.Generic.IReadOnlyDictionary","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AdditionalAttributes"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ChildContent","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ChildContent","Components.ChildContent":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"EditContext","TypeName":"Microsoft.AspNetCore.Components.Forms.EditContext","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"EditContext"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Model","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Model"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"OnInvalidSubmit","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"OnInvalidSubmit","Components.EventCallback":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"OnSubmit","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"OnSubmit","Components.EventCallback":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"OnValidSubmit","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"OnValidSubmit","Components.EventCallback":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Context","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the parameter name for all child content expressions.","Diagnostics":[],"Metadata":{"Components.ChildContentParameterName":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.EditForm","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.Forms.EditForm.ChildContent","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"ChildContent","ParentTag":"EditForm","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.ChildContent","Name":"Context","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the parameter name for the 'ChildContent' child content expression.","Diagnostics":[],"Metadata":{"Components.ChildContentParameterName":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.EditForm.ChildContent","Components.IsSpecialKind":"Components.ChildContent"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.Forms.EditForm.ChildContent","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"ChildContent","ParentTag":"Microsoft.AspNetCore.Components.Forms.EditForm","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.ChildContent","Name":"Context","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the parameter name for the 'ChildContent' child content expression.","Diagnostics":[],"Metadata":{"Components.ChildContentParameterName":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.EditForm.ChildContent","Components.IsSpecialKind":"Components.ChildContent","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Forms.InputCheckbox","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"InputCheckbox","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"AdditionalAttributes","TypeName":"System.Collections.Generic.IReadOnlyDictionary","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AdditionalAttributes"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Value","TypeName":"System.Boolean","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Value"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ValueChanged","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ValueChanged","Components.EventCallback":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ValueExpression","TypeName":"System.Linq.Expressions.Expression>","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ValueExpression"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.InputCheckbox"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Forms.InputCheckbox","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Microsoft.AspNetCore.Components.Forms.InputCheckbox","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"AdditionalAttributes","TypeName":"System.Collections.Generic.IReadOnlyDictionary","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AdditionalAttributes"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Value","TypeName":"System.Boolean","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Value"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ValueChanged","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ValueChanged","Components.EventCallback":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ValueExpression","TypeName":"System.Linq.Expressions.Expression>","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ValueExpression"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.InputCheckbox","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Forms.InputDate","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"InputDate","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"TValue","TypeName":"System.Type","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the type of the type parameter TValue for the Microsoft.AspNetCore.Components.Forms.InputDate component.","Diagnostics":[],"Metadata":{"Common.PropertyName":"TValue","Components.TypeParameter":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ParsingErrorMessage","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ParsingErrorMessage"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"AdditionalAttributes","TypeName":"System.Collections.Generic.IReadOnlyDictionary","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AdditionalAttributes"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Value","TypeName":"TValue","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Value","Components.GenericTyped":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ValueChanged","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ValueChanged","Components.EventCallback":"True","Components.GenericTyped":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ValueExpression","TypeName":"System.Linq.Expressions.Expression>","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ValueExpression","Components.GenericTyped":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.InputDate","Components.GenericTyped":"True"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Forms.InputDate","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Microsoft.AspNetCore.Components.Forms.InputDate","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"TValue","TypeName":"System.Type","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the type of the type parameter TValue for the Microsoft.AspNetCore.Components.Forms.InputDate component.","Diagnostics":[],"Metadata":{"Common.PropertyName":"TValue","Components.TypeParameter":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ParsingErrorMessage","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ParsingErrorMessage"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"AdditionalAttributes","TypeName":"System.Collections.Generic.IReadOnlyDictionary","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AdditionalAttributes"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Value","TypeName":"TValue","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Value","Components.GenericTyped":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ValueChanged","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ValueChanged","Components.EventCallback":"True","Components.GenericTyped":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ValueExpression","TypeName":"System.Linq.Expressions.Expression>","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ValueExpression","Components.GenericTyped":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.InputDate","Components.GenericTyped":"True","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Forms.InputNumber","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"InputNumber","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"TValue","TypeName":"System.Type","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the type of the type parameter TValue for the Microsoft.AspNetCore.Components.Forms.InputNumber component.","Diagnostics":[],"Metadata":{"Common.PropertyName":"TValue","Components.TypeParameter":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ParsingErrorMessage","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ParsingErrorMessage"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"AdditionalAttributes","TypeName":"System.Collections.Generic.IReadOnlyDictionary","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AdditionalAttributes"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Value","TypeName":"TValue","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Value","Components.GenericTyped":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ValueChanged","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ValueChanged","Components.EventCallback":"True","Components.GenericTyped":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ValueExpression","TypeName":"System.Linq.Expressions.Expression>","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ValueExpression","Components.GenericTyped":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.InputNumber","Components.GenericTyped":"True"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Forms.InputNumber","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Microsoft.AspNetCore.Components.Forms.InputNumber","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"TValue","TypeName":"System.Type","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the type of the type parameter TValue for the Microsoft.AspNetCore.Components.Forms.InputNumber component.","Diagnostics":[],"Metadata":{"Common.PropertyName":"TValue","Components.TypeParameter":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ParsingErrorMessage","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ParsingErrorMessage"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"AdditionalAttributes","TypeName":"System.Collections.Generic.IReadOnlyDictionary","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AdditionalAttributes"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Value","TypeName":"TValue","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Value","Components.GenericTyped":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ValueChanged","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ValueChanged","Components.EventCallback":"True","Components.GenericTyped":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ValueExpression","TypeName":"System.Linq.Expressions.Expression>","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ValueExpression","Components.GenericTyped":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.InputNumber","Components.GenericTyped":"True","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Forms.InputSelect","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"InputSelect","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"TValue","TypeName":"System.Type","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the type of the type parameter TValue for the Microsoft.AspNetCore.Components.Forms.InputSelect component.","Diagnostics":[],"Metadata":{"Common.PropertyName":"TValue","Components.TypeParameter":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ChildContent","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ChildContent","Components.ChildContent":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"AdditionalAttributes","TypeName":"System.Collections.Generic.IReadOnlyDictionary","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AdditionalAttributes"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Value","TypeName":"TValue","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Value","Components.GenericTyped":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ValueChanged","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ValueChanged","Components.EventCallback":"True","Components.GenericTyped":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ValueExpression","TypeName":"System.Linq.Expressions.Expression>","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ValueExpression","Components.GenericTyped":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.InputSelect","Components.GenericTyped":"True"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Forms.InputSelect","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Microsoft.AspNetCore.Components.Forms.InputSelect","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"TValue","TypeName":"System.Type","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the type of the type parameter TValue for the Microsoft.AspNetCore.Components.Forms.InputSelect component.","Diagnostics":[],"Metadata":{"Common.PropertyName":"TValue","Components.TypeParameter":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ChildContent","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ChildContent","Components.ChildContent":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"AdditionalAttributes","TypeName":"System.Collections.Generic.IReadOnlyDictionary","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AdditionalAttributes"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Value","TypeName":"TValue","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Value","Components.GenericTyped":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ValueChanged","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ValueChanged","Components.EventCallback":"True","Components.GenericTyped":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ValueExpression","TypeName":"System.Linq.Expressions.Expression>","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ValueExpression","Components.GenericTyped":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.InputSelect","Components.GenericTyped":"True","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.Forms.InputSelect.ChildContent","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"ChildContent","ParentTag":"InputSelect","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.InputSelect.ChildContent","Components.IsSpecialKind":"Components.ChildContent"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.Forms.InputSelect.ChildContent","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"ChildContent","ParentTag":"Microsoft.AspNetCore.Components.Forms.InputSelect","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.InputSelect.ChildContent","Components.IsSpecialKind":"Components.ChildContent","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Forms.InputText","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"InputText","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"AdditionalAttributes","TypeName":"System.Collections.Generic.IReadOnlyDictionary","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AdditionalAttributes"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Value","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Value"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ValueChanged","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ValueChanged","Components.EventCallback":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ValueExpression","TypeName":"System.Linq.Expressions.Expression>","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ValueExpression"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.InputText"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Forms.InputText","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Microsoft.AspNetCore.Components.Forms.InputText","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"AdditionalAttributes","TypeName":"System.Collections.Generic.IReadOnlyDictionary","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AdditionalAttributes"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Value","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Value"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ValueChanged","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ValueChanged","Components.EventCallback":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ValueExpression","TypeName":"System.Linq.Expressions.Expression>","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ValueExpression"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.InputText","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Forms.InputTextArea","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"InputTextArea","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"AdditionalAttributes","TypeName":"System.Collections.Generic.IReadOnlyDictionary","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AdditionalAttributes"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Value","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Value"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ValueChanged","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ValueChanged","Components.EventCallback":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ValueExpression","TypeName":"System.Linq.Expressions.Expression>","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ValueExpression"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.InputTextArea"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Forms.InputTextArea","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Microsoft.AspNetCore.Components.Forms.InputTextArea","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"AdditionalAttributes","TypeName":"System.Collections.Generic.IReadOnlyDictionary","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AdditionalAttributes"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Value","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Value"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ValueChanged","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ValueChanged","Components.EventCallback":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ValueExpression","TypeName":"System.Linq.Expressions.Expression>","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ValueExpression"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.InputTextArea","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Forms.ValidationMessage","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"ValidationMessage","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"TValue","TypeName":"System.Type","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the type of the type parameter TValue for the Microsoft.AspNetCore.Components.Forms.ValidationMessage component.","Diagnostics":[],"Metadata":{"Common.PropertyName":"TValue","Components.TypeParameter":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"AdditionalAttributes","TypeName":"System.Collections.Generic.IReadOnlyDictionary","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AdditionalAttributes"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"For","TypeName":"System.Linq.Expressions.Expression>","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"For","Components.GenericTyped":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.ValidationMessage","Components.GenericTyped":"True"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Forms.ValidationMessage","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Microsoft.AspNetCore.Components.Forms.ValidationMessage","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"TValue","TypeName":"System.Type","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies the type of the type parameter TValue for the Microsoft.AspNetCore.Components.Forms.ValidationMessage component.","Diagnostics":[],"Metadata":{"Common.PropertyName":"TValue","Components.TypeParameter":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"AdditionalAttributes","TypeName":"System.Collections.Generic.IReadOnlyDictionary","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AdditionalAttributes"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"For","TypeName":"System.Linq.Expressions.Expression>","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"For","Components.GenericTyped":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.ValidationMessage","Components.GenericTyped":"True","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Forms.ValidationSummary","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"ValidationSummary","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"AdditionalAttributes","TypeName":"System.Collections.Generic.IReadOnlyDictionary","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AdditionalAttributes"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Model","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Model"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.ValidationSummary"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Forms.ValidationSummary","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Microsoft.AspNetCore.Components.Forms.ValidationSummary","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"AdditionalAttributes","TypeName":"System.Collections.Generic.IReadOnlyDictionary","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AdditionalAttributes"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Model","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Model"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.ValidationSummary","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Routing.NavLink","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"NavLink","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"ActiveClass","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ActiveClass"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"AdditionalAttributes","TypeName":"System.Collections.Generic.IReadOnlyDictionary","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AdditionalAttributes"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ChildContent","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ChildContent","Components.ChildContent":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Match","TypeName":"Microsoft.AspNetCore.Components.Routing.NavLinkMatch","IsEnum":true,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Match"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Routing.NavLink"}},{"Kind":"Components.Component","Name":"Microsoft.AspNetCore.Components.Routing.NavLink","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Microsoft.AspNetCore.Components.Routing.NavLink","ParentTag":null,"TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Component","Name":"ActiveClass","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ActiveClass"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"AdditionalAttributes","TypeName":"System.Collections.Generic.IReadOnlyDictionary","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"AdditionalAttributes"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"ChildContent","TypeName":"Microsoft.AspNetCore.Components.RenderFragment","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"ChildContent","Components.ChildContent":"True"},"BoundAttributeParameters":[]},{"Kind":"Components.Component","Name":"Match","TypeName":"Microsoft.AspNetCore.Components.Routing.NavLinkMatch","IsEnum":true,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":null,"Diagnostics":[],"Metadata":{"Common.PropertyName":"Match"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.IComponent","Common.TypeName":"Microsoft.AspNetCore.Components.Routing.NavLink","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.Routing.NavLink.ChildContent","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"ChildContent","ParentTag":"NavLink","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.Routing.NavLink.ChildContent","Components.IsSpecialKind":"Components.ChildContent"}},{"Kind":"Components.ChildContent","Name":"Microsoft.AspNetCore.Components.Routing.NavLink.ChildContent","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":null,"TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"ChildContent","ParentTag":"Microsoft.AspNetCore.Components.Routing.NavLink","TagStructure":0,"Attributes":[],"Diagnostics":[]}],"BoundAttributes":[],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Common.TypeName":"Microsoft.AspNetCore.Components.Routing.NavLink.ChildContent","Components.IsSpecialKind":"Components.ChildContent","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.EventHandler","Name":"onabort","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onabort' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.ProgressEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onabort","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onabort:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onabort:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onabort","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onabort' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.ProgressEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onabort"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onabort' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onabort' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.ProgressEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onactivate","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onactivate' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onactivate","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onactivate:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onactivate:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onactivate","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onactivate' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onactivate"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onactivate' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onactivate' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onbeforeactivate","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onbeforeactivate' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onbeforeactivate","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onbeforeactivate:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onbeforeactivate:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onbeforeactivate","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onbeforeactivate' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onbeforeactivate"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onbeforeactivate' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onbeforeactivate' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onbeforecopy","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onbeforecopy' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onbeforecopy","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onbeforecopy:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onbeforecopy:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onbeforecopy","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onbeforecopy' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onbeforecopy"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onbeforecopy' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onbeforecopy' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onbeforecut","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onbeforecut' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onbeforecut","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onbeforecut:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onbeforecut:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onbeforecut","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onbeforecut' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onbeforecut"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onbeforecut' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onbeforecut' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onbeforedeactivate","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onbeforedeactivate' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onbeforedeactivate","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onbeforedeactivate:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onbeforedeactivate:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onbeforedeactivate","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onbeforedeactivate' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onbeforedeactivate"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onbeforedeactivate' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onbeforedeactivate' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onbeforepaste","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onbeforepaste' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onbeforepaste","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onbeforepaste:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onbeforepaste:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onbeforepaste","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onbeforepaste' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onbeforepaste"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onbeforepaste' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onbeforepaste' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onblur","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onblur' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.FocusEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onblur","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onblur:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onblur:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onblur","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onblur' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.FocusEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onblur"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onblur' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onblur' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.FocusEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"oncanplay","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@oncanplay' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@oncanplay","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@oncanplay:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@oncanplay:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@oncanplay","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@oncanplay' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"oncanplay"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@oncanplay' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@oncanplay' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"oncanplaythrough","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@oncanplaythrough' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@oncanplaythrough","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@oncanplaythrough:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@oncanplaythrough:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@oncanplaythrough","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@oncanplaythrough' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"oncanplaythrough"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@oncanplaythrough' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@oncanplaythrough' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onchange","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onchange' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.ChangeEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onchange","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onchange:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onchange:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onchange","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onchange' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.ChangeEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onchange"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onchange' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onchange' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.ChangeEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onclick","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onclick' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.MouseEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onclick","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onclick:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onclick:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onclick","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onclick' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.MouseEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onclick"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onclick' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onclick' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.MouseEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"oncontextmenu","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@oncontextmenu' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.MouseEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@oncontextmenu","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@oncontextmenu:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@oncontextmenu:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@oncontextmenu","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@oncontextmenu' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.MouseEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"oncontextmenu"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@oncontextmenu' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@oncontextmenu' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.MouseEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"oncopy","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@oncopy' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.ClipboardEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@oncopy","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@oncopy:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@oncopy:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@oncopy","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@oncopy' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.ClipboardEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"oncopy"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@oncopy' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@oncopy' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.ClipboardEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"oncuechange","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@oncuechange' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@oncuechange","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@oncuechange:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@oncuechange:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@oncuechange","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@oncuechange' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"oncuechange"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@oncuechange' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@oncuechange' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"oncut","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@oncut' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.ClipboardEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@oncut","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@oncut:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@oncut:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@oncut","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@oncut' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.ClipboardEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"oncut"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@oncut' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@oncut' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.ClipboardEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"ondblclick","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@ondblclick' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.MouseEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondblclick","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondblclick:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondblclick:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@ondblclick","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@ondblclick' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.MouseEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"ondblclick"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@ondblclick' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@ondblclick' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.MouseEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"ondeactivate","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@ondeactivate' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondeactivate","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondeactivate:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondeactivate:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@ondeactivate","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@ondeactivate' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"ondeactivate"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@ondeactivate' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@ondeactivate' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"ondrag","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@ondrag' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.DragEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondrag","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondrag:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondrag:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@ondrag","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@ondrag' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.DragEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"ondrag"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@ondrag' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@ondrag' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.DragEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"ondragend","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@ondragend' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.DragEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondragend","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondragend:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondragend:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@ondragend","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@ondragend' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.DragEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"ondragend"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@ondragend' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@ondragend' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.DragEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"ondragenter","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@ondragenter' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.DragEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondragenter","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondragenter:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondragenter:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@ondragenter","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@ondragenter' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.DragEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"ondragenter"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@ondragenter' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@ondragenter' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.DragEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"ondragleave","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@ondragleave' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.DragEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondragleave","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondragleave:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondragleave:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@ondragleave","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@ondragleave' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.DragEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"ondragleave"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@ondragleave' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@ondragleave' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.DragEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"ondragover","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@ondragover' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.DragEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondragover","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondragover:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondragover:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@ondragover","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@ondragover' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.DragEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"ondragover"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@ondragover' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@ondragover' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.DragEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"ondragstart","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@ondragstart' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.DragEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondragstart","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondragstart:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondragstart:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@ondragstart","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@ondragstart' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.DragEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"ondragstart"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@ondragstart' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@ondragstart' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.DragEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"ondrop","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@ondrop' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.DragEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondrop","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondrop:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondrop:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@ondrop","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@ondrop' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.DragEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"ondrop"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@ondrop' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@ondrop' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.DragEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"ondurationchange","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@ondurationchange' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondurationchange","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondurationchange:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ondurationchange:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@ondurationchange","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@ondurationchange' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"ondurationchange"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@ondurationchange' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@ondurationchange' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onemptied","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onemptied' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onemptied","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onemptied:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onemptied:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onemptied","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onemptied' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onemptied"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onemptied' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onemptied' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onended","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onended' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onended","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onended:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onended:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onended","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onended' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onended"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onended' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onended' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onerror","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onerror' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.ErrorEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onerror","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onerror:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onerror:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onerror","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onerror' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.ErrorEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onerror"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onerror' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onerror' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.ErrorEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onfocus","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onfocus' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.FocusEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onfocus","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onfocus:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onfocus:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onfocus","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onfocus' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.FocusEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onfocus"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onfocus' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onfocus' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.FocusEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onfocusin","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onfocusin' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.FocusEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onfocusin","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onfocusin:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onfocusin:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onfocusin","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onfocusin' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.FocusEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onfocusin"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onfocusin' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onfocusin' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.FocusEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onfocusout","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onfocusout' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.FocusEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onfocusout","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onfocusout:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onfocusout:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onfocusout","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onfocusout' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.FocusEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onfocusout"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onfocusout' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onfocusout' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.FocusEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onfullscreenchange","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onfullscreenchange' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onfullscreenchange","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onfullscreenchange:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onfullscreenchange:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onfullscreenchange","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onfullscreenchange' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onfullscreenchange"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onfullscreenchange' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onfullscreenchange' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onfullscreenerror","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onfullscreenerror' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onfullscreenerror","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onfullscreenerror:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onfullscreenerror:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onfullscreenerror","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onfullscreenerror' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onfullscreenerror"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onfullscreenerror' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onfullscreenerror' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"ongotpointercapture","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@ongotpointercapture' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.PointerEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ongotpointercapture","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ongotpointercapture:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ongotpointercapture:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@ongotpointercapture","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@ongotpointercapture' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.PointerEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"ongotpointercapture"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@ongotpointercapture' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@ongotpointercapture' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.PointerEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"oninput","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@oninput' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.ChangeEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@oninput","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@oninput:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@oninput:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@oninput","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@oninput' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.ChangeEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"oninput"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@oninput' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@oninput' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.ChangeEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"oninvalid","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@oninvalid' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@oninvalid","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@oninvalid:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@oninvalid:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@oninvalid","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@oninvalid' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"oninvalid"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@oninvalid' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@oninvalid' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onkeydown","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onkeydown' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.KeyboardEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onkeydown","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onkeydown:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onkeydown:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onkeydown","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onkeydown' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.KeyboardEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onkeydown"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onkeydown' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onkeydown' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.KeyboardEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onkeypress","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onkeypress' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.KeyboardEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onkeypress","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onkeypress:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onkeypress:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onkeypress","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onkeypress' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.KeyboardEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onkeypress"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onkeypress' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onkeypress' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.KeyboardEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onkeyup","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onkeyup' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.KeyboardEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onkeyup","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onkeyup:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onkeyup:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onkeyup","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onkeyup' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.KeyboardEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onkeyup"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onkeyup' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onkeyup' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.KeyboardEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onload","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onload' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.ProgressEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onload","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onload:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onload:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onload","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onload' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.ProgressEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onload"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onload' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onload' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.ProgressEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onloadeddata","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onloadeddata' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onloadeddata","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onloadeddata:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onloadeddata:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onloadeddata","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onloadeddata' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onloadeddata"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onloadeddata' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onloadeddata' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onloadedmetadata","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onloadedmetadata' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onloadedmetadata","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onloadedmetadata:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onloadedmetadata:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onloadedmetadata","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onloadedmetadata' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onloadedmetadata"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onloadedmetadata' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onloadedmetadata' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onloadend","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onloadend' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.ProgressEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onloadend","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onloadend:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onloadend:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onloadend","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onloadend' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.ProgressEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onloadend"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onloadend' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onloadend' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.ProgressEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onloadstart","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onloadstart' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.ProgressEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onloadstart","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onloadstart:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onloadstart:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onloadstart","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onloadstart' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.ProgressEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onloadstart"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onloadstart' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onloadstart' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.ProgressEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onlostpointercapture","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onlostpointercapture' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.PointerEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onlostpointercapture","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onlostpointercapture:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onlostpointercapture:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onlostpointercapture","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onlostpointercapture' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.PointerEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onlostpointercapture"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onlostpointercapture' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onlostpointercapture' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.PointerEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onmousedown","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onmousedown' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.MouseEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onmousedown","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onmousedown:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onmousedown:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onmousedown","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onmousedown' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.MouseEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onmousedown"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onmousedown' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onmousedown' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.MouseEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onmousemove","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onmousemove' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.MouseEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onmousemove","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onmousemove:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onmousemove:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onmousemove","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onmousemove' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.MouseEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onmousemove"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onmousemove' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onmousemove' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.MouseEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onmouseout","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onmouseout' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.MouseEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onmouseout","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onmouseout:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onmouseout:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onmouseout","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onmouseout' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.MouseEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onmouseout"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onmouseout' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onmouseout' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.MouseEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onmouseover","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onmouseover' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.MouseEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onmouseover","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onmouseover:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onmouseover:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onmouseover","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onmouseover' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.MouseEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onmouseover"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onmouseover' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onmouseover' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.MouseEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onmouseup","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onmouseup' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.MouseEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onmouseup","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onmouseup:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onmouseup:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onmouseup","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onmouseup' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.MouseEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onmouseup"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onmouseup' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onmouseup' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.MouseEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onmousewheel","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onmousewheel' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.WheelEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onmousewheel","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onmousewheel:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onmousewheel:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onmousewheel","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onmousewheel' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.WheelEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onmousewheel"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onmousewheel' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onmousewheel' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.WheelEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onpaste","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onpaste' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.ClipboardEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpaste","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpaste:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpaste:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onpaste","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onpaste' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.ClipboardEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onpaste"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onpaste' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onpaste' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.ClipboardEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onpause","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onpause' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpause","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpause:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpause:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onpause","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onpause' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onpause"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onpause' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onpause' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onplay","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onplay' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onplay","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onplay:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onplay:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onplay","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onplay' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onplay"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onplay' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onplay' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onplaying","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onplaying' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onplaying","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onplaying:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onplaying:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onplaying","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onplaying' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onplaying"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onplaying' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onplaying' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onpointercancel","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onpointercancel' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.PointerEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointercancel","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointercancel:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointercancel:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onpointercancel","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onpointercancel' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.PointerEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onpointercancel"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onpointercancel' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onpointercancel' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.PointerEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onpointerdown","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onpointerdown' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.PointerEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointerdown","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointerdown:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointerdown:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onpointerdown","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onpointerdown' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.PointerEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onpointerdown"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onpointerdown' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onpointerdown' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.PointerEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onpointerenter","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onpointerenter' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.PointerEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointerenter","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointerenter:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointerenter:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onpointerenter","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onpointerenter' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.PointerEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onpointerenter"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onpointerenter' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onpointerenter' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.PointerEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onpointerleave","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onpointerleave' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.PointerEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointerleave","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointerleave:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointerleave:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onpointerleave","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onpointerleave' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.PointerEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onpointerleave"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onpointerleave' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onpointerleave' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.PointerEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onpointerlockchange","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onpointerlockchange' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointerlockchange","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointerlockchange:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointerlockchange:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onpointerlockchange","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onpointerlockchange' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onpointerlockchange"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onpointerlockchange' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onpointerlockchange' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onpointerlockerror","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onpointerlockerror' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointerlockerror","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointerlockerror:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointerlockerror:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onpointerlockerror","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onpointerlockerror' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onpointerlockerror"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onpointerlockerror' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onpointerlockerror' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onpointermove","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onpointermove' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.PointerEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointermove","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointermove:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointermove:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onpointermove","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onpointermove' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.PointerEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onpointermove"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onpointermove' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onpointermove' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.PointerEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onpointerout","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onpointerout' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.PointerEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointerout","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointerout:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointerout:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onpointerout","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onpointerout' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.PointerEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onpointerout"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onpointerout' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onpointerout' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.PointerEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onpointerover","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onpointerover' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.PointerEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointerover","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointerover:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointerover:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onpointerover","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onpointerover' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.PointerEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onpointerover"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onpointerover' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onpointerover' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.PointerEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onpointerup","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onpointerup' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.PointerEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointerup","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointerup:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onpointerup:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onpointerup","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onpointerup' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.PointerEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onpointerup"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onpointerup' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onpointerup' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.PointerEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onprogress","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onprogress' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.ProgressEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onprogress","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onprogress:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onprogress:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onprogress","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onprogress' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.ProgressEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onprogress"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onprogress' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onprogress' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.ProgressEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onratechange","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onratechange' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onratechange","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onratechange:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onratechange:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onratechange","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onratechange' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onratechange"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onratechange' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onratechange' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onreadystatechange","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onreadystatechange' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onreadystatechange","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onreadystatechange:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onreadystatechange:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onreadystatechange","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onreadystatechange' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onreadystatechange"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onreadystatechange' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onreadystatechange' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onreset","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onreset' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onreset","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onreset:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onreset:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onreset","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onreset' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onreset"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onreset' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onreset' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onscroll","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onscroll' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onscroll","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onscroll:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onscroll:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onscroll","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onscroll' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onscroll"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onscroll' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onscroll' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onseeked","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onseeked' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onseeked","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onseeked:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onseeked:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onseeked","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onseeked' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onseeked"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onseeked' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onseeked' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onseeking","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onseeking' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onseeking","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onseeking:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onseeking:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onseeking","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onseeking' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onseeking"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onseeking' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onseeking' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onselect","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onselect' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onselect","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onselect:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onselect:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onselect","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onselect' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onselect"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onselect' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onselect' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onselectionchange","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onselectionchange' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onselectionchange","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onselectionchange:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onselectionchange:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onselectionchange","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onselectionchange' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onselectionchange"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onselectionchange' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onselectionchange' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onselectstart","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onselectstart' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onselectstart","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onselectstart:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onselectstart:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onselectstart","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onselectstart' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onselectstart"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onselectstart' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onselectstart' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onstalled","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onstalled' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onstalled","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onstalled:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onstalled:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onstalled","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onstalled' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onstalled"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onstalled' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onstalled' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onstop","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onstop' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onstop","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onstop:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onstop:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onstop","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onstop' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onstop"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onstop' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onstop' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onsubmit","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onsubmit' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onsubmit","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onsubmit:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onsubmit:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onsubmit","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onsubmit' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onsubmit"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onsubmit' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onsubmit' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onsuspend","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onsuspend' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onsuspend","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onsuspend:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onsuspend:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onsuspend","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onsuspend' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onsuspend"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onsuspend' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onsuspend' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"ontimeout","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@ontimeout' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.ProgressEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ontimeout","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ontimeout:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ontimeout:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@ontimeout","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@ontimeout' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.ProgressEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"ontimeout"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@ontimeout' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@ontimeout' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.ProgressEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"ontimeupdate","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@ontimeupdate' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ontimeupdate","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ontimeupdate:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ontimeupdate:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@ontimeupdate","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@ontimeupdate' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"ontimeupdate"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@ontimeupdate' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@ontimeupdate' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"ontouchcancel","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@ontouchcancel' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.TouchEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ontouchcancel","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ontouchcancel:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ontouchcancel:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@ontouchcancel","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@ontouchcancel' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.TouchEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"ontouchcancel"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@ontouchcancel' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@ontouchcancel' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.TouchEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"ontouchend","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@ontouchend' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.TouchEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ontouchend","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ontouchend:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ontouchend:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@ontouchend","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@ontouchend' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.TouchEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"ontouchend"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@ontouchend' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@ontouchend' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.TouchEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"ontouchenter","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@ontouchenter' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.TouchEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ontouchenter","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ontouchenter:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ontouchenter:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@ontouchenter","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@ontouchenter' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.TouchEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"ontouchenter"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@ontouchenter' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@ontouchenter' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.TouchEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"ontouchleave","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@ontouchleave' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.TouchEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ontouchleave","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ontouchleave:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ontouchleave:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@ontouchleave","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@ontouchleave' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.TouchEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"ontouchleave"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@ontouchleave' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@ontouchleave' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.TouchEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"ontouchmove","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@ontouchmove' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.TouchEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ontouchmove","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ontouchmove:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ontouchmove:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@ontouchmove","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@ontouchmove' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.TouchEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"ontouchmove"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@ontouchmove' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@ontouchmove' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.TouchEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"ontouchstart","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@ontouchstart' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.TouchEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ontouchstart","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ontouchstart:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ontouchstart:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@ontouchstart","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@ontouchstart' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.TouchEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"ontouchstart"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@ontouchstart' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@ontouchstart' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.TouchEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onvolumechange","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onvolumechange' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onvolumechange","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onvolumechange:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onvolumechange:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onvolumechange","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onvolumechange' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onvolumechange"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onvolumechange' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onvolumechange' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onwaiting","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onwaiting' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onwaiting","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onwaiting:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onwaiting:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onwaiting","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onwaiting' attribute to the provided string or delegate value. A delegate value should be of type 'System.EventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onwaiting"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onwaiting' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onwaiting' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"System.EventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.EventHandler","Name":"onwheel","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Sets the '@onwheel' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.WheelEventArgs'.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onwheel","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onwheel:preventDefault","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]},{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@onwheel:stopPropagation","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.EventHandler","Name":"@onwheel","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Sets the '@onwheel' attribute to the provided string or delegate value. A delegate value should be of type 'Microsoft.AspNetCore.Components.Web.WheelEventArgs'.","Diagnostics":[],"Metadata":{"Components.IsWeaklyTyped":"True","Common.DirectiveAttribute":"True","Common.PropertyName":"onwheel"},"BoundAttributeParameters":[{"Kind":"Components.EventHandler","Name":"preventDefault","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to cancel (if cancelable) the default action that belongs to the '@onwheel' event.","Diagnostics":[],"Metadata":{"Common.PropertyName":"PreventDefault"}},{"Kind":"Components.EventHandler","Name":"stopPropagation","TypeName":"System.Boolean","IsEnum":false,"Documentation":"Specifies whether to prevent further propagation of the '@onwheel' event in the capturing and bubbling phases.","Diagnostics":[],"Metadata":{"Common.PropertyName":"StopPropagation"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.EventHandler","Components.EventHandler.EventArgs":"Microsoft.AspNetCore.Components.Web.WheelEventArgs","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Web.EventHandlers"}},{"Kind":"Components.Splat","Name":"Attributes","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Merges a collection of attributes into the current element or component.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@attributes","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Splat","Name":"@attributes","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Merges a collection of attributes into the current element or component.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Attributes","Common.DirectiveAttribute":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Splat","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Attributes"}},{"Kind":"Components.Bind","Name":"Bind","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Binds the provided expression to an attribute and a change event, based on the naming of the bind attribute. For example: @bind-value=\"...\" and @bind-value:event=\"onchange\" will assign the current value of the expression to the 'value' attribute, and assign a delegate that attempts to set the value to the 'onchange' attribute.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@bind-","NameComparison":1,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind-...","TypeName":"System.Collections.Generic.Dictionary","IsEnum":false,"IndexerNamePrefix":"@bind-","IndexerTypeName":"System.Object","Documentation":"Binds the provided expression to an attribute and a change event, based on the naming of the bind attribute. For example: @bind-value=\"...\" and @bind-value:event=\"onchange\" will assign the current value of the expression to the 'value' attribute, and assign a delegate that attempts to set the value to the 'onchange' attribute.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Bind"},"BoundAttributeParameters":[{"Kind":"Components.Bind","Name":"format","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies a format to convert the value specified by the corresponding bind attribute. For example: @bind-value:format=\"...\" will apply a format string to the value specified in @bind-value=\"...\". The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format"}},{"Kind":"Components.Bind","Name":"event","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies the event handler name to attach for change notifications for the value provided by the '@bind-...' attribute.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Event"}},{"Kind":"Components.Bind","Name":"culture","TypeName":"System.Globalization.CultureInfo","IsEnum":false,"Documentation":"Specifies the culture to use for conversions.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Culture"}}]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Common.ClassifyAttributesOnly":"True","Components.Bind.Fallback":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Bind"}},{"Kind":"Components.Bind","Name":"Bind","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"select","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@bind","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Bind"},"BoundAttributeParameters":[{"Kind":"Components.Bind","Name":"format","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies a format to convert the value specified by the '@bind' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"}},{"Kind":"Components.Bind","Name":"event","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies the event handler name to attach for change notifications for the value provided by the '@bind' attribute.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Event_value"}},{"Kind":"Components.Bind","Name":"culture","TypeName":"System.Globalization.CultureInfo","IsEnum":false,"Documentation":"Specifies the culture to use for conversions.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Culture"}}]},{"Kind":"Components.Bind","Name":"format-value","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies a format to convert the value specified by the '@bind' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Common.ClassifyAttributesOnly":"True","Components.Bind.ValueAttribute":"value","Components.Bind.ChangeAttribute":"onchange","Components.Bind.IsInvariantCulture":"False","Components.Bind.Format":null,"Common.TypeName":"Microsoft.AspNetCore.Components.Web.BindAttributes"}},{"Kind":"Components.Bind","Name":"Bind","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"textarea","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@bind","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Bind"},"BoundAttributeParameters":[{"Kind":"Components.Bind","Name":"format","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies a format to convert the value specified by the '@bind' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"}},{"Kind":"Components.Bind","Name":"event","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies the event handler name to attach for change notifications for the value provided by the '@bind' attribute.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Event_value"}},{"Kind":"Components.Bind","Name":"culture","TypeName":"System.Globalization.CultureInfo","IsEnum":false,"Documentation":"Specifies the culture to use for conversions.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Culture"}}]},{"Kind":"Components.Bind","Name":"format-value","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies a format to convert the value specified by the '@bind' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Common.ClassifyAttributesOnly":"True","Components.Bind.ValueAttribute":"value","Components.Bind.ChangeAttribute":"onchange","Components.Bind.IsInvariantCulture":"False","Components.Bind.Format":null,"Common.TypeName":"Microsoft.AspNetCore.Components.Web.BindAttributes"}},{"Kind":"Components.Bind","Name":"Bind","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Binds the provided expression to the 'checked' attribute and a change event delegate to the 'onchange' attribute.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"input","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"type","NameComparison":0,"Value":"checkbox","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"@bind","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'checked' attribute and a change event delegate to the 'onchange' attribute.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Bind"},"BoundAttributeParameters":[{"Kind":"Components.Bind","Name":"format","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies a format to convert the value specified by the '@bind' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_checked"}},{"Kind":"Components.Bind","Name":"event","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies the event handler name to attach for change notifications for the value provided by the '@bind' attribute.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Event_checked"}},{"Kind":"Components.Bind","Name":"culture","TypeName":"System.Globalization.CultureInfo","IsEnum":false,"Documentation":"Specifies the culture to use for conversions.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Culture"}}]},{"Kind":"Components.Bind","Name":"format-checked","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies a format to convert the value specified by the '@bind' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_checked"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Common.ClassifyAttributesOnly":"True","Components.Bind.ValueAttribute":"checked","Components.Bind.ChangeAttribute":"onchange","Components.Bind.IsInvariantCulture":"False","Components.Bind.Format":null,"Components.Bind.TypeAttribute":"checkbox","Common.TypeName":"Microsoft.AspNetCore.Components.Web.BindAttributes"}},{"Kind":"Components.Bind","Name":"Bind_value","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"input","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"type","NameComparison":0,"Value":"date","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"@bind-value","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind-value","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Bind_value"},"BoundAttributeParameters":[{"Kind":"Components.Bind","Name":"format","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies a format to convert the value specified by the '@bind-value' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"}},{"Kind":"Components.Bind","Name":"event","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies the event handler name to attach for change notifications for the value provided by the '@bind-value' attribute.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Event_value"}},{"Kind":"Components.Bind","Name":"culture","TypeName":"System.Globalization.CultureInfo","IsEnum":false,"Documentation":"Specifies the culture to use for conversions.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Culture"}}]},{"Kind":"Components.Bind","Name":"format-value","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies a format to convert the value specified by the '@bind-value' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Common.ClassifyAttributesOnly":"True","Components.Bind.ValueAttribute":"value","Components.Bind.ChangeAttribute":"onchange","Components.Bind.IsInvariantCulture":"True","Components.Bind.Format":"yyyy-MM-dd","Components.Bind.TypeAttribute":"date","Common.TypeName":"Microsoft.AspNetCore.Components.Web.BindAttributes"}},{"Kind":"Components.Bind","Name":"Bind","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"input","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"type","NameComparison":0,"Value":"date","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"@bind","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Bind"},"BoundAttributeParameters":[{"Kind":"Components.Bind","Name":"format","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies a format to convert the value specified by the '@bind' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"}},{"Kind":"Components.Bind","Name":"event","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies the event handler name to attach for change notifications for the value provided by the '@bind' attribute.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Event_value"}},{"Kind":"Components.Bind","Name":"culture","TypeName":"System.Globalization.CultureInfo","IsEnum":false,"Documentation":"Specifies the culture to use for conversions.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Culture"}}]},{"Kind":"Components.Bind","Name":"format-value","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies a format to convert the value specified by the '@bind' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Common.ClassifyAttributesOnly":"True","Components.Bind.ValueAttribute":"value","Components.Bind.ChangeAttribute":"onchange","Components.Bind.IsInvariantCulture":"True","Components.Bind.Format":"yyyy-MM-dd","Components.Bind.TypeAttribute":"date","Common.TypeName":"Microsoft.AspNetCore.Components.Web.BindAttributes"}},{"Kind":"Components.Bind","Name":"Bind_value","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"input","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"type","NameComparison":0,"Value":"datetime-local","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"@bind-value","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind-value","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Bind_value"},"BoundAttributeParameters":[{"Kind":"Components.Bind","Name":"format","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies a format to convert the value specified by the '@bind-value' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"}},{"Kind":"Components.Bind","Name":"event","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies the event handler name to attach for change notifications for the value provided by the '@bind-value' attribute.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Event_value"}},{"Kind":"Components.Bind","Name":"culture","TypeName":"System.Globalization.CultureInfo","IsEnum":false,"Documentation":"Specifies the culture to use for conversions.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Culture"}}]},{"Kind":"Components.Bind","Name":"format-value","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies a format to convert the value specified by the '@bind-value' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Common.ClassifyAttributesOnly":"True","Components.Bind.ValueAttribute":"value","Components.Bind.ChangeAttribute":"onchange","Components.Bind.IsInvariantCulture":"True","Components.Bind.Format":"yyyy-MM-ddTHH:mm:ss","Components.Bind.TypeAttribute":"datetime-local","Common.TypeName":"Microsoft.AspNetCore.Components.Web.BindAttributes"}},{"Kind":"Components.Bind","Name":"Bind","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"input","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"type","NameComparison":0,"Value":"datetime-local","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"@bind","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Bind"},"BoundAttributeParameters":[{"Kind":"Components.Bind","Name":"format","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies a format to convert the value specified by the '@bind' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"}},{"Kind":"Components.Bind","Name":"event","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies the event handler name to attach for change notifications for the value provided by the '@bind' attribute.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Event_value"}},{"Kind":"Components.Bind","Name":"culture","TypeName":"System.Globalization.CultureInfo","IsEnum":false,"Documentation":"Specifies the culture to use for conversions.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Culture"}}]},{"Kind":"Components.Bind","Name":"format-value","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies a format to convert the value specified by the '@bind' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Common.ClassifyAttributesOnly":"True","Components.Bind.ValueAttribute":"value","Components.Bind.ChangeAttribute":"onchange","Components.Bind.IsInvariantCulture":"True","Components.Bind.Format":"yyyy-MM-ddTHH:mm:ss","Components.Bind.TypeAttribute":"datetime-local","Common.TypeName":"Microsoft.AspNetCore.Components.Web.BindAttributes"}},{"Kind":"Components.Bind","Name":"Bind_value","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"input","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"type","NameComparison":0,"Value":"month","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"@bind-value","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind-value","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Bind_value"},"BoundAttributeParameters":[{"Kind":"Components.Bind","Name":"format","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies a format to convert the value specified by the '@bind-value' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"}},{"Kind":"Components.Bind","Name":"event","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies the event handler name to attach for change notifications for the value provided by the '@bind-value' attribute.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Event_value"}},{"Kind":"Components.Bind","Name":"culture","TypeName":"System.Globalization.CultureInfo","IsEnum":false,"Documentation":"Specifies the culture to use for conversions.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Culture"}}]},{"Kind":"Components.Bind","Name":"format-value","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies a format to convert the value specified by the '@bind-value' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Common.ClassifyAttributesOnly":"True","Components.Bind.ValueAttribute":"value","Components.Bind.ChangeAttribute":"onchange","Components.Bind.IsInvariantCulture":"True","Components.Bind.Format":"yyyy-MM","Components.Bind.TypeAttribute":"month","Common.TypeName":"Microsoft.AspNetCore.Components.Web.BindAttributes"}},{"Kind":"Components.Bind","Name":"Bind","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"input","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"type","NameComparison":0,"Value":"month","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"@bind","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Bind"},"BoundAttributeParameters":[{"Kind":"Components.Bind","Name":"format","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies a format to convert the value specified by the '@bind' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"}},{"Kind":"Components.Bind","Name":"event","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies the event handler name to attach for change notifications for the value provided by the '@bind' attribute.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Event_value"}},{"Kind":"Components.Bind","Name":"culture","TypeName":"System.Globalization.CultureInfo","IsEnum":false,"Documentation":"Specifies the culture to use for conversions.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Culture"}}]},{"Kind":"Components.Bind","Name":"format-value","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies a format to convert the value specified by the '@bind' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Common.ClassifyAttributesOnly":"True","Components.Bind.ValueAttribute":"value","Components.Bind.ChangeAttribute":"onchange","Components.Bind.IsInvariantCulture":"True","Components.Bind.Format":"yyyy-MM","Components.Bind.TypeAttribute":"month","Common.TypeName":"Microsoft.AspNetCore.Components.Web.BindAttributes"}},{"Kind":"Components.Bind","Name":"Bind_value","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"input","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"type","NameComparison":0,"Value":"number","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"@bind-value","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind-value","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Bind_value"},"BoundAttributeParameters":[{"Kind":"Components.Bind","Name":"format","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies a format to convert the value specified by the '@bind-value' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"}},{"Kind":"Components.Bind","Name":"event","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies the event handler name to attach for change notifications for the value provided by the '@bind-value' attribute.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Event_value"}},{"Kind":"Components.Bind","Name":"culture","TypeName":"System.Globalization.CultureInfo","IsEnum":false,"Documentation":"Specifies the culture to use for conversions.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Culture"}}]},{"Kind":"Components.Bind","Name":"format-value","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies a format to convert the value specified by the '@bind-value' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Common.ClassifyAttributesOnly":"True","Components.Bind.ValueAttribute":"value","Components.Bind.ChangeAttribute":"onchange","Components.Bind.IsInvariantCulture":"True","Components.Bind.Format":null,"Components.Bind.TypeAttribute":"number","Common.TypeName":"Microsoft.AspNetCore.Components.Web.BindAttributes"}},{"Kind":"Components.Bind","Name":"Bind","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"input","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"type","NameComparison":0,"Value":"number","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"@bind","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Bind"},"BoundAttributeParameters":[{"Kind":"Components.Bind","Name":"format","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies a format to convert the value specified by the '@bind' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"}},{"Kind":"Components.Bind","Name":"event","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies the event handler name to attach for change notifications for the value provided by the '@bind' attribute.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Event_value"}},{"Kind":"Components.Bind","Name":"culture","TypeName":"System.Globalization.CultureInfo","IsEnum":false,"Documentation":"Specifies the culture to use for conversions.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Culture"}}]},{"Kind":"Components.Bind","Name":"format-value","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies a format to convert the value specified by the '@bind' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Common.ClassifyAttributesOnly":"True","Components.Bind.ValueAttribute":"value","Components.Bind.ChangeAttribute":"onchange","Components.Bind.IsInvariantCulture":"True","Components.Bind.Format":null,"Components.Bind.TypeAttribute":"number","Common.TypeName":"Microsoft.AspNetCore.Components.Web.BindAttributes"}},{"Kind":"Components.Bind","Name":"Bind","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"input","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"type","NameComparison":0,"Value":"text","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"@bind","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Bind"},"BoundAttributeParameters":[{"Kind":"Components.Bind","Name":"format","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies a format to convert the value specified by the '@bind' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"}},{"Kind":"Components.Bind","Name":"event","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies the event handler name to attach for change notifications for the value provided by the '@bind' attribute.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Event_value"}},{"Kind":"Components.Bind","Name":"culture","TypeName":"System.Globalization.CultureInfo","IsEnum":false,"Documentation":"Specifies the culture to use for conversions.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Culture"}}]},{"Kind":"Components.Bind","Name":"format-value","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies a format to convert the value specified by the '@bind' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Common.ClassifyAttributesOnly":"True","Components.Bind.ValueAttribute":"value","Components.Bind.ChangeAttribute":"onchange","Components.Bind.IsInvariantCulture":"False","Components.Bind.Format":null,"Components.Bind.TypeAttribute":"text","Common.TypeName":"Microsoft.AspNetCore.Components.Web.BindAttributes"}},{"Kind":"Components.Bind","Name":"Bind_value","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"input","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"type","NameComparison":0,"Value":"time","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"@bind-value","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind-value","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Bind_value"},"BoundAttributeParameters":[{"Kind":"Components.Bind","Name":"format","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies a format to convert the value specified by the '@bind-value' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"}},{"Kind":"Components.Bind","Name":"event","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies the event handler name to attach for change notifications for the value provided by the '@bind-value' attribute.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Event_value"}},{"Kind":"Components.Bind","Name":"culture","TypeName":"System.Globalization.CultureInfo","IsEnum":false,"Documentation":"Specifies the culture to use for conversions.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Culture"}}]},{"Kind":"Components.Bind","Name":"format-value","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies a format to convert the value specified by the '@bind-value' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Common.ClassifyAttributesOnly":"True","Components.Bind.ValueAttribute":"value","Components.Bind.ChangeAttribute":"onchange","Components.Bind.IsInvariantCulture":"True","Components.Bind.Format":"HH:mm:ss","Components.Bind.TypeAttribute":"time","Common.TypeName":"Microsoft.AspNetCore.Components.Web.BindAttributes"}},{"Kind":"Components.Bind","Name":"Bind","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"input","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"type","NameComparison":0,"Value":"time","ValueComparison":1,"Diagnostics":[],"Metadata":{}},{"Name":"@bind","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Bind"},"BoundAttributeParameters":[{"Kind":"Components.Bind","Name":"format","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies a format to convert the value specified by the '@bind' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"}},{"Kind":"Components.Bind","Name":"event","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies the event handler name to attach for change notifications for the value provided by the '@bind' attribute.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Event_value"}},{"Kind":"Components.Bind","Name":"culture","TypeName":"System.Globalization.CultureInfo","IsEnum":false,"Documentation":"Specifies the culture to use for conversions.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Culture"}}]},{"Kind":"Components.Bind","Name":"format-value","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies a format to convert the value specified by the '@bind' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Common.ClassifyAttributesOnly":"True","Components.Bind.ValueAttribute":"value","Components.Bind.ChangeAttribute":"onchange","Components.Bind.IsInvariantCulture":"True","Components.Bind.Format":"HH:mm:ss","Components.Bind.TypeAttribute":"time","Common.TypeName":"Microsoft.AspNetCore.Components.Web.BindAttributes"}},{"Kind":"Components.Bind","Name":"Bind_value","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"input","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@bind-value","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind-value","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Bind_value"},"BoundAttributeParameters":[{"Kind":"Components.Bind","Name":"format","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies a format to convert the value specified by the '@bind-value' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"}},{"Kind":"Components.Bind","Name":"event","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies the event handler name to attach for change notifications for the value provided by the '@bind-value' attribute.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Event_value"}},{"Kind":"Components.Bind","Name":"culture","TypeName":"System.Globalization.CultureInfo","IsEnum":false,"Documentation":"Specifies the culture to use for conversions.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Culture"}}]},{"Kind":"Components.Bind","Name":"format-value","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies a format to convert the value specified by the '@bind-value' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Common.ClassifyAttributesOnly":"True","Components.Bind.ValueAttribute":"value","Components.Bind.ChangeAttribute":"onchange","Components.Bind.IsInvariantCulture":"False","Components.Bind.Format":null,"Common.TypeName":"Microsoft.AspNetCore.Components.Web.BindAttributes"}},{"Kind":"Components.Bind","Name":"Bind","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"input","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@bind","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'value' attribute and a change event delegate to the 'onchange' attribute.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Bind"},"BoundAttributeParameters":[{"Kind":"Components.Bind","Name":"format","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies a format to convert the value specified by the '@bind' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"}},{"Kind":"Components.Bind","Name":"event","TypeName":"System.String","IsEnum":false,"Documentation":"Specifies the event handler name to attach for change notifications for the value provided by the '@bind' attribute.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Event_value"}},{"Kind":"Components.Bind","Name":"culture","TypeName":"System.Globalization.CultureInfo","IsEnum":false,"Documentation":"Specifies the culture to use for conversions.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Culture"}}]},{"Kind":"Components.Bind","Name":"format-value","TypeName":"System.String","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Specifies a format to convert the value specified by the '@bind' attribute. The format string can currently only be used with expressions of type DateTime.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Format_value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Common.ClassifyAttributesOnly":"True","Components.Bind.ValueAttribute":"value","Components.Bind.ChangeAttribute":"onchange","Components.Bind.IsInvariantCulture":"False","Components.Bind.Format":null,"Common.TypeName":"Microsoft.AspNetCore.Components.Web.BindAttributes"}},{"Kind":"Components.Bind","Name":"Microsoft.AspNetCore.Components.Forms.InputCheckbox","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":"Binds the provided expression to the 'Value' property and a change event delegate to the 'ValueChanged' property of the component.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"InputCheckbox","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@bind-Value","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind-Value","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'Value' property and a change event delegate to the 'ValueChanged' property of the component.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Components.Bind.ValueAttribute":"Value","Components.Bind.ChangeAttribute":"ValueChanged","Components.Bind.ExpressionAttribute":"ValueExpression","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.InputCheckbox"}},{"Kind":"Components.Bind","Name":"Microsoft.AspNetCore.Components.Forms.InputCheckbox","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":"Binds the provided expression to the 'Value' property and a change event delegate to the 'ValueChanged' property of the component.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Microsoft.AspNetCore.Components.Forms.InputCheckbox","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@bind-Value","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind-Value","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'Value' property and a change event delegate to the 'ValueChanged' property of the component.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Components.Bind.ValueAttribute":"Value","Components.Bind.ChangeAttribute":"ValueChanged","Components.Bind.ExpressionAttribute":"ValueExpression","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.InputCheckbox","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.Bind","Name":"Microsoft.AspNetCore.Components.Forms.InputDate","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":"Binds the provided expression to the 'Value' property and a change event delegate to the 'ValueChanged' property of the component.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"InputDate","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@bind-Value","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind-Value","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'Value' property and a change event delegate to the 'ValueChanged' property of the component.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Components.Bind.ValueAttribute":"Value","Components.Bind.ChangeAttribute":"ValueChanged","Components.Bind.ExpressionAttribute":"ValueExpression","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.InputDate"}},{"Kind":"Components.Bind","Name":"Microsoft.AspNetCore.Components.Forms.InputDate","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":"Binds the provided expression to the 'Value' property and a change event delegate to the 'ValueChanged' property of the component.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Microsoft.AspNetCore.Components.Forms.InputDate","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@bind-Value","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind-Value","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'Value' property and a change event delegate to the 'ValueChanged' property of the component.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Components.Bind.ValueAttribute":"Value","Components.Bind.ChangeAttribute":"ValueChanged","Components.Bind.ExpressionAttribute":"ValueExpression","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.InputDate","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.Bind","Name":"Microsoft.AspNetCore.Components.Forms.InputNumber","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":"Binds the provided expression to the 'Value' property and a change event delegate to the 'ValueChanged' property of the component.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"InputNumber","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@bind-Value","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind-Value","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'Value' property and a change event delegate to the 'ValueChanged' property of the component.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Components.Bind.ValueAttribute":"Value","Components.Bind.ChangeAttribute":"ValueChanged","Components.Bind.ExpressionAttribute":"ValueExpression","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.InputNumber"}},{"Kind":"Components.Bind","Name":"Microsoft.AspNetCore.Components.Forms.InputNumber","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":"Binds the provided expression to the 'Value' property and a change event delegate to the 'ValueChanged' property of the component.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Microsoft.AspNetCore.Components.Forms.InputNumber","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@bind-Value","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind-Value","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'Value' property and a change event delegate to the 'ValueChanged' property of the component.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Components.Bind.ValueAttribute":"Value","Components.Bind.ChangeAttribute":"ValueChanged","Components.Bind.ExpressionAttribute":"ValueExpression","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.InputNumber","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.Bind","Name":"Microsoft.AspNetCore.Components.Forms.InputSelect","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":"Binds the provided expression to the 'Value' property and a change event delegate to the 'ValueChanged' property of the component.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"InputSelect","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@bind-Value","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind-Value","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'Value' property and a change event delegate to the 'ValueChanged' property of the component.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Components.Bind.ValueAttribute":"Value","Components.Bind.ChangeAttribute":"ValueChanged","Components.Bind.ExpressionAttribute":"ValueExpression","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.InputSelect"}},{"Kind":"Components.Bind","Name":"Microsoft.AspNetCore.Components.Forms.InputSelect","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":"Binds the provided expression to the 'Value' property and a change event delegate to the 'ValueChanged' property of the component.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Microsoft.AspNetCore.Components.Forms.InputSelect","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@bind-Value","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind-Value","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'Value' property and a change event delegate to the 'ValueChanged' property of the component.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Components.Bind.ValueAttribute":"Value","Components.Bind.ChangeAttribute":"ValueChanged","Components.Bind.ExpressionAttribute":"ValueExpression","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.InputSelect","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.Bind","Name":"Microsoft.AspNetCore.Components.Forms.InputText","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":"Binds the provided expression to the 'Value' property and a change event delegate to the 'ValueChanged' property of the component.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"InputText","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@bind-Value","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind-Value","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'Value' property and a change event delegate to the 'ValueChanged' property of the component.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Components.Bind.ValueAttribute":"Value","Components.Bind.ChangeAttribute":"ValueChanged","Components.Bind.ExpressionAttribute":"ValueExpression","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.InputText"}},{"Kind":"Components.Bind","Name":"Microsoft.AspNetCore.Components.Forms.InputText","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":"Binds the provided expression to the 'Value' property and a change event delegate to the 'ValueChanged' property of the component.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Microsoft.AspNetCore.Components.Forms.InputText","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@bind-Value","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind-Value","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'Value' property and a change event delegate to the 'ValueChanged' property of the component.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Components.Bind.ValueAttribute":"Value","Components.Bind.ChangeAttribute":"ValueChanged","Components.Bind.ExpressionAttribute":"ValueExpression","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.InputText","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.Bind","Name":"Microsoft.AspNetCore.Components.Forms.InputTextArea","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":"Binds the provided expression to the 'Value' property and a change event delegate to the 'ValueChanged' property of the component.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"InputTextArea","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@bind-Value","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind-Value","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'Value' property and a change event delegate to the 'ValueChanged' property of the component.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Components.Bind.ValueAttribute":"Value","Components.Bind.ChangeAttribute":"ValueChanged","Components.Bind.ExpressionAttribute":"ValueExpression","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.InputTextArea"}},{"Kind":"Components.Bind","Name":"Microsoft.AspNetCore.Components.Forms.InputTextArea","AssemblyName":"Microsoft.AspNetCore.Components.Web","Documentation":"Binds the provided expression to the 'Value' property and a change event delegate to the 'ValueChanged' property of the component.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"Microsoft.AspNetCore.Components.Forms.InputTextArea","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@bind-Value","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Bind","Name":"@bind-Value","TypeName":"Microsoft.AspNetCore.Components.EventCallback","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Binds the provided expression to the 'Value' property and a change event delegate to the 'ValueChanged' property of the component.","Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True","Common.PropertyName":"Value"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Bind","Components.Bind.ValueAttribute":"Value","Components.Bind.ChangeAttribute":"ValueChanged","Components.Bind.ExpressionAttribute":"ValueExpression","Common.TypeName":"Microsoft.AspNetCore.Components.Forms.InputTextArea","Components.NameMatch":"Components.FullyQualifiedNameMatch"}},{"Kind":"Components.Ref","Name":"Ref","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Populates the specified field or property with a reference to the element or component.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@ref","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Ref","Name":"@ref","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Populates the specified field or property with a reference to the element or component.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Ref","Common.DirectiveAttribute":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Ref","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Ref"}},{"Kind":"Components.Key","Name":"Key","AssemblyName":"Microsoft.AspNetCore.Components","Documentation":"Ensures that the component or element will be preserved across renders if (and only if) the supplied key value matches.","TagOutputHint":null,"CaseSensitive":true,"TagMatchingRules":[{"TagName":"*","ParentTag":null,"TagStructure":0,"Attributes":[{"Name":"@key","NameComparison":0,"Value":null,"ValueComparison":0,"Diagnostics":[],"Metadata":{"Common.DirectiveAttribute":"True"}}],"Diagnostics":[]}],"BoundAttributes":[{"Kind":"Components.Key","Name":"@key","TypeName":"System.Object","IsEnum":false,"IndexerNamePrefix":null,"IndexerTypeName":null,"Documentation":"Ensures that the component or element will be preserved across renders if (and only if) the supplied key value matches.","Diagnostics":[],"Metadata":{"Common.PropertyName":"Key","Common.DirectiveAttribute":"True"},"BoundAttributeParameters":[]}],"AllowedChildTags":[],"Diagnostics":[],"Metadata":{"Runtime.Name":"Components.None","Components.IsSpecialKind":"Components.Key","Common.ClassifyAttributesOnly":"True","Common.TypeName":"Microsoft.AspNetCore.Components.Key"}}] \ No newline at end of file diff --git a/obj/Debug/netcoreapp3.1/contacts.Views.dll b/obj/Debug/netcoreapp3.1/contacts.Views.dll new file mode 100644 index 0000000000000000000000000000000000000000..37f0f708c6aa1213fbb07e30731ee4675e1bd6ae GIT binary patch literal 10240 zcmeHNd2Af#b$>HEdytYSk&-M*rsdIP(>j)qM!OAdO?kMU&=eVkBu($1RkmfP)%E63Bo9R0)jKaB3id z5%>4r%4gg*d z53ur~6HUc!$4-MHzV!p)K)2(nI{Lwm+h)#!Ap1&FxHt!Q;Hoq% zyhdv?WOi>=FMy=&-mZo&2?7Gb@d$!|5DEx_fPln!5`usb4hVvz)Yi=~zH6U$$A&#& zYYT7}wr<_MUu}gS5ev@Nqs!J7+-Y|Z2Sgg3t$rLBM?oBG8QplPfo~VNfjA(GIJi-c z1Ebe-N)R{|4G4mOfI;F(2m(S~KoA6k`heggt+$DXa20;RRl2o3L_a{zk%>n20;jf~ z)C-(+iOfb0i#D1?3xh3S*~muG(kp~kNJOk{Agqe+?e`7XtChu4zFm>s4p|H1rEGGp zEF7qRs!aJ=^J?|>-$~(BDSWJTC#(K!!(wvlE~f5QWX?wEV~W63 zAD~P-E)#X3I-f-icO+dqTbOZJ;zjt}fA3W?fWYc(9G* zNsVc!E8Q20L?ZNKft%FV!fWXccp9NURc;`AA6Hwn26{U5I%GZ``cExFtpYC!{JF{$ zRqzqu_4Ewnn`oyp1o=0VNaPm!d*!w8Ewl%gx6romY-B4v8lI*t^pwEQgntv-LOT5> zw4JVM2cY#{m9@@8K0<$}eKN9z;xr5Tq38|tbs9D!6b|3e?jSqNlGh-)n`T0W7N=i= zyPG!93*jdE8~D&f4@HMy;X~0`(4SUb;N;OD1LTv>b@aXPfyg_`Ej`LUL})FAFc3IL zC1mc_s#XJS1^qgG74WO{4Zu3(+kpQ>-v#_MeIIaT?lsu{cjX1ZE8%|w{7~d4%P80B zn9d&lBb}ntu=X)&JrcVo{4!d9A*}~vC&M?;`kc@Ek@hQ8_bH$EqV{XF{?_Luqrb%p z@T|`>qHm)0oX=Yu4l5e{i_dEg*Q52K&wEx|r-bRc&wEbWjMfdGcZ7B*sQfm<@ks1Z zZ7*7Dy;k!NQMm{;OUsJ^mGmV!h6rV(<;4)8ywBqpqEzyE97B{Y`#g>zMvwSBjv+=L z_IVsb9eu**aSU~I)#p8{btv`p1)ukv)}ySVzxH_I=W6=qqSil1>m{WWjo^v-1uSGl zFDV739jz})>k-jgLtpWEEV+haSnUEyo|Ou{hDG=7Lbg%Sx~wpM85Nnwte>Yk`e9h1 zM!*Pd2CSzJz;)CE*h~Wg69SJ5JSET&m=$;y@HTo7FhU;%+)2*^?xueg%B#e&yhR^7 z(V8(oK1d%1d_VmeC_h)4VMh&r0x*Gob-F-rs5(7NZJ}*+MxaB5&|UNd@Hl2+Nr}^X z)Azw1Nh zUKji&A2Nj$&Vb@Wrqn5%2VE%Je8}{>gx)Wd0fqe>@Nwo22_+#iQ$o)OB`cIGf?pB* zx^jWKLe~|}KdIciF0fzVl)wdnR|S4Y;B|o%5_y4FLyxfqjo~1jr-$fqtVIge96TWD zJz+dZ=_lHKfM)avU`zNo;6H080gurn;ODeiz?CKQiVBNJ5iYojr(76#7^jN0B?>%> zQ$>Gu!0T|T*f^{Lz6z&`@wowhEYjW|_m!st?Ptp~n=HUi&>Q^k{X6Yxzq zRcgk}Q*doYuiY4d8r?&?&~qQ~F!clP#cn`b;F()}bn>na`l?TS0<(uvjv_d|MBO!L zAE`kb!V{Y9DOL9F<%j`P^YMS2S(3PG-$>LxyV%Wz%lf zDj4=Wh`pm$rj#@LXvTCW0|}}&OQYGeZ8_Go8y|3rW2QT3*=BrnE-fnK=Gl_zxQUFk zlC##i3Z<93?>jR&dB{kg!9HyyYvwZ4d%~_ke5Yd-mW#qUGdFy`Xq%1$myg-jTsC9c z%LNCme9N#e>P2}xqFk-rk+D1yA@*K7RF?zRExn@ zjlz6I!yml^#bPd-mOhRdwmV{^UCXW#^9QM@yV+DWmvyVSb4IRolYusF7BD|B*KRh( z4_l7QBL1ux${I5TCZ(OY6hWr)gyEd2ZG;E3H(3$|*R%^p&KsjgFiveWcqNgEOT)Hp z*&dp<3N9jb;=IN<@l4K>;}wD&CU(X?uUvgBgNVger~8>fYf7G7P0EmJSe;uS;3wl_xxIXK^eFN`jP z&jaqG45$T~LE8qsk17V@&}|d#K5Vo+OZ(r3r2*L0#jfX&4!3ywT@n{f^sLi4*w2dV zIu*t7G&I=Dtazp4b;J@49bA*n0%yL94+@@l`{6Tt$Cr}TVUy2ZSo7!sCAjyBHhaWT z_tE$wt2!lU2-`un&An9Q*k&498OZk$-N_P_HuqlXp{?9I{qcN|x=yGKL3s{W4u*=9 z2Ub8QI*s~RPv&6N3%KH01~do# z@!**Urb_}`w7jx$5xG>;@WVz#27Ji^=h7RL0#=d;0}pwa1;c@9EWdnU#QpdyiCkXL zrLj)&4lU6ldH zAEb+GQaw}>(i`h=zIcE;;tA)3v&wx{=RcSf4kYmu0*|xJBWmR;OiRA=kl-oL)2k?2 zTqCZhH-gw6$5;Z5Ys9`+dpd$>ZSXm2_BRKdr$P!EGdMlZ_JUfSwg1hLnL_q;@z#}i zcsj4#-vGWJ9K-k3Vf@ZBh~I?9flcBX!@Eubt)sw3r9Dw|@^e(R=EodzVI%rroCNt? zIy!5Q%H=b$I_EqpxF+7X;5ld4h}0W<%V&&&N5ihycXe(){J_!Af1veS^r+KFKpGpPdPr&7*wDb_h6oxB4GqE>X4te*;5@_I)X2uBg^wyNT2yIThflDL3lB!y z6-8OM6(8t9(sXLdhXEG;T;Su7KdUqupsy!Z+Q4EPBGFJxZMqcJRi&W?j;Oe#OVFZf ztm#thnR_SS-}vMDdty(0W4`;YpFTYmiZqSlI*#iEu2WH1elILX<6gRs6$_-(?Er=3~e^wO9@+iIGr-mk0M9P0N*{iQ;R76LXUvXNx?_L4kv6CA?l3wJws*H5I8eK`qk$R2FpaxY znFC#>(RHAw=U{hF`r!WQ&bvFiy3MZi!Oo6U`~I%!p6;8LR=kXz`J;zO89m0H7I0m} zF6W{yECC$MdR%wn`UQBu(1BDP@{?XwdptRm{9xj7=f7Tmap1H1-?e=0;a@(+Hrh@& zc*$Q}Qg3ow4Od@WZ*s znZ)Onpc=wTd-_V~rBBpI!EzuXQ?BmM|{U97V-QRyz!k=<@>gtm`D!%#wODI zbnJTU*RH7_-7FVjjX7_TA)a2h=-0XhZ)O-KE&6UTZ6c>9+iIJ8U1XI>QJG?_+e@o+ zvNsn7mB~#q3Jmp};D7kkRLnjMjqT#fVA44n9&`?u!DeBWYU*ohY3ONcYw0X8(9}^| zW^bTx;J9p=z3x&6sw35Yi4I*`cd7OgEqh&EeJ#2+RnNddOKXW1hDl{Pxl^6!7~DJz z+m**~VR%z{kkNr|@9w1G%5>*qIPNU)0bQuEC7K2rTsp^tK?BB(G`d7nSIyC2nZ7<~ zf~G@vr0Y?&bo8|J3>+QkT2z{&p3V|IJ$&>a~pI%b^}7H6Vv zY+__XP^Xxz!&z9FU@a|${#?3k3FbV;IDpKcaoAk8BTo~{b*0dGI5vl_i3O56vN=w4 z&Q47SCYYUKQ==AN!=zy_LFAOYtQ9zs5Gb# zu7Iw~LuDVNQz361Kj(M@@n{=Xu__9$@HccgHhTwyjxu$;pWFbM+%9H38hu~NC`dAP zfBwdn>3_!r`pWNL+L6HX7+(zL>>0^@^Knw-)Jt+dU#V3u_!}BNgSkU!IM68O;_s6Y z&hHy6V%BhIC0a{I{|$o$7HCW$$zlB6JlG-Q&hDPa+O-x3mBVMx_O3ZIA`hD*Fg5{! zr2CQgkRY33z67V|WmNRI?CWaVPpkiez>>{m(9j{L+J6p#DtTOM-zygL*&@&0XZFH} zDRm-wa9}F2Szyq)ny@cJWm;!(@HgaQ@32s)-1p5W**?)Z?c$-%|Kj4S_PmgahM&N?8X3zl3uNapA zRTBNrm(sM#DC3ksjeS`v$8tu%b5K>j`TFr3G%z-;fQ)VKq~yv^(btSS=^+}&+3Ct- zJ8`J4&O0@UEFPW1qA~@_h|tS_3Og{rYn8OBY`#U(!lc_R?O*o)H<3Agr!k$w@ZdWb zzLn%(UHlGq=a%c7aipb=rZL1*_X|R1dW&Q;rt+wk95#=yUQsUU-+QHRAl-y6?ME!^ zIkOYv-!gUYd{p}zI=(=a(~5lISicIMDfyIwG0$$FMV0y@e)w+~OuTq>7F?51r8h*k z2SRZi;sZ5?T&Y4czfp)9jX<`i& zCG36)W$~MPh6h(vGbT=#3lho2Z+>Cn%GVHLZu;nxYU*d>lzoMtZodE4D-vP~w18(Y zf!V<&mQPT+g>@Jb94`w@J#_q=dCbH>XT$E(_eLauP!Vc8aF^5p^>F^QU)8?p48sT< zov0oo-TFr!z6eH{tIi^e#nuU%nUD4x?%Q+7>RjvLCx3(rT#*P#!i*iGVUG?yZcP{~ zWkK*W`Ci`YMQRgG$8%wd>W;?mCkG+Ptg5jmCpB*)_%2W`Z(!<-AAyADDvD(KLQEiZ z)dl!}dwSkz6Asp2!o10$pB$M4#~yHUU=?v;vjoF*e}Ydkl&6liD`9*y(JZXIN2xx1 zv*_t#$^-HUQ}OkD+utY-4$*`MeN$%!x#Gh~Z;I7-UN;?C96rv>bbJ9EpRLo5IaY_3 zQ})Sy`+>jEv0`N0unF5r@@R%lZ$BN-Ios+GKEmLKZ^@_gqStXmd_0}XbLaF&HU^_H z`H7E3r@+Ir)*oOgwIx$ z9+7}MXn8pCGXhyL7g_3vbHi^Nm%W}}JC`J{ED}z1fB_#5jU8Oo_r*fl(_Ot*KRn__ z2&!FB*~AtTy|j?nG%9m&45Jz6_MnNH4x4X(yn`_m!*IuFUw1d3V&sQ^F2>Cha9d96E9aL2*S~rV;;FC z9*U7gU30tia5k>&?L4E()ZghNQXmmL-;6K0l@?;sMq$1mCOaqpa5u{>-+WpVdq=bl z!Y%+T>X|3qJ(UgH)lt@c_c`eSvB2fCqel2|(NhOv;gX7FvDiFhQATN!ri7&;Gcd>} z=i->xl)Q;IWPO(P1&$~_U-A&mJ)dFg%MI72UR3lktx8$ZXQn;w^N27Q>rr{Y&vP}+ zxcxpvv-xKlq=`u|IBEAg!Z7jPk>@*=}RB&6stXx|L*gN7Kmjr;W1iiLy}^9X9^QikM+4C|;)rgWw& z)F;0KS7q#eLm4W!HX4~uuA&6Hm7dsf*PSsU!+HkYbBIf`iPwFJc_N0f^6+I=gsQXa4}S;-~9^-tXg;AAp8LdwezdzKWf>zgBrhVzi@ZUus3? zf@FwG$5Cm{Bg77u${mror~Sp_hk-ml^U|C*KdR;x&Jiup5I+8ZG%j0T0{b*MqcZin zV;(toPKB)Q#+7gWOabyVu*AT~QqVKQQ^}to&7q?*XHv~I3=dUNDoUomG#-J*lf&Sl zNwaCO^g*~v-lQygqa(eBlyD)v(fMPdifE|7F^dRa9?%+&Lgl6gVRdL#J?6#AmmloP zGu8Sd4_^t(t*ry0MXXGp*^{VjLp&58Agk7!nIRG?2%z9%YrPY-Yn}Y25R9T2W`>4Q z!<4lZ_jaB2WR7obVf0zDc=`8D+KKWG)#m* zP6SIL0;14y1?5l&b*a|-g6+N1w_fKM&(?MZ{&V*hY9TJW+rxlh>A8aFb zFWIu3uy5t5PWry3;eSKJ*XZm$t`DFfwcF;nE1g#-9g$x18T(M0_%{seI8+ueeGX64 znoZk52gLwB=ll!_B$R2m9K)cM_~5JXZH-hZanWmu^&s=y9`X4k6lZK^q{C5TH&XbF zBCGwN&m=yKlos!c$?L@*s*<`RCt$aj7N>aHsEgRP))tbfns0XQK)pAEd+wd4n z25+EPsGhHy3|l{6)u0ma_AdF9M)^%cCrZZv9%t=L<+uvWHh%l^TTtl{jrE?VrZ22HyTANed!?fp zO0xd*!3vFx*(CpEaUWR426dtt*epkele@sZi14?yWz%z@JjbdVaVD#$8D|*n9DQk` zm-Sz;88KK6{h?`DeI`{P{DqW67DJ#b@hKg5Ac_ArwU^q99}vpz-QIi0mUaIH ziBNFdS1=zj?^oV|y*?rKgo2Z1h92!*(w$;|wep5$l*;kWBY=&ovv1PUBSl{NN2G&qMx#Y#?a2N)XF{ zB*ofF{z-CnM#0;jN984Mau7*kOn0RN!)DQT5?R|vt_c>64-1ABy&e^%bXWUlq-xKn zP9?ZWm;RcQZv(iM3vOZT#4vUjw(E?N*Tfd2&y`@BofnFmgv`cRsFpXVfF@#MYsq@& z!ahsKzipb7+d_(6?t1isZCIRW`9>n<3z@R`0>VWXn-J7`jfaoRbXby-xi3p37qkSh zZh3&}14tM|NcOz@5|YrDsCZi$YTq_4e0F5Zr<4x$zhFbQ7PtdZr`!)e#5z*^$6%Y4 z{RvTzT2}m8Uxxb&Diarbx`PAVL145~J_koZb%c0`k&kwsGJ%m64zfW z5(-=c+IkCNdTAQWX%!E#H9m4=OGL!U?+5=(V9f)eFB)aGY~OPfE&w-Anh_GF1{fyI z%U4*W*B}%l2~Dd(DY^)QeN#(EN~$tyUz1mclwpf^#4nTA=|~nS&mc0sLe#?D>!BiJ z3OVEDy7F*Gtc<1fe%0xWfOm2lVJuS>Yo9~Cyl;LKPM9;z+^;9qWl9-as46?CQ+ys! z2o;I|_yT$OzUhYAv18c2x?}2Q5j3Xr<^9M6p~y=#5trTX>u46^*}VGWtyOJ@?uzzbAipqS(LkB0zsO~Ac~=vZyFFo5!NdnehR3!x6Ytg? ze?HK-8Irqm*r?+pQLZ2eir7-ekB+j~kno7-wM83+d^R{#p^4P@!Rjs4)ab==$Ygr@ z&}!FnoP_b=GXFEK1(RItzpr}!q#@n@idZU*X|Y5O#Xl=r-^o!YQb zCeBxu3f8Mm~U^Gn0O#^x?KDb7cPy>VKUI& zaMk!r(J(D-T2L>sV%JY{N{ge*lVqt77KjCTAU&XR(4~6fTfc{x^J17uT>6)3_&G*r zmsLrXaea~~bWa|zYYVs6a3HhZO4rFy{xF%kTjdfUv)u|-4)CP z9^H#4@JpR`6+hsx>nx02eH*W66#3gIbd1EjHo^Ty?v9QFHXFflsg^xf-x&6Jr zcBSdn9c}-J#*219zdDny!4dVivgCS<4Z$KyMVv6_QHQ5!4!*9l${xLk7+s88Y|N;) z*h+`SfY&}x!bD?`wFOL0x&xNGlZ7e{vtbI7#bRuo-gE`3k%C^lkGymz-(EDwu<2&+ z*^Lxq7fc&nHa!oAjd2SyVeC@Z77bsw)0GZP3~c*>eGkFN-HfMHV$#GgqyKSL(hIp_ z82Z@vYu&tNgMNnLk-@v9*euxZ%lh++lX4r(!lT1xN3_U&AAktO0H?cMi=btUnXkU< z(YzOi$zI2wOA&OY_ut%KH`558hSaBv#vH)BSAA)mawSm;=a9Wca3>tM!G$`j2VN~0 zLvc)2Q_9ozC0@qG3nN+*x8BVW20)ZGohP&q@yD+GwqFqJ!w!%4u8V(9B`2z>2IziM zKQD~s-^sY5oCZ6PX(yTXNj%CZYC}``LmyXk`UXDHdsr$!8T_ytPAR6UxH|C|FeK!OD%zX}!=|&?H3@|qGYq3PFRY{5keoyyVGg$* zxH%9h5Lu3Ffjw#T5W``g?b^D6)3JRfm0u1&x$J-6Rs;b^0Krxbs;m&L@JOiV8QBsE zi`O=povYkZD5t&rn+Tvak4oEt1W1BLWh7^$L#$u4M4<}_LpnX%Etc~j5%u2#TH_uS1SGHuK~E+i`dDxgQGI0cwSUi~O(Dk4cWUW+bp;B#Q;R=paw0LVArsfJ>iaP{{Jm)ZZ%W?Mp5@j;s{ocXCJJBR8y z!1&_8RHT;wc6x(x&+~5LapN=c8MHH5Lv9}ChLp-ojzX)E3>jN8(KrcTGfx~wB$%%W`=1_2jF}{P%k{qeX@b96?tAa~&tyeHhB=G{ zcFsudf1@;d*T=wOnPLAXnLuu0K9jSYsF8oRu!1CMJvH!~r zc%ON(=fc$OwWi0dZ?8)2`C2z{-!QT2u*p}U#a<9I6_46{#PCq&;-kHfB~XtIG$8~r z2IuwYLZ0P#?=K|Xn1AWH7xwiHa_Wz!rN;{!O+~gh%tWVtABQYjDV#EWhXp?PW8xw1 zcE?-LDLT064OAY@x!)!#q z3!KSa#=~2%w^w~NpIq`XGLEpFnlx?mX#W9$`89ho)zy{m0DF%5lhe97P!G?nB~;R?omXwLMMbq(kQ{)0;@B;{q~51bR2U zB?eK(x)*P5)g~$vs+X#|KULppGr(`d0_Aql6$ieE)?nX|>LTcuk8TH&7HjtI$TAGB zG)ww)rSjR0%Z36psL{I#?qtg2-$D)4;hJKN6{nl|P4Uw=_+Fqcd?z@*BG_O?rJHJ& zeHR9z4PGkSH^1^C?|ZyMVd1vbAB9ntR1Ouy&1iNT+jz7KIw09Ck~N7x-jS23JF1Dr zCLY3&weH|}x=_4(Qhn_UC|sYe%|x=JGd}uulf&W1p+^OnLHj9_v)6RMu$p>Ur)9&k ze8Vi8#VzdgIU5A`!jz3aDO?B_kSg-(h-sOu!+5ZFv`6smuNnQeLtInK4-%coi8 z@o}Tmtkny6IdQ#0tpKbio3jJXQFxeU0DJwTX(}9!%o#dcFJzv^9kQL}BBK`zchNx= zQxmpnIk4*d*7m#)tv&WjU{jk{G9misn1_AF-_V=|xqE2d{;pd018m{IhNN*v%i>7| zkJYussp%m?Em+ar+`)!7YE>6Q=OK|zU+9M!+UF}?fZ zm2JLpGT~6_!g@O*=Z27E0K%^y4CI#r6CINqf^5B*6)$>oD=n1}FLS26ymTyeFc<`9 zUZ^4-+&F&|cIjExRZ<-}!8q{wspYkjb>4#!Xs-rII%Rema!f%_&0%78nY_udgO9g} zeYu8u8bRk!D1TNoZxlx~=yRhe>5Fy`skHmV!+OWEQD}4SE->>%$F;OI0SP#Ny`9&R zHRfN_qH$!hr_$Zlp?9wbN%p{LwX>CiS!0g7Kf<0qVa zp(2mpKu!dC5NDnYm6kJ1F_x`TP5pwpWGlL(AdA;DW^i5M`XQ{r>OD+~PCxqs=Mz%^ojt@7PUEWyC;vW#p) za{oY5hL>`!VY-;)TYr@=3r7GENk|SaJa5m(Uw8z?Tq;{Sh>^YFY^-fEO*biS z_U+aj-6sM%e9X3BndP(Q=_a8{iS0dHFEn)*((SOI;C*-k5<$;*JGtVQ zl$&{o!7hCtY%Q8{3PEA&JS--p>_|w2>N@r9g4Wnc|C;7IyNuqy^`2ROZ@EYrn5$`p zRPqEmN;che8KQK~v2-KbEXgJ9UG}!M&>Yv1#t-2Ulp9AvteI)X67V}t7JnpamJ8;wm-&#JhYgMA^66m0iD42h zek$)d8e($xoZGsWGh9#)iT2kN6b%Q$uIM)V4%ok_k1^Hi`|F7T)7PirBG?Q{09WM9!?AZKA7NHWd(lx2C zP{lL86kU|rsYc0`JB(Sp?Qqo}@xvU_)2(abAq(|qWiftophaB7OPO!hhtQQ49o4~V z7&yZa+MN{uSG7se*5Qjida$XA@p|HW4x_1Ce|&?b!NLntuIk?)D)KP@3bD3*?{t1W zvmyG@s3#Wd{#-5SKtC48q%!)Sl54e^eGP)ndN7I6$#rG{i_$!gEWhkG3?%$i7nbP+ zp7-N9_p=yeulogAl(FM(wKm9@7W(V^1go~9f!09N!YsJ{=X2gP96thwPA*jGqt$9{ zvw-92mC{R8(EMx!I2YZK**oqmGV=O zIeCFp`iUCs(xIa8Cr`V+N-8v4yo=dWGt6D{f-|2EJylNGJ@jsH2FQhh941CR4D&$6 zbLe5n?e9LHn}5&rsHEL$;15kA3R?-heoEi!v<*!NTilM-w# zpI{ElqIut7Fn<^q+%-ZfKXVim#+BHX7?o;Hbjc(UQKb%s3|n&7Z?Lb2(pntMwU90J z!=1cj;G7?DYl5JMgV0=<(g-wj?%x8W{<*9Bt!9%l+t6P{$I`oQCc1}#;Dj8lVyg_2 z`8}O65%+DX4KYsNQ?*QKcAs!FV0Y1-N#zVLEo^LyZ-Hi=6fNDYoStYF>EOHj&C*mR z3U&r%4hJ~YIA))h~lsqmp(i=YANWq1B+h)qX{JLuxj;~0+Ood$7%rXUC zBT0jwCV4#@KKL(Pfd)$J`kR4|U@?*Mk3bnO<*kw2=R9-Ceg{WyqavA4mu4G$>mP!C z_cD&?AIPT`nyN*l<+>ejkX&g{hCV6=T{E*5G&-4KD z*bqlG5FZu$m~ixD#$N5Nvo*ufNY@1&oiefVJCs?XRD*gVUV)UY@}&IOYh|=JF`!`n zUqa^~Y9w$-fhJ>9PR3@xy|@hJPOr|rYZni14}A9m8q>U2Q$QAXN;lQ^?p`@;#KPmD z%?-?46aS zc9*It>wEDP-#6E26LNM6T3SzKy3^OWyY_F|ZfjP32iy5Rb8?P>YLi*k!pOE+B)u%b z{R6X%@@NOL!TGh%xwNaZ*XYy**O-#uThRmn-Utg*{1eb<;(y*@8&WFJsLU%U^}T=% z+x>gl9uG!XOl*NHwkFfPKmN_ZX-)Du`~7O>wB z(|76|YE!V=;2HwDo@F2tUR)2JMcj*m;b}LHH{M{>q2HD&Vgs z_^Si_!cTy|bR^;FX6^*|XrePrr&&(mxQaAt1>CWk;LBMwfZft~lE`8|&V<7OkNwfO z&fqES8H<5I;T^%n1lKNb`GYG0Tyc{X#Mf_;4?Taw?$OK(il;ufW!U-J7>vSz$5i0% z;4BHrnIM41$dB742fv0#Onfi+P98bTGzroy_$nr$3*Jw{VC2D0KL7iOFjBL`#P{W6 zMzQU;OCsCX<5_ebIIcqn>)BGxCG*g}Ya$QUt)qgkhv8wlT)K-r6P%g`8^$!Qk|==* z^5-#xS>RFvmzLtUc@NJ#D80bCqOyM0%h5fBYp*nA&k9{#y}$caZO2@-O_B(`{5Gg} zA~-3+0To}qIy9ZYAB+C8iFm$_2q}t>Ru)fv_GxF5wBPAQO?^LtXXveM?=_xJ?`m4z zxL}XOMLA(*|KHe6M=4gH#lI_K?2g&pty5Y1;V`eKxBYw3*@-@nAgv2dk233jhEB literal 0 HcmV?d00001 diff --git a/obj/Debug/netcoreapp3.1/contacts.assets.cache b/obj/Debug/netcoreapp3.1/contacts.assets.cache new file mode 100644 index 0000000000000000000000000000000000000000..38cae32d8615b92feb6744c3329ff555838f4f3c GIT binary patch literal 11521 zcmdT~-ES0C6feq$wE{{-5l~v7rR8H53WWj+ENyLyr8X)0VtknH-fjoCGn1WZwc*K# z;lacQjT#eQOne|A;Z6Sp6Q6wZ5AfX={{qix@9CVmdv^EEPHmP=ZrVM2&b`0iz2|=Y zX6D|TD!$m&)%EeC-~RmR-s*!t9`=6y@Rz3t?+*O^*gbrt=gGg;wDD+ia3Tn#n zgR+9)Rj&jd7o7{vSfT1I6!gz-7=o>EcQdjWg|jLi$H-ZToY#>~xmw+&A?<*_&p~+} z%1$U~-wg%rd!V5Gi#(8{&}|R#eCSGmUjRTHa5sEMz-TAHKW-6VM|~D6Kk@=UV{dcp zlbdz$e#g||G(LXoX%(`0#CP?K$FCZV%IObwepB_ zo~@%Svm`o=^6OQD+d<6@?ZhqDbXoMODy#*o9^_Tjgca@`b(;et^)A#iw^>gkIE)okgOrZT7N;2C$wpz(&Lfp((tO`eQH8qr!5tK~{H zSb$kyNmFQ({UQ5uBedz=6OSq01IuS7sB>JK)LjoYr{Gz+b#uorQw=i+03= zcKYCb>yUVJD~2IC;o+!XbmG@L^zIYA*tGa_k@N|}B*OZX^-(&8P9=!$l!&hW1c1IrMPI%C zql4Uwv_Y6qPdBTseppYoa>wPnF-*Pepu;7xrWWfG1|Aawlf?ji_8SutZ8*6G?Iu3D zIzqxBBKVgRkt7_6$VG_De!*b!8PlTv z2Wf}s*+@GQy-Pr^VMf7YWD2d*6px24g6!Ef=rX*f(1Ft+6`D#wdityV=RucYq0Dq@SS;Wmo%96O< z0B#*CaS^#b0Lf33{qP-c+GwYnzeMgP{N7R07ZE~Bs+kk$yNjkG4=oB*8s zGYMbz&8|$Tcy8mxi|KM}fvuMZds37c%I zAzlMAl9jh~s~h^|&9>T0p8Q*DpEoQU5@b_k)ShfQqZ{Q4xhUF6t(u)G4`o_QRsnjlDG!4_KiLigJ8re5q~Ec`Pwk{uF_zTOU#$fB zQOl+h2_Hwnl<;?NJbfD!GRYA8F}k}LMJm3x7OFipe7$m6b&m((+DriNlI)CYE9$_6 zir}rw^%vvjR~B%~9!Sv5&OY1aLebw681SJzmFRx|{>r>W8=@?p)kvKce82<=vdQ)5;;kq$vt8$Ha!oA=NPB34tfX!1Rpl73SH0rfT5M literal 0 HcmV?d00001 diff --git a/obj/Debug/netcoreapp3.1/contacts.csproj.CopyComplete b/obj/Debug/netcoreapp3.1/contacts.csproj.CopyComplete new file mode 100644 index 0000000..e69de29 diff --git a/obj/Debug/netcoreapp3.1/contacts.csproj.CoreCompileInputs.cache b/obj/Debug/netcoreapp3.1/contacts.csproj.CoreCompileInputs.cache new file mode 100644 index 0000000..29c5f8a --- /dev/null +++ b/obj/Debug/netcoreapp3.1/contacts.csproj.CoreCompileInputs.cache @@ -0,0 +1 @@ +41448f36a4b4298880db006de5b61d1f24715179 diff --git a/obj/Debug/netcoreapp3.1/contacts.csproj.FileListAbsolute.txt b/obj/Debug/netcoreapp3.1/contacts.csproj.FileListAbsolute.txt new file mode 100644 index 0000000..d35ec38 --- /dev/null +++ b/obj/Debug/netcoreapp3.1/contacts.csproj.FileListAbsolute.txt @@ -0,0 +1,102 @@ +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/appsettings.Development.json +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/appsettings.json +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/Properties/launchSettings.json +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/contacts.deps.json +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/contacts.runtimeconfig.json +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/contacts.runtimeconfig.dev.json +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/contacts.dll +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/contacts.pdb +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/contacts.Views.dll +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/contacts.Views.pdb +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/Microsoft.AspNetCore.NodeServices.dll +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/Microsoft.AspNetCore.SpaServices.dll +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/Microsoft.AspNetCore.SpaServices.Extensions.dll +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Configuration.dll +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Configuration.Abstractions.dll +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Configuration.Binder.dll +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/Microsoft.Extensions.DependencyInjection.dll +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/Microsoft.Extensions.DependencyInjection.Abstractions.dll +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/Microsoft.Extensions.FileProviders.Abstractions.dll +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/Microsoft.Extensions.FileProviders.Physical.dll +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/Microsoft.Extensions.FileSystemGlobbing.dll +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Logging.dll +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Logging.Abstractions.dll +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Logging.Configuration.dll +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Logging.Console.dll +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Options.dll +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Options.ConfigurationExtensions.dll +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Primitives.dll +/Users/matthuntington/Downloads/contacts/bin/Debug/netcoreapp3.1/Newtonsoft.Json.dll +/Users/matthuntington/Downloads/contacts/obj/Debug/netcoreapp3.1/contacts.csprojAssemblyReference.cache +/Users/matthuntington/Downloads/contacts/obj/Debug/netcoreapp3.1/contacts.AssemblyInfoInputs.cache +/Users/matthuntington/Downloads/contacts/obj/Debug/netcoreapp3.1/contacts.AssemblyInfo.cs +/Users/matthuntington/Downloads/contacts/obj/Debug/netcoreapp3.1/contacts.csproj.CoreCompileInputs.cache +/Users/matthuntington/Downloads/contacts/obj/Debug/netcoreapp3.1/contacts.MvcApplicationPartsAssemblyInfo.cs +/Users/matthuntington/Downloads/contacts/obj/Debug/netcoreapp3.1/contacts.MvcApplicationPartsAssemblyInfo.cache +/Users/matthuntington/Downloads/contacts/obj/Debug/netcoreapp3.1/contacts.RazorAssemblyInfo.cache +/Users/matthuntington/Downloads/contacts/obj/Debug/netcoreapp3.1/contacts.RazorAssemblyInfo.cs +/Users/matthuntington/Downloads/contacts/obj/Debug/netcoreapp3.1/contacts.TagHelpers.input.cache +/Users/matthuntington/Downloads/contacts/obj/Debug/netcoreapp3.1/contacts.TagHelpers.output.cache +/Users/matthuntington/Downloads/contacts/obj/Debug/netcoreapp3.1/contacts.RazorCoreGenerate.cache +/Users/matthuntington/Downloads/contacts/obj/Debug/netcoreapp3.1/Razor/Pages/Error.cshtml.g.cs +/Users/matthuntington/Downloads/contacts/obj/Debug/netcoreapp3.1/Razor/Pages/_ViewImports.cshtml.g.cs +/Users/matthuntington/Downloads/contacts/obj/Debug/netcoreapp3.1/contacts.RazorTargetAssemblyInfo.cache +/Users/matthuntington/Downloads/contacts/obj/Debug/netcoreapp3.1/contacts.RazorTargetAssemblyInfo.cs +/Users/matthuntington/Downloads/contacts/obj/Debug/netcoreapp3.1/contacts.Views.pdb +/Users/matthuntington/Downloads/contacts/obj/Debug/netcoreapp3.1/contacts.csproj.CopyComplete +/Users/matthuntington/Downloads/contacts/obj/Debug/netcoreapp3.1/staticwebassets/contacts.StaticWebAssets.Manifest.cache +/Users/matthuntington/Downloads/contacts/obj/Debug/netcoreapp3.1/staticwebassets/contacts.StaticWebAssets.xml +/Users/matthuntington/Downloads/contacts/obj/Debug/netcoreapp3.1/contacts.dll +/Users/matthuntington/Downloads/contacts/obj/Debug/netcoreapp3.1/contacts.pdb +/Users/matthuntington/Downloads/contacts/obj/Debug/netcoreapp3.1/contacts.genruntimeconfig.cache +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/appsettings.Development.json +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/appsettings.json +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/Properties/launchSettings.json +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/contacts.deps.json +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/contacts.runtimeconfig.json +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/contacts.runtimeconfig.dev.json +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/contacts.dll +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/contacts.pdb +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/contacts.Views.dll +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/contacts.Views.pdb +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/Microsoft.AspNetCore.NodeServices.dll +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/Microsoft.AspNetCore.SpaServices.dll +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/Microsoft.AspNetCore.SpaServices.Extensions.dll +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Configuration.dll +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Configuration.Abstractions.dll +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Configuration.Binder.dll +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/Microsoft.Extensions.DependencyInjection.dll +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/Microsoft.Extensions.DependencyInjection.Abstractions.dll +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/Microsoft.Extensions.FileProviders.Abstractions.dll +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/Microsoft.Extensions.FileProviders.Physical.dll +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/Microsoft.Extensions.FileSystemGlobbing.dll +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Logging.dll +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Logging.Abstractions.dll +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Logging.Configuration.dll +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Logging.Console.dll +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Options.dll +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Options.ConfigurationExtensions.dll +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/Microsoft.Extensions.Primitives.dll +/Users/matthuntington/Documents/.NET-React/bin/Debug/netcoreapp3.1/Newtonsoft.Json.dll +/Users/matthuntington/Documents/.NET-React/obj/Debug/netcoreapp3.1/contacts.csprojAssemblyReference.cache +/Users/matthuntington/Documents/.NET-React/obj/Debug/netcoreapp3.1/contacts.AssemblyInfoInputs.cache +/Users/matthuntington/Documents/.NET-React/obj/Debug/netcoreapp3.1/contacts.AssemblyInfo.cs +/Users/matthuntington/Documents/.NET-React/obj/Debug/netcoreapp3.1/contacts.csproj.CoreCompileInputs.cache +/Users/matthuntington/Documents/.NET-React/obj/Debug/netcoreapp3.1/contacts.MvcApplicationPartsAssemblyInfo.cs +/Users/matthuntington/Documents/.NET-React/obj/Debug/netcoreapp3.1/contacts.MvcApplicationPartsAssemblyInfo.cache +/Users/matthuntington/Documents/.NET-React/obj/Debug/netcoreapp3.1/contacts.RazorAssemblyInfo.cache +/Users/matthuntington/Documents/.NET-React/obj/Debug/netcoreapp3.1/contacts.RazorAssemblyInfo.cs +/Users/matthuntington/Documents/.NET-React/obj/Debug/netcoreapp3.1/contacts.TagHelpers.input.cache +/Users/matthuntington/Documents/.NET-React/obj/Debug/netcoreapp3.1/contacts.TagHelpers.output.cache +/Users/matthuntington/Documents/.NET-React/obj/Debug/netcoreapp3.1/contacts.RazorCoreGenerate.cache +/Users/matthuntington/Documents/.NET-React/obj/Debug/netcoreapp3.1/Razor/Pages/Error.cshtml.g.cs +/Users/matthuntington/Documents/.NET-React/obj/Debug/netcoreapp3.1/Razor/Pages/_ViewImports.cshtml.g.cs +/Users/matthuntington/Documents/.NET-React/obj/Debug/netcoreapp3.1/contacts.RazorTargetAssemblyInfo.cache +/Users/matthuntington/Documents/.NET-React/obj/Debug/netcoreapp3.1/contacts.RazorTargetAssemblyInfo.cs +/Users/matthuntington/Documents/.NET-React/obj/Debug/netcoreapp3.1/contacts.Views.pdb +/Users/matthuntington/Documents/.NET-React/obj/Debug/netcoreapp3.1/contacts.csproj.CopyComplete +/Users/matthuntington/Documents/.NET-React/obj/Debug/netcoreapp3.1/staticwebassets/contacts.StaticWebAssets.Manifest.cache +/Users/matthuntington/Documents/.NET-React/obj/Debug/netcoreapp3.1/staticwebassets/contacts.StaticWebAssets.xml +/Users/matthuntington/Documents/.NET-React/obj/Debug/netcoreapp3.1/contacts.dll +/Users/matthuntington/Documents/.NET-React/obj/Debug/netcoreapp3.1/contacts.pdb +/Users/matthuntington/Documents/.NET-React/obj/Debug/netcoreapp3.1/contacts.genruntimeconfig.cache diff --git a/obj/Debug/netcoreapp3.1/contacts.csprojAssemblyReference.cache b/obj/Debug/netcoreapp3.1/contacts.csprojAssemblyReference.cache new file mode 100644 index 0000000000000000000000000000000000000000..9432b1daeb4dc5fecb2c8db2e7d0c611b7303d42 GIT binary patch literal 164929 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 UA8P-}$>QdzXDJ=AZZJpw2mZdWWdHyG literal 0 HcmV?d00001 diff --git a/obj/Debug/netcoreapp3.1/staticwebassets/contacts.StaticWebAssets.Manifest.cache b/obj/Debug/netcoreapp3.1/staticwebassets/contacts.StaticWebAssets.Manifest.cache new file mode 100644 index 0000000..e69de29 diff --git a/obj/Debug/netcoreapp3.1/staticwebassets/contacts.StaticWebAssets.xml b/obj/Debug/netcoreapp3.1/staticwebassets/contacts.StaticWebAssets.xml new file mode 100644 index 0000000..7b21d22 --- /dev/null +++ b/obj/Debug/netcoreapp3.1/staticwebassets/contacts.StaticWebAssets.xml @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/obj/contacts.csproj.nuget.dgspec.json b/obj/contacts.csproj.nuget.dgspec.json new file mode 100644 index 0000000..e520ef6 --- /dev/null +++ b/obj/contacts.csproj.nuget.dgspec.json @@ -0,0 +1,67 @@ +{ + "format": 1, + "restore": { + "/Users/matthuntington/Documents/.NET-React/contacts.csproj": {} + }, + "projects": { + "/Users/matthuntington/Documents/.NET-React/contacts.csproj": { + "version": "1.0.0", + "restore": { + "projectUniqueName": "/Users/matthuntington/Documents/.NET-React/contacts.csproj", + "projectName": "contacts", + "projectPath": "/Users/matthuntington/Documents/.NET-React/contacts.csproj", + "packagesPath": "/Users/matthuntington/.nuget/packages/", + "outputPath": "/Users/matthuntington/Documents/.NET-React/obj/", + "projectStyle": "PackageReference", + "configFilePaths": [ + "/Users/matthuntington/.nuget/NuGet/NuGet.Config" + ], + "originalTargetFrameworks": [ + "netcoreapp3.1" + ], + "sources": { + "https://api.nuget.org/v3/index.json": {} + }, + "frameworks": { + "netcoreapp3.1": { + "projectReferences": {} + } + }, + "warningProperties": { + "warnAsError": [ + "NU1605" + ] + } + }, + "frameworks": { + "netcoreapp3.1": { + "dependencies": { + "Microsoft.AspNetCore.SpaServices.Extensions": { + "target": "Package", + "version": "[3.1.8, )" + } + }, + "imports": [ + "net461", + "net462", + "net47", + "net471", + "net472", + "net48" + ], + "assetTargetFallback": true, + "warn": true, + "frameworkReferences": { + "Microsoft.AspNetCore.App": { + "privateAssets": "none" + }, + "Microsoft.NETCore.App": { + "privateAssets": "all" + } + }, + "runtimeIdentifierGraphPath": "/usr/local/share/dotnet/sdk/3.1.402/RuntimeIdentifierGraph.json" + } + } + } + } +} \ No newline at end of file diff --git a/obj/contacts.csproj.nuget.g.props b/obj/contacts.csproj.nuget.g.props new file mode 100644 index 0000000..89e02e6 --- /dev/null +++ b/obj/contacts.csproj.nuget.g.props @@ -0,0 +1,18 @@ + + + + True + NuGet + $(MSBuildThisFileDirectory)project.assets.json + /Users/matthuntington/.nuget/packages/ + /Users/matthuntington/.nuget/packages/ + PackageReference + 5.7.0 + + + + + + $(MSBuildAllProjects);$(MSBuildThisFileFullPath) + + \ No newline at end of file diff --git a/obj/contacts.csproj.nuget.g.targets b/obj/contacts.csproj.nuget.g.targets new file mode 100644 index 0000000..53cfaa1 --- /dev/null +++ b/obj/contacts.csproj.nuget.g.targets @@ -0,0 +1,6 @@ + + + + $(MSBuildAllProjects);$(MSBuildThisFileFullPath) + + \ No newline at end of file diff --git a/obj/project.assets.json b/obj/project.assets.json new file mode 100644 index 0000000..923e3b8 --- /dev/null +++ b/obj/project.assets.json @@ -0,0 +1,621 @@ +{ + "version": 3, + "targets": { + ".NETCoreApp,Version=v3.1": { + "Microsoft.AspNetCore.NodeServices/3.1.8": { + "type": "package", + "dependencies": { + "Microsoft.Extensions.Logging.Console": "3.1.8", + "Newtonsoft.Json": "12.0.2" + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.AspNetCore.NodeServices.dll": {} + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.AspNetCore.NodeServices.dll": {} + }, + "frameworkReferences": [ + "Microsoft.AspNetCore.App" + ] + }, + "Microsoft.AspNetCore.SpaServices/3.1.8": { + "type": "package", + "dependencies": { + "Microsoft.AspNetCore.NodeServices": "3.1.8" + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.AspNetCore.SpaServices.dll": {} + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.AspNetCore.SpaServices.dll": {} + }, + "frameworkReferences": [ + "Microsoft.AspNetCore.App" + ] + }, + "Microsoft.AspNetCore.SpaServices.Extensions/3.1.8": { + "type": "package", + "dependencies": { + "Microsoft.AspNetCore.SpaServices": "3.1.8", + "Microsoft.Extensions.FileProviders.Physical": "3.1.8" + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.AspNetCore.SpaServices.Extensions.dll": {} + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.AspNetCore.SpaServices.Extensions.dll": {} + }, + "frameworkReferences": [ + "Microsoft.AspNetCore.App" + ] + }, + "Microsoft.Extensions.Configuration/3.1.8": { + "type": "package", + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "3.1.8" + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.Extensions.Configuration.dll": {} + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.Extensions.Configuration.dll": {} + } + }, + "Microsoft.Extensions.Configuration.Abstractions/3.1.8": { + "type": "package", + "dependencies": { + "Microsoft.Extensions.Primitives": "3.1.8" + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.Extensions.Configuration.Abstractions.dll": {} + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.Extensions.Configuration.Abstractions.dll": {} + } + }, + "Microsoft.Extensions.Configuration.Binder/3.1.8": { + "type": "package", + "dependencies": { + "Microsoft.Extensions.Configuration": "3.1.8" + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.Extensions.Configuration.Binder.dll": {} + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.Extensions.Configuration.Binder.dll": {} + } + }, + "Microsoft.Extensions.DependencyInjection/3.1.8": { + "type": "package", + "dependencies": { + "Microsoft.Extensions.DependencyInjection.Abstractions": "3.1.8" + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.Extensions.DependencyInjection.dll": {} + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.Extensions.DependencyInjection.dll": {} + } + }, + "Microsoft.Extensions.DependencyInjection.Abstractions/3.1.8": { + "type": "package", + "compile": { + "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.Abstractions.dll": {} + }, + "runtime": { + "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.Abstractions.dll": {} + } + }, + "Microsoft.Extensions.FileProviders.Abstractions/3.1.8": { + "type": "package", + "dependencies": { + "Microsoft.Extensions.Primitives": "3.1.8" + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.Extensions.FileProviders.Abstractions.dll": {} + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.Extensions.FileProviders.Abstractions.dll": {} + } + }, + "Microsoft.Extensions.FileProviders.Physical/3.1.8": { + "type": "package", + "dependencies": { + "Microsoft.Extensions.FileProviders.Abstractions": "3.1.8", + "Microsoft.Extensions.FileSystemGlobbing": "3.1.8" + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.Extensions.FileProviders.Physical.dll": {} + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.Extensions.FileProviders.Physical.dll": {} + } + }, + "Microsoft.Extensions.FileSystemGlobbing/3.1.8": { + "type": "package", + "compile": { + "lib/netstandard2.0/Microsoft.Extensions.FileSystemGlobbing.dll": {} + }, + "runtime": { + "lib/netstandard2.0/Microsoft.Extensions.FileSystemGlobbing.dll": {} + } + }, + "Microsoft.Extensions.Logging/3.1.8": { + "type": "package", + "dependencies": { + "Microsoft.Extensions.Configuration.Binder": "3.1.8", + "Microsoft.Extensions.DependencyInjection": "3.1.8", + "Microsoft.Extensions.Logging.Abstractions": "3.1.8", + "Microsoft.Extensions.Options": "3.1.8" + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.Extensions.Logging.dll": {} + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.Extensions.Logging.dll": {} + } + }, + "Microsoft.Extensions.Logging.Abstractions/3.1.8": { + "type": "package", + "compile": { + "lib/netstandard2.0/Microsoft.Extensions.Logging.Abstractions.dll": {} + }, + "runtime": { + "lib/netstandard2.0/Microsoft.Extensions.Logging.Abstractions.dll": {} + } + }, + "Microsoft.Extensions.Logging.Configuration/3.1.8": { + "type": "package", + "dependencies": { + "Microsoft.Extensions.Logging": "3.1.8", + "Microsoft.Extensions.Options.ConfigurationExtensions": "3.1.8" + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.Extensions.Logging.Configuration.dll": {} + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.Extensions.Logging.Configuration.dll": {} + } + }, + "Microsoft.Extensions.Logging.Console/3.1.8": { + "type": "package", + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "3.1.8", + "Microsoft.Extensions.Logging": "3.1.8", + "Microsoft.Extensions.Logging.Configuration": "3.1.8" + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.Extensions.Logging.Console.dll": {} + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.Extensions.Logging.Console.dll": {} + } + }, + "Microsoft.Extensions.Options/3.1.8": { + "type": "package", + "dependencies": { + "Microsoft.Extensions.DependencyInjection.Abstractions": "3.1.8", + "Microsoft.Extensions.Primitives": "3.1.8" + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.Extensions.Options.dll": {} + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.Extensions.Options.dll": {} + } + }, + "Microsoft.Extensions.Options.ConfigurationExtensions/3.1.8": { + "type": "package", + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "3.1.8", + "Microsoft.Extensions.Configuration.Binder": "3.1.8", + "Microsoft.Extensions.DependencyInjection.Abstractions": "3.1.8", + "Microsoft.Extensions.Options": "3.1.8" + }, + "compile": { + "lib/netcoreapp3.1/Microsoft.Extensions.Options.ConfigurationExtensions.dll": {} + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.Extensions.Options.ConfigurationExtensions.dll": {} + } + }, + "Microsoft.Extensions.Primitives/3.1.8": { + "type": "package", + "compile": { + "lib/netcoreapp3.1/Microsoft.Extensions.Primitives.dll": {} + }, + "runtime": { + "lib/netcoreapp3.1/Microsoft.Extensions.Primitives.dll": {} + } + }, + "Newtonsoft.Json/12.0.2": { + "type": "package", + "compile": { + "lib/netstandard2.0/Newtonsoft.Json.dll": {} + }, + "runtime": { + "lib/netstandard2.0/Newtonsoft.Json.dll": {} + } + } + } + }, + "libraries": { + "Microsoft.AspNetCore.NodeServices/3.1.8": { + "sha512": "RIQRd+xuvFntX1ZP0vFOFjGwMxMLkSNOwWuEiCWG8pcc/L9pl/NraefrjFTH88pvyX8a0y1eyA4l/EkHMGjZ/g==", + "type": "package", + "path": "microsoft.aspnetcore.nodeservices/3.1.8", + "files": [ + ".nupkg.metadata", + ".signature.p7s", + "Icon.png", + "THIRD-PARTY-NOTICES.TXT", + "lib/netcoreapp3.1/Microsoft.AspNetCore.NodeServices.dll", + "microsoft.aspnetcore.nodeservices.3.1.8.nupkg.sha512", + "microsoft.aspnetcore.nodeservices.nuspec" + ] + }, + "Microsoft.AspNetCore.SpaServices/3.1.8": { + "sha512": "jnd1fpGjmVud8iyaaN0N/R3wxySvweMUo6Hml1OaWHWBbRI0wjX7TfOqvRJXC5Mwq9SP3B8bg5ik/BfHEKGgog==", + "type": "package", + "path": "microsoft.aspnetcore.spaservices/3.1.8", + "files": [ + ".nupkg.metadata", + ".signature.p7s", + "Icon.png", + "THIRD-PARTY-NOTICES.TXT", + "lib/netcoreapp3.1/Microsoft.AspNetCore.SpaServices.dll", + "microsoft.aspnetcore.spaservices.3.1.8.nupkg.sha512", + "microsoft.aspnetcore.spaservices.nuspec" + ] + }, + "Microsoft.AspNetCore.SpaServices.Extensions/3.1.8": { + "sha512": "c1OftMALLUQOVbHKalS8JfdjadiRw/Teta0GDzpig7t7FkzLx56LMxmfeZBGg47oG21mnulX3o5eZuSj6EDR+Q==", + "type": "package", + "path": "microsoft.aspnetcore.spaservices.extensions/3.1.8", + "files": [ + ".nupkg.metadata", + ".signature.p7s", + "Icon.png", + "THIRD-PARTY-NOTICES.TXT", + "lib/netcoreapp3.1/Microsoft.AspNetCore.SpaServices.Extensions.dll", + "microsoft.aspnetcore.spaservices.extensions.3.1.8.nupkg.sha512", + "microsoft.aspnetcore.spaservices.extensions.nuspec" + ] + }, + "Microsoft.Extensions.Configuration/3.1.8": { + "sha512": "xWvtu/ra8xDOy62ZXzQj1ElmmH3GpZBSKvw4LbfNXKCy+PaziS5Uh0gQ47D4H4w3u+PJfhNWCCGCp9ORNEzkRw==", + "type": "package", + "path": "microsoft.extensions.configuration/3.1.8", + "files": [ + ".nupkg.metadata", + ".signature.p7s", + "Icon.png", + "lib/netcoreapp3.1/Microsoft.Extensions.Configuration.dll", + "lib/netcoreapp3.1/Microsoft.Extensions.Configuration.xml", + "lib/netstandard2.0/Microsoft.Extensions.Configuration.dll", + "lib/netstandard2.0/Microsoft.Extensions.Configuration.xml", + "microsoft.extensions.configuration.3.1.8.nupkg.sha512", + "microsoft.extensions.configuration.nuspec" + ] + }, + "Microsoft.Extensions.Configuration.Abstractions/3.1.8": { + "sha512": "0qbNyxGpuNP/fuQ3FLHesm1Vn/83qYcAgVsi1UQCQN1peY4YH1uiizOh4xbYkQyxiVMD/c/zhiYYv94G0DXSSA==", + "type": "package", + "path": "microsoft.extensions.configuration.abstractions/3.1.8", + "files": [ + ".nupkg.metadata", + ".signature.p7s", + "Icon.png", + "lib/netcoreapp3.1/Microsoft.Extensions.Configuration.Abstractions.dll", + "lib/netcoreapp3.1/Microsoft.Extensions.Configuration.Abstractions.xml", + "lib/netstandard2.0/Microsoft.Extensions.Configuration.Abstractions.dll", + "lib/netstandard2.0/Microsoft.Extensions.Configuration.Abstractions.xml", + "microsoft.extensions.configuration.abstractions.3.1.8.nupkg.sha512", + "microsoft.extensions.configuration.abstractions.nuspec" + ] + }, + "Microsoft.Extensions.Configuration.Binder/3.1.8": { + "sha512": "l/oqIWRM4YF62mlCOrIKGUOCemsaID/lngK2SZEtpYI8LrktpjPd4QzvENWj5GebbLbqOtsFhF6Ko6dgzmUnBw==", + "type": "package", + "path": "microsoft.extensions.configuration.binder/3.1.8", + "files": [ + ".nupkg.metadata", + ".signature.p7s", + "Icon.png", + "lib/netcoreapp3.1/Microsoft.Extensions.Configuration.Binder.dll", + "lib/netcoreapp3.1/Microsoft.Extensions.Configuration.Binder.xml", + "lib/netstandard2.0/Microsoft.Extensions.Configuration.Binder.dll", + "lib/netstandard2.0/Microsoft.Extensions.Configuration.Binder.xml", + "microsoft.extensions.configuration.binder.3.1.8.nupkg.sha512", + "microsoft.extensions.configuration.binder.nuspec" + ] + }, + "Microsoft.Extensions.DependencyInjection/3.1.8": { + "sha512": "tUpYcVxFqwh8wVD8O+6A8gJnVtl6L4N1Vd9bLJgQSJ0gjBTUQ/eKwJn0LglkkaDU7GAxODDv4eexgZn3QSE0NQ==", + "type": "package", + "path": "microsoft.extensions.dependencyinjection/3.1.8", + "files": [ + ".nupkg.metadata", + ".signature.p7s", + "Icon.png", + "lib/net461/Microsoft.Extensions.DependencyInjection.dll", + "lib/net461/Microsoft.Extensions.DependencyInjection.xml", + "lib/netcoreapp3.1/Microsoft.Extensions.DependencyInjection.dll", + "lib/netcoreapp3.1/Microsoft.Extensions.DependencyInjection.xml", + "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.dll", + "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.xml", + "lib/netstandard2.1/Microsoft.Extensions.DependencyInjection.dll", + "lib/netstandard2.1/Microsoft.Extensions.DependencyInjection.xml", + "microsoft.extensions.dependencyinjection.3.1.8.nupkg.sha512", + "microsoft.extensions.dependencyinjection.nuspec" + ] + }, + "Microsoft.Extensions.DependencyInjection.Abstractions/3.1.8": { + "sha512": "YP0kEBkSLTVl3znqZEux+xyJpz5iVNwFZf0OPS7nupdKbojSlO7Fa+JuQjLYpWfpAshaMcznu27tjWzfXRJnOA==", + "type": "package", + "path": "microsoft.extensions.dependencyinjection.abstractions/3.1.8", + "files": [ + ".nupkg.metadata", + ".signature.p7s", + "Icon.png", + "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.Abstractions.dll", + "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.Abstractions.xml", + "microsoft.extensions.dependencyinjection.abstractions.3.1.8.nupkg.sha512", + "microsoft.extensions.dependencyinjection.abstractions.nuspec" + ] + }, + "Microsoft.Extensions.FileProviders.Abstractions/3.1.8": { + "sha512": "U7ffyzrPfRDH5K3h/mBpqJVoHbppw1kc1KyHZcZeDR7b1A0FRaqMSiizGpN9IGwWs9BuN7oXIKFyviuSGBjHtQ==", + "type": "package", + "path": "microsoft.extensions.fileproviders.abstractions/3.1.8", + "files": [ + ".nupkg.metadata", + ".signature.p7s", + "Icon.png", + "lib/netcoreapp3.1/Microsoft.Extensions.FileProviders.Abstractions.dll", + "lib/netcoreapp3.1/Microsoft.Extensions.FileProviders.Abstractions.xml", + "lib/netstandard2.0/Microsoft.Extensions.FileProviders.Abstractions.dll", + "lib/netstandard2.0/Microsoft.Extensions.FileProviders.Abstractions.xml", + "microsoft.extensions.fileproviders.abstractions.3.1.8.nupkg.sha512", + "microsoft.extensions.fileproviders.abstractions.nuspec" + ] + }, + "Microsoft.Extensions.FileProviders.Physical/3.1.8": { + "sha512": "C75r2Xos93s0cAFFihJjyUui7wXaTQjvbqxDhJnpGkAS2Iqw5LBzIida5qz0qgI7IrAfWoOHxKHD3o83YdGA7w==", + "type": "package", + "path": "microsoft.extensions.fileproviders.physical/3.1.8", + "files": [ + ".nupkg.metadata", + ".signature.p7s", + "Icon.png", + "lib/netcoreapp3.1/Microsoft.Extensions.FileProviders.Physical.dll", + "lib/netcoreapp3.1/Microsoft.Extensions.FileProviders.Physical.xml", + "lib/netstandard2.0/Microsoft.Extensions.FileProviders.Physical.dll", + "lib/netstandard2.0/Microsoft.Extensions.FileProviders.Physical.xml", + "microsoft.extensions.fileproviders.physical.3.1.8.nupkg.sha512", + "microsoft.extensions.fileproviders.physical.nuspec" + ] + }, + "Microsoft.Extensions.FileSystemGlobbing/3.1.8": { + "sha512": "WkVBJy0bgkvegB11KT6Jc1xZEnd4qwowZsjsASx2y0AaulSkBHydGUqpEGkYgtIIQdvIvf2QeoEHM/K0JDCIrA==", + "type": "package", + "path": "microsoft.extensions.filesystemglobbing/3.1.8", + "files": [ + ".nupkg.metadata", + ".signature.p7s", + "Icon.png", + "lib/netstandard2.0/Microsoft.Extensions.FileSystemGlobbing.dll", + "lib/netstandard2.0/Microsoft.Extensions.FileSystemGlobbing.xml", + "microsoft.extensions.filesystemglobbing.3.1.8.nupkg.sha512", + "microsoft.extensions.filesystemglobbing.nuspec" + ] + }, + "Microsoft.Extensions.Logging/3.1.8": { + "sha512": "Bch88WGwrgJUabSOiTbPgne/jkCcWTyP97db8GWzQH9RcGi6TThiRm8ggsD+OXBW2UBwAYx1Zb1ns1elsMiomQ==", + "type": "package", + "path": "microsoft.extensions.logging/3.1.8", + "files": [ + ".nupkg.metadata", + ".signature.p7s", + "Icon.png", + "lib/netcoreapp3.1/Microsoft.Extensions.Logging.dll", + "lib/netcoreapp3.1/Microsoft.Extensions.Logging.xml", + "lib/netstandard2.0/Microsoft.Extensions.Logging.dll", + "lib/netstandard2.0/Microsoft.Extensions.Logging.xml", + "microsoft.extensions.logging.3.1.8.nupkg.sha512", + "microsoft.extensions.logging.nuspec" + ] + }, + "Microsoft.Extensions.Logging.Abstractions/3.1.8": { + "sha512": "LxQPR/KE4P9nx304VcFipWPcW8ZOZOGHuiYlG0ncAQJItogDzR9nyYUNvziLObx2MfX2Z9iCTdAqEtoImaQOYg==", + "type": "package", + "path": "microsoft.extensions.logging.abstractions/3.1.8", + "files": [ + ".nupkg.metadata", + ".signature.p7s", + "Icon.png", + "lib/netstandard2.0/Microsoft.Extensions.Logging.Abstractions.dll", + "lib/netstandard2.0/Microsoft.Extensions.Logging.Abstractions.xml", + "microsoft.extensions.logging.abstractions.3.1.8.nupkg.sha512", + "microsoft.extensions.logging.abstractions.nuspec" + ] + }, + "Microsoft.Extensions.Logging.Configuration/3.1.8": { + "sha512": "tfvQYDDwc3ni8VTXQavINMHRUIsM8fQ8gBQTs98mt1QFE3YIVm8XzhqPZMBBlLnXTESymb8HctM2fMnU8qC8Rg==", + "type": "package", + "path": "microsoft.extensions.logging.configuration/3.1.8", + "files": [ + ".nupkg.metadata", + ".signature.p7s", + "Icon.png", + "lib/netcoreapp3.1/Microsoft.Extensions.Logging.Configuration.dll", + "lib/netcoreapp3.1/Microsoft.Extensions.Logging.Configuration.xml", + "lib/netstandard2.0/Microsoft.Extensions.Logging.Configuration.dll", + "lib/netstandard2.0/Microsoft.Extensions.Logging.Configuration.xml", + "microsoft.extensions.logging.configuration.3.1.8.nupkg.sha512", + "microsoft.extensions.logging.configuration.nuspec" + ] + }, + "Microsoft.Extensions.Logging.Console/3.1.8": { + "sha512": "7JCZuqty78ZDwoXOGXGUXMC44rpocfeaa/48ONY7neKhCh2Oml/faW3PANPCdwy6M3TicmU03kIOhyrw3dQ2Eg==", + "type": "package", + "path": "microsoft.extensions.logging.console/3.1.8", + "files": [ + ".nupkg.metadata", + ".signature.p7s", + "Icon.png", + "lib/netcoreapp3.1/Microsoft.Extensions.Logging.Console.dll", + "lib/netcoreapp3.1/Microsoft.Extensions.Logging.Console.xml", + "lib/netstandard2.0/Microsoft.Extensions.Logging.Console.dll", + "lib/netstandard2.0/Microsoft.Extensions.Logging.Console.xml", + "microsoft.extensions.logging.console.3.1.8.nupkg.sha512", + "microsoft.extensions.logging.console.nuspec" + ] + }, + "Microsoft.Extensions.Options/3.1.8": { + "sha512": "mpkwjNg5sr1XHEJwVS8G1w6dsh5/72vQOOe4aqhg012j93m8OOmfyIBwoQN4SE0KRRS+fatdW3qqUrHbRwlWOA==", + "type": "package", + "path": "microsoft.extensions.options/3.1.8", + "files": [ + ".nupkg.metadata", + ".signature.p7s", + "Icon.png", + "lib/netcoreapp3.1/Microsoft.Extensions.Options.dll", + "lib/netcoreapp3.1/Microsoft.Extensions.Options.xml", + "lib/netstandard2.0/Microsoft.Extensions.Options.dll", + "lib/netstandard2.0/Microsoft.Extensions.Options.xml", + "microsoft.extensions.options.3.1.8.nupkg.sha512", + "microsoft.extensions.options.nuspec" + ] + }, + "Microsoft.Extensions.Options.ConfigurationExtensions/3.1.8": { + "sha512": "/q7OhcsgDq6cPqg03nv55QqLt8o/OAvrVkd/w6h0YNasZ4C/Lxpx6I0DsnIH0MB5ORnqCyhmeyv1hFqOeehJng==", + "type": "package", + "path": "microsoft.extensions.options.configurationextensions/3.1.8", + "files": [ + ".nupkg.metadata", + ".signature.p7s", + "Icon.png", + "lib/netcoreapp3.1/Microsoft.Extensions.Options.ConfigurationExtensions.dll", + "lib/netcoreapp3.1/Microsoft.Extensions.Options.ConfigurationExtensions.xml", + "lib/netstandard2.0/Microsoft.Extensions.Options.ConfigurationExtensions.dll", + "lib/netstandard2.0/Microsoft.Extensions.Options.ConfigurationExtensions.xml", + "microsoft.extensions.options.configurationextensions.3.1.8.nupkg.sha512", + "microsoft.extensions.options.configurationextensions.nuspec" + ] + }, + "Microsoft.Extensions.Primitives/3.1.8": { + "sha512": "XcIoXQhT0kwnEhOKv/LmpWR6yF6QWmBTy9Fcsz4aHuCOgTJ7Zd23ELtUA4BfwlYoFlSedavS+vURz9tNekd44g==", + "type": "package", + "path": "microsoft.extensions.primitives/3.1.8", + "files": [ + ".nupkg.metadata", + ".signature.p7s", + "Icon.png", + "lib/netcoreapp3.1/Microsoft.Extensions.Primitives.dll", + "lib/netcoreapp3.1/Microsoft.Extensions.Primitives.xml", + "lib/netstandard2.0/Microsoft.Extensions.Primitives.dll", + "lib/netstandard2.0/Microsoft.Extensions.Primitives.xml", + "microsoft.extensions.primitives.3.1.8.nupkg.sha512", + "microsoft.extensions.primitives.nuspec" + ] + }, + "Newtonsoft.Json/12.0.2": { + "sha512": "rTK0s2EKlfHsQsH6Yx2smvcTCeyoDNgCW7FEYyV01drPlh2T243PR2DiDXqtC5N4GDm4Ma/lkxfW5a/4793vbA==", + "type": "package", + "path": "newtonsoft.json/12.0.2", + "files": [ + ".nupkg.metadata", + ".signature.p7s", + "LICENSE.md", + "lib/net20/Newtonsoft.Json.dll", + "lib/net20/Newtonsoft.Json.xml", + "lib/net35/Newtonsoft.Json.dll", + "lib/net35/Newtonsoft.Json.xml", + "lib/net40/Newtonsoft.Json.dll", + "lib/net40/Newtonsoft.Json.xml", + "lib/net45/Newtonsoft.Json.dll", + "lib/net45/Newtonsoft.Json.xml", + "lib/netstandard1.0/Newtonsoft.Json.dll", + "lib/netstandard1.0/Newtonsoft.Json.xml", + "lib/netstandard1.3/Newtonsoft.Json.dll", + "lib/netstandard1.3/Newtonsoft.Json.xml", + "lib/netstandard2.0/Newtonsoft.Json.dll", + "lib/netstandard2.0/Newtonsoft.Json.xml", + "lib/portable-net40+sl5+win8+wp8+wpa81/Newtonsoft.Json.dll", + "lib/portable-net40+sl5+win8+wp8+wpa81/Newtonsoft.Json.xml", + "lib/portable-net45+win8+wp8+wpa81/Newtonsoft.Json.dll", + "lib/portable-net45+win8+wp8+wpa81/Newtonsoft.Json.xml", + "newtonsoft.json.12.0.2.nupkg.sha512", + "newtonsoft.json.nuspec" + ] + } + }, + "projectFileDependencyGroups": { + ".NETCoreApp,Version=v3.1": [ + "Microsoft.AspNetCore.SpaServices.Extensions >= 3.1.8" + ] + }, + "packageFolders": { + "/Users/matthuntington/.nuget/packages/": {} + }, + "project": { + "version": "1.0.0", + "restore": { + "projectUniqueName": "/Users/matthuntington/Documents/.NET-React/contacts.csproj", + "projectName": "contacts", + "projectPath": "/Users/matthuntington/Documents/.NET-React/contacts.csproj", + "packagesPath": "/Users/matthuntington/.nuget/packages/", + "outputPath": "/Users/matthuntington/Documents/.NET-React/obj/", + "projectStyle": "PackageReference", + "configFilePaths": [ + "/Users/matthuntington/.nuget/NuGet/NuGet.Config" + ], + "originalTargetFrameworks": [ + "netcoreapp3.1" + ], + "sources": { + "https://api.nuget.org/v3/index.json": {} + }, + "frameworks": { + "netcoreapp3.1": { + "projectReferences": {} + } + }, + "warningProperties": { + "warnAsError": [ + "NU1605" + ] + } + }, + "frameworks": { + "netcoreapp3.1": { + "dependencies": { + "Microsoft.AspNetCore.SpaServices.Extensions": { + "target": "Package", + "version": "[3.1.8, )" + } + }, + "imports": [ + "net461", + "net462", + "net47", + "net471", + "net472", + "net48" + ], + "assetTargetFallback": true, + "warn": true, + "frameworkReferences": { + "Microsoft.AspNetCore.App": { + "privateAssets": "none" + }, + "Microsoft.NETCore.App": { + "privateAssets": "all" + } + }, + "runtimeIdentifierGraphPath": "/usr/local/share/dotnet/sdk/3.1.402/RuntimeIdentifierGraph.json" + } + } + } +} \ No newline at end of file diff --git a/obj/project.nuget.cache b/obj/project.nuget.cache new file mode 100644 index 0000000..3f318a4 --- /dev/null +++ b/obj/project.nuget.cache @@ -0,0 +1,28 @@ +{ + "version": 2, + "dgSpecHash": "csB71exohL+UCphcjOTUeYWTjPQW2Vwy+bhgwjWVYqzdIoVRsdwPR/k1yUsLggDWgxze5wwlDasX/0l+387vVQ==", + "success": true, + "projectFilePath": "/Users/matthuntington/Documents/.NET-React/contacts.csproj", + "expectedPackageFiles": [ + "/Users/matthuntington/.nuget/packages/microsoft.aspnetcore.nodeservices/3.1.8/microsoft.aspnetcore.nodeservices.3.1.8.nupkg.sha512", + "/Users/matthuntington/.nuget/packages/microsoft.aspnetcore.spaservices/3.1.8/microsoft.aspnetcore.spaservices.3.1.8.nupkg.sha512", + "/Users/matthuntington/.nuget/packages/microsoft.aspnetcore.spaservices.extensions/3.1.8/microsoft.aspnetcore.spaservices.extensions.3.1.8.nupkg.sha512", + "/Users/matthuntington/.nuget/packages/microsoft.extensions.configuration/3.1.8/microsoft.extensions.configuration.3.1.8.nupkg.sha512", + "/Users/matthuntington/.nuget/packages/microsoft.extensions.configuration.abstractions/3.1.8/microsoft.extensions.configuration.abstractions.3.1.8.nupkg.sha512", + "/Users/matthuntington/.nuget/packages/microsoft.extensions.configuration.binder/3.1.8/microsoft.extensions.configuration.binder.3.1.8.nupkg.sha512", + "/Users/matthuntington/.nuget/packages/microsoft.extensions.dependencyinjection/3.1.8/microsoft.extensions.dependencyinjection.3.1.8.nupkg.sha512", + "/Users/matthuntington/.nuget/packages/microsoft.extensions.dependencyinjection.abstractions/3.1.8/microsoft.extensions.dependencyinjection.abstractions.3.1.8.nupkg.sha512", + "/Users/matthuntington/.nuget/packages/microsoft.extensions.fileproviders.abstractions/3.1.8/microsoft.extensions.fileproviders.abstractions.3.1.8.nupkg.sha512", + "/Users/matthuntington/.nuget/packages/microsoft.extensions.fileproviders.physical/3.1.8/microsoft.extensions.fileproviders.physical.3.1.8.nupkg.sha512", + "/Users/matthuntington/.nuget/packages/microsoft.extensions.filesystemglobbing/3.1.8/microsoft.extensions.filesystemglobbing.3.1.8.nupkg.sha512", + "/Users/matthuntington/.nuget/packages/microsoft.extensions.logging/3.1.8/microsoft.extensions.logging.3.1.8.nupkg.sha512", + "/Users/matthuntington/.nuget/packages/microsoft.extensions.logging.abstractions/3.1.8/microsoft.extensions.logging.abstractions.3.1.8.nupkg.sha512", + "/Users/matthuntington/.nuget/packages/microsoft.extensions.logging.configuration/3.1.8/microsoft.extensions.logging.configuration.3.1.8.nupkg.sha512", + "/Users/matthuntington/.nuget/packages/microsoft.extensions.logging.console/3.1.8/microsoft.extensions.logging.console.3.1.8.nupkg.sha512", + "/Users/matthuntington/.nuget/packages/microsoft.extensions.options/3.1.8/microsoft.extensions.options.3.1.8.nupkg.sha512", + "/Users/matthuntington/.nuget/packages/microsoft.extensions.options.configurationextensions/3.1.8/microsoft.extensions.options.configurationextensions.3.1.8.nupkg.sha512", + "/Users/matthuntington/.nuget/packages/microsoft.extensions.primitives/3.1.8/microsoft.extensions.primitives.3.1.8.nupkg.sha512", + "/Users/matthuntington/.nuget/packages/newtonsoft.json/12.0.2/newtonsoft.json.12.0.2.nupkg.sha512" + ], + "logs": [] +} \ No newline at end of file